Gnu.cpp revision 360660 
1//===--- Gnu.cpp - Gnu Tool and ToolChain Implementations -------*- C++ -*-===//
2//
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
6//
7//===----------------------------------------------------------------------===//
8
9#include "Gnu.h"
10#include "Arch/ARM.h"
11#include "Arch/Mips.h"
12#include "Arch/PPC.h"
13#include "Arch/RISCV.h"
14#include "Arch/Sparc.h"
15#include "Arch/SystemZ.h"
16#include "CommonArgs.h"
17#include "Linux.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>
31
32using namespace clang::driver;
33using namespace clang::driver::toolchains;
34using namespace clang;
35using namespace llvm::opt;
36
37using tools::addMultilibFlag;
38
39void tools::GnuTool::anchor() {}
40
41static bool forwardToGCC(const Option &O) {
42  // Don't forward inputs from the original command line.  They are added from
43  // InputInfoList.
44  return O.getKind() != Option::InputClass &&
45         !O.hasFlag(options::DriverOption) && !O.hasFlag(options::LinkerInput);
46}
47
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
50// flag.
51static 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");
59    else
60      Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ);
61  }
62}
63
64void tools::gcc::Common::ConstructJob(Compilation &C, const JobAction &JA,
65                                      const InputInfo &Output,
66                                      const InputInfoList &Inputs,
67                                      const ArgList &Args,
68                                      const char *LinkingOutput) const {
69  const Driver &D = getToolChain().getDriver();
70  ArgStringList CmdArgs;
71
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.
78      A->claim();
79
80      // Don't forward any -g arguments to assembly steps.
81      if (isa<AssembleJobAction>(JA) &&
82          A->getOption().matches(options::OPT_g_Group))
83        continue;
84
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))
88        continue;
89
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)))
95        continue;
96
97      A->render(Args, CmdArgs);
98    }
99  }
100
101  RenderExtraToolArgs(JA, CmdArgs);
102
103  // If using a driver driver, force the arch.
104  if (getToolChain().getTriple().isOSDarwin()) {
105    CmdArgs.push_back("-arch");
106    CmdArgs.push_back(
107        Args.MakeArgString(getToolChain().getDefaultUniversalArchName()));
108  }
109
110  // Try to force gcc to match the tool chain we want, if we recognize
111  // the arch.
112  //
113  // FIXME: The triple class should directly provide the information we want
114  // here.
115  switch (getToolChain().getArch()) {
116  default:
117    break;
118  case llvm::Triple::x86:
119  case llvm::Triple::ppc:
120    CmdArgs.push_back("-m32");
121    break;
122  case llvm::Triple::x86_64:
123  case llvm::Triple::ppc64:
124  case llvm::Triple::ppc64le:
125    CmdArgs.push_back("-m64");
126    break;
127  case llvm::Triple::sparcel:
128    CmdArgs.push_back("-EL");
129    break;
130  }
131
132  if (Output.isFilename()) {
133    CmdArgs.push_back("-o");
134    CmdArgs.push_back(Output.getFilename());
135  } else {
136    assert(Output.isNothing() && "Unexpected output");
137    CmdArgs.push_back("-fsyntax-only");
138  }
139
140  Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
141
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.
147  //
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();
160
161    if (types::canTypeBeUserSpecified(II.getType())) {
162      CmdArgs.push_back("-x");
163      CmdArgs.push_back(types::getTypeName(II.getType()));
164    }
165
166    if (II.isFilename())
167      CmdArgs.push_back(II.getFilename());
168    else {
169      const Arg &A = II.getInputArg();
170
171      // Reverse translate some rewritten options.
172      if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
173        CmdArgs.push_back("-lstdc++");
174        continue;
175      }
176
177      // Don't render as input, we need gcc to do the translations.
178      A.render(Args, CmdArgs);
179    }
180  }
181
182  const std::string &customGCCName = D.getCCCGenericGCCName();
183  const char *GCCName;
184  if (!customGCCName.empty())
185    GCCName = customGCCName.c_str();
186  else if (D.CCCIsCXX()) {
187    GCCName = "g++";
188  } else
189    GCCName = "gcc";
190
191  const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
192  C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
193}
194
195void tools::gcc::Preprocessor::RenderExtraToolArgs(
196    const JobAction &JA, ArgStringList &CmdArgs) const {
197  CmdArgs.push_back("-E");
198}
199
200void tools::gcc::Compiler::RenderExtraToolArgs(const JobAction &JA,
201                                               ArgStringList &CmdArgs) const {
202  const Driver &D = getToolChain().getDriver();
203
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");
211    break;
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");
216    break;
217  case types::TY_PP_Asm:
218    CmdArgs.push_back("-S");
219    break;
220  case types::TY_Nothing:
221    CmdArgs.push_back("-fsyntax-only");
222    break;
223  default:
224    D.Diag(diag::err_drv_invalid_gcc_output_type) << getTypeName(JA.getType());
225  }
226}
227
228void tools::gcc::Linker::RenderExtraToolArgs(const JobAction &JA,
229                                             ArgStringList &CmdArgs) const {
230  // The types are (hopefully) good enough.
231}
232
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.
237static 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:
243    IsBigEndian = true;
244    LLVM_FALLTHROUGH;
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);
250    break;
251  default:
252    break;
253  }
254  return IsBigEndian;
255}
256
257static const char *getLDMOption(const llvm::Triple &T, const ArgList &Args) {
258  switch (T.getArch()) {
259  case llvm::Triple::x86:
260    if (T.isOSIAMCU())
261      return "elf_iamcu";
262    return "elf_i386";
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:
275    return "elf64ppc";
276  case llvm::Triple::ppc64le:
277    return "elf64lppc";
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:
302    return "elf64_s390";
303  case llvm::Triple::x86_64:
304    if (T.getEnvironment() == llvm::Triple::GNUX32)
305      return "elf32_x86_64";
306    return "elf_x86_64";
307  default:
308    return nullptr;
309  }
310}
311
312static 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))
315    return false;
316
317  Arg *A = Args.getLastArg(options::OPT_pie, options::OPT_no_pie,
318                           options::OPT_nopie);
319  if (!A)
320    return ToolChain.isPIEDefault();
321  return A->getOption().matches(options::OPT_pie);
322}
323
324static 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
328  // -no-pie as well.
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;
335  }
336  return HasStaticPIE;
337}
338
339static bool getStatic(const ArgList &Args) {
340  return Args.hasArg(options::OPT_static) &&
341      !Args.hasArg(options::OPT_static_pie);
342}
343
344void tools::gnutools::Linker::ConstructJob(Compilation &C, const JobAction &JA,
345                                           const InputInfo &Output,
346                                           const InputInfoList &Inputs,
347                                           const ArgList &Args,
348                                           const char *LinkingOutput) const {
349  const toolchains::Linux &ToolChain =
350      static_cast<const toolchains::Linux &>(getToolChain());
351  const Driver &D = ToolChain.getDriver();
352
353  const llvm::Triple &Triple = getToolChain().getEffectiveTriple();
354
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);
364
365  ArgStringList CmdArgs;
366
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);
374
375  if (!D.SysRoot.empty())
376    CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
377
378  if (IsPIE)
379    CmdArgs.push_back("-pie");
380
381  if (IsStaticPIE) {
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");
387  }
388
389  if (ToolChain.isNoExecStackDefault()) {
390    CmdArgs.push_back("-z");
391    CmdArgs.push_back("noexecstack");
392  }
393
394  if (Args.hasArg(options::OPT_rdynamic))
395    CmdArgs.push_back("-export-dynamic");
396
397  if (Args.hasArg(options::OPT_s))
398    CmdArgs.push_back("-s");
399
400  if (Triple.isARM() || Triple.isThumb() || Triple.isAArch64()) {
401    bool IsBigEndian = isArmBigEndian(Triple, Args);
402    if (IsBigEndian)
403      arm::appendBE8LinkFlag(Args, CmdArgs, Triple);
404    IsBigEndian = IsBigEndian || Arch == llvm::Triple::aarch64_be;
405    CmdArgs.push_back(IsBigEndian ? "-EB" : "-EL");
406  }
407
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");
414  }
415
416  // Android does not allow shared text relocations. Emit a warning if the
417  // user's code contains any.
418  if (isAndroid)
419      CmdArgs.push_back("--warn-shared-textrel");
420
421  for (const auto &Opt : ToolChain.ExtraOpts)
422    CmdArgs.push_back(Opt.c_str());
423
424  CmdArgs.push_back("--eh-frame-hdr");
425
426  if (const char *LDMOption = getLDMOption(ToolChain.getTriple(), Args)) {
427    CmdArgs.push_back("-m");
428    CmdArgs.push_back(LDMOption);
429  } else {
430    D.Diag(diag::err_target_unknown_triple) << Triple.str();
431    return;
432  }
433
434  if (IsStatic) {
435    if (Arch == llvm::Triple::arm || Arch == llvm::Triple::armeb ||
436        Arch == llvm::Triple::thumb || Arch == llvm::Triple::thumbeb)
437      CmdArgs.push_back("-Bstatic");
438    else
439      CmdArgs.push_back("-static");
440  } else if (Args.hasArg(options::OPT_shared)) {
441    CmdArgs.push_back("-shared");
442  }
443
444  if (!IsStatic) {
445    if (Args.hasArg(options::OPT_rdynamic))
446      CmdArgs.push_back("-export-dynamic");
447
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));
453    }
454  }
455
456  CmdArgs.push_back("-o");
457  CmdArgs.push_back(Output.getFilename());
458
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))
464          crt1 = "gcrt1.o";
465        else if (IsPIE)
466          crt1 = "Scrt1.o";
467        else if (IsStaticPIE)
468          crt1 = "rcrt1.o";
469        else
470          crt1 = "crt1.o";
471      }
472      if (crt1)
473        CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
474
475      CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
476    }
477
478    if (IsIAMCU)
479      CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crt0.o")));
480    else if (HasCRTBeginEndFiles) {
481      std::string P;
482      if (ToolChain.GetRuntimeLibType(Args) == ToolChain::RLT_CompilerRT &&
483          !isAndroid) {
484        std::string crtbegin = ToolChain.getCompilerRT(Args, "crtbegin",
485                                                       ToolChain::FT_Object);
486        if (ToolChain.getVFS().exists(crtbegin))
487          P = crtbegin;
488      }
489      if (P.empty()) {
490        const char *crtbegin;
491        if (IsStatic)
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";
497        else
498          crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbegin.o";
499        P = ToolChain.GetFilePath(crtbegin);
500      }
501      CmdArgs.push_back(Args.MakeArgString(P));
502	  }
503
504    // Add crtfastmath.o if available and fast math is enabled.
505    ToolChain.AddFastMathRuntimeIfAvailable(Args, CmdArgs);
506  }
507
508  Args.AddAllArgs(CmdArgs, options::OPT_L);
509  Args.AddAllArgs(CmdArgs, options::OPT_u);
510
511  ToolChain.AddFilePathLibArgs(Args, CmdArgs);
512
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);
517  }
518
519  if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
520    CmdArgs.push_back("--no-demangle");
521
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);
527
528  if (D.CCCIsCXX() &&
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");
538    }
539    CmdArgs.push_back("-lm");
540  }
541  // Silence warnings when linking C code with a C++ '-stdlib' argument.
542  Args.ClaimAllArgs(options::OPT_stdlib_EQ);
543
544  if (!Args.hasArg(options::OPT_nostdlib)) {
545    if (!Args.hasArg(options::OPT_nodefaultlibs)) {
546      if (IsStatic || IsStaticPIE)
547        CmdArgs.push_back("--start-group");
548
549      if (NeedsSanitizerDeps)
550        linkSanitizerRuntimeDeps(ToolChain, CmdArgs);
551
552      if (NeedsXRayDeps)
553        linkXRayRuntimeDeps(ToolChain, CmdArgs);
554
555      bool WantPthread = Args.hasArg(options::OPT_pthread) ||
556                         Args.hasArg(options::OPT_pthreads);
557
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?
565        WantPthread = true;
566
567      AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
568
569      if (WantPthread && !isAndroid)
570        CmdArgs.push_back("-lpthread");
571
572      if (Args.hasArg(options::OPT_fsplit_stack))
573        CmdArgs.push_back("--wrap=pthread_create");
574
575      if (!Args.hasArg(options::OPT_nolibc))
576        CmdArgs.push_back("-lc");
577
578      // Add IAMCU specific libs, if needed.
579      if (IsIAMCU)
580        CmdArgs.push_back("-lgloss");
581
582      if (IsStatic || IsStaticPIE)
583        CmdArgs.push_back("--end-group");
584      else
585        AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
586
587      // Add IAMCU specific libs (outside the group), if needed.
588      if (IsIAMCU) {
589        CmdArgs.push_back("--as-needed");
590        CmdArgs.push_back("-lsoftfp");
591        CmdArgs.push_back("--no-as-needed");
592      }
593    }
594
595    if (!Args.hasArg(options::OPT_nostartfiles) && !IsIAMCU) {
596      if (HasCRTBeginEndFiles) {
597        std::string P;
598        if (ToolChain.GetRuntimeLibType(Args) == ToolChain::RLT_CompilerRT &&
599            !isAndroid) {
600          std::string crtend = ToolChain.getCompilerRT(Args, "crtend",
601                                                       ToolChain::FT_Object);
602          if (ToolChain.getVFS().exists(crtend))
603            P = crtend;
604        }
605        if (P.empty()) {
606          const char *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";
611          else
612            crtend = isAndroid ? "crtend_android.o" : "crtend.o";
613          P = ToolChain.GetFilePath(crtend);
614        }
615        CmdArgs.push_back(Args.MakeArgString(P));
616      }
617      if (!isAndroid)
618        CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
619    }
620  }
621
622  // Add OpenMP offloading linker script args if required.
623  AddOpenMPLinkerScript(getToolChain(), C, Output, Inputs, Args, CmdArgs, JA);
624
625  // Add HIP offloading linker script args if required.
626  AddHIPLinkerScript(getToolChain(), C, Output, Inputs, Args, CmdArgs, JA,
627                     *this);
628
629  const char *Exec = Args.MakeArgString(ToolChain.GetLinkerPath());
630  C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
631}
632
633void tools::gnutools::Assembler::ConstructJob(Compilation &C,
634                                              const JobAction &JA,
635                                              const InputInfo &Output,
636                                              const InputInfoList &Inputs,
637                                              const ArgList &Args,
638                                              const char *LinkingOutput) const {
639  const auto &D = getToolChain().getDriver();
640
641  claimNoWarnArgs(Args);
642
643  ArgStringList CmdArgs;
644
645  llvm::Reloc::Model RelocationModel;
646  unsigned PICLevel;
647  bool IsPIE;
648  std::tie(RelocationModel, PICLevel, IsPIE) =
649      ParsePICArgs(getToolChain(), Args);
650
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");
654    } else {
655      StringRef Value = A->getValue();
656      if (Value == "none" || Value == "zlib" || Value == "zlib-gnu") {
657        CmdArgs.push_back(
658            Args.MakeArgString("--compress-debug-sections=" + Twine(Value)));
659      } else {
660        D.Diag(diag::err_drv_unsupported_option_argument)
661            << A->getOption().getName() << Value;
662      }
663    }
664  }
665
666  if (getToolChain().isNoExecStackDefault()) {
667      CmdArgs.push_back("--noexecstack");
668  }
669
670  switch (getToolChain().getArch()) {
671  default:
672    break;
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");
677    break;
678  case llvm::Triple::x86_64:
679    if (getToolChain().getTriple().getEnvironment() == llvm::Triple::GNUX32)
680      CmdArgs.push_back("--x32");
681    else
682      CmdArgs.push_back("--64");
683    break;
684  case llvm::Triple::ppc: {
685    CmdArgs.push_back("-a32");
686    CmdArgs.push_back("-mppc");
687    CmdArgs.push_back(
688      ppc::getPPCAsmModeForCPU(getCPUName(Args, getToolChain().getTriple())));
689    break;
690  }
691  case llvm::Triple::ppc64: {
692    CmdArgs.push_back("-a64");
693    CmdArgs.push_back("-mppc64");
694    CmdArgs.push_back(
695      ppc::getPPCAsmModeForCPU(getCPUName(Args, getToolChain().getTriple())));
696    break;
697  }
698  case llvm::Triple::ppc64le: {
699    CmdArgs.push_back("-a64");
700    CmdArgs.push_back("-mppc64");
701    CmdArgs.push_back("-mlittle-endian");
702    CmdArgs.push_back(
703      ppc::getPPCAsmModeForCPU(getCPUName(Args, getToolChain().getTriple())));
704    break;
705  }
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());
715    }
716    break;
717  }
718  case llvm::Triple::sparc:
719  case llvm::Triple::sparcel: {
720    CmdArgs.push_back("-32");
721    std::string CPU = getCPUName(Args, getToolChain().getTriple());
722    CmdArgs.push_back(
723        sparc::getSparcAsmModeForCPU(CPU, getToolChain().getTriple()));
724    AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
725    break;
726  }
727  case llvm::Triple::sparcv9: {
728    CmdArgs.push_back("-64");
729    std::string CPU = getCPUName(Args, getToolChain().getTriple());
730    CmdArgs.push_back(
731        sparc::getSparcAsmModeForCPU(CPU, getToolChain().getTriple()));
732    AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
733    break;
734  }
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");
744      break;
745    case llvm::Triple::ARMSubArch_v8:
746      CmdArgs.push_back("-mfpu=crypto-neon-fp-armv8");
747      break;
748    default:
749      break;
750    }
751
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"));
756      break;
757    case arm::FloatABI::SoftFP:
758      CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=softfp"));
759      break;
760    case arm::FloatABI::Hard:
761      CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=hard"));
762      break;
763    }
764
765    Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
766    normalizeCPUNamesForAssembler(Args, CmdArgs);
767
768    Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ);
769    break;
770  }
771  case llvm::Triple::aarch64:
772  case llvm::Triple::aarch64_be: {
773    CmdArgs.push_back(
774        getToolChain().getArch() == llvm::Triple::aarch64_be ? "-EB" : "-EL");
775    Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
776    normalizeCPUNamesForAssembler(Args, CmdArgs);
777
778    break;
779  }
780  case llvm::Triple::mips:
781  case llvm::Triple::mipsel:
782  case llvm::Triple::mips64:
783  case llvm::Triple::mips64el: {
784    StringRef CPUName;
785    StringRef ABIName;
786    mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
787    ABIName = mips::getGnuCompatibleMipsABIName(ABIName);
788
789    CmdArgs.push_back("-march");
790    CmdArgs.push_back(CPUName.data());
791
792    CmdArgs.push_back("-mabi");
793    CmdArgs.push_back(ABIName.data());
794
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");
799
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");
804
805    if (getToolChain().getTriple().isLittleEndian())
806      CmdArgs.push_back("-EL");
807    else
808      CmdArgs.push_back("-EB");
809
810    if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
811      if (StringRef(A->getValue()) == "2008")
812        CmdArgs.push_back(Args.MakeArgString("-mnan=2008"));
813    }
814
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)) {
818      A->claim();
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");
825
826    // Pass on -mmips16 or -mno-mips16. However, the assembler equivalent of
827    // -mno-mips16 is actually -no-mips16.
828    if (Arg *A =
829            Args.getLastArg(options::OPT_mips16, options::OPT_mno_mips16)) {
830      if (A->getOption().matches(options::OPT_mips16)) {
831        A->claim();
832        A->render(Args, CmdArgs);
833      } else {
834        A->claim();
835        CmdArgs.push_back("-no-mips16");
836      }
837    }
838
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);
843
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"));
849    }
850
851    Args.AddLastArg(CmdArgs, options::OPT_mhard_float,
852                    options::OPT_msoft_float);
853
854    Args.AddLastArg(CmdArgs, options::OPT_mdouble_float,
855                    options::OPT_msingle_float);
856
857    Args.AddLastArg(CmdArgs, options::OPT_modd_spreg,
858                    options::OPT_mno_odd_spreg);
859
860    AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
861    break;
862  }
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));
868    break;
869  }
870  }
871
872  Args.AddAllArgs(CmdArgs, options::OPT_I);
873  Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
874
875  CmdArgs.push_back("-o");
876  CmdArgs.push_back(Output.getFilename());
877
878  for (const auto &II : Inputs)
879    CmdArgs.push_back(II.getFilename());
880
881  const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
882  C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
883
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));
891}
892
893namespace {
894// Filter to remove Multilibs that don't exist as a suffix to Path
895class FilterNonExistent {
896  StringRef Base, File;
897  llvm::vfs::FileSystem &VFS;
898
899public:
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);
904  }
905};
906} // end anonymous namespace
907
908static bool isSoftFloatABI(const ArgList &Args) {
909  Arg *A = Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float,
910                           options::OPT_mfloat_abi_EQ);
911  if (!A)
912    return false;
913
914  return A->getOption().matches(options::OPT_msoft_float) ||
915         (A->getOption().matches(options::OPT_mfloat_abi_EQ) &&
916          A->getValue() == StringRef("soft"));
917}
918
919static bool isArmOrThumbArch(llvm::Triple::ArchType Arch) {
920  return Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb;
921}
922
923static bool isMipsEL(llvm::Triple::ArchType Arch) {
924  return Arch == llvm::Triple::mipsel || Arch == llvm::Triple::mips64el;
925}
926
927static 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);
930}
931
932static 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);
935}
936
937static bool isMSP430(llvm::Triple::ArchType Arch) {
938  return Arch == llvm::Triple::msp430;
939}
940
941static Multilib makeMultilib(StringRef commonSuffix) {
942  return Multilib(commonSuffix, commonSuffix, commonSuffix);
943}
944
945static bool findMipsCsMultilibs(const Multilib::flags_list &Flags,
946                                FilterNonExistent &NonExistent,
947                                DetectedMultilibs &Result) {
948  // Check for Code Sourcery toolchain multilibs
949  MultilibSet CSMipsMultilibs;
950  {
951    auto MArchMips16 = makeMultilib("/mips16").flag("+m32").flag("+mips16");
952
953    auto MArchMicroMips =
954        makeMultilib("/micromips").flag("+m32").flag("+mmicromips");
955
956    auto MArchDefault = makeMultilib("").flag("-mips16").flag("-mmicromips");
957
958    auto UCLibc = makeMultilib("/uclibc").flag("+muclibc");
959
960    auto SoftFloat = makeMultilib("/soft-float").flag("+msoft-float");
961
962    auto Nan2008 = makeMultilib("/nan2008").flag("+mnan=2008");
963
964    auto DefaultFloat =
965        makeMultilib("").flag("-msoft-float").flag("-mnan=2008");
966
967    auto BigEndian = makeMultilib("").flag("+EB").flag("-EL");
968
969    auto LittleEndian = makeMultilib("/el").flag("+EL").flag("-EB");
970
971    // Note that this one's osSuffix is ""
972    auto MAbi64 = makeMultilib("")
973                      .gccSuffix("/64")
974                      .includeSuffix("/64")
975                      .flag("+mabi=n64")
976                      .flag("-mabi=n32")
977                      .flag("-m32");
978
979    CSMipsMultilibs =
980        MultilibSet()
981            .Either(MArchMips16, MArchMicroMips, MArchDefault)
982            .Maybe(UCLibc)
983            .Either(SoftFloat, Nan2008, DefaultFloat)
984            .FilterOut("/micromips/nan2008")
985            .FilterOut("/mips16/nan2008")
986            .Either(BigEndian, LittleEndian)
987            .Maybe(MAbi64)
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"))
994                Dirs.push_back(
995                    "/../../../../mips-linux-gnu/libc/uclibc/usr/include");
996              else
997                Dirs.push_back("/../../../../mips-linux-gnu/libc/usr/include");
998              return Dirs;
999            });
1000  }
1001
1002  MultilibSet DebianMipsMultilibs;
1003  {
1004    Multilib MAbiN32 =
1005        Multilib().gccSuffix("/n32").includeSuffix("/n32").flag("+mabi=n32");
1006
1007    Multilib M64 = Multilib()
1008                       .gccSuffix("/64")
1009                       .includeSuffix("/64")
1010                       .flag("+m64")
1011                       .flag("-m32")
1012                       .flag("-mabi=n32");
1013
1014    Multilib M32 = Multilib().flag("-m64").flag("+m32").flag("-mabi=n32");
1015
1016    DebianMipsMultilibs =
1017        MultilibSet().Either(M32, M64, MAbiN32).FilterOut(NonExistent);
1018  }
1019
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;
1030      return true;
1031    }
1032  }
1033  return false;
1034}
1035
1036static bool findMipsAndroidMultilibs(llvm::vfs::FileSystem &VFS, StringRef Path,
1037                                     const Multilib::flags_list &Flags,
1038                                     FilterNonExistent &NonExistent,
1039                                     DetectedMultilibs &Result) {
1040
1041  MultilibSet AndroidMipsMultilibs =
1042      MultilibSet()
1043          .Maybe(Multilib("/mips-r2").flag("+march=mips32r2"))
1044          .Maybe(Multilib("/mips-r6").flag("+march=mips32r6"))
1045          .FilterOut(NonExistent);
1046
1047  MultilibSet AndroidMipselMultilibs =
1048      MultilibSet()
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);
1053
1054  MultilibSet AndroidMips64elMultilibs =
1055      MultilibSet()
1056          .Either(
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);
1062
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;
1070    return true;
1071  }
1072  return false;
1073}
1074
1075static bool findMipsMuslMultilibs(const Multilib::flags_list &Flags,
1076                                  FilterNonExistent &NonExistent,
1077                                  DetectedMultilibs &Result) {
1078  // Musl toolchain multilibs
1079  MultilibSet MuslMipsMultilibs;
1080  {
1081    auto MArchMipsR2 = makeMultilib("")
1082                           .osSuffix("/mips-r2-hard-musl")
1083                           .flag("+EB")
1084                           .flag("-EL")
1085                           .flag("+march=mips32r2");
1086
1087    auto MArchMipselR2 = makeMultilib("/mipsel-r2-hard-musl")
1088                             .flag("-EB")
1089                             .flag("+EL")
1090                             .flag("+march=mips32r2");
1091
1092    MuslMipsMultilibs = MultilibSet().Either(MArchMipsR2, MArchMipselR2);
1093
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"});
1098    });
1099  }
1100  if (MuslMipsMultilibs.select(Flags, Result.SelectedMultilib)) {
1101    Result.Multilibs = MuslMipsMultilibs;
1102    return true;
1103  }
1104  return false;
1105}
1106
1107static bool findMipsMtiMultilibs(const Multilib::flags_list &Flags,
1108                                 FilterNonExistent &NonExistent,
1109                                 DetectedMultilibs &Result) {
1110  // CodeScape MTI toolchain v1.2 and early.
1111  MultilibSet MtiMipsMultilibsV1;
1112  {
1113    auto MArchMips32 = makeMultilib("/mips32")
1114                           .flag("+m32")
1115                           .flag("-m64")
1116                           .flag("-mmicromips")
1117                           .flag("+march=mips32");
1118
1119    auto MArchMicroMips = makeMultilib("/micromips")
1120                              .flag("+m32")
1121                              .flag("-m64")
1122                              .flag("+mmicromips");
1123
1124    auto MArchMips64r2 = makeMultilib("/mips64r2")
1125                             .flag("-m32")
1126                             .flag("+m64")
1127                             .flag("+march=mips64r2");
1128
1129    auto MArchMips64 = makeMultilib("/mips64").flag("-m32").flag("+m64").flag(
1130        "-march=mips64r2");
1131
1132    auto MArchDefault = makeMultilib("")
1133                            .flag("+m32")
1134                            .flag("-m64")
1135                            .flag("-mmicromips")
1136                            .flag("+march=mips32r2");
1137
1138    auto Mips16 = makeMultilib("/mips16").flag("+mips16");
1139
1140    auto UCLibc = makeMultilib("/uclibc").flag("+muclibc");
1141
1142    auto MAbi64 =
1143        makeMultilib("/64").flag("+mabi=n64").flag("-mabi=n32").flag("-m32");
1144
1145    auto BigEndian = makeMultilib("").flag("+EB").flag("-EL");
1146
1147    auto LittleEndian = makeMultilib("/el").flag("+EL").flag("-EB");
1148
1149    auto SoftFloat = makeMultilib("/sof").flag("+msoft-float");
1150
1151    auto Nan2008 = makeMultilib("/nan2008").flag("+mnan=2008");
1152
1153    MtiMipsMultilibsV1 =
1154        MultilibSet()
1155            .Either(MArchMips32, MArchMicroMips, MArchMips64r2, MArchMips64,
1156                    MArchDefault)
1157            .Maybe(UCLibc)
1158            .Maybe(Mips16)
1159            .FilterOut("/mips64/mips16")
1160            .FilterOut("/mips64r2/mips16")
1161            .FilterOut("/micromips/mips16")
1162            .Maybe(MAbi64)
1163            .FilterOut("/micromips/64")
1164            .FilterOut("/mips32/64")
1165            .FilterOut("^/64")
1166            .FilterOut("/mips16/64")
1167            .Either(BigEndian, LittleEndian)
1168            .Maybe(SoftFloat)
1169            .Maybe(Nan2008)
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");
1176              else
1177                Dirs.push_back("/../../../../sysroot/usr/include");
1178              return Dirs;
1179            });
1180  }
1181
1182  // CodeScape IMG toolchain starting from v1.3.
1183  MultilibSet MtiMipsMultilibsV2;
1184  {
1185    auto BeHard = makeMultilib("/mips-r2-hard")
1186                      .flag("+EB")
1187                      .flag("-msoft-float")
1188                      .flag("-mnan=2008")
1189                      .flag("-muclibc");
1190    auto BeSoft = makeMultilib("/mips-r2-soft")
1191                      .flag("+EB")
1192                      .flag("+msoft-float")
1193                      .flag("-mnan=2008");
1194    auto ElHard = makeMultilib("/mipsel-r2-hard")
1195                      .flag("+EL")
1196                      .flag("-msoft-float")
1197                      .flag("-mnan=2008")
1198                      .flag("-muclibc");
1199    auto ElSoft = makeMultilib("/mipsel-r2-soft")
1200                      .flag("+EL")
1201                      .flag("+msoft-float")
1202                      .flag("-mnan=2008")
1203                      .flag("-mmicromips");
1204    auto BeHardNan = makeMultilib("/mips-r2-hard-nan2008")
1205                         .flag("+EB")
1206                         .flag("-msoft-float")
1207                         .flag("+mnan=2008")
1208                         .flag("-muclibc");
1209    auto ElHardNan = makeMultilib("/mipsel-r2-hard-nan2008")
1210                         .flag("+EL")
1211                         .flag("-msoft-float")
1212                         .flag("+mnan=2008")
1213                         .flag("-muclibc")
1214                         .flag("-mmicromips");
1215    auto BeHardNanUclibc = makeMultilib("/mips-r2-hard-nan2008-uclibc")
1216                               .flag("+EB")
1217                               .flag("-msoft-float")
1218                               .flag("+mnan=2008")
1219                               .flag("+muclibc");
1220    auto ElHardNanUclibc = makeMultilib("/mipsel-r2-hard-nan2008-uclibc")
1221                               .flag("+EL")
1222                               .flag("-msoft-float")
1223                               .flag("+mnan=2008")
1224                               .flag("+muclibc");
1225    auto BeHardUclibc = makeMultilib("/mips-r2-hard-uclibc")
1226                            .flag("+EB")
1227                            .flag("-msoft-float")
1228                            .flag("-mnan=2008")
1229                            .flag("+muclibc");
1230    auto ElHardUclibc = makeMultilib("/mipsel-r2-hard-uclibc")
1231                            .flag("+EL")
1232                            .flag("-msoft-float")
1233                            .flag("-mnan=2008")
1234                            .flag("+muclibc");
1235    auto ElMicroHardNan = makeMultilib("/micromipsel-r2-hard-nan2008")
1236                              .flag("+EL")
1237                              .flag("-msoft-float")
1238                              .flag("+mnan=2008")
1239                              .flag("+mmicromips");
1240    auto ElMicroSoft = makeMultilib("/micromipsel-r2-soft")
1241                           .flag("+EL")
1242                           .flag("+msoft-float")
1243                           .flag("-mnan=2008")
1244                           .flag("+mmicromips");
1245
1246    auto O32 =
1247        makeMultilib("/lib").osSuffix("").flag("-mabi=n32").flag("-mabi=n64");
1248    auto N32 =
1249        makeMultilib("/lib32").osSuffix("").flag("+mabi=n32").flag("-mabi=n64");
1250    auto N64 =
1251        makeMultilib("/lib64").osSuffix("").flag("-mabi=n32").flag("+mabi=n64");
1252
1253    MtiMipsMultilibsV2 =
1254        MultilibSet()
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" +
1262                                               M.includeSuffix() +
1263                                               "/../usr/include"});
1264            })
1265            .setFilePathsCallback([](const Multilib &M) {
1266              return std::vector<std::string>(
1267                  {"/../../../../mips-mti-linux-gnu/lib" + M.gccSuffix()});
1268            });
1269  }
1270  for (auto Candidate : {&MtiMipsMultilibsV1, &MtiMipsMultilibsV2}) {
1271    if (Candidate->select(Flags, Result.SelectedMultilib)) {
1272      Result.Multilibs = *Candidate;
1273      return true;
1274    }
1275  }
1276  return false;
1277}
1278
1279static bool findMipsImgMultilibs(const Multilib::flags_list &Flags,
1280                                 FilterNonExistent &NonExistent,
1281                                 DetectedMultilibs &Result) {
1282  // CodeScape IMG toolchain v1.2 and early.
1283  MultilibSet ImgMultilibsV1;
1284  {
1285    auto Mips64r6 = makeMultilib("/mips64r6").flag("+m64").flag("-m32");
1286
1287    auto LittleEndian = makeMultilib("/el").flag("+EL").flag("-EB");
1288
1289    auto MAbi64 =
1290        makeMultilib("/64").flag("+mabi=n64").flag("-mabi=n32").flag("-m32");
1291
1292    ImgMultilibsV1 =
1293        MultilibSet()
1294            .Maybe(Mips64r6)
1295            .Maybe(MAbi64)
1296            .Maybe(LittleEndian)
1297            .FilterOut(NonExistent)
1298            .setIncludeDirsCallback([](const Multilib &M) {
1299              return std::vector<std::string>(
1300                  {"/include", "/../../../../sysroot/usr/include"});
1301            });
1302  }
1303
1304  // CodeScape IMG toolchain starting from v1.3.
1305  MultilibSet ImgMultilibsV2;
1306  {
1307    auto BeHard = makeMultilib("/mips-r6-hard")
1308                      .flag("+EB")
1309                      .flag("-msoft-float")
1310                      .flag("-mmicromips");
1311    auto BeSoft = makeMultilib("/mips-r6-soft")
1312                      .flag("+EB")
1313                      .flag("+msoft-float")
1314                      .flag("-mmicromips");
1315    auto ElHard = makeMultilib("/mipsel-r6-hard")
1316                      .flag("+EL")
1317                      .flag("-msoft-float")
1318                      .flag("-mmicromips");
1319    auto ElSoft = makeMultilib("/mipsel-r6-soft")
1320                      .flag("+EL")
1321                      .flag("+msoft-float")
1322                      .flag("-mmicromips");
1323    auto BeMicroHard = makeMultilib("/micromips-r6-hard")
1324                           .flag("+EB")
1325                           .flag("-msoft-float")
1326                           .flag("+mmicromips");
1327    auto BeMicroSoft = makeMultilib("/micromips-r6-soft")
1328                           .flag("+EB")
1329                           .flag("+msoft-float")
1330                           .flag("+mmicromips");
1331    auto ElMicroHard = makeMultilib("/micromipsel-r6-hard")
1332                           .flag("+EL")
1333                           .flag("-msoft-float")
1334                           .flag("+mmicromips");
1335    auto ElMicroSoft = makeMultilib("/micromipsel-r6-soft")
1336                           .flag("+EL")
1337                           .flag("+msoft-float")
1338                           .flag("+mmicromips");
1339
1340    auto O32 =
1341        makeMultilib("/lib").osSuffix("").flag("-mabi=n32").flag("-mabi=n64");
1342    auto N32 =
1343        makeMultilib("/lib32").osSuffix("").flag("+mabi=n32").flag("-mabi=n64");
1344    auto N64 =
1345        makeMultilib("/lib64").osSuffix("").flag("-mabi=n32").flag("+mabi=n64");
1346
1347    ImgMultilibsV2 =
1348        MultilibSet()
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" +
1355                                               M.includeSuffix() +
1356                                               "/../usr/include"});
1357            })
1358            .setFilePathsCallback([](const Multilib &M) {
1359              return std::vector<std::string>(
1360                  {"/../../../../mips-img-linux-gnu/lib" + M.gccSuffix()});
1361            });
1362  }
1363  for (auto Candidate : {&ImgMultilibsV1, &ImgMultilibsV2}) {
1364    if (Candidate->select(Flags, Result.SelectedMultilib)) {
1365      Result.Multilibs = *Candidate;
1366      return true;
1367    }
1368  }
1369  return false;
1370}
1371
1372bool 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());
1377
1378  StringRef CPUName;
1379  StringRef ABIName;
1380  tools::mips::getMipsCPUAndABI(Args, TargetTriple, CPUName, ABIName);
1381
1382  llvm::Triple::ArchType TargetArch = TargetTriple.getArch();
1383
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",
1402                  Flags);
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);
1409
1410  if (TargetTriple.isAndroid())
1411    return findMipsAndroidMultilibs(D.getVFS(), Path, Flags, NonExistent,
1412                                    Result);
1413
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);
1418
1419  if (TargetTriple.getVendor() == llvm::Triple::MipsTechnologies &&
1420      TargetTriple.getOS() == llvm::Triple::Linux &&
1421      TargetTriple.isGNUEnvironment())
1422    return findMipsMtiMultilibs(Flags, NonExistent, Result);
1423
1424  if (TargetTriple.getVendor() == llvm::Triple::ImaginationTechnologies &&
1425      TargetTriple.getOS() == llvm::Triple::Linux &&
1426      TargetTriple.isGNUEnvironment())
1427    return findMipsImgMultilibs(Flags, NonExistent, Result);
1428
1429  if (findMipsCsMultilibs(Flags, NonExistent, Result))
1430    return true;
1431
1432  // Fallback to the regular toolchain-tree structure.
1433  Multilib Default;
1434  Result.Multilibs.push_back(Default);
1435  Result.Multilibs.FilterOut(NonExistent);
1436
1437  if (Result.Multilibs.select(Flags, Result.SelectedMultilib)) {
1438    Result.BiarchSibling = Multilib();
1439    return true;
1440  }
1441
1442  return false;
1443}
1444
1445static 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")
1453                               .flag("-mthumb");
1454  Multilib ThumbMultilib = makeMultilib("/thumb")
1455                               .flag("-march=armv7-a")
1456                               .flag("+mthumb");
1457  Multilib ArmV7ThumbMultilib = makeMultilib("/armv7-a/thumb")
1458                               .flag("+march=armv7-a")
1459                               .flag("+mthumb");
1460  Multilib DefaultMultilib = makeMultilib("")
1461                               .flag("-march=armv7-a")
1462                               .flag("-mthumb");
1463  MultilibSet AndroidArmMultilibs =
1464      MultilibSet()
1465          .Either(ThumbMultilib, ArmV7Multilib,
1466                  ArmV7ThumbMultilib, DefaultMultilib)
1467          .FilterOut(NonExistent);
1468
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);
1482
1483  if (AndroidArmMultilibs.select(Flags, Result.SelectedMultilib))
1484    Result.Multilibs = AndroidArmMultilibs;
1485}
1486
1487static 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");
1496
1497  Result.Multilibs.push_back(MSP430Multilib);
1498  Result.Multilibs.FilterOut(NonExistent);
1499
1500  Multilib::flags_list Flags;
1501  if (Result.Multilibs.select(Flags, Result.SelectedMultilib))
1502    return true;
1503
1504  return false;
1505}
1506
1507static void findRISCVMultilibs(const Driver &D,
1508                               const llvm::Triple &TargetTriple, StringRef Path,
1509                               const ArgList &Args, DetectedMultilibs &Result) {
1510
1511  FilterNonExistent NonExistent(Path, "/crtbegin.o", D.getVFS());
1512  Multilib Ilp32 = makeMultilib("lib32/ilp32").flag("+m32").flag("+mabi=ilp32");
1513  Multilib Ilp32f =
1514      makeMultilib("lib32/ilp32f").flag("+m32").flag("+mabi=ilp32f");
1515  Multilib Ilp32d =
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 =
1521      MultilibSet()
1522          .Either({Ilp32, Ilp32f, Ilp32d, Lp64, Lp64f, Lp64d})
1523          .FilterOut(NonExistent);
1524
1525  Multilib::flags_list Flags;
1526  bool IsRV64 = TargetTriple.getArch() == llvm::Triple::riscv64;
1527  StringRef ABIName = tools::riscv::getRISCVABI(Args, TargetTriple);
1528
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);
1537
1538  if (RISCVMultilibs.select(Flags, Result.SelectedMultilib))
1539    Result.Multilibs = RISCVMultilibs;
1540}
1541
1542static bool findBiarchMultilibs(const Driver &D,
1543                                const llvm::Triple &TargetTriple,
1544                                StringRef Path, const ArgList &Args,
1545                                bool NeedsBiarchSuffix,
1546                                DetectedMultilibs &Result) {
1547  Multilib Default;
1548
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.
1555
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:
1562      Suff64 = "/amd64";
1563      break;
1564    case llvm::Triple::sparc:
1565    case llvm::Triple::sparcv9:
1566      Suff64 = "/sparcv9";
1567      break;
1568    default:
1569      break;
1570    }
1571  }
1572
1573  Multilib Alt64 = Multilib()
1574                       .gccSuffix(Suff64)
1575                       .includeSuffix(Suff64)
1576                       .flag("-m32")
1577                       .flag("+m64")
1578                       .flag("-mx32");
1579  Multilib Alt32 = Multilib()
1580                       .gccSuffix("/32")
1581                       .includeSuffix("/32")
1582                       .flag("+m32")
1583                       .flag("-m64")
1584                       .flag("-mx32");
1585  Multilib Altx32 = Multilib()
1586                        .gccSuffix("/x32")
1587                        .includeSuffix("/x32")
1588                        .flag("-m32")
1589                        .flag("-m64")
1590                        .flag("+mx32");
1591
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());
1595
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))
1601    Want = WANT64;
1602  else if (TargetTriple.isArch64Bit() && IsX32 && !NonExistent(Altx32))
1603    Want = WANT64;
1604  else if (TargetTriple.isArch64Bit() && !IsX32 && !NonExistent(Alt64))
1605    Want = WANT32;
1606  else {
1607    if (TargetTriple.isArch32Bit())
1608      Want = NeedsBiarchSuffix ? WANT64 : WANT32;
1609    else if (IsX32)
1610      Want = NeedsBiarchSuffix ? WANT64 : WANTX32;
1611    else
1612      Want = NeedsBiarchSuffix ? WANT32 : WANT64;
1613  }
1614
1615  if (Want == WANT32)
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");
1621  else
1622    return false;
1623
1624  Result.Multilibs.push_back(Default);
1625  Result.Multilibs.push_back(Alt64);
1626  Result.Multilibs.push_back(Alt32);
1627  Result.Multilibs.push_back(Altx32);
1628
1629  Result.Multilibs.FilterOut(NonExistent);
1630
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);
1635
1636  if (!Result.Multilibs.select(Flags, Result.SelectedMultilib))
1637    return false;
1638
1639  if (Result.SelectedMultilib == Alt64 || Result.SelectedMultilib == Alt32 ||
1640      Result.SelectedMultilib == Altx32)
1641    Result.BiarchSibling = Default;
1642
1643  return true;
1644}
1645
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.
1649
1650/// Less-than for GCCVersion, implementing a Strict Weak Ordering.
1651bool Generic_GCC::GCCVersion::isOlderThan(int RHSMajor, int RHSMinor,
1652                                          int RHSPatch,
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
1660    // a patch.
1661    if (RHSPatch == -1)
1662      return true;
1663    if (Patch == -1)
1664      return false;
1665
1666    // Otherwise just sort on the patch itself.
1667    return Patch < RHSPatch;
1668  }
1669  if (PatchSuffix != RHSPatchSuffix) {
1670    // Sort empty suffixes higher.
1671    if (RHSPatchSuffix.empty())
1672      return true;
1673    if (PatchSuffix.empty())
1674      return false;
1675
1676    // Provide a lexicographic sort to make this a total ordering.
1677    return PatchSuffix < RHSPatchSuffix;
1678  }
1679
1680  // The versions are equal.
1681  return false;
1682}
1683
1684/// Parse a GCCVersion object out of a string of text.
1685///
1686/// This is the primary means of forming GCCVersion objects.
1687/*static*/
1688Generic_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('.');
1692
1693  GCCVersion GoodVersion = {VersionText.str(), -1, -1, -1, "", "", ""};
1694  if (First.first.getAsInteger(10, GoodVersion.Major) || GoodVersion.Major < 0)
1695    return BadVersion;
1696  GoodVersion.MajorStr = First.first.str();
1697  if (First.second.empty())
1698    return GoodVersion;
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);
1704    }
1705  }
1706  if (MinorStr.getAsInteger(10, GoodVersion.Minor) || GoodVersion.Minor < 0)
1707    return BadVersion;
1708  GoodVersion.MinorStr = MinorStr.str();
1709
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)
1714  //   4.4
1715  //   4.4-patched
1716  //   4.4.0
1717  //   4.4.x
1718  //   4.4.2-rc4
1719  //   4.4.x-patched
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)
1727        return BadVersion;
1728      GoodVersion.PatchSuffix = PatchText.substr(EndNumber);
1729    }
1730  }
1731
1732  return GoodVersion;
1733}
1734
1735static llvm::StringRef getGCCToolchainDir(const ArgList &Args,
1736                                          llvm::StringRef SysRoot) {
1737  const Arg *A = Args.getLastArg(clang::driver::options::OPT_gcc_toolchain);
1738  if (A)
1739    return A->getValue();
1740
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())
1745    return "";
1746
1747  return GCC_INSTALL_PREFIX;
1748}
1749
1750/// Initialize a GCCInstallationDetector from the driver.
1751///
1752/// This performs all of the autodetection and sets up the various paths.
1753/// Once constructed, a GCCInstallationDetector is essentially immutable.
1754///
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
1758/// triple.
1759void 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);
1773
1774  // Compute the set of prefixes for our search.
1775  SmallVector<std::string, 8> Prefixes(D.PrefixDirs.begin(),
1776                                       D.PrefixDirs.end());
1777
1778  StringRef GCCToolchainDir = getGCCToolchainDir(Args, D.SysRoot);
1779  if (GCCToolchainDir != "") {
1780    if (GCCToolchainDir.back() == '/')
1781      GCCToolchainDir = GCCToolchainDir.drop_back(); // remove the /
1782
1783    Prefixes.push_back(GCCToolchainDir);
1784  } else {
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);
1789    }
1790
1791    // Then look for gcc installed alongside clang.
1792    Prefixes.push_back(D.InstalledDir + "/..");
1793
1794    // Next, look for prefix(es) that correspond to distribution-supplied gcc
1795    // installations.
1796    if (D.SysRoot.empty()) {
1797      // Typically /usr.
1798      AddDefaultGCCPrefixes(TargetTriple, Prefixes, D.SysRoot);
1799    }
1800  }
1801
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))
1821      return;
1822  }
1823
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))
1829      continue;
1830    for (StringRef Suffix : CandidateLibDirs) {
1831      const std::string LibDir = Prefix + Suffix.str();
1832      if (!D.getVFS().exists(LibDir))
1833        continue;
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);
1841    }
1842    for (StringRef Suffix : CandidateBiarchLibDirs) {
1843      const std::string LibDir = Prefix + Suffix.str();
1844      if (!D.getVFS().exists(LibDir))
1845        continue;
1846      for (StringRef Candidate : CandidateBiarchTripleAliases)
1847        ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate,
1848                               /*NeedsBiarchSuffix=*/ true);
1849    }
1850  }
1851}
1852
1853void Generic_GCC::GCCInstallationDetector::print(raw_ostream &OS) const {
1854  for (const auto &InstallPath : CandidateGCCInstallPaths)
1855    OS << "Found candidate GCC installation: " << InstallPath << "\n";
1856
1857  if (!GCCInstallPath.empty())
1858    OS << "Selected GCC installation: " << GCCInstallPath << "\n";
1859
1860  for (const auto &Multilib : Multilibs)
1861    OS << "Candidate multilib: " << Multilib << "\n";
1862
1863  if (Multilibs.size() != 0 || !SelectedMultilib.isDefault())
1864    OS << "Selected multilib: " << SelectedMultilib << "\n";
1865}
1866
1867bool Generic_GCC::GCCInstallationDetector::getBiarchSibling(Multilib &M) const {
1868  if (BiarchSibling.hasValue()) {
1869    M = BiarchSibling.getValue();
1870    return true;
1871  }
1872  return false;
1873}
1874
1875void 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.
1884
1885    std::string PrefixDir = SysRoot.str() + "/usr/gcc";
1886    std::error_code EC;
1887    for (llvm::vfs::directory_iterator LI = D.getVFS().dir_begin(PrefixDir, EC),
1888                                       LE;
1889         !EC && LI != LE; LI = LI.increment(EC)) {
1890      StringRef VersionText = llvm::sys::path::filename(LI->path());
1891      GCCVersion CandidateVersion = GCCVersion::Parse(VersionText);
1892
1893      // Filter out obviously bad entries.
1894      if (CandidateVersion.Major == -1 || CandidateVersion.isOlderThan(4, 1, 1))
1895        continue;
1896
1897      std::string CandidatePrefix = PrefixDir + "/" + VersionText.str();
1898      std::string CandidateLibPath = CandidatePrefix + "/lib/gcc";
1899      if (!D.getVFS().exists(CandidateLibPath))
1900        continue;
1901
1902      Prefixes.push_back(CandidatePrefix);
1903    }
1904    return;
1905  }
1906
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");
1916  }
1917  Prefixes.push_back(SysRoot.str() + "/usr");
1918}
1919
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"};
1936
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"};
1949
1950  static const char *const AVRLibDirs[] = {"/lib"};
1951  static const char *const AVRTriples[] = {"avr"};
1952
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"};
1970
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"};
1979
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"};
1991
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"};
1998
1999  static const char *const MSP430LibDirs[] = {"/lib"};
2000  static const char *const MSP430Triples[] = {"msp430-elf"};
2001
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"};
2014
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"};
2023
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"};
2030
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"};
2035
2036
2037  using std::begin;
2038  using std::end;
2039
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));
2057      break;
2058    case llvm::Triple::x86_64:
2059      TripleAliases.append(begin(SolarisX86_64Triples),
2060                           end(SolarisX86_64Triples));
2061      BiarchTripleAliases.append(begin(SolarisX86Triples),
2062                                 end(SolarisX86Triples));
2063      break;
2064    case llvm::Triple::sparc:
2065      TripleAliases.append(begin(SolarisSparcV8Triples),
2066                           end(SolarisSparcV8Triples));
2067      BiarchTripleAliases.append(begin(SolarisSparcV9Triples),
2068                                 end(SolarisSparcV9Triples));
2069      break;
2070    case llvm::Triple::sparcv9:
2071      TripleAliases.append(begin(SolarisSparcV9Triples),
2072                           end(SolarisSparcV9Triples));
2073      BiarchTripleAliases.append(begin(SolarisSparcV8Triples),
2074                                 end(SolarisSparcV8Triples));
2075      break;
2076    default:
2077      break;
2078    }
2079    return;
2080  }
2081
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"};
2092
2093    switch (TargetTriple.getArch()) {
2094    case llvm::Triple::aarch64:
2095      LibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs));
2096      TripleAliases.append(begin(AArch64AndroidTriples),
2097                           end(AArch64AndroidTriples));
2098      break;
2099    case llvm::Triple::arm:
2100    case llvm::Triple::thumb:
2101      LibDirs.append(begin(ARMLibDirs), end(ARMLibDirs));
2102      TripleAliases.append(begin(ARMAndroidTriples), end(ARMAndroidTriples));
2103      break;
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));
2111      break;
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));
2119      break;
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));
2127      break;
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));
2134      break;
2135    default:
2136      break;
2137    }
2138
2139    return;
2140  }
2141
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));
2148    break;
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));
2154    break;
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));
2160    } else {
2161      TripleAliases.append(begin(ARMTriples), end(ARMTriples));
2162    }
2163    break;
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));
2169    } else {
2170      TripleAliases.append(begin(ARMebTriples), end(ARMebTriples));
2171    }
2172    break;
2173  case llvm::Triple::avr:
2174    LibDirs.append(begin(AVRLibDirs), end(AVRLibDirs));
2175    TripleAliases.append(begin(AVRTriples), end(AVRTriples));
2176    break;
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));
2185    } else {
2186      BiarchLibDirs.append(begin(X86LibDirs), end(X86LibDirs));
2187      BiarchTripleAliases.append(begin(X86Triples), end(X86Triples));
2188    }
2189    break;
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));
2198    }
2199    break;
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));
2207    break;
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));
2216    break;
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));
2224    break;
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));
2233    break;
2234  case llvm::Triple::msp430:
2235    LibDirs.append(begin(MSP430LibDirs), end(MSP430LibDirs));
2236    TripleAliases.append(begin(MSP430Triples), end(MSP430Triples));
2237    break;
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));
2243    break;
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));
2249    break;
2250  case llvm::Triple::ppc64le:
2251    LibDirs.append(begin(PPC64LELibDirs), end(PPC64LELibDirs));
2252    TripleAliases.append(begin(PPC64LETriples), end(PPC64LETriples));
2253    break;
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));
2259    break;
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));
2265    break;
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));
2272    break;
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));
2278    break;
2279  case llvm::Triple::systemz:
2280    LibDirs.append(begin(SystemZLibDirs), end(SystemZLibDirs));
2281    TripleAliases.append(begin(SystemZTriples), end(SystemZTriples));
2282    break;
2283  default:
2284    // By default, just rely on the standard lib directories and the original
2285    // triple.
2286    break;
2287  }
2288
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());
2292
2293  // Also include the multiarch variant if it's different.
2294  if (TargetTriple.str() != BiarchTriple.str())
2295    BiarchTripleAliases.push_back(BiarchTriple.str());
2296}
2297
2298bool 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;
2303
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))
2312      return false;
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)) {
2321    return false;
2322  }
2323
2324  Multilibs = Detected.Multilibs;
2325  SelectedMultilib = Detected.SelectedMultilib;
2326  BiarchSibling = Detected.BiarchSibling;
2327
2328  return true;
2329}
2330
2331void 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.
2345    bool Active;
2346  } Suffixes[] = {
2347      // This is the normal place.
2348      {"gcc/" + CandidateTriple.str(), "../..", true},
2349
2350      // Debian puts cross-compilers in gcc-cross.
2351      {"gcc-cross/" + CandidateTriple.str(), "../..",
2352       TargetTriple.getOS() != llvm::Triple::Solaris},
2353
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},
2361
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},
2367
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
2371      // triple.
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)}};
2378
2379  for (auto &Suffix : Suffixes) {
2380    if (!Suffix.Active)
2381      continue;
2382
2383    StringRef LibSuffix = Suffix.LibSuffix;
2384    std::error_code EC;
2385    for (llvm::vfs::directory_iterator
2386             LI = D.getVFS().dir_begin(LibDir + "/" + LibSuffix, EC),
2387             LE;
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))
2395        continue;
2396      if (CandidateVersion <= Version)
2397        continue;
2398
2399      if (!ScanGCCForMultilibs(TargetTriple, Args, LI->path(),
2400                               NeedsBiarchSuffix))
2401        continue;
2402
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
2407      // Linux.
2408      GCCInstallPath = (LibDir + "/" + LibSuffix + "/" + VersionText).str();
2409      GCCParentLibPath = (GCCInstallPath + "/../" + Suffix.ReversePath).str();
2410      IsValid = true;
2411    }
2412  }
2413}
2414
2415bool 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))
2421      return true;
2422  }
2423
2424  for (StringRef CandidateTriple : CandidateBiarchTriples) {
2425    if (ScanGentooGccConfig(TargetTriple, Args, CandidateTriple, true))
2426      return true;
2427  }
2428  return false;
2429}
2430
2431bool 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());
2437  if (File) {
2438    SmallVector<StringRef, 2> Lines;
2439    File.get()->getBuffer().split(Lines, "\n");
2440    for (StringRef Line : Lines) {
2441      Line = Line.trim();
2442      // CURRENT=triple-version
2443      if (!Line.consume_front("CURRENT="))
2444        continue;
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/" +
2448                                      Line.str());
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=... .
2460      if (ConfigFile) {
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);
2471          }
2472        }
2473      }
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));
2478
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,
2484                                   NeedsBiarchSuffix))
2485            continue;
2486
2487          Version = GCCVersion::Parse(ActiveVersion.second);
2488          GCCInstallPath = GentooPath;
2489          GCCParentLibPath = GentooPath + std::string("/../../..");
2490          GCCTriple.setTriple(ActiveVersion.first);
2491          IsValid = true;
2492          return true;
2493        }
2494      }
2495    }
2496  }
2497
2498  return false;
2499}
2500
2501Generic_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);
2508}
2509
2510Generic_GCC::~Generic_GCC() {}
2511
2512Tool *Generic_GCC::getTool(Action::ActionClass AC) const {
2513  switch (AC) {
2514  case Action::PreprocessJobClass:
2515    if (!Preprocess)
2516      Preprocess.reset(new clang::driver::tools::gcc::Preprocessor(*this));
2517    return Preprocess.get();
2518  case Action::CompileJobClass:
2519    if (!Compile)
2520      Compile.reset(new tools::gcc::Compiler(*this));
2521    return Compile.get();
2522  default:
2523    return ToolChain::getTool(AC);
2524  }
2525}
2526
2527Tool *Generic_GCC::buildAssembler() const {
2528  return new tools::gnutools::Assembler(*this);
2529}
2530
2531Tool *Generic_GCC::buildLinker() const { return new tools::gcc::Linker(*this); }
2532
2533void 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);
2537}
2538
2539bool Generic_GCC::IsUnwindTablesDefault(const ArgList &Args) const {
2540  return getArch() == llvm::Triple::x86_64;
2541}
2542
2543bool 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:
2552    return true;
2553  default:
2554    return false;
2555  }
2556}
2557
2558bool Generic_GCC::isPIEDefault() const { return false; }
2559
2560bool Generic_GCC::isPICDefaultForced() const {
2561  return getArch() == llvm::Triple::x86_64 && getTriple().isOSWindows();
2562}
2563
2564bool 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:
2588    return true;
2589  case llvm::Triple::sparc:
2590  case llvm::Triple::sparcel:
2591  case llvm::Triple::sparcv9:
2592    if (getTriple().isOSFreeBSD() || getTriple().isOSOpenBSD() ||
2593        getTriple().isOSSolaris())
2594      return true;
2595    return false;
2596  default:
2597    return false;
2598  }
2599}
2600
2601void Generic_GCC::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
2602                                               ArgStringList &CC1Args) const {
2603  if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
2604      DriverArgs.hasArg(options::OPT_nostdincxx))
2605    return;
2606
2607  switch (GetCXXStdlibType(DriverArgs)) {
2608  case ToolChain::CST_Libcxx:
2609    addLibCxxIncludePaths(DriverArgs, CC1Args);
2610    break;
2611
2612  case ToolChain::CST_Libstdcxx:
2613    addLibStdCxxIncludePaths(DriverArgs, CC1Args);
2614    break;
2615  }
2616}
2617
2618void
2619Generic_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");
2624}
2625
2626void
2627Generic_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.
2631}
2632
2633/// Helper to add the variant paths of a libstdc++ installation.
2634bool 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))
2639    return false;
2640
2641  addSystemInclude(DriverArgs, CC1Args, Base + Suffix);
2642
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);
2650  } else {
2651    // Otherwise try to use multiarch naming schemes which have normalized the
2652    // triples and put the triple before the suffix.
2653    //
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);
2660  }
2661
2662  addSystemInclude(DriverArgs, CC1Args, Base + Suffix + "/backward");
2663  return true;
2664}
2665
2666llvm::opt::DerivedArgList *
2667Generic_GCC::TranslateArgs(const llvm::opt::DerivedArgList &Args, StringRef,
2668                           Action::OffloadKind DeviceOffloadKind) const {
2669
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();
2677
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));
2682
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()) {
2687      default:
2688        DAL->append(A);
2689        break;
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:
2701        break;
2702      }
2703    }
2704    return DAL;
2705  }
2706  return nullptr;
2707}
2708
2709void Generic_ELF::anchor() {}
2710
2711void 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;
2729
2730  if (DriverArgs.hasFlag(options::OPT_fuse_init_array,
2731                         options::OPT_fno_use_init_array, UseInitArrayDefault))
2732    CC1Args.push_back("-fuse-init-array");
2733}
2734