1 //===--- Gnu.cpp - Gnu Tool and ToolChain Implementations -------*- C++ -*-===//
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //===----------------------------------------------------------------------===//
11 #include "Arch/Mips.h"
13 #include "Arch/RISCV.h"
14 #include "Arch/Sparc.h"
15 #include "Arch/SystemZ.h"
16 #include "CommonArgs.h"
18 #include "clang/Config/config.h" // for GCC_INSTALL_PREFIX
19 #include "clang/Driver/Compilation.h"
20 #include "clang/Driver/Driver.h"
21 #include "clang/Driver/DriverDiagnostic.h"
22 #include "clang/Driver/Options.h"
23 #include "clang/Driver/Tool.h"
24 #include "clang/Driver/ToolChain.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>
32 using namespace clang::driver;
33 using namespace clang::driver::toolchains;
34 using namespace clang;
35 using namespace llvm::opt;
37 using tools::addMultilibFlag;
39 void tools::GnuTool::anchor() {}
41 static bool forwardToGCC(const Option &O) {
42 // Don't forward inputs from the original command line. They are added from
44 return O.getKind() != Option::InputClass &&
45 !O.hasFlag(options::DriverOption) && !O.hasFlag(options::LinkerInput);
48 // Switch CPU names not recognized by GNU assembler to a close CPU that it does
49 // recognize, instead of a lower march from being picked in the absence of a cpu
51 static void normalizeCPUNamesForAssembler(const ArgList &Args,
52 ArgStringList &CmdArgs) {
53 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
54 StringRef CPUArg(A->getValue());
55 if (CPUArg.equals_lower("krait"))
56 CmdArgs.push_back("-mcpu=cortex-a15");
57 else if(CPUArg.equals_lower("kryo"))
58 CmdArgs.push_back("-mcpu=cortex-a57");
60 Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ);
64 void tools::gcc::Common::ConstructJob(Compilation &C, const JobAction &JA,
65 const InputInfo &Output,
66 const InputInfoList &Inputs,
68 const char *LinkingOutput) const {
69 const Driver &D = getToolChain().getDriver();
70 ArgStringList CmdArgs;
72 for (const auto &A : Args) {
73 if (forwardToGCC(A->getOption())) {
74 // It is unfortunate that we have to claim here, as this means
75 // we will basically never report anything interesting for
76 // platforms using a generic gcc, even if we are just using gcc
77 // to get to the assembler.
80 // Don't forward any -g arguments to assembly steps.
81 if (isa<AssembleJobAction>(JA) &&
82 A->getOption().matches(options::OPT_g_Group))
85 // Don't forward any -W arguments to assembly and link steps.
86 if ((isa<AssembleJobAction>(JA) || isa<LinkJobAction>(JA)) &&
87 A->getOption().matches(options::OPT_W_Group))
90 // Don't forward -mno-unaligned-access since GCC doesn't understand
91 // it and because it doesn't affect the assembly or link steps.
92 if ((isa<AssembleJobAction>(JA) || isa<LinkJobAction>(JA)) &&
93 (A->getOption().matches(options::OPT_munaligned_access) ||
94 A->getOption().matches(options::OPT_mno_unaligned_access)))
97 A->render(Args, CmdArgs);
101 RenderExtraToolArgs(JA, CmdArgs);
103 // If using a driver driver, force the arch.
104 if (getToolChain().getTriple().isOSDarwin()) {
105 CmdArgs.push_back("-arch");
107 Args.MakeArgString(getToolChain().getDefaultUniversalArchName()));
110 // Try to force gcc to match the tool chain we want, if we recognize
113 // FIXME: The triple class should directly provide the information we want
115 switch (getToolChain().getArch()) {
118 case llvm::Triple::x86:
119 case llvm::Triple::ppc:
120 CmdArgs.push_back("-m32");
122 case llvm::Triple::x86_64:
123 case llvm::Triple::ppc64:
124 case llvm::Triple::ppc64le:
125 CmdArgs.push_back("-m64");
127 case llvm::Triple::sparcel:
128 CmdArgs.push_back("-EL");
132 if (Output.isFilename()) {
133 CmdArgs.push_back("-o");
134 CmdArgs.push_back(Output.getFilename());
136 assert(Output.isNothing() && "Unexpected output");
137 CmdArgs.push_back("-fsyntax-only");
140 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
142 // Only pass -x if gcc will understand it; otherwise hope gcc
143 // understands the suffix correctly. The main use case this would go
144 // wrong in is for linker inputs if they happened to have an odd
145 // suffix; really the only way to get this to happen is a command
146 // like '-x foobar a.c' which will treat a.c like a linker input.
148 // FIXME: For the linker case specifically, can we safely convert
149 // inputs into '-Wl,' options?
150 for (const auto &II : Inputs) {
151 // Don't try to pass LLVM or AST inputs to a generic gcc.
152 if (types::isLLVMIR(II.getType()))
153 D.Diag(clang::diag::err_drv_no_linker_llvm_support)
154 << getToolChain().getTripleString();
155 else if (II.getType() == types::TY_AST)
156 D.Diag(diag::err_drv_no_ast_support) << getToolChain().getTripleString();
157 else if (II.getType() == types::TY_ModuleFile)
158 D.Diag(diag::err_drv_no_module_support)
159 << getToolChain().getTripleString();
161 if (types::canTypeBeUserSpecified(II.getType())) {
162 CmdArgs.push_back("-x");
163 CmdArgs.push_back(types::getTypeName(II.getType()));
167 CmdArgs.push_back(II.getFilename());
169 const Arg &A = II.getInputArg();
171 // Reverse translate some rewritten options.
172 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
173 CmdArgs.push_back("-lstdc++");
177 // Don't render as input, we need gcc to do the translations.
178 A.render(Args, CmdArgs);
182 const std::string &customGCCName = D.getCCCGenericGCCName();
184 if (!customGCCName.empty())
185 GCCName = customGCCName.c_str();
186 else if (D.CCCIsCXX()) {
191 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
192 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
195 void tools::gcc::Preprocessor::RenderExtraToolArgs(
196 const JobAction &JA, ArgStringList &CmdArgs) const {
197 CmdArgs.push_back("-E");
200 void tools::gcc::Compiler::RenderExtraToolArgs(const JobAction &JA,
201 ArgStringList &CmdArgs) const {
202 const Driver &D = getToolChain().getDriver();
204 switch (JA.getType()) {
205 // If -flto, etc. are present then make sure not to force assembly output.
206 case types::TY_LLVM_IR:
207 case types::TY_LTO_IR:
208 case types::TY_LLVM_BC:
209 case types::TY_LTO_BC:
210 CmdArgs.push_back("-c");
212 // We assume we've got an "integrated" assembler in that gcc will produce an
213 // object file itself.
214 case types::TY_Object:
215 CmdArgs.push_back("-c");
217 case types::TY_PP_Asm:
218 CmdArgs.push_back("-S");
220 case types::TY_Nothing:
221 CmdArgs.push_back("-fsyntax-only");
224 D.Diag(diag::err_drv_invalid_gcc_output_type) << getTypeName(JA.getType());
228 void tools::gcc::Linker::RenderExtraToolArgs(const JobAction &JA,
229 ArgStringList &CmdArgs) const {
230 // The types are (hopefully) good enough.
233 // On Arm the endianness of the output file is determined by the target and
234 // can be overridden by the pseudo-target flags '-mlittle-endian'/'-EL' and
235 // '-mbig-endian'/'-EB'. Unlike other targets the flag does not result in a
236 // normalized triple so we must handle the flag here.
237 static bool isArmBigEndian(const llvm::Triple &Triple,
238 const ArgList &Args) {
239 bool IsBigEndian = false;
240 switch (Triple.getArch()) {
241 case llvm::Triple::armeb:
242 case llvm::Triple::thumbeb:
245 case llvm::Triple::arm:
246 case llvm::Triple::thumb:
247 if (Arg *A = Args.getLastArg(options::OPT_mlittle_endian,
248 options::OPT_mbig_endian))
249 IsBigEndian = !A->getOption().matches(options::OPT_mlittle_endian);
257 static const char *getLDMOption(const llvm::Triple &T, const ArgList &Args) {
258 switch (T.getArch()) {
259 case llvm::Triple::x86:
263 case llvm::Triple::aarch64:
264 return "aarch64linux";
265 case llvm::Triple::aarch64_be:
266 return "aarch64linuxb";
267 case llvm::Triple::arm:
268 case llvm::Triple::thumb:
269 case llvm::Triple::armeb:
270 case llvm::Triple::thumbeb:
271 return isArmBigEndian(T, Args) ? "armelfb_linux_eabi" : "armelf_linux_eabi";
272 case llvm::Triple::ppc:
273 return "elf32ppclinux";
274 case llvm::Triple::ppc64:
276 case llvm::Triple::ppc64le:
278 case llvm::Triple::riscv32:
279 return "elf32lriscv";
280 case llvm::Triple::riscv64:
281 return "elf64lriscv";
282 case llvm::Triple::sparc:
283 case llvm::Triple::sparcel:
284 return "elf32_sparc";
285 case llvm::Triple::sparcv9:
286 return "elf64_sparc";
287 case llvm::Triple::mips:
288 return "elf32btsmip";
289 case llvm::Triple::mipsel:
290 return "elf32ltsmip";
291 case llvm::Triple::mips64:
292 if (tools::mips::hasMipsAbiArg(Args, "n32") ||
293 T.getEnvironment() == llvm::Triple::GNUABIN32)
294 return "elf32btsmipn32";
295 return "elf64btsmip";
296 case llvm::Triple::mips64el:
297 if (tools::mips::hasMipsAbiArg(Args, "n32") ||
298 T.getEnvironment() == llvm::Triple::GNUABIN32)
299 return "elf32ltsmipn32";
300 return "elf64ltsmip";
301 case llvm::Triple::systemz:
303 case llvm::Triple::x86_64:
304 if (T.getEnvironment() == llvm::Triple::GNUX32)
305 return "elf32_x86_64";
312 static bool getPIE(const ArgList &Args, const toolchains::Linux &ToolChain) {
313 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_static) ||
314 Args.hasArg(options::OPT_r) || Args.hasArg(options::OPT_static_pie))
317 Arg *A = Args.getLastArg(options::OPT_pie, options::OPT_no_pie,
320 return ToolChain.isPIEDefault();
321 return A->getOption().matches(options::OPT_pie);
324 static bool getStaticPIE(const ArgList &Args,
325 const toolchains::Linux &ToolChain) {
326 bool HasStaticPIE = Args.hasArg(options::OPT_static_pie);
327 // -no-pie is an alias for -nopie. So, handling -nopie takes care of
329 if (HasStaticPIE && Args.hasArg(options::OPT_nopie)) {
330 const Driver &D = ToolChain.getDriver();
331 const llvm::opt::OptTable &Opts = D.getOpts();
332 const char *StaticPIEName = Opts.getOptionName(options::OPT_static_pie);
333 const char *NoPIEName = Opts.getOptionName(options::OPT_nopie);
334 D.Diag(diag::err_drv_cannot_mix_options) << StaticPIEName << NoPIEName;
339 static bool getStatic(const ArgList &Args) {
340 return Args.hasArg(options::OPT_static) &&
341 !Args.hasArg(options::OPT_static_pie);
344 void tools::gnutools::Linker::ConstructJob(Compilation &C, const JobAction &JA,
345 const InputInfo &Output,
346 const InputInfoList &Inputs,
348 const char *LinkingOutput) const {
349 const toolchains::Linux &ToolChain =
350 static_cast<const toolchains::Linux &>(getToolChain());
351 const Driver &D = ToolChain.getDriver();
353 const llvm::Triple &Triple = getToolChain().getEffectiveTriple();
355 const llvm::Triple::ArchType Arch = ToolChain.getArch();
356 const bool isAndroid = ToolChain.getTriple().isAndroid();
357 const bool IsIAMCU = ToolChain.getTriple().isOSIAMCU();
358 const bool IsPIE = getPIE(Args, ToolChain);
359 const bool IsStaticPIE = getStaticPIE(Args, ToolChain);
360 const bool IsStatic = getStatic(Args);
361 const bool HasCRTBeginEndFiles =
362 ToolChain.getTriple().hasEnvironment() ||
363 (ToolChain.getTriple().getVendor() != llvm::Triple::MipsTechnologies);
365 ArgStringList CmdArgs;
367 // Silence warning for "clang -g foo.o -o foo"
368 Args.ClaimAllArgs(options::OPT_g_Group);
369 // and "clang -emit-llvm foo.o -o foo"
370 Args.ClaimAllArgs(options::OPT_emit_llvm);
371 // and for "clang -w foo.o -o foo". Other warning options are already
372 // handled somewhere else.
373 Args.ClaimAllArgs(options::OPT_w);
375 if (!D.SysRoot.empty())
376 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
379 CmdArgs.push_back("-pie");
382 CmdArgs.push_back("-static");
383 CmdArgs.push_back("-pie");
384 CmdArgs.push_back("--no-dynamic-linker");
385 CmdArgs.push_back("-z");
386 CmdArgs.push_back("text");
389 if (ToolChain.isNoExecStackDefault()) {
390 CmdArgs.push_back("-z");
391 CmdArgs.push_back("noexecstack");
394 if (Args.hasArg(options::OPT_rdynamic))
395 CmdArgs.push_back("-export-dynamic");
397 if (Args.hasArg(options::OPT_s))
398 CmdArgs.push_back("-s");
400 if (Triple.isARM() || Triple.isThumb() || Triple.isAArch64()) {
401 bool IsBigEndian = isArmBigEndian(Triple, Args);
403 arm::appendBE8LinkFlag(Args, CmdArgs, Triple);
404 IsBigEndian = IsBigEndian || Arch == llvm::Triple::aarch64_be;
405 CmdArgs.push_back(IsBigEndian ? "-EB" : "-EL");
408 // Most Android ARM64 targets should enable the linker fix for erratum
409 // 843419. Only non-Cortex-A53 devices are allowed to skip this flag.
410 if (Arch == llvm::Triple::aarch64 && isAndroid) {
411 std::string CPU = getCPUName(Args, Triple);
412 if (CPU.empty() || CPU == "generic" || CPU == "cortex-a53")
413 CmdArgs.push_back("--fix-cortex-a53-843419");
416 // Android does not allow shared text relocations. Emit a warning if the
417 // user's code contains any.
419 CmdArgs.push_back("--warn-shared-textrel");
421 for (const auto &Opt : ToolChain.ExtraOpts)
422 CmdArgs.push_back(Opt.c_str());
424 CmdArgs.push_back("--eh-frame-hdr");
426 if (const char *LDMOption = getLDMOption(ToolChain.getTriple(), Args)) {
427 CmdArgs.push_back("-m");
428 CmdArgs.push_back(LDMOption);
430 D.Diag(diag::err_target_unknown_triple) << Triple.str();
435 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::armeb ||
436 Arch == llvm::Triple::thumb || Arch == llvm::Triple::thumbeb)
437 CmdArgs.push_back("-Bstatic");
439 CmdArgs.push_back("-static");
440 } else if (Args.hasArg(options::OPT_shared)) {
441 CmdArgs.push_back("-shared");
445 if (Args.hasArg(options::OPT_rdynamic))
446 CmdArgs.push_back("-export-dynamic");
448 if (!Args.hasArg(options::OPT_shared) && !IsStaticPIE) {
449 const std::string Loader =
450 D.DyldPrefix + ToolChain.getDynamicLinker(Args);
451 CmdArgs.push_back("-dynamic-linker");
452 CmdArgs.push_back(Args.MakeArgString(Loader));
456 CmdArgs.push_back("-o");
457 CmdArgs.push_back(Output.getFilename());
459 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
460 if (!isAndroid && !IsIAMCU) {
461 const char *crt1 = nullptr;
462 if (!Args.hasArg(options::OPT_shared)) {
463 if (Args.hasArg(options::OPT_pg))
467 else if (IsStaticPIE)
473 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
475 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
479 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crt0.o")));
480 else if (HasCRTBeginEndFiles) {
482 if (ToolChain.GetRuntimeLibType(Args) == ToolChain::RLT_CompilerRT &&
484 std::string crtbegin = ToolChain.getCompilerRT(Args, "crtbegin",
485 ToolChain::FT_Object);
486 if (ToolChain.getVFS().exists(crtbegin))
490 const char *crtbegin;
492 crtbegin = isAndroid ? "crtbegin_static.o" : "crtbeginT.o";
493 else if (Args.hasArg(options::OPT_shared))
494 crtbegin = isAndroid ? "crtbegin_so.o" : "crtbeginS.o";
495 else if (IsPIE || IsStaticPIE)
496 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbeginS.o";
498 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbegin.o";
499 P = ToolChain.GetFilePath(crtbegin);
501 CmdArgs.push_back(Args.MakeArgString(P));
504 // Add crtfastmath.o if available and fast math is enabled.
505 ToolChain.AddFastMathRuntimeIfAvailable(Args, CmdArgs);
508 Args.AddAllArgs(CmdArgs, options::OPT_L);
509 Args.AddAllArgs(CmdArgs, options::OPT_u);
511 ToolChain.AddFilePathLibArgs(Args, CmdArgs);
513 if (D.isUsingLTO()) {
514 assert(!Inputs.empty() && "Must have at least one input.");
515 AddGoldPlugin(ToolChain, Args, CmdArgs, Output, Inputs[0],
516 D.getLTOMode() == LTOK_Thin);
519 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
520 CmdArgs.push_back("--no-demangle");
522 bool NeedsSanitizerDeps = addSanitizerRuntimes(ToolChain, Args, CmdArgs);
523 bool NeedsXRayDeps = addXRayRuntime(ToolChain, Args, CmdArgs);
524 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs, JA);
525 // The profile runtime also needs access to system libraries.
526 getToolChain().addProfileRTLibs(Args, CmdArgs);
529 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
530 if (ToolChain.ShouldLinkCXXStdlib(Args)) {
531 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
532 !Args.hasArg(options::OPT_static);
533 if (OnlyLibstdcxxStatic)
534 CmdArgs.push_back("-Bstatic");
535 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
536 if (OnlyLibstdcxxStatic)
537 CmdArgs.push_back("-Bdynamic");
539 CmdArgs.push_back("-lm");
541 // Silence warnings when linking C code with a C++ '-stdlib' argument.
542 Args.ClaimAllArgs(options::OPT_stdlib_EQ);
544 if (!Args.hasArg(options::OPT_nostdlib)) {
545 if (!Args.hasArg(options::OPT_nodefaultlibs)) {
546 if (IsStatic || IsStaticPIE)
547 CmdArgs.push_back("--start-group");
549 if (NeedsSanitizerDeps)
550 linkSanitizerRuntimeDeps(ToolChain, CmdArgs);
553 linkXRayRuntimeDeps(ToolChain, CmdArgs);
555 bool WantPthread = Args.hasArg(options::OPT_pthread) ||
556 Args.hasArg(options::OPT_pthreads);
558 // FIXME: Only pass GompNeedsRT = true for platforms with libgomp that
559 // require librt. Most modern Linux platforms do, but some may not.
560 if (addOpenMPRuntime(CmdArgs, ToolChain, Args,
561 JA.isHostOffloading(Action::OFK_OpenMP),
562 /* GompNeedsRT= */ true))
563 // OpenMP runtimes implies pthreads when using the GNU toolchain.
564 // FIXME: Does this really make sense for all GNU toolchains?
567 AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
569 if (WantPthread && !isAndroid)
570 CmdArgs.push_back("-lpthread");
572 if (Args.hasArg(options::OPT_fsplit_stack))
573 CmdArgs.push_back("--wrap=pthread_create");
575 if (!Args.hasArg(options::OPT_nolibc))
576 CmdArgs.push_back("-lc");
578 // Add IAMCU specific libs, if needed.
580 CmdArgs.push_back("-lgloss");
582 if (IsStatic || IsStaticPIE)
583 CmdArgs.push_back("--end-group");
585 AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
587 // Add IAMCU specific libs (outside the group), if needed.
589 CmdArgs.push_back("--as-needed");
590 CmdArgs.push_back("-lsoftfp");
591 CmdArgs.push_back("--no-as-needed");
595 if (!Args.hasArg(options::OPT_nostartfiles) && !IsIAMCU) {
596 if (HasCRTBeginEndFiles) {
598 if (ToolChain.GetRuntimeLibType(Args) == ToolChain::RLT_CompilerRT &&
600 std::string crtend = ToolChain.getCompilerRT(Args, "crtend",
601 ToolChain::FT_Object);
602 if (ToolChain.getVFS().exists(crtend))
607 if (Args.hasArg(options::OPT_shared))
608 crtend = isAndroid ? "crtend_so.o" : "crtendS.o";
609 else if (IsPIE || IsStaticPIE)
610 crtend = isAndroid ? "crtend_android.o" : "crtendS.o";
612 crtend = isAndroid ? "crtend_android.o" : "crtend.o";
613 P = ToolChain.GetFilePath(crtend);
615 CmdArgs.push_back(Args.MakeArgString(P));
618 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
622 // Add OpenMP offloading linker script args if required.
623 AddOpenMPLinkerScript(getToolChain(), C, Output, Inputs, Args, CmdArgs, JA);
625 // Add HIP offloading linker script args if required.
626 AddHIPLinkerScript(getToolChain(), C, Output, Inputs, Args, CmdArgs, JA,
629 const char *Exec = Args.MakeArgString(ToolChain.GetLinkerPath());
630 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
633 void tools::gnutools::Assembler::ConstructJob(Compilation &C,
635 const InputInfo &Output,
636 const InputInfoList &Inputs,
638 const char *LinkingOutput) const {
639 const auto &D = getToolChain().getDriver();
641 claimNoWarnArgs(Args);
643 ArgStringList CmdArgs;
645 llvm::Reloc::Model RelocationModel;
648 std::tie(RelocationModel, PICLevel, IsPIE) =
649 ParsePICArgs(getToolChain(), Args);
651 if (const Arg *A = Args.getLastArg(options::OPT_gz, options::OPT_gz_EQ)) {
652 if (A->getOption().getID() == options::OPT_gz) {
653 CmdArgs.push_back("--compress-debug-sections");
655 StringRef Value = A->getValue();
656 if (Value == "none" || Value == "zlib" || Value == "zlib-gnu") {
658 Args.MakeArgString("--compress-debug-sections=" + Twine(Value)));
660 D.Diag(diag::err_drv_unsupported_option_argument)
661 << A->getOption().getName() << Value;
666 if (getToolChain().isNoExecStackDefault()) {
667 CmdArgs.push_back("--noexecstack");
670 switch (getToolChain().getArch()) {
673 // Add --32/--64 to make sure we get the format we want.
674 // This is incomplete
675 case llvm::Triple::x86:
676 CmdArgs.push_back("--32");
678 case llvm::Triple::x86_64:
679 if (getToolChain().getTriple().getEnvironment() == llvm::Triple::GNUX32)
680 CmdArgs.push_back("--x32");
682 CmdArgs.push_back("--64");
684 case llvm::Triple::ppc: {
685 CmdArgs.push_back("-a32");
686 CmdArgs.push_back("-mppc");
688 ppc::getPPCAsmModeForCPU(getCPUName(Args, getToolChain().getTriple())));
691 case llvm::Triple::ppc64: {
692 CmdArgs.push_back("-a64");
693 CmdArgs.push_back("-mppc64");
695 ppc::getPPCAsmModeForCPU(getCPUName(Args, getToolChain().getTriple())));
698 case llvm::Triple::ppc64le: {
699 CmdArgs.push_back("-a64");
700 CmdArgs.push_back("-mppc64");
701 CmdArgs.push_back("-mlittle-endian");
703 ppc::getPPCAsmModeForCPU(getCPUName(Args, getToolChain().getTriple())));
706 case llvm::Triple::riscv32:
707 case llvm::Triple::riscv64: {
708 StringRef ABIName = riscv::getRISCVABI(Args, getToolChain().getTriple());
709 CmdArgs.push_back("-mabi");
710 CmdArgs.push_back(ABIName.data());
711 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
712 StringRef MArch = A->getValue();
713 CmdArgs.push_back("-march");
714 CmdArgs.push_back(MArch.data());
718 case llvm::Triple::sparc:
719 case llvm::Triple::sparcel: {
720 CmdArgs.push_back("-32");
721 std::string CPU = getCPUName(Args, getToolChain().getTriple());
723 sparc::getSparcAsmModeForCPU(CPU, getToolChain().getTriple()));
724 AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
727 case llvm::Triple::sparcv9: {
728 CmdArgs.push_back("-64");
729 std::string CPU = getCPUName(Args, getToolChain().getTriple());
731 sparc::getSparcAsmModeForCPU(CPU, getToolChain().getTriple()));
732 AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
735 case llvm::Triple::arm:
736 case llvm::Triple::armeb:
737 case llvm::Triple::thumb:
738 case llvm::Triple::thumbeb: {
739 const llvm::Triple &Triple2 = getToolChain().getTriple();
740 CmdArgs.push_back(isArmBigEndian(Triple2, Args) ? "-EB" : "-EL");
741 switch (Triple2.getSubArch()) {
742 case llvm::Triple::ARMSubArch_v7:
743 CmdArgs.push_back("-mfpu=neon");
745 case llvm::Triple::ARMSubArch_v8:
746 CmdArgs.push_back("-mfpu=crypto-neon-fp-armv8");
752 switch (arm::getARMFloatABI(getToolChain(), Args)) {
753 case arm::FloatABI::Invalid: llvm_unreachable("must have an ABI!");
754 case arm::FloatABI::Soft:
755 CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=soft"));
757 case arm::FloatABI::SoftFP:
758 CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=softfp"));
760 case arm::FloatABI::Hard:
761 CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=hard"));
765 Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
766 normalizeCPUNamesForAssembler(Args, CmdArgs);
768 Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ);
771 case llvm::Triple::aarch64:
772 case llvm::Triple::aarch64_be: {
774 getToolChain().getArch() == llvm::Triple::aarch64_be ? "-EB" : "-EL");
775 Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
776 normalizeCPUNamesForAssembler(Args, CmdArgs);
780 case llvm::Triple::mips:
781 case llvm::Triple::mipsel:
782 case llvm::Triple::mips64:
783 case llvm::Triple::mips64el: {
786 mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
787 ABIName = mips::getGnuCompatibleMipsABIName(ABIName);
789 CmdArgs.push_back("-march");
790 CmdArgs.push_back(CPUName.data());
792 CmdArgs.push_back("-mabi");
793 CmdArgs.push_back(ABIName.data());
795 // -mno-shared should be emitted unless -fpic, -fpie, -fPIC, -fPIE,
796 // or -mshared (not implemented) is in effect.
797 if (RelocationModel == llvm::Reloc::Static)
798 CmdArgs.push_back("-mno-shared");
800 // LLVM doesn't support -mplt yet and acts as if it is always given.
801 // However, -mplt has no effect with the N64 ABI.
802 if (ABIName != "64" && !Args.hasArg(options::OPT_mno_abicalls))
803 CmdArgs.push_back("-call_nonpic");
805 if (getToolChain().getTriple().isLittleEndian())
806 CmdArgs.push_back("-EL");
808 CmdArgs.push_back("-EB");
810 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
811 if (StringRef(A->getValue()) == "2008")
812 CmdArgs.push_back(Args.MakeArgString("-mnan=2008"));
815 // Add the last -mfp32/-mfpxx/-mfp64 or -mfpxx if it is enabled by default.
816 if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfpxx,
817 options::OPT_mfp64)) {
819 A->render(Args, CmdArgs);
820 } else if (mips::shouldUseFPXX(
821 Args, getToolChain().getTriple(), CPUName, ABIName,
822 mips::getMipsFloatABI(getToolChain().getDriver(), Args,
823 getToolChain().getTriple())))
824 CmdArgs.push_back("-mfpxx");
826 // Pass on -mmips16 or -mno-mips16. However, the assembler equivalent of
827 // -mno-mips16 is actually -no-mips16.
829 Args.getLastArg(options::OPT_mips16, options::OPT_mno_mips16)) {
830 if (A->getOption().matches(options::OPT_mips16)) {
832 A->render(Args, CmdArgs);
835 CmdArgs.push_back("-no-mips16");
839 Args.AddLastArg(CmdArgs, options::OPT_mmicromips,
840 options::OPT_mno_micromips);
841 Args.AddLastArg(CmdArgs, options::OPT_mdsp, options::OPT_mno_dsp);
842 Args.AddLastArg(CmdArgs, options::OPT_mdspr2, options::OPT_mno_dspr2);
844 if (Arg *A = Args.getLastArg(options::OPT_mmsa, options::OPT_mno_msa)) {
845 // Do not use AddLastArg because not all versions of MIPS assembler
846 // support -mmsa / -mno-msa options.
847 if (A->getOption().matches(options::OPT_mmsa))
848 CmdArgs.push_back(Args.MakeArgString("-mmsa"));
851 Args.AddLastArg(CmdArgs, options::OPT_mhard_float,
852 options::OPT_msoft_float);
854 Args.AddLastArg(CmdArgs, options::OPT_mdouble_float,
855 options::OPT_msingle_float);
857 Args.AddLastArg(CmdArgs, options::OPT_modd_spreg,
858 options::OPT_mno_odd_spreg);
860 AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
863 case llvm::Triple::systemz: {
864 // Always pass an -march option, since our default of z10 is later
865 // than the GNU assembler's default.
866 StringRef CPUName = systemz::getSystemZTargetCPU(Args);
867 CmdArgs.push_back(Args.MakeArgString("-march=" + CPUName));
872 Args.AddAllArgs(CmdArgs, options::OPT_I);
873 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
875 CmdArgs.push_back("-o");
876 CmdArgs.push_back(Output.getFilename());
878 for (const auto &II : Inputs)
879 CmdArgs.push_back(II.getFilename());
881 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
882 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
884 // Handle the debug info splitting at object creation time if we're
885 // creating an object.
886 // TODO: Currently only works on linux with newer objcopy.
887 if (Args.hasArg(options::OPT_gsplit_dwarf) &&
888 getToolChain().getTriple().isOSLinux())
889 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
890 SplitDebugName(Args, Inputs[0], Output));
894 // Filter to remove Multilibs that don't exist as a suffix to Path
895 class FilterNonExistent {
896 StringRef Base, File;
897 llvm::vfs::FileSystem &VFS;
900 FilterNonExistent(StringRef Base, StringRef File, llvm::vfs::FileSystem &VFS)
901 : Base(Base), File(File), VFS(VFS) {}
902 bool operator()(const Multilib &M) {
903 return !VFS.exists(Base + M.gccSuffix() + File);
906 } // end anonymous namespace
908 static bool isSoftFloatABI(const ArgList &Args) {
909 Arg *A = Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float,
910 options::OPT_mfloat_abi_EQ);
914 return A->getOption().matches(options::OPT_msoft_float) ||
915 (A->getOption().matches(options::OPT_mfloat_abi_EQ) &&
916 A->getValue() == StringRef("soft"));
919 static bool isArmOrThumbArch(llvm::Triple::ArchType Arch) {
920 return Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb;
923 static bool isMipsEL(llvm::Triple::ArchType Arch) {
924 return Arch == llvm::Triple::mipsel || Arch == llvm::Triple::mips64el;
927 static bool isMips16(const ArgList &Args) {
928 Arg *A = Args.getLastArg(options::OPT_mips16, options::OPT_mno_mips16);
929 return A && A->getOption().matches(options::OPT_mips16);
932 static bool isMicroMips(const ArgList &Args) {
933 Arg *A = Args.getLastArg(options::OPT_mmicromips, options::OPT_mno_micromips);
934 return A && A->getOption().matches(options::OPT_mmicromips);
937 static bool isMSP430(llvm::Triple::ArchType Arch) {
938 return Arch == llvm::Triple::msp430;
941 static Multilib makeMultilib(StringRef commonSuffix) {
942 return Multilib(commonSuffix, commonSuffix, commonSuffix);
945 static bool findMipsCsMultilibs(const Multilib::flags_list &Flags,
946 FilterNonExistent &NonExistent,
947 DetectedMultilibs &Result) {
948 // Check for Code Sourcery toolchain multilibs
949 MultilibSet CSMipsMultilibs;
951 auto MArchMips16 = makeMultilib("/mips16").flag("+m32").flag("+mips16");
953 auto MArchMicroMips =
954 makeMultilib("/micromips").flag("+m32").flag("+mmicromips");
956 auto MArchDefault = makeMultilib("").flag("-mips16").flag("-mmicromips");
958 auto UCLibc = makeMultilib("/uclibc").flag("+muclibc");
960 auto SoftFloat = makeMultilib("/soft-float").flag("+msoft-float");
962 auto Nan2008 = makeMultilib("/nan2008").flag("+mnan=2008");
965 makeMultilib("").flag("-msoft-float").flag("-mnan=2008");
967 auto BigEndian = makeMultilib("").flag("+EB").flag("-EL");
969 auto LittleEndian = makeMultilib("/el").flag("+EL").flag("-EB");
971 // Note that this one's osSuffix is ""
972 auto MAbi64 = makeMultilib("")
974 .includeSuffix("/64")
981 .Either(MArchMips16, MArchMicroMips, MArchDefault)
983 .Either(SoftFloat, Nan2008, DefaultFloat)
984 .FilterOut("/micromips/nan2008")
985 .FilterOut("/mips16/nan2008")
986 .Either(BigEndian, LittleEndian)
988 .FilterOut("/mips16.*/64")
989 .FilterOut("/micromips.*/64")
990 .FilterOut(NonExistent)
991 .setIncludeDirsCallback([](const Multilib &M) {
992 std::vector<std::string> Dirs({"/include"});
993 if (StringRef(M.includeSuffix()).startswith("/uclibc"))
995 "/../../../../mips-linux-gnu/libc/uclibc/usr/include");
997 Dirs.push_back("/../../../../mips-linux-gnu/libc/usr/include");
1002 MultilibSet DebianMipsMultilibs;
1005 Multilib().gccSuffix("/n32").includeSuffix("/n32").flag("+mabi=n32");
1007 Multilib M64 = Multilib()
1009 .includeSuffix("/64")
1014 Multilib M32 = Multilib().flag("-m64").flag("+m32").flag("-mabi=n32");
1016 DebianMipsMultilibs =
1017 MultilibSet().Either(M32, M64, MAbiN32).FilterOut(NonExistent);
1020 // Sort candidates. Toolchain that best meets the directories tree goes first.
1021 // Then select the first toolchains matches command line flags.
1022 MultilibSet *Candidates[] = {&CSMipsMultilibs, &DebianMipsMultilibs};
1023 if (CSMipsMultilibs.size() < DebianMipsMultilibs.size())
1024 std::iter_swap(Candidates, Candidates + 1);
1025 for (const MultilibSet *Candidate : Candidates) {
1026 if (Candidate->select(Flags, Result.SelectedMultilib)) {
1027 if (Candidate == &DebianMipsMultilibs)
1028 Result.BiarchSibling = Multilib();
1029 Result.Multilibs = *Candidate;
1036 static bool findMipsAndroidMultilibs(llvm::vfs::FileSystem &VFS, StringRef Path,
1037 const Multilib::flags_list &Flags,
1038 FilterNonExistent &NonExistent,
1039 DetectedMultilibs &Result) {
1041 MultilibSet AndroidMipsMultilibs =
1043 .Maybe(Multilib("/mips-r2").flag("+march=mips32r2"))
1044 .Maybe(Multilib("/mips-r6").flag("+march=mips32r6"))
1045 .FilterOut(NonExistent);
1047 MultilibSet AndroidMipselMultilibs =
1049 .Either(Multilib().flag("+march=mips32"),
1050 Multilib("/mips-r2", "", "/mips-r2").flag("+march=mips32r2"),
1051 Multilib("/mips-r6", "", "/mips-r6").flag("+march=mips32r6"))
1052 .FilterOut(NonExistent);
1054 MultilibSet AndroidMips64elMultilibs =
1057 Multilib().flag("+march=mips64r6"),
1058 Multilib("/32/mips-r1", "", "/mips-r1").flag("+march=mips32"),
1059 Multilib("/32/mips-r2", "", "/mips-r2").flag("+march=mips32r2"),
1060 Multilib("/32/mips-r6", "", "/mips-r6").flag("+march=mips32r6"))
1061 .FilterOut(NonExistent);
1063 MultilibSet *MS = &AndroidMipsMultilibs;
1064 if (VFS.exists(Path + "/mips-r6"))
1065 MS = &AndroidMipselMultilibs;
1066 else if (VFS.exists(Path + "/32"))
1067 MS = &AndroidMips64elMultilibs;
1068 if (MS->select(Flags, Result.SelectedMultilib)) {
1069 Result.Multilibs = *MS;
1075 static bool findMipsMuslMultilibs(const Multilib::flags_list &Flags,
1076 FilterNonExistent &NonExistent,
1077 DetectedMultilibs &Result) {
1078 // Musl toolchain multilibs
1079 MultilibSet MuslMipsMultilibs;
1081 auto MArchMipsR2 = makeMultilib("")
1082 .osSuffix("/mips-r2-hard-musl")
1085 .flag("+march=mips32r2");
1087 auto MArchMipselR2 = makeMultilib("/mipsel-r2-hard-musl")
1090 .flag("+march=mips32r2");
1092 MuslMipsMultilibs = MultilibSet().Either(MArchMipsR2, MArchMipselR2);
1094 // Specify the callback that computes the include directories.
1095 MuslMipsMultilibs.setIncludeDirsCallback([](const Multilib &M) {
1096 return std::vector<std::string>(
1097 {"/../sysroot" + M.osSuffix() + "/usr/include"});
1100 if (MuslMipsMultilibs.select(Flags, Result.SelectedMultilib)) {
1101 Result.Multilibs = MuslMipsMultilibs;
1107 static bool findMipsMtiMultilibs(const Multilib::flags_list &Flags,
1108 FilterNonExistent &NonExistent,
1109 DetectedMultilibs &Result) {
1110 // CodeScape MTI toolchain v1.2 and early.
1111 MultilibSet MtiMipsMultilibsV1;
1113 auto MArchMips32 = makeMultilib("/mips32")
1116 .flag("-mmicromips")
1117 .flag("+march=mips32");
1119 auto MArchMicroMips = makeMultilib("/micromips")
1122 .flag("+mmicromips");
1124 auto MArchMips64r2 = makeMultilib("/mips64r2")
1127 .flag("+march=mips64r2");
1129 auto MArchMips64 = makeMultilib("/mips64").flag("-m32").flag("+m64").flag(
1132 auto MArchDefault = makeMultilib("")
1135 .flag("-mmicromips")
1136 .flag("+march=mips32r2");
1138 auto Mips16 = makeMultilib("/mips16").flag("+mips16");
1140 auto UCLibc = makeMultilib("/uclibc").flag("+muclibc");
1143 makeMultilib("/64").flag("+mabi=n64").flag("-mabi=n32").flag("-m32");
1145 auto BigEndian = makeMultilib("").flag("+EB").flag("-EL");
1147 auto LittleEndian = makeMultilib("/el").flag("+EL").flag("-EB");
1149 auto SoftFloat = makeMultilib("/sof").flag("+msoft-float");
1151 auto Nan2008 = makeMultilib("/nan2008").flag("+mnan=2008");
1153 MtiMipsMultilibsV1 =
1155 .Either(MArchMips32, MArchMicroMips, MArchMips64r2, MArchMips64,
1159 .FilterOut("/mips64/mips16")
1160 .FilterOut("/mips64r2/mips16")
1161 .FilterOut("/micromips/mips16")
1163 .FilterOut("/micromips/64")
1164 .FilterOut("/mips32/64")
1166 .FilterOut("/mips16/64")
1167 .Either(BigEndian, LittleEndian)
1170 .FilterOut(".*sof/nan2008")
1171 .FilterOut(NonExistent)
1172 .setIncludeDirsCallback([](const Multilib &M) {
1173 std::vector<std::string> Dirs({"/include"});
1174 if (StringRef(M.includeSuffix()).startswith("/uclibc"))
1175 Dirs.push_back("/../../../../sysroot/uclibc/usr/include");
1177 Dirs.push_back("/../../../../sysroot/usr/include");
1182 // CodeScape IMG toolchain starting from v1.3.
1183 MultilibSet MtiMipsMultilibsV2;
1185 auto BeHard = makeMultilib("/mips-r2-hard")
1187 .flag("-msoft-float")
1190 auto BeSoft = makeMultilib("/mips-r2-soft")
1192 .flag("+msoft-float")
1193 .flag("-mnan=2008");
1194 auto ElHard = makeMultilib("/mipsel-r2-hard")
1196 .flag("-msoft-float")
1199 auto ElSoft = makeMultilib("/mipsel-r2-soft")
1201 .flag("+msoft-float")
1203 .flag("-mmicromips");
1204 auto BeHardNan = makeMultilib("/mips-r2-hard-nan2008")
1206 .flag("-msoft-float")
1209 auto ElHardNan = makeMultilib("/mipsel-r2-hard-nan2008")
1211 .flag("-msoft-float")
1214 .flag("-mmicromips");
1215 auto BeHardNanUclibc = makeMultilib("/mips-r2-hard-nan2008-uclibc")
1217 .flag("-msoft-float")
1220 auto ElHardNanUclibc = makeMultilib("/mipsel-r2-hard-nan2008-uclibc")
1222 .flag("-msoft-float")
1225 auto BeHardUclibc = makeMultilib("/mips-r2-hard-uclibc")
1227 .flag("-msoft-float")
1230 auto ElHardUclibc = makeMultilib("/mipsel-r2-hard-uclibc")
1232 .flag("-msoft-float")
1235 auto ElMicroHardNan = makeMultilib("/micromipsel-r2-hard-nan2008")
1237 .flag("-msoft-float")
1239 .flag("+mmicromips");
1240 auto ElMicroSoft = makeMultilib("/micromipsel-r2-soft")
1242 .flag("+msoft-float")
1244 .flag("+mmicromips");
1247 makeMultilib("/lib").osSuffix("").flag("-mabi=n32").flag("-mabi=n64");
1249 makeMultilib("/lib32").osSuffix("").flag("+mabi=n32").flag("-mabi=n64");
1251 makeMultilib("/lib64").osSuffix("").flag("-mabi=n32").flag("+mabi=n64");
1253 MtiMipsMultilibsV2 =
1255 .Either({BeHard, BeSoft, ElHard, ElSoft, BeHardNan, ElHardNan,
1256 BeHardNanUclibc, ElHardNanUclibc, BeHardUclibc,
1257 ElHardUclibc, ElMicroHardNan, ElMicroSoft})
1258 .Either(O32, N32, N64)
1259 .FilterOut(NonExistent)
1260 .setIncludeDirsCallback([](const Multilib &M) {
1261 return std::vector<std::string>({"/../../../../sysroot" +
1263 "/../usr/include"});
1265 .setFilePathsCallback([](const Multilib &M) {
1266 return std::vector<std::string>(
1267 {"/../../../../mips-mti-linux-gnu/lib" + M.gccSuffix()});
1270 for (auto Candidate : {&MtiMipsMultilibsV1, &MtiMipsMultilibsV2}) {
1271 if (Candidate->select(Flags, Result.SelectedMultilib)) {
1272 Result.Multilibs = *Candidate;
1279 static bool findMipsImgMultilibs(const Multilib::flags_list &Flags,
1280 FilterNonExistent &NonExistent,
1281 DetectedMultilibs &Result) {
1282 // CodeScape IMG toolchain v1.2 and early.
1283 MultilibSet ImgMultilibsV1;
1285 auto Mips64r6 = makeMultilib("/mips64r6").flag("+m64").flag("-m32");
1287 auto LittleEndian = makeMultilib("/el").flag("+EL").flag("-EB");
1290 makeMultilib("/64").flag("+mabi=n64").flag("-mabi=n32").flag("-m32");
1296 .Maybe(LittleEndian)
1297 .FilterOut(NonExistent)
1298 .setIncludeDirsCallback([](const Multilib &M) {
1299 return std::vector<std::string>(
1300 {"/include", "/../../../../sysroot/usr/include"});
1304 // CodeScape IMG toolchain starting from v1.3.
1305 MultilibSet ImgMultilibsV2;
1307 auto BeHard = makeMultilib("/mips-r6-hard")
1309 .flag("-msoft-float")
1310 .flag("-mmicromips");
1311 auto BeSoft = makeMultilib("/mips-r6-soft")
1313 .flag("+msoft-float")
1314 .flag("-mmicromips");
1315 auto ElHard = makeMultilib("/mipsel-r6-hard")
1317 .flag("-msoft-float")
1318 .flag("-mmicromips");
1319 auto ElSoft = makeMultilib("/mipsel-r6-soft")
1321 .flag("+msoft-float")
1322 .flag("-mmicromips");
1323 auto BeMicroHard = makeMultilib("/micromips-r6-hard")
1325 .flag("-msoft-float")
1326 .flag("+mmicromips");
1327 auto BeMicroSoft = makeMultilib("/micromips-r6-soft")
1329 .flag("+msoft-float")
1330 .flag("+mmicromips");
1331 auto ElMicroHard = makeMultilib("/micromipsel-r6-hard")
1333 .flag("-msoft-float")
1334 .flag("+mmicromips");
1335 auto ElMicroSoft = makeMultilib("/micromipsel-r6-soft")
1337 .flag("+msoft-float")
1338 .flag("+mmicromips");
1341 makeMultilib("/lib").osSuffix("").flag("-mabi=n32").flag("-mabi=n64");
1343 makeMultilib("/lib32").osSuffix("").flag("+mabi=n32").flag("-mabi=n64");
1345 makeMultilib("/lib64").osSuffix("").flag("-mabi=n32").flag("+mabi=n64");
1349 .Either({BeHard, BeSoft, ElHard, ElSoft, BeMicroHard, BeMicroSoft,
1350 ElMicroHard, ElMicroSoft})
1351 .Either(O32, N32, N64)
1352 .FilterOut(NonExistent)
1353 .setIncludeDirsCallback([](const Multilib &M) {
1354 return std::vector<std::string>({"/../../../../sysroot" +
1356 "/../usr/include"});
1358 .setFilePathsCallback([](const Multilib &M) {
1359 return std::vector<std::string>(
1360 {"/../../../../mips-img-linux-gnu/lib" + M.gccSuffix()});
1363 for (auto Candidate : {&ImgMultilibsV1, &ImgMultilibsV2}) {
1364 if (Candidate->select(Flags, Result.SelectedMultilib)) {
1365 Result.Multilibs = *Candidate;
1372 bool clang::driver::findMIPSMultilibs(const Driver &D,
1373 const llvm::Triple &TargetTriple,
1374 StringRef Path, const ArgList &Args,
1375 DetectedMultilibs &Result) {
1376 FilterNonExistent NonExistent(Path, "/crtbegin.o", D.getVFS());
1380 tools::mips::getMipsCPUAndABI(Args, TargetTriple, CPUName, ABIName);
1382 llvm::Triple::ArchType TargetArch = TargetTriple.getArch();
1384 Multilib::flags_list Flags;
1385 addMultilibFlag(TargetTriple.isMIPS32(), "m32", Flags);
1386 addMultilibFlag(TargetTriple.isMIPS64(), "m64", Flags);
1387 addMultilibFlag(isMips16(Args), "mips16", Flags);
1388 addMultilibFlag(CPUName == "mips32", "march=mips32", Flags);
1389 addMultilibFlag(CPUName == "mips32r2" || CPUName == "mips32r3" ||
1390 CPUName == "mips32r5" || CPUName == "p5600",
1391 "march=mips32r2", Flags);
1392 addMultilibFlag(CPUName == "mips32r6", "march=mips32r6", Flags);
1393 addMultilibFlag(CPUName == "mips64", "march=mips64", Flags);
1394 addMultilibFlag(CPUName == "mips64r2" || CPUName == "mips64r3" ||
1395 CPUName == "mips64r5" || CPUName == "octeon" ||
1396 CPUName == "octeon+",
1397 "march=mips64r2", Flags);
1398 addMultilibFlag(CPUName == "mips64r6", "march=mips64r6", Flags);
1399 addMultilibFlag(isMicroMips(Args), "mmicromips", Flags);
1400 addMultilibFlag(tools::mips::isUCLibc(Args), "muclibc", Flags);
1401 addMultilibFlag(tools::mips::isNaN2008(Args, TargetTriple), "mnan=2008",
1403 addMultilibFlag(ABIName == "n32", "mabi=n32", Flags);
1404 addMultilibFlag(ABIName == "n64", "mabi=n64", Flags);
1405 addMultilibFlag(isSoftFloatABI(Args), "msoft-float", Flags);
1406 addMultilibFlag(!isSoftFloatABI(Args), "mhard-float", Flags);
1407 addMultilibFlag(isMipsEL(TargetArch), "EL", Flags);
1408 addMultilibFlag(!isMipsEL(TargetArch), "EB", Flags);
1410 if (TargetTriple.isAndroid())
1411 return findMipsAndroidMultilibs(D.getVFS(), Path, Flags, NonExistent,
1414 if (TargetTriple.getVendor() == llvm::Triple::MipsTechnologies &&
1415 TargetTriple.getOS() == llvm::Triple::Linux &&
1416 TargetTriple.getEnvironment() == llvm::Triple::UnknownEnvironment)
1417 return findMipsMuslMultilibs(Flags, NonExistent, Result);
1419 if (TargetTriple.getVendor() == llvm::Triple::MipsTechnologies &&
1420 TargetTriple.getOS() == llvm::Triple::Linux &&
1421 TargetTriple.isGNUEnvironment())
1422 return findMipsMtiMultilibs(Flags, NonExistent, Result);
1424 if (TargetTriple.getVendor() == llvm::Triple::ImaginationTechnologies &&
1425 TargetTriple.getOS() == llvm::Triple::Linux &&
1426 TargetTriple.isGNUEnvironment())
1427 return findMipsImgMultilibs(Flags, NonExistent, Result);
1429 if (findMipsCsMultilibs(Flags, NonExistent, Result))
1432 // Fallback to the regular toolchain-tree structure.
1434 Result.Multilibs.push_back(Default);
1435 Result.Multilibs.FilterOut(NonExistent);
1437 if (Result.Multilibs.select(Flags, Result.SelectedMultilib)) {
1438 Result.BiarchSibling = Multilib();
1445 static void findAndroidArmMultilibs(const Driver &D,
1446 const llvm::Triple &TargetTriple,
1447 StringRef Path, const ArgList &Args,
1448 DetectedMultilibs &Result) {
1449 // Find multilibs with subdirectories like armv7-a, thumb, armv7-a/thumb.
1450 FilterNonExistent NonExistent(Path, "/crtbegin.o", D.getVFS());
1451 Multilib ArmV7Multilib = makeMultilib("/armv7-a")
1452 .flag("+march=armv7-a")
1454 Multilib ThumbMultilib = makeMultilib("/thumb")
1455 .flag("-march=armv7-a")
1457 Multilib ArmV7ThumbMultilib = makeMultilib("/armv7-a/thumb")
1458 .flag("+march=armv7-a")
1460 Multilib DefaultMultilib = makeMultilib("")
1461 .flag("-march=armv7-a")
1463 MultilibSet AndroidArmMultilibs =
1465 .Either(ThumbMultilib, ArmV7Multilib,
1466 ArmV7ThumbMultilib, DefaultMultilib)
1467 .FilterOut(NonExistent);
1469 Multilib::flags_list Flags;
1470 llvm::StringRef Arch = Args.getLastArgValue(options::OPT_march_EQ);
1471 bool IsArmArch = TargetTriple.getArch() == llvm::Triple::arm;
1472 bool IsThumbArch = TargetTriple.getArch() == llvm::Triple::thumb;
1473 bool IsV7SubArch = TargetTriple.getSubArch() == llvm::Triple::ARMSubArch_v7;
1474 bool IsThumbMode = IsThumbArch ||
1475 Args.hasFlag(options::OPT_mthumb, options::OPT_mno_thumb, false) ||
1476 (IsArmArch && llvm::ARM::parseArchISA(Arch) == llvm::ARM::ISAKind::THUMB);
1477 bool IsArmV7Mode = (IsArmArch || IsThumbArch) &&
1478 (llvm::ARM::parseArchVersion(Arch) == 7 ||
1479 (IsArmArch && Arch == "" && IsV7SubArch));
1480 addMultilibFlag(IsArmV7Mode, "march=armv7-a", Flags);
1481 addMultilibFlag(IsThumbMode, "mthumb", Flags);
1483 if (AndroidArmMultilibs.select(Flags, Result.SelectedMultilib))
1484 Result.Multilibs = AndroidArmMultilibs;
1487 static bool findMSP430Multilibs(const Driver &D,
1488 const llvm::Triple &TargetTriple,
1489 StringRef Path, const ArgList &Args,
1490 DetectedMultilibs &Result) {
1491 FilterNonExistent NonExistent(Path, "/crtbegin.o", D.getVFS());
1492 Multilib MSP430Multilib = makeMultilib("/430");
1493 // FIXME: when clang starts to support msp430x ISA additional logic
1494 // to select between multilib must be implemented
1495 // Multilib MSP430xMultilib = makeMultilib("/large");
1497 Result.Multilibs.push_back(MSP430Multilib);
1498 Result.Multilibs.FilterOut(NonExistent);
1500 Multilib::flags_list Flags;
1501 if (Result.Multilibs.select(Flags, Result.SelectedMultilib))
1507 static void findRISCVMultilibs(const Driver &D,
1508 const llvm::Triple &TargetTriple, StringRef Path,
1509 const ArgList &Args, DetectedMultilibs &Result) {
1511 FilterNonExistent NonExistent(Path, "/crtbegin.o", D.getVFS());
1512 Multilib Ilp32 = makeMultilib("lib32/ilp32").flag("+m32").flag("+mabi=ilp32");
1514 makeMultilib("lib32/ilp32f").flag("+m32").flag("+mabi=ilp32f");
1516 makeMultilib("lib32/ilp32d").flag("+m32").flag("+mabi=ilp32d");
1517 Multilib Lp64 = makeMultilib("lib64/lp64").flag("+m64").flag("+mabi=lp64");
1518 Multilib Lp64f = makeMultilib("lib64/lp64f").flag("+m64").flag("+mabi=lp64f");
1519 Multilib Lp64d = makeMultilib("lib64/lp64d").flag("+m64").flag("+mabi=lp64d");
1520 MultilibSet RISCVMultilibs =
1522 .Either({Ilp32, Ilp32f, Ilp32d, Lp64, Lp64f, Lp64d})
1523 .FilterOut(NonExistent);
1525 Multilib::flags_list Flags;
1526 bool IsRV64 = TargetTriple.getArch() == llvm::Triple::riscv64;
1527 StringRef ABIName = tools::riscv::getRISCVABI(Args, TargetTriple);
1529 addMultilibFlag(!IsRV64, "m32", Flags);
1530 addMultilibFlag(IsRV64, "m64", Flags);
1531 addMultilibFlag(ABIName == "ilp32", "mabi=ilp32", Flags);
1532 addMultilibFlag(ABIName == "ilp32f", "mabi=ilp32f", Flags);
1533 addMultilibFlag(ABIName == "ilp32d", "mabi=ilp32d", Flags);
1534 addMultilibFlag(ABIName == "lp64", "mabi=lp64", Flags);
1535 addMultilibFlag(ABIName == "lp64f", "mabi=lp64f", Flags);
1536 addMultilibFlag(ABIName == "lp64d", "mabi=lp64d", Flags);
1538 if (RISCVMultilibs.select(Flags, Result.SelectedMultilib))
1539 Result.Multilibs = RISCVMultilibs;
1542 static bool findBiarchMultilibs(const Driver &D,
1543 const llvm::Triple &TargetTriple,
1544 StringRef Path, const ArgList &Args,
1545 bool NeedsBiarchSuffix,
1546 DetectedMultilibs &Result) {
1549 // Some versions of SUSE and Fedora on ppc64 put 32-bit libs
1550 // in what would normally be GCCInstallPath and put the 64-bit
1551 // libs in a subdirectory named 64. The simple logic we follow is that
1552 // *if* there is a subdirectory of the right name with crtbegin.o in it,
1553 // we use that. If not, and if not a biarch triple alias, we look for
1554 // crtbegin.o without the subdirectory.
1556 StringRef Suff64 = "/64";
1557 // Solaris uses platform-specific suffixes instead of /64.
1558 if (TargetTriple.getOS() == llvm::Triple::Solaris) {
1559 switch (TargetTriple.getArch()) {
1560 case llvm::Triple::x86:
1561 case llvm::Triple::x86_64:
1564 case llvm::Triple::sparc:
1565 case llvm::Triple::sparcv9:
1566 Suff64 = "/sparcv9";
1573 Multilib Alt64 = Multilib()
1575 .includeSuffix(Suff64)
1579 Multilib Alt32 = Multilib()
1581 .includeSuffix("/32")
1585 Multilib Altx32 = Multilib()
1587 .includeSuffix("/x32")
1592 // GCC toolchain for IAMCU doesn't have crtbegin.o, so look for libgcc.a.
1593 FilterNonExistent NonExistent(
1594 Path, TargetTriple.isOSIAMCU() ? "/libgcc.a" : "/crtbegin.o", D.getVFS());
1596 // Determine default multilib from: 32, 64, x32
1597 // Also handle cases such as 64 on 32, 32 on 64, etc.
1598 enum { UNKNOWN, WANT32, WANT64, WANTX32 } Want = UNKNOWN;
1599 const bool IsX32 = TargetTriple.getEnvironment() == llvm::Triple::GNUX32;
1600 if (TargetTriple.isArch32Bit() && !NonExistent(Alt32))
1602 else if (TargetTriple.isArch64Bit() && IsX32 && !NonExistent(Altx32))
1604 else if (TargetTriple.isArch64Bit() && !IsX32 && !NonExistent(Alt64))
1607 if (TargetTriple.isArch32Bit())
1608 Want = NeedsBiarchSuffix ? WANT64 : WANT32;
1610 Want = NeedsBiarchSuffix ? WANT64 : WANTX32;
1612 Want = NeedsBiarchSuffix ? WANT32 : WANT64;
1616 Default.flag("+m32").flag("-m64").flag("-mx32");
1617 else if (Want == WANT64)
1618 Default.flag("-m32").flag("+m64").flag("-mx32");
1619 else if (Want == WANTX32)
1620 Default.flag("-m32").flag("-m64").flag("+mx32");
1624 Result.Multilibs.push_back(Default);
1625 Result.Multilibs.push_back(Alt64);
1626 Result.Multilibs.push_back(Alt32);
1627 Result.Multilibs.push_back(Altx32);
1629 Result.Multilibs.FilterOut(NonExistent);
1631 Multilib::flags_list Flags;
1632 addMultilibFlag(TargetTriple.isArch64Bit() && !IsX32, "m64", Flags);
1633 addMultilibFlag(TargetTriple.isArch32Bit(), "m32", Flags);
1634 addMultilibFlag(TargetTriple.isArch64Bit() && IsX32, "mx32", Flags);
1636 if (!Result.Multilibs.select(Flags, Result.SelectedMultilib))
1639 if (Result.SelectedMultilib == Alt64 || Result.SelectedMultilib == Alt32 ||
1640 Result.SelectedMultilib == Altx32)
1641 Result.BiarchSibling = Default;
1646 /// Generic_GCC - A tool chain using the 'gcc' command to perform
1647 /// all subcommands; this relies on gcc translating the majority of
1648 /// command line options.
1650 /// Less-than for GCCVersion, implementing a Strict Weak Ordering.
1651 bool Generic_GCC::GCCVersion::isOlderThan(int RHSMajor, int RHSMinor,
1653 StringRef RHSPatchSuffix) const {
1654 if (Major != RHSMajor)
1655 return Major < RHSMajor;
1656 if (Minor != RHSMinor)
1657 return Minor < RHSMinor;
1658 if (Patch != RHSPatch) {
1659 // Note that versions without a specified patch sort higher than those with
1666 // Otherwise just sort on the patch itself.
1667 return Patch < RHSPatch;
1669 if (PatchSuffix != RHSPatchSuffix) {
1670 // Sort empty suffixes higher.
1671 if (RHSPatchSuffix.empty())
1673 if (PatchSuffix.empty())
1676 // Provide a lexicographic sort to make this a total ordering.
1677 return PatchSuffix < RHSPatchSuffix;
1680 // The versions are equal.
1684 /// Parse a GCCVersion object out of a string of text.
1686 /// This is the primary means of forming GCCVersion objects.
1688 Generic_GCC::GCCVersion Generic_GCC::GCCVersion::Parse(StringRef VersionText) {
1689 const GCCVersion BadVersion = {VersionText.str(), -1, -1, -1, "", "", ""};
1690 std::pair<StringRef, StringRef> First = VersionText.split('.');
1691 std::pair<StringRef, StringRef> Second = First.second.split('.');
1693 GCCVersion GoodVersion = {VersionText.str(), -1, -1, -1, "", "", ""};
1694 if (First.first.getAsInteger(10, GoodVersion.Major) || GoodVersion.Major < 0)
1696 GoodVersion.MajorStr = First.first.str();
1697 if (First.second.empty())
1699 StringRef MinorStr = Second.first;
1700 if (Second.second.empty()) {
1701 if (size_t EndNumber = MinorStr.find_first_not_of("0123456789")) {
1702 GoodVersion.PatchSuffix = MinorStr.substr(EndNumber);
1703 MinorStr = MinorStr.slice(0, EndNumber);
1706 if (MinorStr.getAsInteger(10, GoodVersion.Minor) || GoodVersion.Minor < 0)
1708 GoodVersion.MinorStr = MinorStr.str();
1710 // First look for a number prefix and parse that if present. Otherwise just
1711 // stash the entire patch string in the suffix, and leave the number
1712 // unspecified. This covers versions strings such as:
1713 // 5 (handled above)
1720 // And retains any patch number it finds.
1721 StringRef PatchText = Second.second;
1722 if (!PatchText.empty()) {
1723 if (size_t EndNumber = PatchText.find_first_not_of("0123456789")) {
1724 // Try to parse the number and any suffix.
1725 if (PatchText.slice(0, EndNumber).getAsInteger(10, GoodVersion.Patch) ||
1726 GoodVersion.Patch < 0)
1728 GoodVersion.PatchSuffix = PatchText.substr(EndNumber);
1735 static llvm::StringRef getGCCToolchainDir(const ArgList &Args,
1736 llvm::StringRef SysRoot) {
1737 const Arg *A = Args.getLastArg(clang::driver::options::OPT_gcc_toolchain);
1739 return A->getValue();
1741 // If we have a SysRoot, ignore GCC_INSTALL_PREFIX.
1742 // GCC_INSTALL_PREFIX specifies the gcc installation for the default
1743 // sysroot and is likely not valid with a different sysroot.
1744 if (!SysRoot.empty())
1747 return GCC_INSTALL_PREFIX;
1750 /// Initialize a GCCInstallationDetector from the driver.
1752 /// This performs all of the autodetection and sets up the various paths.
1753 /// Once constructed, a GCCInstallationDetector is essentially immutable.
1755 /// FIXME: We shouldn't need an explicit TargetTriple parameter here, and
1756 /// should instead pull the target out of the driver. This is currently
1757 /// necessary because the driver doesn't store the final version of the target
1759 void Generic_GCC::GCCInstallationDetector::init(
1760 const llvm::Triple &TargetTriple, const ArgList &Args,
1761 ArrayRef<std::string> ExtraTripleAliases) {
1762 llvm::Triple BiarchVariantTriple = TargetTriple.isArch32Bit()
1763 ? TargetTriple.get64BitArchVariant()
1764 : TargetTriple.get32BitArchVariant();
1765 // The library directories which may contain GCC installations.
1766 SmallVector<StringRef, 4> CandidateLibDirs, CandidateBiarchLibDirs;
1767 // The compatible GCC triples for this particular architecture.
1768 SmallVector<StringRef, 16> CandidateTripleAliases;
1769 SmallVector<StringRef, 16> CandidateBiarchTripleAliases;
1770 CollectLibDirsAndTriples(TargetTriple, BiarchVariantTriple, CandidateLibDirs,
1771 CandidateTripleAliases, CandidateBiarchLibDirs,
1772 CandidateBiarchTripleAliases);
1774 // Compute the set of prefixes for our search.
1775 SmallVector<std::string, 8> Prefixes(D.PrefixDirs.begin(),
1776 D.PrefixDirs.end());
1778 StringRef GCCToolchainDir = getGCCToolchainDir(Args, D.SysRoot);
1779 if (GCCToolchainDir != "") {
1780 if (GCCToolchainDir.back() == '/')
1781 GCCToolchainDir = GCCToolchainDir.drop_back(); // remove the /
1783 Prefixes.push_back(GCCToolchainDir);
1785 // If we have a SysRoot, try that first.
1786 if (!D.SysRoot.empty()) {
1787 Prefixes.push_back(D.SysRoot);
1788 AddDefaultGCCPrefixes(TargetTriple, Prefixes, D.SysRoot);
1791 // Then look for gcc installed alongside clang.
1792 Prefixes.push_back(D.InstalledDir + "/..");
1794 // Next, look for prefix(es) that correspond to distribution-supplied gcc
1796 if (D.SysRoot.empty()) {
1798 AddDefaultGCCPrefixes(TargetTriple, Prefixes, D.SysRoot);
1802 // Try to respect gcc-config on Gentoo. However, do that only
1803 // if --gcc-toolchain is not provided or equal to the Gentoo install
1804 // in /usr. This avoids accidentally enforcing the system GCC version
1805 // when using a custom toolchain.
1806 if (GCCToolchainDir == "" || GCCToolchainDir == D.SysRoot + "/usr") {
1807 SmallVector<StringRef, 16> GentooTestTriples;
1808 // Try to match an exact triple as target triple first.
1809 // e.g. crossdev -S x86_64-gentoo-linux-gnu will install gcc libs for
1810 // x86_64-gentoo-linux-gnu. But "clang -target x86_64-gentoo-linux-gnu"
1811 // may pick the libraries for x86_64-pc-linux-gnu even when exact matching
1812 // triple x86_64-gentoo-linux-gnu is present.
1813 GentooTestTriples.push_back(TargetTriple.str());
1814 // Check rest of triples.
1815 GentooTestTriples.append(ExtraTripleAliases.begin(),
1816 ExtraTripleAliases.end());
1817 GentooTestTriples.append(CandidateTripleAliases.begin(),
1818 CandidateTripleAliases.end());
1819 if (ScanGentooConfigs(TargetTriple, Args, GentooTestTriples,
1820 CandidateBiarchTripleAliases))
1824 // Loop over the various components which exist and select the best GCC
1825 // installation available. GCC installs are ranked by version number.
1826 Version = GCCVersion::Parse("0.0.0");
1827 for (const std::string &Prefix : Prefixes) {
1828 if (!D.getVFS().exists(Prefix))
1830 for (StringRef Suffix : CandidateLibDirs) {
1831 const std::string LibDir = Prefix + Suffix.str();
1832 if (!D.getVFS().exists(LibDir))
1834 // Try to match the exact target triple first.
1835 ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, TargetTriple.str());
1836 // Try rest of possible triples.
1837 for (StringRef Candidate : ExtraTripleAliases) // Try these first.
1838 ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate);
1839 for (StringRef Candidate : CandidateTripleAliases)
1840 ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate);
1842 for (StringRef Suffix : CandidateBiarchLibDirs) {
1843 const std::string LibDir = Prefix + Suffix.str();
1844 if (!D.getVFS().exists(LibDir))
1846 for (StringRef Candidate : CandidateBiarchTripleAliases)
1847 ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate,
1848 /*NeedsBiarchSuffix=*/ true);
1853 void Generic_GCC::GCCInstallationDetector::print(raw_ostream &OS) const {
1854 for (const auto &InstallPath : CandidateGCCInstallPaths)
1855 OS << "Found candidate GCC installation: " << InstallPath << "\n";
1857 if (!GCCInstallPath.empty())
1858 OS << "Selected GCC installation: " << GCCInstallPath << "\n";
1860 for (const auto &Multilib : Multilibs)
1861 OS << "Candidate multilib: " << Multilib << "\n";
1863 if (Multilibs.size() != 0 || !SelectedMultilib.isDefault())
1864 OS << "Selected multilib: " << SelectedMultilib << "\n";
1867 bool Generic_GCC::GCCInstallationDetector::getBiarchSibling(Multilib &M) const {
1868 if (BiarchSibling.hasValue()) {
1869 M = BiarchSibling.getValue();
1875 void Generic_GCC::GCCInstallationDetector::AddDefaultGCCPrefixes(
1876 const llvm::Triple &TargetTriple, SmallVectorImpl<std::string> &Prefixes,
1877 StringRef SysRoot) {
1878 if (TargetTriple.getOS() == llvm::Triple::Solaris) {
1879 // Solaris is a special case.
1880 // The GCC installation is under
1881 // /usr/gcc/<major>.<minor>/lib/gcc/<triple>/<major>.<minor>.<patch>/
1882 // so we need to find those /usr/gcc/*/lib/gcc libdirs and go with
1883 // /usr/gcc/<version> as a prefix.
1885 std::string PrefixDir = SysRoot.str() + "/usr/gcc";
1887 for (llvm::vfs::directory_iterator LI = D.getVFS().dir_begin(PrefixDir, EC),
1889 !EC && LI != LE; LI = LI.increment(EC)) {
1890 StringRef VersionText = llvm::sys::path::filename(LI->path());
1891 GCCVersion CandidateVersion = GCCVersion::Parse(VersionText);
1893 // Filter out obviously bad entries.
1894 if (CandidateVersion.Major == -1 || CandidateVersion.isOlderThan(4, 1, 1))
1897 std::string CandidatePrefix = PrefixDir + "/" + VersionText.str();
1898 std::string CandidateLibPath = CandidatePrefix + "/lib/gcc";
1899 if (!D.getVFS().exists(CandidateLibPath))
1902 Prefixes.push_back(CandidatePrefix);
1907 // Non-Solaris is much simpler - most systems just go with "/usr".
1908 if (SysRoot.empty() && TargetTriple.getOS() == llvm::Triple::Linux) {
1909 // Yet, still look for RHEL devtoolsets.
1910 Prefixes.push_back("/opt/rh/devtoolset-8/root/usr");
1911 Prefixes.push_back("/opt/rh/devtoolset-7/root/usr");
1912 Prefixes.push_back("/opt/rh/devtoolset-6/root/usr");
1913 Prefixes.push_back("/opt/rh/devtoolset-4/root/usr");
1914 Prefixes.push_back("/opt/rh/devtoolset-3/root/usr");
1915 Prefixes.push_back("/opt/rh/devtoolset-2/root/usr");
1917 Prefixes.push_back(SysRoot.str() + "/usr");
1920 /*static*/ void Generic_GCC::GCCInstallationDetector::CollectLibDirsAndTriples(
1921 const llvm::Triple &TargetTriple, const llvm::Triple &BiarchTriple,
1922 SmallVectorImpl<StringRef> &LibDirs,
1923 SmallVectorImpl<StringRef> &TripleAliases,
1924 SmallVectorImpl<StringRef> &BiarchLibDirs,
1925 SmallVectorImpl<StringRef> &BiarchTripleAliases) {
1926 // Declare a bunch of static data sets that we'll select between below. These
1927 // are specifically designed to always refer to string literals to avoid any
1928 // lifetime or initialization issues.
1929 static const char *const AArch64LibDirs[] = {"/lib64", "/lib"};
1930 static const char *const AArch64Triples[] = {
1931 "aarch64-none-linux-gnu", "aarch64-linux-gnu", "aarch64-redhat-linux",
1932 "aarch64-suse-linux", "aarch64-linux-android"};
1933 static const char *const AArch64beLibDirs[] = {"/lib"};
1934 static const char *const AArch64beTriples[] = {"aarch64_be-none-linux-gnu",
1935 "aarch64_be-linux-gnu"};
1937 static const char *const ARMLibDirs[] = {"/lib"};
1938 static const char *const ARMTriples[] = {"arm-linux-gnueabi",
1939 "arm-linux-androideabi"};
1940 static const char *const ARMHFTriples[] = {"arm-linux-gnueabihf",
1941 "armv7hl-redhat-linux-gnueabi",
1942 "armv6hl-suse-linux-gnueabi",
1943 "armv7hl-suse-linux-gnueabi"};
1944 static const char *const ARMebLibDirs[] = {"/lib"};
1945 static const char *const ARMebTriples[] = {"armeb-linux-gnueabi",
1946 "armeb-linux-androideabi"};
1947 static const char *const ARMebHFTriples[] = {
1948 "armeb-linux-gnueabihf", "armebv7hl-redhat-linux-gnueabi"};
1950 static const char *const AVRLibDirs[] = {"/lib"};
1951 static const char *const AVRTriples[] = {"avr"};
1953 static const char *const X86_64LibDirs[] = {"/lib64", "/lib"};
1954 static const char *const X86_64Triples[] = {
1955 "x86_64-linux-gnu", "x86_64-unknown-linux-gnu",
1956 "x86_64-pc-linux-gnu", "x86_64-redhat-linux6E",
1957 "x86_64-redhat-linux", "x86_64-suse-linux",
1958 "x86_64-manbo-linux-gnu", "x86_64-linux-gnu",
1959 "x86_64-slackware-linux", "x86_64-unknown-linux",
1960 "x86_64-amazon-linux", "x86_64-linux-android"};
1961 static const char *const X32LibDirs[] = {"/libx32"};
1962 static const char *const X86LibDirs[] = {"/lib32", "/lib"};
1963 static const char *const X86Triples[] = {
1964 "i686-linux-gnu", "i686-pc-linux-gnu", "i486-linux-gnu",
1965 "i386-linux-gnu", "i386-redhat-linux6E", "i686-redhat-linux",
1966 "i586-redhat-linux", "i386-redhat-linux", "i586-suse-linux",
1967 "i486-slackware-linux", "i686-montavista-linux", "i586-linux-gnu",
1968 "i686-linux-android", "i386-gnu", "i486-gnu",
1969 "i586-gnu", "i686-gnu"};
1971 static const char *const MIPSLibDirs[] = {"/lib"};
1972 static const char *const MIPSTriples[] = {
1973 "mips-linux-gnu", "mips-mti-linux", "mips-mti-linux-gnu",
1974 "mips-img-linux-gnu", "mipsisa32r6-linux-gnu"};
1975 static const char *const MIPSELLibDirs[] = {"/lib"};
1976 static const char *const MIPSELTriples[] = {
1977 "mipsel-linux-gnu", "mips-img-linux-gnu", "mipsisa32r6el-linux-gnu",
1978 "mipsel-linux-android"};
1980 static const char *const MIPS64LibDirs[] = {"/lib64", "/lib"};
1981 static const char *const MIPS64Triples[] = {
1982 "mips64-linux-gnu", "mips-mti-linux-gnu",
1983 "mips-img-linux-gnu", "mips64-linux-gnuabi64",
1984 "mipsisa64r6-linux-gnu", "mipsisa64r6-linux-gnuabi64"};
1985 static const char *const MIPS64ELLibDirs[] = {"/lib64", "/lib"};
1986 static const char *const MIPS64ELTriples[] = {
1987 "mips64el-linux-gnu", "mips-mti-linux-gnu",
1988 "mips-img-linux-gnu", "mips64el-linux-gnuabi64",
1989 "mipsisa64r6el-linux-gnu", "mipsisa64r6el-linux-gnuabi64",
1990 "mips64el-linux-android"};
1992 static const char *const MIPSN32LibDirs[] = {"/lib32"};
1993 static const char *const MIPSN32Triples[] = {"mips64-linux-gnuabin32",
1994 "mipsisa64r6-linux-gnuabin32"};
1995 static const char *const MIPSN32ELLibDirs[] = {"/lib32"};
1996 static const char *const MIPSN32ELTriples[] = {
1997 "mips64el-linux-gnuabin32", "mipsisa64r6el-linux-gnuabin32"};
1999 static const char *const MSP430LibDirs[] = {"/lib"};
2000 static const char *const MSP430Triples[] = {"msp430-elf"};
2002 static const char *const PPCLibDirs[] = {"/lib32", "/lib"};
2003 static const char *const PPCTriples[] = {
2004 "powerpc-linux-gnu", "powerpc-unknown-linux-gnu", "powerpc-linux-gnuspe",
2005 "powerpc-suse-linux", "powerpc-montavista-linuxspe"};
2006 static const char *const PPC64LibDirs[] = {"/lib64", "/lib"};
2007 static const char *const PPC64Triples[] = {
2008 "powerpc64-linux-gnu", "powerpc64-unknown-linux-gnu",
2009 "powerpc64-suse-linux", "ppc64-redhat-linux"};
2010 static const char *const PPC64LELibDirs[] = {"/lib64", "/lib"};
2011 static const char *const PPC64LETriples[] = {
2012 "powerpc64le-linux-gnu", "powerpc64le-unknown-linux-gnu",
2013 "powerpc64le-suse-linux", "ppc64le-redhat-linux"};
2015 static const char *const RISCV32LibDirs[] = {"/lib32", "/lib"};
2016 static const char *const RISCV32Triples[] = {"riscv32-unknown-linux-gnu",
2017 "riscv32-linux-gnu",
2018 "riscv32-unknown-elf"};
2019 static const char *const RISCV64LibDirs[] = {"/lib64", "/lib"};
2020 static const char *const RISCV64Triples[] = {"riscv64-unknown-linux-gnu",
2021 "riscv64-linux-gnu",
2022 "riscv64-unknown-elf"};
2024 static const char *const SPARCv8LibDirs[] = {"/lib32", "/lib"};
2025 static const char *const SPARCv8Triples[] = {"sparc-linux-gnu",
2026 "sparcv8-linux-gnu"};
2027 static const char *const SPARCv9LibDirs[] = {"/lib64", "/lib"};
2028 static const char *const SPARCv9Triples[] = {"sparc64-linux-gnu",
2029 "sparcv9-linux-gnu"};
2031 static const char *const SystemZLibDirs[] = {"/lib64", "/lib"};
2032 static const char *const SystemZTriples[] = {
2033 "s390x-linux-gnu", "s390x-unknown-linux-gnu", "s390x-ibm-linux-gnu",
2034 "s390x-suse-linux", "s390x-redhat-linux"};
2040 if (TargetTriple.getOS() == llvm::Triple::Solaris) {
2041 static const char *const SolarisLibDirs[] = {"/lib"};
2042 static const char *const SolarisSparcV8Triples[] = {
2043 "sparc-sun-solaris2.11", "sparc-sun-solaris2.12"};
2044 static const char *const SolarisSparcV9Triples[] = {
2045 "sparcv9-sun-solaris2.11", "sparcv9-sun-solaris2.12"};
2046 static const char *const SolarisX86Triples[] = {"i386-pc-solaris2.11",
2047 "i386-pc-solaris2.12"};
2048 static const char *const SolarisX86_64Triples[] = {"x86_64-pc-solaris2.11",
2049 "x86_64-pc-solaris2.12"};
2050 LibDirs.append(begin(SolarisLibDirs), end(SolarisLibDirs));
2051 BiarchLibDirs.append(begin(SolarisLibDirs), end(SolarisLibDirs));
2052 switch (TargetTriple.getArch()) {
2053 case llvm::Triple::x86:
2054 TripleAliases.append(begin(SolarisX86Triples), end(SolarisX86Triples));
2055 BiarchTripleAliases.append(begin(SolarisX86_64Triples),
2056 end(SolarisX86_64Triples));
2058 case llvm::Triple::x86_64:
2059 TripleAliases.append(begin(SolarisX86_64Triples),
2060 end(SolarisX86_64Triples));
2061 BiarchTripleAliases.append(begin(SolarisX86Triples),
2062 end(SolarisX86Triples));
2064 case llvm::Triple::sparc:
2065 TripleAliases.append(begin(SolarisSparcV8Triples),
2066 end(SolarisSparcV8Triples));
2067 BiarchTripleAliases.append(begin(SolarisSparcV9Triples),
2068 end(SolarisSparcV9Triples));
2070 case llvm::Triple::sparcv9:
2071 TripleAliases.append(begin(SolarisSparcV9Triples),
2072 end(SolarisSparcV9Triples));
2073 BiarchTripleAliases.append(begin(SolarisSparcV8Triples),
2074 end(SolarisSparcV8Triples));
2082 // Android targets should not use GNU/Linux tools or libraries.
2083 if (TargetTriple.isAndroid()) {
2084 static const char *const AArch64AndroidTriples[] = {
2085 "aarch64-linux-android"};
2086 static const char *const ARMAndroidTriples[] = {"arm-linux-androideabi"};
2087 static const char *const MIPSELAndroidTriples[] = {"mipsel-linux-android"};
2088 static const char *const MIPS64ELAndroidTriples[] = {
2089 "mips64el-linux-android"};
2090 static const char *const X86AndroidTriples[] = {"i686-linux-android"};
2091 static const char *const X86_64AndroidTriples[] = {"x86_64-linux-android"};
2093 switch (TargetTriple.getArch()) {
2094 case llvm::Triple::aarch64:
2095 LibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs));
2096 TripleAliases.append(begin(AArch64AndroidTriples),
2097 end(AArch64AndroidTriples));
2099 case llvm::Triple::arm:
2100 case llvm::Triple::thumb:
2101 LibDirs.append(begin(ARMLibDirs), end(ARMLibDirs));
2102 TripleAliases.append(begin(ARMAndroidTriples), end(ARMAndroidTriples));
2104 case llvm::Triple::mipsel:
2105 LibDirs.append(begin(MIPSELLibDirs), end(MIPSELLibDirs));
2106 TripleAliases.append(begin(MIPSELAndroidTriples),
2107 end(MIPSELAndroidTriples));
2108 BiarchLibDirs.append(begin(MIPS64ELLibDirs), end(MIPS64ELLibDirs));
2109 BiarchTripleAliases.append(begin(MIPS64ELAndroidTriples),
2110 end(MIPS64ELAndroidTriples));
2112 case llvm::Triple::mips64el:
2113 LibDirs.append(begin(MIPS64ELLibDirs), end(MIPS64ELLibDirs));
2114 TripleAliases.append(begin(MIPS64ELAndroidTriples),
2115 end(MIPS64ELAndroidTriples));
2116 BiarchLibDirs.append(begin(MIPSELLibDirs), end(MIPSELLibDirs));
2117 BiarchTripleAliases.append(begin(MIPSELAndroidTriples),
2118 end(MIPSELAndroidTriples));
2120 case llvm::Triple::x86_64:
2121 LibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
2122 TripleAliases.append(begin(X86_64AndroidTriples),
2123 end(X86_64AndroidTriples));
2124 BiarchLibDirs.append(begin(X86LibDirs), end(X86LibDirs));
2125 BiarchTripleAliases.append(begin(X86AndroidTriples),
2126 end(X86AndroidTriples));
2128 case llvm::Triple::x86:
2129 LibDirs.append(begin(X86LibDirs), end(X86LibDirs));
2130 TripleAliases.append(begin(X86AndroidTriples), end(X86AndroidTriples));
2131 BiarchLibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
2132 BiarchTripleAliases.append(begin(X86_64AndroidTriples),
2133 end(X86_64AndroidTriples));
2142 switch (TargetTriple.getArch()) {
2143 case llvm::Triple::aarch64:
2144 LibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs));
2145 TripleAliases.append(begin(AArch64Triples), end(AArch64Triples));
2146 BiarchLibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs));
2147 BiarchTripleAliases.append(begin(AArch64Triples), end(AArch64Triples));
2149 case llvm::Triple::aarch64_be:
2150 LibDirs.append(begin(AArch64beLibDirs), end(AArch64beLibDirs));
2151 TripleAliases.append(begin(AArch64beTriples), end(AArch64beTriples));
2152 BiarchLibDirs.append(begin(AArch64beLibDirs), end(AArch64beLibDirs));
2153 BiarchTripleAliases.append(begin(AArch64beTriples), end(AArch64beTriples));
2155 case llvm::Triple::arm:
2156 case llvm::Triple::thumb:
2157 LibDirs.append(begin(ARMLibDirs), end(ARMLibDirs));
2158 if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) {
2159 TripleAliases.append(begin(ARMHFTriples), end(ARMHFTriples));
2161 TripleAliases.append(begin(ARMTriples), end(ARMTriples));
2164 case llvm::Triple::armeb:
2165 case llvm::Triple::thumbeb:
2166 LibDirs.append(begin(ARMebLibDirs), end(ARMebLibDirs));
2167 if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) {
2168 TripleAliases.append(begin(ARMebHFTriples), end(ARMebHFTriples));
2170 TripleAliases.append(begin(ARMebTriples), end(ARMebTriples));
2173 case llvm::Triple::avr:
2174 LibDirs.append(begin(AVRLibDirs), end(AVRLibDirs));
2175 TripleAliases.append(begin(AVRTriples), end(AVRTriples));
2177 case llvm::Triple::x86_64:
2178 LibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
2179 TripleAliases.append(begin(X86_64Triples), end(X86_64Triples));
2180 // x32 is always available when x86_64 is available, so adding it as
2181 // secondary arch with x86_64 triples
2182 if (TargetTriple.getEnvironment() == llvm::Triple::GNUX32) {
2183 BiarchLibDirs.append(begin(X32LibDirs), end(X32LibDirs));
2184 BiarchTripleAliases.append(begin(X86_64Triples), end(X86_64Triples));
2186 BiarchLibDirs.append(begin(X86LibDirs), end(X86LibDirs));
2187 BiarchTripleAliases.append(begin(X86Triples), end(X86Triples));
2190 case llvm::Triple::x86:
2191 LibDirs.append(begin(X86LibDirs), end(X86LibDirs));
2192 // MCU toolchain is 32 bit only and its triple alias is TargetTriple
2193 // itself, which will be appended below.
2194 if (!TargetTriple.isOSIAMCU()) {
2195 TripleAliases.append(begin(X86Triples), end(X86Triples));
2196 BiarchLibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
2197 BiarchTripleAliases.append(begin(X86_64Triples), end(X86_64Triples));
2200 case llvm::Triple::mips:
2201 LibDirs.append(begin(MIPSLibDirs), end(MIPSLibDirs));
2202 TripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
2203 BiarchLibDirs.append(begin(MIPS64LibDirs), end(MIPS64LibDirs));
2204 BiarchTripleAliases.append(begin(MIPS64Triples), end(MIPS64Triples));
2205 BiarchLibDirs.append(begin(MIPSN32LibDirs), end(MIPSN32LibDirs));
2206 BiarchTripleAliases.append(begin(MIPSN32Triples), end(MIPSN32Triples));
2208 case llvm::Triple::mipsel:
2209 LibDirs.append(begin(MIPSELLibDirs), end(MIPSELLibDirs));
2210 TripleAliases.append(begin(MIPSELTriples), end(MIPSELTriples));
2211 TripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
2212 BiarchLibDirs.append(begin(MIPS64ELLibDirs), end(MIPS64ELLibDirs));
2213 BiarchTripleAliases.append(begin(MIPS64ELTriples), end(MIPS64ELTriples));
2214 BiarchLibDirs.append(begin(MIPSN32ELLibDirs), end(MIPSN32ELLibDirs));
2215 BiarchTripleAliases.append(begin(MIPSN32ELTriples), end(MIPSN32ELTriples));
2217 case llvm::Triple::mips64:
2218 LibDirs.append(begin(MIPS64LibDirs), end(MIPS64LibDirs));
2219 TripleAliases.append(begin(MIPS64Triples), end(MIPS64Triples));
2220 BiarchLibDirs.append(begin(MIPSLibDirs), end(MIPSLibDirs));
2221 BiarchTripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
2222 BiarchLibDirs.append(begin(MIPSN32LibDirs), end(MIPSN32LibDirs));
2223 BiarchTripleAliases.append(begin(MIPSN32Triples), end(MIPSN32Triples));
2225 case llvm::Triple::mips64el:
2226 LibDirs.append(begin(MIPS64ELLibDirs), end(MIPS64ELLibDirs));
2227 TripleAliases.append(begin(MIPS64ELTriples), end(MIPS64ELTriples));
2228 BiarchLibDirs.append(begin(MIPSELLibDirs), end(MIPSELLibDirs));
2229 BiarchTripleAliases.append(begin(MIPSELTriples), end(MIPSELTriples));
2230 BiarchLibDirs.append(begin(MIPSN32ELLibDirs), end(MIPSN32ELLibDirs));
2231 BiarchTripleAliases.append(begin(MIPSN32ELTriples), end(MIPSN32ELTriples));
2232 BiarchTripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
2234 case llvm::Triple::msp430:
2235 LibDirs.append(begin(MSP430LibDirs), end(MSP430LibDirs));
2236 TripleAliases.append(begin(MSP430Triples), end(MSP430Triples));
2238 case llvm::Triple::ppc:
2239 LibDirs.append(begin(PPCLibDirs), end(PPCLibDirs));
2240 TripleAliases.append(begin(PPCTriples), end(PPCTriples));
2241 BiarchLibDirs.append(begin(PPC64LibDirs), end(PPC64LibDirs));
2242 BiarchTripleAliases.append(begin(PPC64Triples), end(PPC64Triples));
2244 case llvm::Triple::ppc64:
2245 LibDirs.append(begin(PPC64LibDirs), end(PPC64LibDirs));
2246 TripleAliases.append(begin(PPC64Triples), end(PPC64Triples));
2247 BiarchLibDirs.append(begin(PPCLibDirs), end(PPCLibDirs));
2248 BiarchTripleAliases.append(begin(PPCTriples), end(PPCTriples));
2250 case llvm::Triple::ppc64le:
2251 LibDirs.append(begin(PPC64LELibDirs), end(PPC64LELibDirs));
2252 TripleAliases.append(begin(PPC64LETriples), end(PPC64LETriples));
2254 case llvm::Triple::riscv32:
2255 LibDirs.append(begin(RISCV32LibDirs), end(RISCV32LibDirs));
2256 TripleAliases.append(begin(RISCV32Triples), end(RISCV32Triples));
2257 BiarchLibDirs.append(begin(RISCV64LibDirs), end(RISCV64LibDirs));
2258 BiarchTripleAliases.append(begin(RISCV64Triples), end(RISCV64Triples));
2260 case llvm::Triple::riscv64:
2261 LibDirs.append(begin(RISCV64LibDirs), end(RISCV64LibDirs));
2262 TripleAliases.append(begin(RISCV64Triples), end(RISCV64Triples));
2263 BiarchLibDirs.append(begin(RISCV32LibDirs), end(RISCV32LibDirs));
2264 BiarchTripleAliases.append(begin(RISCV32Triples), end(RISCV32Triples));
2266 case llvm::Triple::sparc:
2267 case llvm::Triple::sparcel:
2268 LibDirs.append(begin(SPARCv8LibDirs), end(SPARCv8LibDirs));
2269 TripleAliases.append(begin(SPARCv8Triples), end(SPARCv8Triples));
2270 BiarchLibDirs.append(begin(SPARCv9LibDirs), end(SPARCv9LibDirs));
2271 BiarchTripleAliases.append(begin(SPARCv9Triples), end(SPARCv9Triples));
2273 case llvm::Triple::sparcv9:
2274 LibDirs.append(begin(SPARCv9LibDirs), end(SPARCv9LibDirs));
2275 TripleAliases.append(begin(SPARCv9Triples), end(SPARCv9Triples));
2276 BiarchLibDirs.append(begin(SPARCv8LibDirs), end(SPARCv8LibDirs));
2277 BiarchTripleAliases.append(begin(SPARCv8Triples), end(SPARCv8Triples));
2279 case llvm::Triple::systemz:
2280 LibDirs.append(begin(SystemZLibDirs), end(SystemZLibDirs));
2281 TripleAliases.append(begin(SystemZTriples), end(SystemZTriples));
2284 // By default, just rely on the standard lib directories and the original
2289 // Always append the drivers target triple to the end, in case it doesn't
2290 // match any of our aliases.
2291 TripleAliases.push_back(TargetTriple.str());
2293 // Also include the multiarch variant if it's different.
2294 if (TargetTriple.str() != BiarchTriple.str())
2295 BiarchTripleAliases.push_back(BiarchTriple.str());
2298 bool Generic_GCC::GCCInstallationDetector::ScanGCCForMultilibs(
2299 const llvm::Triple &TargetTriple, const ArgList &Args,
2300 StringRef Path, bool NeedsBiarchSuffix) {
2301 llvm::Triple::ArchType TargetArch = TargetTriple.getArch();
2302 DetectedMultilibs Detected;
2304 // Android standalone toolchain could have multilibs for ARM and Thumb.
2305 // Debian mips multilibs behave more like the rest of the biarch ones,
2306 // so handle them there
2307 if (isArmOrThumbArch(TargetArch) && TargetTriple.isAndroid()) {
2308 // It should also work without multilibs in a simplified toolchain.
2309 findAndroidArmMultilibs(D, TargetTriple, Path, Args, Detected);
2310 } else if (TargetTriple.isMIPS()) {
2311 if (!findMIPSMultilibs(D, TargetTriple, Path, Args, Detected))
2313 } else if (TargetTriple.isRISCV()) {
2314 findRISCVMultilibs(D, TargetTriple, Path, Args, Detected);
2315 } else if (isMSP430(TargetArch)) {
2316 findMSP430Multilibs(D, TargetTriple, Path, Args, Detected);
2317 } else if (TargetArch == llvm::Triple::avr) {
2318 // AVR has no multilibs.
2319 } else if (!findBiarchMultilibs(D, TargetTriple, Path, Args,
2320 NeedsBiarchSuffix, Detected)) {
2324 Multilibs = Detected.Multilibs;
2325 SelectedMultilib = Detected.SelectedMultilib;
2326 BiarchSibling = Detected.BiarchSibling;
2331 void Generic_GCC::GCCInstallationDetector::ScanLibDirForGCCTriple(
2332 const llvm::Triple &TargetTriple, const ArgList &Args,
2333 const std::string &LibDir, StringRef CandidateTriple,
2334 bool NeedsBiarchSuffix) {
2335 llvm::Triple::ArchType TargetArch = TargetTriple.getArch();
2336 // Locations relative to the system lib directory where GCC's triple-specific
2337 // directories might reside.
2338 struct GCCLibSuffix {
2339 // Path from system lib directory to GCC triple-specific directory.
2340 std::string LibSuffix;
2341 // Path from GCC triple-specific directory back to system lib directory.
2342 // This is one '..' component per component in LibSuffix.
2343 StringRef ReversePath;
2344 // Whether this library suffix is relevant for the triple.
2347 // This is the normal place.
2348 {"gcc/" + CandidateTriple.str(), "../..", true},
2350 // Debian puts cross-compilers in gcc-cross.
2351 {"gcc-cross/" + CandidateTriple.str(), "../..",
2352 TargetTriple.getOS() != llvm::Triple::Solaris},
2354 // The Freescale PPC SDK has the gcc libraries in
2355 // <sysroot>/usr/lib/<triple>/x.y.z so have a look there as well. Only do
2356 // this on Freescale triples, though, since some systems put a *lot* of
2357 // files in that location, not just GCC installation data.
2358 {CandidateTriple.str(), "..",
2359 TargetTriple.getVendor() == llvm::Triple::Freescale ||
2360 TargetTriple.getVendor() == llvm::Triple::OpenEmbedded},
2362 // Natively multiarch systems sometimes put the GCC triple-specific
2363 // directory within their multiarch lib directory, resulting in the
2364 // triple appearing twice.
2365 {CandidateTriple.str() + "/gcc/" + CandidateTriple.str(), "../../..",
2366 TargetTriple.getOS() != llvm::Triple::Solaris},
2368 // Deal with cases (on Ubuntu) where the system architecture could be i386
2369 // but the GCC target architecture could be (say) i686.
2370 // FIXME: It may be worthwhile to generalize this and look for a second
2372 {"i386-linux-gnu/gcc/" + CandidateTriple.str(), "../../..",
2373 (TargetArch == llvm::Triple::x86 &&
2374 TargetTriple.getOS() != llvm::Triple::Solaris)},
2375 {"i386-gnu/gcc/" + CandidateTriple.str(), "../../..",
2376 (TargetArch == llvm::Triple::x86 &&
2377 TargetTriple.getOS() != llvm::Triple::Solaris)}};
2379 for (auto &Suffix : Suffixes) {
2383 StringRef LibSuffix = Suffix.LibSuffix;
2385 for (llvm::vfs::directory_iterator
2386 LI = D.getVFS().dir_begin(LibDir + "/" + LibSuffix, EC),
2388 !EC && LI != LE; LI = LI.increment(EC)) {
2389 StringRef VersionText = llvm::sys::path::filename(LI->path());
2390 GCCVersion CandidateVersion = GCCVersion::Parse(VersionText);
2391 if (CandidateVersion.Major != -1) // Filter obviously bad entries.
2392 if (!CandidateGCCInstallPaths.insert(LI->path()).second)
2393 continue; // Saw this path before; no need to look at it again.
2394 if (CandidateVersion.isOlderThan(4, 1, 1))
2396 if (CandidateVersion <= Version)
2399 if (!ScanGCCForMultilibs(TargetTriple, Args, LI->path(),
2403 Version = CandidateVersion;
2404 GCCTriple.setTriple(CandidateTriple);
2405 // FIXME: We hack together the directory name here instead of
2406 // using LI to ensure stable path separators across Windows and
2408 GCCInstallPath = (LibDir + "/" + LibSuffix + "/" + VersionText).str();
2409 GCCParentLibPath = (GCCInstallPath + "/../" + Suffix.ReversePath).str();
2415 bool Generic_GCC::GCCInstallationDetector::ScanGentooConfigs(
2416 const llvm::Triple &TargetTriple, const ArgList &Args,
2417 const SmallVectorImpl<StringRef> &CandidateTriples,
2418 const SmallVectorImpl<StringRef> &CandidateBiarchTriples) {
2419 for (StringRef CandidateTriple : CandidateTriples) {
2420 if (ScanGentooGccConfig(TargetTriple, Args, CandidateTriple))
2424 for (StringRef CandidateTriple : CandidateBiarchTriples) {
2425 if (ScanGentooGccConfig(TargetTriple, Args, CandidateTriple, true))
2431 bool Generic_GCC::GCCInstallationDetector::ScanGentooGccConfig(
2432 const llvm::Triple &TargetTriple, const ArgList &Args,
2433 StringRef CandidateTriple, bool NeedsBiarchSuffix) {
2434 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> File =
2435 D.getVFS().getBufferForFile(D.SysRoot + "/etc/env.d/gcc/config-" +
2436 CandidateTriple.str());
2438 SmallVector<StringRef, 2> Lines;
2439 File.get()->getBuffer().split(Lines, "\n");
2440 for (StringRef Line : Lines) {
2442 // CURRENT=triple-version
2443 if (!Line.consume_front("CURRENT="))
2445 // Process the config file pointed to by CURRENT.
2446 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> ConfigFile =
2447 D.getVFS().getBufferForFile(D.SysRoot + "/etc/env.d/gcc/" +
2449 std::pair<StringRef, StringRef> ActiveVersion = Line.rsplit('-');
2450 // List of paths to scan for libraries.
2451 SmallVector<StringRef, 4> GentooScanPaths;
2452 // Scan the Config file to find installed GCC libraries path.
2453 // Typical content of the GCC config file:
2454 // LDPATH="/usr/lib/gcc/x86_64-pc-linux-gnu/4.9.x:/usr/lib/gcc/
2455 // (continued from previous line) x86_64-pc-linux-gnu/4.9.x/32"
2456 // MANPATH="/usr/share/gcc-data/x86_64-pc-linux-gnu/4.9.x/man"
2457 // INFOPATH="/usr/share/gcc-data/x86_64-pc-linux-gnu/4.9.x/info"
2458 // STDCXX_INCDIR="/usr/lib/gcc/x86_64-pc-linux-gnu/4.9.x/include/g++-v4"
2459 // We are looking for the paths listed in LDPATH=... .
2461 SmallVector<StringRef, 2> ConfigLines;
2462 ConfigFile.get()->getBuffer().split(ConfigLines, "\n");
2463 for (StringRef ConfLine : ConfigLines) {
2464 ConfLine = ConfLine.trim();
2465 if (ConfLine.consume_front("LDPATH=")) {
2466 // Drop '"' from front and back if present.
2467 ConfLine.consume_back("\"");
2468 ConfLine.consume_front("\"");
2469 // Get all paths sperated by ':'
2470 ConfLine.split(GentooScanPaths, ':', -1, /*AllowEmpty*/ false);
2474 // Test the path based on the version in /etc/env.d/gcc/config-{tuple}.
2475 std::string basePath = "/usr/lib/gcc/" + ActiveVersion.first.str() + "/"
2476 + ActiveVersion.second.str();
2477 GentooScanPaths.push_back(StringRef(basePath));
2479 // Scan all paths for GCC libraries.
2480 for (const auto &GentooScanPath : GentooScanPaths) {
2481 std::string GentooPath = D.SysRoot + std::string(GentooScanPath);
2482 if (D.getVFS().exists(GentooPath + "/crtbegin.o")) {
2483 if (!ScanGCCForMultilibs(TargetTriple, Args, GentooPath,
2487 Version = GCCVersion::Parse(ActiveVersion.second);
2488 GCCInstallPath = GentooPath;
2489 GCCParentLibPath = GentooPath + std::string("/../../..");
2490 GCCTriple.setTriple(ActiveVersion.first);
2501 Generic_GCC::Generic_GCC(const Driver &D, const llvm::Triple &Triple,
2502 const ArgList &Args)
2503 : ToolChain(D, Triple, Args), GCCInstallation(D),
2504 CudaInstallation(D, Triple, Args) {
2505 getProgramPaths().push_back(getDriver().getInstalledDir());
2506 if (getDriver().getInstalledDir() != getDriver().Dir)
2507 getProgramPaths().push_back(getDriver().Dir);
2510 Generic_GCC::~Generic_GCC() {}
2512 Tool *Generic_GCC::getTool(Action::ActionClass AC) const {
2514 case Action::PreprocessJobClass:
2516 Preprocess.reset(new clang::driver::tools::gcc::Preprocessor(*this));
2517 return Preprocess.get();
2518 case Action::CompileJobClass:
2520 Compile.reset(new tools::gcc::Compiler(*this));
2521 return Compile.get();
2523 return ToolChain::getTool(AC);
2527 Tool *Generic_GCC::buildAssembler() const {
2528 return new tools::gnutools::Assembler(*this);
2531 Tool *Generic_GCC::buildLinker() const { return new tools::gcc::Linker(*this); }
2533 void Generic_GCC::printVerboseInfo(raw_ostream &OS) const {
2534 // Print the information about how we detected the GCC installation.
2535 GCCInstallation.print(OS);
2536 CudaInstallation.print(OS);
2539 bool Generic_GCC::IsUnwindTablesDefault(const ArgList &Args) const {
2540 return getArch() == llvm::Triple::x86_64;
2543 bool Generic_GCC::isPICDefault() const {
2544 switch (getArch()) {
2545 case llvm::Triple::x86_64:
2546 return getTriple().isOSWindows();
2547 case llvm::Triple::ppc64:
2548 // Big endian PPC is PIC by default
2549 return !getTriple().isOSBinFormatMachO() && !getTriple().isMacOSX();
2550 case llvm::Triple::mips64:
2551 case llvm::Triple::mips64el:
2558 bool Generic_GCC::isPIEDefault() const { return false; }
2560 bool Generic_GCC::isPICDefaultForced() const {
2561 return getArch() == llvm::Triple::x86_64 && getTriple().isOSWindows();
2564 bool Generic_GCC::IsIntegratedAssemblerDefault() const {
2565 switch (getTriple().getArch()) {
2566 case llvm::Triple::x86:
2567 case llvm::Triple::x86_64:
2568 case llvm::Triple::aarch64:
2569 case llvm::Triple::aarch64_be:
2570 case llvm::Triple::arm:
2571 case llvm::Triple::armeb:
2572 case llvm::Triple::avr:
2573 case llvm::Triple::bpfel:
2574 case llvm::Triple::bpfeb:
2575 case llvm::Triple::thumb:
2576 case llvm::Triple::thumbeb:
2577 case llvm::Triple::ppc:
2578 case llvm::Triple::ppc64:
2579 case llvm::Triple::ppc64le:
2580 case llvm::Triple::riscv32:
2581 case llvm::Triple::riscv64:
2582 case llvm::Triple::systemz:
2583 case llvm::Triple::mips:
2584 case llvm::Triple::mipsel:
2585 case llvm::Triple::mips64:
2586 case llvm::Triple::mips64el:
2587 case llvm::Triple::msp430:
2589 case llvm::Triple::sparc:
2590 case llvm::Triple::sparcel:
2591 case llvm::Triple::sparcv9:
2592 if (getTriple().isOSFreeBSD() || getTriple().isOSOpenBSD() ||
2593 getTriple().isOSSolaris())
2601 void Generic_GCC::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
2602 ArgStringList &CC1Args) const {
2603 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
2604 DriverArgs.hasArg(options::OPT_nostdincxx))
2607 switch (GetCXXStdlibType(DriverArgs)) {
2608 case ToolChain::CST_Libcxx:
2609 addLibCxxIncludePaths(DriverArgs, CC1Args);
2612 case ToolChain::CST_Libstdcxx:
2613 addLibStdCxxIncludePaths(DriverArgs, CC1Args);
2619 Generic_GCC::addLibCxxIncludePaths(const llvm::opt::ArgList &DriverArgs,
2620 llvm::opt::ArgStringList &CC1Args) const {
2621 // FIXME: The Linux behavior would probaby be a better approach here.
2622 addSystemInclude(DriverArgs, CC1Args,
2623 getDriver().SysRoot + "/usr/include/c++/v1");
2627 Generic_GCC::addLibStdCxxIncludePaths(const llvm::opt::ArgList &DriverArgs,
2628 llvm::opt::ArgStringList &CC1Args) const {
2629 // By default, we don't assume we know where libstdc++ might be installed.
2630 // FIXME: If we have a valid GCCInstallation, use it.
2633 /// Helper to add the variant paths of a libstdc++ installation.
2634 bool Generic_GCC::addLibStdCXXIncludePaths(
2635 Twine Base, Twine Suffix, StringRef GCCTriple, StringRef GCCMultiarchTriple,
2636 StringRef TargetMultiarchTriple, Twine IncludeSuffix,
2637 const ArgList &DriverArgs, ArgStringList &CC1Args) const {
2638 if (!getVFS().exists(Base + Suffix))
2641 addSystemInclude(DriverArgs, CC1Args, Base + Suffix);
2643 // The vanilla GCC layout of libstdc++ headers uses a triple subdirectory. If
2644 // that path exists or we have neither a GCC nor target multiarch triple, use
2645 // this vanilla search path.
2646 if ((GCCMultiarchTriple.empty() && TargetMultiarchTriple.empty()) ||
2647 getVFS().exists(Base + Suffix + "/" + GCCTriple + IncludeSuffix)) {
2648 addSystemInclude(DriverArgs, CC1Args,
2649 Base + Suffix + "/" + GCCTriple + IncludeSuffix);
2651 // Otherwise try to use multiarch naming schemes which have normalized the
2652 // triples and put the triple before the suffix.
2654 // GCC surprisingly uses *both* the GCC triple with a multilib suffix and
2655 // the target triple, so we support that here.
2656 addSystemInclude(DriverArgs, CC1Args,
2657 Base + "/" + GCCMultiarchTriple + Suffix + IncludeSuffix);
2658 addSystemInclude(DriverArgs, CC1Args,
2659 Base + "/" + TargetMultiarchTriple + Suffix);
2662 addSystemInclude(DriverArgs, CC1Args, Base + Suffix + "/backward");
2666 llvm::opt::DerivedArgList *
2667 Generic_GCC::TranslateArgs(const llvm::opt::DerivedArgList &Args, StringRef,
2668 Action::OffloadKind DeviceOffloadKind) const {
2670 // If this tool chain is used for an OpenMP offloading device we have to make
2671 // sure we always generate a shared library regardless of the commands the
2672 // user passed to the host. This is required because the runtime library
2673 // is required to load the device image dynamically at run time.
2674 if (DeviceOffloadKind == Action::OFK_OpenMP) {
2675 DerivedArgList *DAL = new DerivedArgList(Args.getBaseArgs());
2676 const OptTable &Opts = getDriver().getOpts();
2678 // Request the shared library. Given that these options are decided
2679 // implicitly, they do not refer to any base argument.
2680 DAL->AddFlagArg(/*BaseArg=*/nullptr, Opts.getOption(options::OPT_shared));
2681 DAL->AddFlagArg(/*BaseArg=*/nullptr, Opts.getOption(options::OPT_fPIC));
2683 // Filter all the arguments we don't care passing to the offloading
2684 // toolchain as they can mess up with the creation of a shared library.
2685 for (auto *A : Args) {
2686 switch ((options::ID)A->getOption().getID()) {
2690 case options::OPT_shared:
2691 case options::OPT_dynamic:
2692 case options::OPT_static:
2693 case options::OPT_fPIC:
2694 case options::OPT_fno_PIC:
2695 case options::OPT_fpic:
2696 case options::OPT_fno_pic:
2697 case options::OPT_fPIE:
2698 case options::OPT_fno_PIE:
2699 case options::OPT_fpie:
2700 case options::OPT_fno_pie:
2709 void Generic_ELF::anchor() {}
2711 void Generic_ELF::addClangTargetOptions(const ArgList &DriverArgs,
2712 ArgStringList &CC1Args,
2713 Action::OffloadKind) const {
2714 const Generic_GCC::GCCVersion &V = GCCInstallation.getVersion();
2715 bool UseInitArrayDefault =
2716 getTriple().getArch() == llvm::Triple::aarch64 ||
2717 getTriple().getArch() == llvm::Triple::aarch64_be ||
2718 (getTriple().isOSFreeBSD() &&
2719 getTriple().getOSMajorVersion() >= 12) ||
2720 (getTriple().getOS() == llvm::Triple::Linux &&
2721 ((!GCCInstallation.isValid() || !V.isOlderThan(4, 7, 0)) ||
2722 getTriple().isAndroid())) ||
2723 getTriple().getOS() == llvm::Triple::NaCl ||
2724 (getTriple().getVendor() == llvm::Triple::MipsTechnologies &&
2725 !getTriple().hasEnvironment()) ||
2726 getTriple().getOS() == llvm::Triple::Solaris ||
2727 getTriple().getArch() == llvm::Triple::riscv32 ||
2728 getTriple().getArch() == llvm::Triple::riscv64;
2730 if (DriverArgs.hasFlag(options::OPT_fuse_init_array,
2731 options::OPT_fno_use_init_array, UseInitArrayDefault))
2732 CC1Args.push_back("-fuse-init-array");