clang  19.0.0git
Gnu.cpp
Go to the documentation of this file.
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/CSKY.h"
12 #include "Arch/LoongArch.h"
13 #include "Arch/Mips.h"
14 #include "Arch/PPC.h"
15 #include "Arch/RISCV.h"
16 #include "Arch/Sparc.h"
17 #include "Arch/SystemZ.h"
18 #include "CommonArgs.h"
19 #include "Linux.h"
20 #include "clang/Config/config.h" // for GCC_INSTALL_PREFIX
21 #include "clang/Driver/Compilation.h"
22 #include "clang/Driver/Driver.h"
23 #include "clang/Driver/DriverDiagnostic.h"
24 #include "clang/Driver/MultilibBuilder.h"
25 #include "clang/Driver/Options.h"
26 #include "clang/Driver/Tool.h"
27 #include "clang/Driver/ToolChain.h"
28 #include "llvm/ADT/StringSet.h"
29 #include "llvm/ADT/Twine.h"
30 #include "llvm/Option/ArgList.h"
31 #include "llvm/Support/CodeGen.h"
32 #include "llvm/Support/Path.h"
33 #include "llvm/Support/VirtualFileSystem.h"
34 #include "llvm/TargetParser/RISCVISAInfo.h"
35 #include "llvm/TargetParser/TargetParser.h"
36 #include <system_error>
37 
38 using namespace clang::driver;
39 using namespace clang::driver::toolchains;
40 using namespace clang;
41 using namespace llvm::opt;
42 
43 using tools::addMultilibFlag;
44 using tools::addPathIfExists;
45 
46 static bool forwardToGCC(const Option &O) {
47  // LinkerInput options have been forwarded. Don't duplicate.
48  if (O.hasFlag(options::LinkerInput))
49  return false;
50  return O.matches(options::OPT_Link_Group) || O.hasFlag(options::LinkOption);
51 }
52 
53 // Switch CPU names not recognized by GNU assembler to a close CPU that it does
54 // recognize, instead of a lower march from being picked in the absence of a cpu
55 // flag.
56 static void normalizeCPUNamesForAssembler(const ArgList &Args,
57  ArgStringList &CmdArgs) {
58  if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
59  StringRef CPUArg(A->getValue());
60  if (CPUArg.equals_insensitive("krait"))
61  CmdArgs.push_back("-mcpu=cortex-a15");
62  else if (CPUArg.equals_insensitive("kryo"))
63  CmdArgs.push_back("-mcpu=cortex-a57");
64  else
65  Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ);
66  }
67 }
68 
69 void tools::gcc::Common::ConstructJob(Compilation &C, const JobAction &JA,
70  const InputInfo &Output,
71  const InputInfoList &Inputs,
72  const ArgList &Args,
73  const char *LinkingOutput) const {
74  const Driver &D = getToolChain().getDriver();
75  ArgStringList CmdArgs;
76 
77  for (const auto &A : Args) {
78  if (forwardToGCC(A->getOption())) {
79  // It is unfortunate that we have to claim here, as this means
80  // we will basically never report anything interesting for
81  // platforms using a generic gcc, even if we are just using gcc
82  // to get to the assembler.
83  A->claim();
84 
85  A->render(Args, CmdArgs);
86  }
87  }
88 
89  RenderExtraToolArgs(JA, CmdArgs);
90 
91  // If using a driver, force the arch.
92  if (getToolChain().getTriple().isOSDarwin()) {
93  CmdArgs.push_back("-arch");
94  CmdArgs.push_back(
95  Args.MakeArgString(getToolChain().getDefaultUniversalArchName()));
96  }
97 
98  // Try to force gcc to match the tool chain we want, if we recognize
99  // the arch.
100  //
101  // FIXME: The triple class should directly provide the information we want
102  // here.
103  switch (getToolChain().getArch()) {
104  default:
105  break;
106  case llvm::Triple::x86:
107  case llvm::Triple::ppc:
108  case llvm::Triple::ppcle:
109  CmdArgs.push_back("-m32");
110  break;
111  case llvm::Triple::x86_64:
112  case llvm::Triple::ppc64:
113  case llvm::Triple::ppc64le:
114  CmdArgs.push_back("-m64");
115  break;
116  case llvm::Triple::sparcel:
117  CmdArgs.push_back("-EL");
118  break;
119  }
120 
121  assert((Output.isFilename() || Output.isNothing()) && "Invalid output.");
122  if (Output.isFilename()) {
123  CmdArgs.push_back("-o");
124  CmdArgs.push_back(Output.getFilename());
125  } else {
126  CmdArgs.push_back("-fsyntax-only");
127  }
128 
129  Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
130 
131  // Only pass -x if gcc will understand it; otherwise hope gcc
132  // understands the suffix correctly. The main use case this would go
133  // wrong in is for linker inputs if they happened to have an odd
134  // suffix; really the only way to get this to happen is a command
135  // like '-x foobar a.c' which will treat a.c like a linker input.
136  //
137  // FIXME: For the linker case specifically, can we safely convert
138  // inputs into '-Wl,' options?
139  for (const auto &II : Inputs) {
140  // Don't try to pass LLVM or AST inputs to a generic gcc.
141  if (types::isLLVMIR(II.getType()))
142  D.Diag(clang::diag::err_drv_no_linker_llvm_support)
143  << getToolChain().getTripleString();
144  else if (II.getType() == types::TY_AST)
145  D.Diag(diag::err_drv_no_ast_support) << getToolChain().getTripleString();
146  else if (II.getType() == types::TY_ModuleFile)
147  D.Diag(diag::err_drv_no_module_support)
148  << getToolChain().getTripleString();
149 
150  if (types::canTypeBeUserSpecified(II.getType())) {
151  CmdArgs.push_back("-x");
152  CmdArgs.push_back(types::getTypeName(II.getType()));
153  }
154 
155  if (II.isFilename())
156  CmdArgs.push_back(II.getFilename());
157  else {
158  const Arg &A = II.getInputArg();
159 
160  // Reverse translate some rewritten options.
161  if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
162  CmdArgs.push_back("-lstdc++");
163  continue;
164  }
165 
166  // Don't render as input, we need gcc to do the translations.
167  A.render(Args, CmdArgs);
168  }
169  }
170 
171  const std::string &customGCCName = D.getCCCGenericGCCName();
172  const char *GCCName;
173  if (!customGCCName.empty())
174  GCCName = customGCCName.c_str();
175  else if (D.CCCIsCXX()) {
176  GCCName = "g++";
177  } else
178  GCCName = "gcc";
179 
180  const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
181  C.addCommand(std::make_unique<Command>(JA, *this,
182  ResponseFileSupport::AtFileCurCP(),
183  Exec, CmdArgs, Inputs, Output));
184 }
185 
186 void tools::gcc::Preprocessor::RenderExtraToolArgs(
187  const JobAction &JA, ArgStringList &CmdArgs) const {
188  CmdArgs.push_back("-E");
189 }
190 
191 void tools::gcc::Compiler::RenderExtraToolArgs(const JobAction &JA,
192  ArgStringList &CmdArgs) const {
193  const Driver &D = getToolChain().getDriver();
194 
195  switch (JA.getType()) {
196  // If -flto, etc. are present then make sure not to force assembly output.
197  case types::TY_LLVM_IR:
198  case types::TY_LTO_IR:
199  case types::TY_LLVM_BC:
200  case types::TY_LTO_BC:
201  CmdArgs.push_back("-c");
202  break;
203  // We assume we've got an "integrated" assembler in that gcc will produce an
204  // object file itself.
205  case types::TY_Object:
206  CmdArgs.push_back("-c");
207  break;
208  case types::TY_PP_Asm:
209  CmdArgs.push_back("-S");
210  break;
211  case types::TY_Nothing:
212  CmdArgs.push_back("-fsyntax-only");
213  break;
214  default:
215  D.Diag(diag::err_drv_invalid_gcc_output_type) << getTypeName(JA.getType());
216  }
217 }
218 
219 void tools::gcc::Linker::RenderExtraToolArgs(const JobAction &JA,
220  ArgStringList &CmdArgs) const {
221  // The types are (hopefully) good enough.
222 }
223 
224 static const char *getLDMOption(const llvm::Triple &T, const ArgList &Args) {
225  switch (T.getArch()) {
226  case llvm::Triple::x86:
227  if (T.isOSIAMCU())
228  return "elf_iamcu";
229  return "elf_i386";
230  case llvm::Triple::aarch64:
231  return "aarch64linux";
232  case llvm::Triple::aarch64_be:
233  return "aarch64linuxb";
234  case llvm::Triple::arm:
235  case llvm::Triple::thumb:
236  case llvm::Triple::armeb:
237  case llvm::Triple::thumbeb:
238  return tools::arm::isARMBigEndian(T, Args) ? "armelfb_linux_eabi"
239  : "armelf_linux_eabi";
240  case llvm::Triple::m68k:
241  return "m68kelf";
242  case llvm::Triple::ppc:
243  if (T.isOSLinux())
244  return "elf32ppclinux";
245  return "elf32ppc";
246  case llvm::Triple::ppcle:
247  if (T.isOSLinux())
248  return "elf32lppclinux";
249  return "elf32lppc";
250  case llvm::Triple::ppc64:
251  return "elf64ppc";
252  case llvm::Triple::ppc64le:
253  return "elf64lppc";
254  case llvm::Triple::riscv32:
255  return "elf32lriscv";
256  case llvm::Triple::riscv64:
257  return "elf64lriscv";
258  case llvm::Triple::sparc:
259  case llvm::Triple::sparcel:
260  return "elf32_sparc";
261  case llvm::Triple::sparcv9:
262  return "elf64_sparc";
263  case llvm::Triple::loongarch32:
264  return "elf32loongarch";
265  case llvm::Triple::loongarch64:
266  return "elf64loongarch";
267  case llvm::Triple::mips:
268  return "elf32btsmip";
269  case llvm::Triple::mipsel:
270  return "elf32ltsmip";
271  case llvm::Triple::mips64:
272  if (tools::mips::hasMipsAbiArg(Args, "n32") ||
273  T.getEnvironment() == llvm::Triple::GNUABIN32)
274  return "elf32btsmipn32";
275  return "elf64btsmip";
276  case llvm::Triple::mips64el:
277  if (tools::mips::hasMipsAbiArg(Args, "n32") ||
278  T.getEnvironment() == llvm::Triple::GNUABIN32)
279  return "elf32ltsmipn32";
280  return "elf64ltsmip";
281  case llvm::Triple::systemz:
282  return "elf64_s390";
283  case llvm::Triple::x86_64:
284  if (T.isX32())
285  return "elf32_x86_64";
286  return "elf_x86_64";
287  case llvm::Triple::ve:
288  return "elf64ve";
289  case llvm::Triple::csky:
290  return "cskyelf_linux";
291  default:
292  return nullptr;
293  }
294 }
295 
296 static bool getStaticPIE(const ArgList &Args, const ToolChain &TC) {
297  bool HasStaticPIE = Args.hasArg(options::OPT_static_pie);
298  if (HasStaticPIE && Args.hasArg(options::OPT_no_pie)) {
299  const Driver &D = TC.getDriver();
300  const llvm::opt::OptTable &Opts = D.getOpts();
301  StringRef StaticPIEName = Opts.getOptionName(options::OPT_static_pie);
302  StringRef NoPIEName = Opts.getOptionName(options::OPT_nopie);
303  D.Diag(diag::err_drv_cannot_mix_options) << StaticPIEName << NoPIEName;
304  }
305  return HasStaticPIE;
306 }
307 
308 static bool getStatic(const ArgList &Args) {
309  return Args.hasArg(options::OPT_static) &&
310  !Args.hasArg(options::OPT_static_pie);
311 }
312 
313 // Create an archive with llvm-ar. This is used to create an archive that
314 // contains host objects and the wrapped FPGA device binary
315 void tools::gnutools::Linker::constructLLVMARCommand(
316  Compilation &C, const JobAction &JA, const InputInfo &Output,
317  const InputInfoList &Input, const ArgList &Args) const {
318  ArgStringList CmdArgs;
319  // Use 'cqL' to create the archive. This allows for any fat archives that
320  // are passed on the command line to be added via contents instead of the
321  // full archive. Any usage of the generated archive will then have full
322  // access to resolve any dependencies.
323  CmdArgs.push_back("cqL");
324  const char *OutputFilename = Output.getFilename();
325  if (llvm::sys::fs::exists(OutputFilename)) {
326  C.getDriver().Diag(clang::diag::warn_drv_existing_archive_append)
327  << OutputFilename;
328  }
329  CmdArgs.push_back(OutputFilename);
330  for (const auto &II : Input) {
331  if (II.getType() == types::TY_Tempfilelist) {
332  // Take the list file and pass it in with '@'.
333  std::string FileName(II.getFilename());
334  const char *ArgFile = Args.MakeArgString("@" + FileName);
335  CmdArgs.push_back(ArgFile);
336  continue;
337  }
338  if (II.isFilename())
339  CmdArgs.push_back(II.getFilename());
340  }
341 
342  SmallString<128> LLVMARPath(C.getDriver().Dir);
343  llvm::sys::path::append(LLVMARPath, "llvm-ar");
344  const char *Exec = C.getArgs().MakeArgString(LLVMARPath);
345  C.addCommand(std::make_unique<Command>(
346  JA, *this, ResponseFileSupport::None(), Exec, CmdArgs, std::nullopt));
347 }
348 
349 void tools::gnutools::StaticLibTool::ConstructJob(
350  Compilation &C, const JobAction &JA, const InputInfo &Output,
351  const InputInfoList &Inputs, const ArgList &Args,
352  const char *LinkingOutput) const {
353  const Driver &D = getToolChain().getDriver();
354 
355  // Silence warning for "clang -g foo.o -o foo"
356  Args.ClaimAllArgs(options::OPT_g_Group);
357  // and "clang -emit-llvm foo.o -o foo"
358  Args.ClaimAllArgs(options::OPT_emit_llvm);
359  // and for "clang -w foo.o -o foo". Other warning options are already
360  // handled somewhere else.
361  Args.ClaimAllArgs(options::OPT_w);
362  // Silence warnings when linking C code with a C++ '-stdlib' argument.
363  Args.ClaimAllArgs(options::OPT_stdlib_EQ);
364 
365  // ar tool command "llvm-ar <options> <output_file> <input_files>".
366  ArgStringList CmdArgs;
367  // Create and insert file members with a deterministic index.
368  CmdArgs.push_back("rcsD");
369  CmdArgs.push_back(Output.getFilename());
370 
371  for (const auto &II : Inputs) {
372  if (II.isFilename()) {
373  CmdArgs.push_back(II.getFilename());
374  }
375  }
376 
377  // Delete old output archive file if it already exists before generating a new
378  // archive file.
379  auto OutputFileName = Output.getFilename();
380  if (Output.isFilename() && llvm::sys::fs::exists(OutputFileName)) {
381  if (std::error_code EC = llvm::sys::fs::remove(OutputFileName)) {
382  D.Diag(diag::err_drv_unable_to_remove_file) << EC.message();
383  return;
384  }
385  }
386 
387  const char *Exec = Args.MakeArgString(getToolChain().GetStaticLibToolPath());
388  C.addCommand(std::make_unique<Command>(JA, *this,
389  ResponseFileSupport::AtFileCurCP(),
390  Exec, CmdArgs, Inputs, Output));
391 }
392 
393 void tools::gnutools::Linker::ConstructJob(Compilation &C, const JobAction &JA,
394  const InputInfo &Output,
395  const InputInfoList &Inputs,
396  const ArgList &Args,
397  const char *LinkingOutput) const {
398  // FIXME: The Linker class constructor takes a ToolChain and not a
399  // Generic_ELF, so the static_cast might return a reference to a invalid
400  // instance (see PR45061). Ideally, the Linker constructor needs to take a
401  // Generic_ELF instead.
402  const auto &ToolChain = static_cast<const Generic_ELF &>(getToolChain());
403  const Driver &D = ToolChain.getDriver();
404 
405  const llvm::Triple &Triple = getToolChain().getEffectiveTriple();
406 
407  const llvm::Triple::ArchType Arch = ToolChain.getArch();
408  const bool isOHOSFamily = ToolChain.getTriple().isOHOSFamily();
409  const bool isAndroid = ToolChain.getTriple().isAndroid();
410  const bool IsIAMCU = ToolChain.getTriple().isOSIAMCU();
411  const bool IsVE = ToolChain.getTriple().isVE();
412  const bool IsStaticPIE = getStaticPIE(Args, ToolChain);
413  const bool IsStatic = getStatic(Args);
414  const bool HasCRTBeginEndFiles =
415  ToolChain.getTriple().hasEnvironment() ||
416  (ToolChain.getTriple().getVendor() != llvm::Triple::MipsTechnologies);
417 
418  // Use of -fsycl-link creates an archive.
419  if (Args.hasArg(options::OPT_fsycl_link_EQ) &&
420  JA.getType() == types::TY_Archive) {
421  constructLLVMARCommand(C, JA, Output, Inputs, Args);
422  return;
423  }
424  ArgStringList CmdArgs;
425 
426  // Silence warning for "clang -g foo.o -o foo"
427  Args.ClaimAllArgs(options::OPT_g_Group);
428  // and "clang -emit-llvm foo.o -o foo"
429  Args.ClaimAllArgs(options::OPT_emit_llvm);
430  // and for "clang -w foo.o -o foo". Other warning options are already
431  // handled somewhere else.
432  Args.ClaimAllArgs(options::OPT_w);
433 
434  if (!D.SysRoot.empty())
435  CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
436 
437  if (Args.hasArg(options::OPT_s))
438  CmdArgs.push_back("-s");
439 
440  if (Triple.isARM() || Triple.isThumb()) {
441  bool IsBigEndian = arm::isARMBigEndian(Triple, Args);
442  if (IsBigEndian)
443  arm::appendBE8LinkFlag(Args, CmdArgs, Triple);
444  CmdArgs.push_back(IsBigEndian ? "-EB" : "-EL");
445  } else if (Triple.isAArch64()) {
446  CmdArgs.push_back(Arch == llvm::Triple::aarch64_be ? "-EB" : "-EL");
447  }
448 
449  // Most Android ARM64 targets should enable the linker fix for erratum
450  // 843419. Only non-Cortex-A53 devices are allowed to skip this flag.
451  if (Arch == llvm::Triple::aarch64 && (isAndroid || isOHOSFamily)) {
452  std::string CPU = getCPUName(D, Args, Triple);
453  if (CPU.empty() || CPU == "generic" || CPU == "cortex-a53")
454  CmdArgs.push_back("--fix-cortex-a53-843419");
455  }
456 
457  ToolChain.addExtraOpts(CmdArgs);
458 
459  CmdArgs.push_back("--eh-frame-hdr");
460 
461  if (const char *LDMOption = getLDMOption(ToolChain.getTriple(), Args)) {
462  CmdArgs.push_back("-m");
463  CmdArgs.push_back(LDMOption);
464  } else {
465  D.Diag(diag::err_target_unknown_triple) << Triple.str();
466  return;
467  }
468 
469  if (Triple.isRISCV()) {
470  CmdArgs.push_back("-X");
471  if (Args.hasArg(options::OPT_mno_relax))
472  CmdArgs.push_back("--no-relax");
473  }
474 
475  const bool IsShared = Args.hasArg(options::OPT_shared);
476  if (IsShared)
477  CmdArgs.push_back("-shared");
478  bool IsPIE = false;
479  if (IsStaticPIE) {
480  CmdArgs.push_back("-static");
481  CmdArgs.push_back("-pie");
482  CmdArgs.push_back("--no-dynamic-linker");
483  CmdArgs.push_back("-z");
484  CmdArgs.push_back("text");
485  } else if (IsStatic) {
486  CmdArgs.push_back("-static");
487  } else if (!Args.hasArg(options::OPT_r)) {
488  if (Args.hasArg(options::OPT_rdynamic))
489  CmdArgs.push_back("-export-dynamic");
490  if (!IsShared) {
491  IsPIE = Args.hasFlag(options::OPT_pie, options::OPT_no_pie,
492  ToolChain.isPIEDefault(Args));
493  if (IsPIE)
494  CmdArgs.push_back("-pie");
495  CmdArgs.push_back("-dynamic-linker");
496  CmdArgs.push_back(Args.MakeArgString(Twine(D.DyldPrefix) +
497  ToolChain.getDynamicLinker(Args)));
498  }
499  }
500 
501  CmdArgs.push_back("-o");
502  CmdArgs.push_back(Output.getFilename());
503 
504  if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles,
505  options::OPT_r)) {
506  if (!isAndroid && !IsIAMCU) {
507  const char *crt1 = nullptr;
508  if (!Args.hasArg(options::OPT_shared)) {
509  if (Args.hasArg(options::OPT_pg))
510  crt1 = "gcrt1.o";
511  else if (IsPIE)
512  crt1 = "Scrt1.o";
513  else if (IsStaticPIE)
514  crt1 = "rcrt1.o";
515  else
516  crt1 = "crt1.o";
517  }
518  if (crt1)
519  CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
520 
521  CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
522  }
523 
524  if (IsVE) {
525  CmdArgs.push_back("-z");
526  CmdArgs.push_back("max-page-size=0x4000000");
527  }
528 
529  if (IsIAMCU)
530  CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crt0.o")));
531  else if (HasCRTBeginEndFiles) {
532  std::string P;
533  if (ToolChain.GetRuntimeLibType(Args) == ToolChain::RLT_CompilerRT &&
534  !isAndroid) {
535  std::string crtbegin = ToolChain.getCompilerRT(Args, "crtbegin",
536  ToolChain::FT_Object);
537  if (ToolChain.getVFS().exists(crtbegin))
538  P = crtbegin;
539  }
540  if (P.empty()) {
541  const char *crtbegin;
542  if (Args.hasArg(options::OPT_shared))
543  crtbegin = isAndroid ? "crtbegin_so.o" : "crtbeginS.o";
544  else if (IsStatic)
545  crtbegin = isAndroid ? "crtbegin_static.o" : "crtbeginT.o";
546  else if (IsPIE || IsStaticPIE)
547  crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbeginS.o";
548  else
549  crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbegin.o";
550  P = ToolChain.GetFilePath(crtbegin);
551  }
552  CmdArgs.push_back(Args.MakeArgString(P));
553  }
554 
555  // Add crtfastmath.o if available and fast math is enabled.
556  ToolChain.addFastMathRuntimeIfAvailable(Args, CmdArgs);
557 
558  if (isAndroid && Args.hasFlag(options::OPT_fandroid_pad_segment,
559  options::OPT_fno_android_pad_segment, false))
560  CmdArgs.push_back(
561  Args.MakeArgString(ToolChain.GetFilePath("crt_pad_segment.o")));
562  }
563 
564  // Performing link for dependency file information, undefined symbols are OK.
565  // True link time errors for symbols will be captured at host link.
566  if (JA.getType() == types::TY_Host_Dependencies_Image)
567  CmdArgs.push_back("--unresolved-symbols=ignore-all");
568 
569  Args.addAllArgs(CmdArgs, {options::OPT_L, options::OPT_u});
570 
571  ToolChain.AddFilePathLibArgs(Args, CmdArgs);
572 
573  if (D.isUsingLTO()) {
574  assert(!Inputs.empty() && "Must have at least one input.");
575  // Find the first filename InputInfo object.
576  auto Input = llvm::find_if(
577  Inputs, [](const InputInfo &II) -> bool { return II.isFilename(); });
578  if (Input == Inputs.end())
579  // For a very rare case, all of the inputs to the linker are
580  // InputArg. If that happens, just use the first InputInfo.
581  Input = Inputs.begin();
582 
583  addLTOOptions(ToolChain, Args, CmdArgs, Output, *Input,
584  D.getLTOMode() == LTOK_Thin);
585  }
586 
587  if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
588  CmdArgs.push_back("--no-demangle");
589 
590  bool NeedsSanitizerDeps = addSanitizerRuntimes(ToolChain, Args, CmdArgs);
591  bool NeedsXRayDeps = addXRayRuntime(ToolChain, Args, CmdArgs);
592  addLinkerCompressDebugSectionsOption(ToolChain, Args, CmdArgs);
593  // When offloading, the input file(s) could be from unbundled partially
594  // linked archives. The unbundled information is a list of files and not
595  // an actual object/archive. Take that list and pass those to the linker
596  // instead of the original object.
597  if (JA.isDeviceOffloading(Action::OFK_OpenMP) ||
598  JA.isOffloading(Action::OFK_SYCL)) {
599  InputInfoList UpdatedInputs;
600  // Go through the Inputs to the link. When a listfile is encountered, we
601  // know it is an unbundled generated list.
602  for (const auto &II : Inputs) {
603  // TODO: Incoming file from the unbundling of the AOCX archive is
604  // represented as an object. The file should be considered as a filelist
605  // file to correspond with the '@' addition.
606  bool IsAOCXFile = false;
607  if (II.isFilename())
608  IsAOCXFile = llvm::sys::path::extension(II.getFilename()) == ".aocx";
609 
610  if (II.getType() == types::TY_Tempfilelist ||
611  (IsAOCXFile && II.getType() == types::TY_Object)) {
612  // Take the unbundled list file and pass it in with '@'.
613  const char *ArgFile =
614  C.getArgs().MakeArgString("@" + StringRef(II.getFilename()));
615  auto CurInput = InputInfo(types::TY_Object, ArgFile, ArgFile);
616  UpdatedInputs.push_back(CurInput);
617  } else
618  UpdatedInputs.push_back(II);
619  }
620  AddLinkerInputs(ToolChain, UpdatedInputs, Args, CmdArgs, JA);
621  } else
622  AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs, JA);
623 
624  addHIPRuntimeLibArgs(ToolChain, C, Args, CmdArgs);
625 
626  // The profile runtime also needs access to system libraries.
627  getToolChain().addProfileRTLibs(Args, CmdArgs);
628 
629  if (D.CCCIsCXX() &&
630  !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs,
631  options::OPT_r)) {
632  if (ToolChain.ShouldLinkCXXStdlib(Args)) {
633  bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
634  !Args.hasArg(options::OPT_static);
635  if (OnlyLibstdcxxStatic)
636  CmdArgs.push_back("-Bstatic");
637  ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
638  if (OnlyLibstdcxxStatic)
639  CmdArgs.push_back("-Bdynamic");
640  }
641  CmdArgs.push_back("-lm");
642  }
643 
644  // Silence warnings when linking C code with a C++ '-stdlib' argument.
645  Args.ClaimAllArgs(options::OPT_stdlib_EQ);
646 
647  // Additional linker set-up and flags for Fortran. This is required in order
648  // to generate executables. As Fortran runtime depends on the C runtime,
649  // these dependencies need to be listed before the C runtime below (i.e.
650  // AddRunTimeLibs).
651  if (D.IsFlangMode()) {
652  addFortranRuntimeLibraryPath(ToolChain, Args, CmdArgs);
653  addFortranRuntimeLibs(ToolChain, Args, CmdArgs);
654  CmdArgs.push_back("-lm");
655  }
656 
657  // If requested, use a custom linker script to handle very large device code
658  // sections.
659  if (Args.hasArg(options::OPT_fsycl, options::OPT_fopenmp_targets_EQ) &&
660  Args.hasFlag(options::OPT_flink_huge_device_code,
661  options::OPT_fno_link_huge_device_code, false)) {
662  // Create temporary linker script. Keep it if save-temps is enabled.
663  const char *LKS;
664  SmallString<256> Name = llvm::sys::path::filename(Output.getFilename());
665  if (C.getDriver().isSaveTempsEnabled()) {
666  llvm::sys::path::replace_extension(Name, "ld");
667  LKS = C.getArgs().MakeArgString(Name.c_str());
668  } else {
669  llvm::sys::path::replace_extension(Name, "");
670  Name = C.getDriver().GetTemporaryPath(Name, "ld");
671  LKS = C.addTempFile(C.getArgs().MakeArgString(Name.c_str()));
672  }
673 
674  // Add linker script option to the command.
675  CmdArgs.push_back("-T");
676  CmdArgs.push_back(LKS);
677 
678  // If this is not a dry run, create the linker script file.
679  if (!C.getArgs().hasArg(options::OPT__HASH_HASH_HASH)) {
680  std::error_code EC;
681  llvm::raw_fd_ostream ScriptOS(LKS, EC, llvm::sys::fs::OF_None);
682 
683  if (EC) {
684  C.getDriver().Diag(clang::diag::err_unable_to_make_temp)
685  << EC.message();
686  } else {
687  ScriptOS
688  << "/*\n"
689  " * This linker script allows huge (>3GB) device code\n"
690  " * sections. It has been auto-generated by the driver.\n"
691  " */\n"
692  "SECTIONS\n"
693  "{\n"
694  " . = SEGMENT_START(\"offload-device-code\", .);\n"
695  " OFFLOAD_DEVICE_CODE ALIGN(CONSTANT (MAXPAGESIZE)) + (. & "
696  "(CONSTANT (MAXPAGESIZE) - 1)) :\n"
697  " {\n"
698  " *(__CLANG_OFFLOAD_BUNDLE__*)\n"
699  " }\n"
700  "}\n"
701  "INSERT AFTER .bss\n";
702  ScriptOS.close();
703  }
704  }
705  }
706 
707  if (!Args.hasArg(options::OPT_nostdlib, options::OPT_r)) {
708  if (!Args.hasArg(options::OPT_nodefaultlibs)) {
709  if (IsStatic || IsStaticPIE)
710  CmdArgs.push_back("--start-group");
711 
712  if (NeedsSanitizerDeps)
713  linkSanitizerRuntimeDeps(ToolChain, Args, CmdArgs);
714 
715  if (NeedsXRayDeps)
716  linkXRayRuntimeDeps(ToolChain, Args, CmdArgs);
717 
718  bool WantPthread = Args.hasArg(options::OPT_pthread) ||
719  Args.hasArg(options::OPT_pthreads);
720 
721  // Use the static OpenMP runtime with -static-openmp
722  bool StaticOpenMP = Args.hasArg(options::OPT_static_openmp) &&
723  !Args.hasArg(options::OPT_static);
724 
725  // FIXME: Only pass GompNeedsRT = true for platforms with libgomp that
726  // require librt. Most modern Linux platforms do, but some may not.
727  if (addOpenMPRuntime(C, CmdArgs, ToolChain, Args, StaticOpenMP,
728  JA.isHostOffloading(Action::OFK_OpenMP),
729  /* GompNeedsRT= */ true))
730  // OpenMP runtimes implies pthreads when using the GNU toolchain.
731  // FIXME: Does this really make sense for all GNU toolchains?
732  WantPthread = true;
733 
734  AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
735 
736  if (Args.hasArg(options::OPT_fsycl) &&
737  !Args.hasArg(options::OPT_nolibsycl)) {
738  if (Args.hasArg(options::OPT_fpreview_breaking_changes))
739  CmdArgs.push_back("-lsycl-preview");
740  else
741  CmdArgs.push_back("-lsycl");
742  CmdArgs.push_back("-lsycl-devicelib-host");
743  // Use of -fintelfpga implies -lOpenCL.
744  // FIXME: Adjust to use plugin interface when available.
745  if (Args.hasArg(options::OPT_fintelfpga))
746  CmdArgs.push_back("-lOpenCL");
747  }
748 
749  // LLVM support for atomics on 32-bit SPARC V8+ is incomplete, so
750  // forcibly link with libatomic as a workaround.
751  // TODO: Issue #41880 and D118021.
752  if (getToolChain().getTriple().getArch() == llvm::Triple::sparc) {
753  CmdArgs.push_back("--push-state");
754  CmdArgs.push_back("--as-needed");
755  CmdArgs.push_back("-latomic");
756  CmdArgs.push_back("--pop-state");
757  }
758 
759  // We don't need libpthread neither for bionic (Android) nor for musl,
760  // (used by OHOS as runtime library).
761  if (WantPthread && !isAndroid && !isOHOSFamily)
762  CmdArgs.push_back("-lpthread");
763 
764  if (Args.hasArg(options::OPT_fsplit_stack))
765  CmdArgs.push_back("--wrap=pthread_create");
766 
767  if (!Args.hasArg(options::OPT_nolibc))
768  CmdArgs.push_back("-lc");
769 
770  // Add IAMCU specific libs, if needed.
771  if (IsIAMCU)
772  CmdArgs.push_back("-lgloss");
773 
774  if (IsStatic || IsStaticPIE)
775  CmdArgs.push_back("--end-group");
776  else
777  AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
778 
779  // Add IAMCU specific libs (outside the group), if needed.
780  if (IsIAMCU) {
781  CmdArgs.push_back("--as-needed");
782  CmdArgs.push_back("-lsoftfp");
783  CmdArgs.push_back("--no-as-needed");
784  }
785  }
786 
787  if (!Args.hasArg(options::OPT_nostartfiles) && !IsIAMCU) {
788  if (HasCRTBeginEndFiles) {
789  std::string P;
790  if (ToolChain.GetRuntimeLibType(Args) == ToolChain::RLT_CompilerRT &&
791  !isAndroid) {
792  std::string crtend = ToolChain.getCompilerRT(Args, "crtend",
793  ToolChain::FT_Object);
794  if (ToolChain.getVFS().exists(crtend))
795  P = crtend;
796  }
797  if (P.empty()) {
798  const char *crtend;
799  if (Args.hasArg(options::OPT_shared))
800  crtend = isAndroid ? "crtend_so.o" : "crtendS.o";
801  else if (IsPIE || IsStaticPIE)
802  crtend = isAndroid ? "crtend_android.o" : "crtendS.o";
803  else
804  crtend = isAndroid ? "crtend_android.o" : "crtend.o";
805  P = ToolChain.GetFilePath(crtend);
806  }
807  CmdArgs.push_back(Args.MakeArgString(P));
808  }
809  if (!isAndroid)
810  CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
811  }
812  }
813 
814  Args.AddAllArgs(CmdArgs, options::OPT_T);
815 
816  const char *Exec = Args.MakeArgString(ToolChain.GetLinkerPath());
817  C.addCommand(std::make_unique<Command>(JA, *this,
818  ResponseFileSupport::AtFileCurCP(),
819  Exec, CmdArgs, Inputs, Output));
820 }
821 
822 void tools::gnutools::Assembler::ConstructJob(Compilation &C,
823  const JobAction &JA,
824  const InputInfo &Output,
825  const InputInfoList &Inputs,
826  const ArgList &Args,
827  const char *LinkingOutput) const {
828  const auto &D = getToolChain().getDriver();
829 
830  claimNoWarnArgs(Args);
831 
832  ArgStringList CmdArgs;
833 
834  llvm::Reloc::Model RelocationModel;
835  unsigned PICLevel;
836  bool IsPIE;
837  const char *DefaultAssembler = "as";
838  // Enforce GNU as on Solaris; the native assembler's input syntax isn't fully
839  // compatible.
840  if (getToolChain().getTriple().isOSSolaris())
841  DefaultAssembler = "gas";
842  std::tie(RelocationModel, PICLevel, IsPIE) =
843  ParsePICArgs(getToolChain(), Args);
844 
845  if (const Arg *A = Args.getLastArg(options::OPT_gz, options::OPT_gz_EQ)) {
846  if (A->getOption().getID() == options::OPT_gz) {
847  CmdArgs.push_back("--compress-debug-sections");
848  } else {
849  StringRef Value = A->getValue();
850  if (Value == "none" || Value == "zlib" || Value == "zstd") {
851  CmdArgs.push_back(
852  Args.MakeArgString("--compress-debug-sections=" + Twine(Value)));
853  } else {
854  D.Diag(diag::err_drv_unsupported_option_argument)
855  << A->getSpelling() << Value;
856  }
857  }
858  }
859 
860  switch (getToolChain().getArch()) {
861  default:
862  break;
863  // Add --32/--64 to make sure we get the format we want.
864  // This is incomplete
865  case llvm::Triple::x86:
866  CmdArgs.push_back("--32");
867  break;
868  case llvm::Triple::x86_64:
869  if (getToolChain().getTriple().isX32())
870  CmdArgs.push_back("--x32");
871  else
872  CmdArgs.push_back("--64");
873  break;
874  case llvm::Triple::ppc: {
875  CmdArgs.push_back("-a32");
876  CmdArgs.push_back("-mppc");
877  CmdArgs.push_back("-mbig-endian");
878  CmdArgs.push_back(ppc::getPPCAsmModeForCPU(
879  getCPUName(D, Args, getToolChain().getTriple())));
880  break;
881  }
882  case llvm::Triple::ppcle: {
883  CmdArgs.push_back("-a32");
884  CmdArgs.push_back("-mppc");
885  CmdArgs.push_back("-mlittle-endian");
886  CmdArgs.push_back(ppc::getPPCAsmModeForCPU(
887  getCPUName(D, Args, getToolChain().getTriple())));
888  break;
889  }
890  case llvm::Triple::ppc64: {
891  CmdArgs.push_back("-a64");
892  CmdArgs.push_back("-mppc64");
893  CmdArgs.push_back("-mbig-endian");
894  CmdArgs.push_back(ppc::getPPCAsmModeForCPU(
895  getCPUName(D, Args, getToolChain().getTriple())));
896  break;
897  }
898  case llvm::Triple::ppc64le: {
899  CmdArgs.push_back("-a64");
900  CmdArgs.push_back("-mppc64");
901  CmdArgs.push_back("-mlittle-endian");
902  CmdArgs.push_back(ppc::getPPCAsmModeForCPU(
903  getCPUName(D, Args, getToolChain().getTriple())));
904  break;
905  }
906  case llvm::Triple::riscv32:
907  case llvm::Triple::riscv64: {
908  StringRef ABIName = riscv::getRISCVABI(Args, getToolChain().getTriple());
909  CmdArgs.push_back("-mabi");
910  CmdArgs.push_back(ABIName.data());
911  StringRef MArchName = riscv::getRISCVArch(Args, getToolChain().getTriple());
912  CmdArgs.push_back("-march");
913  CmdArgs.push_back(MArchName.data());
914  if (!Args.hasFlag(options::OPT_mrelax, options::OPT_mno_relax, true))
915  Args.addOptOutFlag(CmdArgs, options::OPT_mrelax, options::OPT_mno_relax);
916  break;
917  }
918  case llvm::Triple::sparc:
919  case llvm::Triple::sparcel: {
920  CmdArgs.push_back("-32");
921  std::string CPU = getCPUName(D, Args, getToolChain().getTriple());
922  CmdArgs.push_back(
923  sparc::getSparcAsmModeForCPU(CPU, getToolChain().getTriple()));
924  AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
925  break;
926  }
927  case llvm::Triple::sparcv9: {
928  CmdArgs.push_back("-64");
929  std::string CPU = getCPUName(D, Args, getToolChain().getTriple());
930  CmdArgs.push_back(
931  sparc::getSparcAsmModeForCPU(CPU, getToolChain().getTriple()));
932  AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
933  break;
934  }
935  case llvm::Triple::arm:
936  case llvm::Triple::armeb:
937  case llvm::Triple::thumb:
938  case llvm::Triple::thumbeb: {
939  const llvm::Triple &Triple2 = getToolChain().getTriple();
940  CmdArgs.push_back(arm::isARMBigEndian(Triple2, Args) ? "-EB" : "-EL");
941  switch (Triple2.getSubArch()) {
942  case llvm::Triple::ARMSubArch_v7:
943  CmdArgs.push_back("-mfpu=neon");
944  break;
945  case llvm::Triple::ARMSubArch_v8:
946  CmdArgs.push_back("-mfpu=crypto-neon-fp-armv8");
947  break;
948  default:
949  break;
950  }
951 
952  switch (arm::getARMFloatABI(getToolChain(), Args)) {
953  case arm::FloatABI::Invalid: llvm_unreachable("must have an ABI!");
954  case arm::FloatABI::Soft:
955  CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=soft"));
956  break;
957  case arm::FloatABI::SoftFP:
958  CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=softfp"));
959  break;
960  case arm::FloatABI::Hard:
961  CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=hard"));
962  break;
963  }
964 
965  Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
966  normalizeCPUNamesForAssembler(Args, CmdArgs);
967 
968  Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ);
969  // The integrated assembler doesn't implement e_flags setting behavior for
970  // -meabi=gnu (gcc -mabi={apcs-gnu,atpcs} passes -meabi=gnu to gas). For
971  // compatibility we accept but warn.
972  if (Arg *A = Args.getLastArgNoClaim(options::OPT_mabi_EQ))
973  A->ignoreTargetSpecific();
974  break;
975  }
976  case llvm::Triple::aarch64:
977  case llvm::Triple::aarch64_be: {
978  CmdArgs.push_back(
979  getToolChain().getArch() == llvm::Triple::aarch64_be ? "-EB" : "-EL");
980  Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
981  normalizeCPUNamesForAssembler(Args, CmdArgs);
982 
983  break;
984  }
985  // TODO: handle loongarch32.
986  case llvm::Triple::loongarch64: {
987  StringRef ABIName =
988  loongarch::getLoongArchABI(D, Args, getToolChain().getTriple());
989  CmdArgs.push_back(Args.MakeArgString("-mabi=" + ABIName));
990  break;
991  }
992  case llvm::Triple::mips:
993  case llvm::Triple::mipsel:
994  case llvm::Triple::mips64:
995  case llvm::Triple::mips64el: {
996  StringRef CPUName;
997  StringRef ABIName;
998  mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
999  ABIName = mips::getGnuCompatibleMipsABIName(ABIName);
1000 
1001  CmdArgs.push_back("-march");
1002  CmdArgs.push_back(CPUName.data());
1003 
1004  CmdArgs.push_back("-mabi");
1005  CmdArgs.push_back(ABIName.data());
1006 
1007  // -mno-shared should be emitted unless -fpic, -fpie, -fPIC, -fPIE,
1008  // or -mshared (not implemented) is in effect.
1009  if (RelocationModel == llvm::Reloc::Static)
1010  CmdArgs.push_back("-mno-shared");
1011 
1012  // LLVM doesn't support -mplt yet and acts as if it is always given.
1013  // However, -mplt has no effect with the N64 ABI.
1014  if (ABIName != "64" && !Args.hasArg(options::OPT_mno_abicalls))
1015  CmdArgs.push_back("-call_nonpic");
1016 
1017  if (getToolChain().getTriple().isLittleEndian())
1018  CmdArgs.push_back("-EL");
1019  else
1020  CmdArgs.push_back("-EB");
1021 
1022  if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
1023  if (StringRef(A->getValue()) == "2008")
1024  CmdArgs.push_back(Args.MakeArgString("-mnan=2008"));
1025  }
1026 
1027  // Add the last -mfp32/-mfpxx/-mfp64 or -mfpxx if it is enabled by default.
1028  if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfpxx,
1029  options::OPT_mfp64)) {
1030  A->claim();
1031  A->render(Args, CmdArgs);
1032  } else if (mips::shouldUseFPXX(
1033  Args, getToolChain().getTriple(), CPUName, ABIName,
1034  mips::getMipsFloatABI(getToolChain().getDriver(), Args,
1035  getToolChain().getTriple())))
1036  CmdArgs.push_back("-mfpxx");
1037 
1038  // Pass on -mmips16 or -mno-mips16. However, the assembler equivalent of
1039  // -mno-mips16 is actually -no-mips16.
1040  if (Arg *A =
1041  Args.getLastArg(options::OPT_mips16, options::OPT_mno_mips16)) {
1042  if (A->getOption().matches(options::OPT_mips16)) {
1043  A->claim();
1044  A->render(Args, CmdArgs);
1045  } else {
1046  A->claim();
1047  CmdArgs.push_back("-no-mips16");
1048  }
1049  }
1050 
1051  Args.AddLastArg(CmdArgs, options::OPT_mmicromips,
1052  options::OPT_mno_micromips);
1053  Args.AddLastArg(CmdArgs, options::OPT_mdsp, options::OPT_mno_dsp);
1054  Args.AddLastArg(CmdArgs, options::OPT_mdspr2, options::OPT_mno_dspr2);
1055 
1056  if (Arg *A = Args.getLastArg(options::OPT_mmsa, options::OPT_mno_msa)) {
1057  // Do not use AddLastArg because not all versions of MIPS assembler
1058  // support -mmsa / -mno-msa options.
1059  if (A->getOption().matches(options::OPT_mmsa))
1060  CmdArgs.push_back(Args.MakeArgString("-mmsa"));
1061  }
1062 
1063  Args.AddLastArg(CmdArgs, options::OPT_mhard_float,
1064  options::OPT_msoft_float);
1065 
1066  Args.AddLastArg(CmdArgs, options::OPT_mdouble_float,
1067  options::OPT_msingle_float);
1068 
1069  Args.AddLastArg(CmdArgs, options::OPT_modd_spreg,
1070  options::OPT_mno_odd_spreg);
1071 
1072  AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
1073  break;
1074  }
1075  case llvm::Triple::systemz: {
1076  // Always pass an -march option, since our default of z10 is later
1077  // than the GNU assembler's default.
1078  std::string CPUName = systemz::getSystemZTargetCPU(Args);
1079  CmdArgs.push_back(Args.MakeArgString("-march=" + CPUName));
1080  break;
1081  }
1082  case llvm::Triple::ve:
1083  DefaultAssembler = "nas";
1084  }
1085 
1086  for (const Arg *A : Args.filtered(options::OPT_ffile_prefix_map_EQ,
1087  options::OPT_fdebug_prefix_map_EQ)) {
1088  StringRef Map = A->getValue();
1089  if (!Map.contains('='))
1090  D.Diag(diag::err_drv_invalid_argument_to_option)
1091  << Map << A->getOption().getName();
1092  else {
1093  CmdArgs.push_back(Args.MakeArgString("--debug-prefix-map"));
1094  CmdArgs.push_back(Args.MakeArgString(Map));
1095  }
1096  A->claim();
1097  }
1098 
1099  Args.AddAllArgs(CmdArgs, options::OPT_I);
1100  Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
1101 
1102  CmdArgs.push_back("-o");
1103  CmdArgs.push_back(Output.getFilename());
1104 
1105  for (const auto &II : Inputs)
1106  CmdArgs.push_back(II.getFilename());
1107 
1108  if (Arg *A = Args.getLastArg(options::OPT_g_Flag, options::OPT_gN_Group,
1109  options::OPT_gdwarf_2, options::OPT_gdwarf_3,
1110  options::OPT_gdwarf_4, options::OPT_gdwarf_5,
1111  options::OPT_gdwarf))
1112  if (!A->getOption().matches(options::OPT_g0)) {
1113  Args.AddLastArg(CmdArgs, options::OPT_g_Flag);
1114 
1115  unsigned DwarfVersion = getDwarfVersion(getToolChain(), Args);
1116  CmdArgs.push_back(Args.MakeArgString("-gdwarf-" + Twine(DwarfVersion)));
1117  }
1118 
1119  const char *Exec =
1120  Args.MakeArgString(getToolChain().GetProgramPath(DefaultAssembler));
1121  C.addCommand(std::make_unique<Command>(JA, *this,
1122  ResponseFileSupport::AtFileCurCP(),
1123  Exec, CmdArgs, Inputs, Output));
1124 
1125  // Handle the debug info splitting at object creation time if we're
1126  // creating an object.
1127  // TODO: Currently only works on linux with newer objcopy.
1128  if (Args.hasArg(options::OPT_gsplit_dwarf) &&
1129  getToolChain().getTriple().isOSLinux())
1130  SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
1131  SplitDebugName(JA, Args, Inputs[0], Output));
1132 }
1133 
1134 namespace {
1135 // Filter to remove Multilibs that don't exist as a suffix to Path
1136 class FilterNonExistent {
1137  StringRef Base, File;
1138  llvm::vfs::FileSystem &VFS;
1139 
1140 public:
1141  FilterNonExistent(StringRef Base, StringRef File, llvm::vfs::FileSystem &VFS)
1142  : Base(Base), File(File), VFS(VFS) {}
1143  bool operator()(const Multilib &M) {
1144  return !VFS.exists(Base + M.gccSuffix() + File);
1145  }
1146 };
1147 } // end anonymous namespace
1148 
1149 static bool isSoftFloatABI(const ArgList &Args) {
1150  Arg *A = Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float,
1151  options::OPT_mfloat_abi_EQ);
1152  if (!A)
1153  return false;
1154 
1155  return A->getOption().matches(options::OPT_msoft_float) ||
1156  (A->getOption().matches(options::OPT_mfloat_abi_EQ) &&
1157  A->getValue() == StringRef("soft"));
1158 }
1159 
1160 static bool isArmOrThumbArch(llvm::Triple::ArchType Arch) {
1161  return Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb;
1162 }
1163 
1164 static bool isMipsEL(llvm::Triple::ArchType Arch) {
1165  return Arch == llvm::Triple::mipsel || Arch == llvm::Triple::mips64el;
1166 }
1167 
1168 static bool isMips16(const ArgList &Args) {
1169  Arg *A = Args.getLastArg(options::OPT_mips16, options::OPT_mno_mips16);
1170  return A && A->getOption().matches(options::OPT_mips16);
1171 }
1172 
1173 static bool isMicroMips(const ArgList &Args) {
1174  Arg *A = Args.getLastArg(options::OPT_mmicromips, options::OPT_mno_micromips);
1175  return A && A->getOption().matches(options::OPT_mmicromips);
1176 }
1177 
1178 static bool isMSP430(llvm::Triple::ArchType Arch) {
1179  return Arch == llvm::Triple::msp430;
1180 }
1181 
1182 static bool findMipsCsMultilibs(const Multilib::flags_list &Flags,
1183  FilterNonExistent &NonExistent,
1184  DetectedMultilibs &Result) {
1185  // Check for Code Sourcery toolchain multilibs
1186  MultilibSet CSMipsMultilibs;
1187  {
1188  auto MArchMips16 = MultilibBuilder("/mips16").flag("-m32").flag("-mips16");
1189 
1190  auto MArchMicroMips =
1191  MultilibBuilder("/micromips").flag("-m32").flag("-mmicromips");
1192 
1193  auto MArchDefault = MultilibBuilder("")
1194  .flag("-mips16", /*Disallow=*/true)
1195  .flag("-mmicromips", /*Disallow=*/true);
1196 
1197  auto UCLibc = MultilibBuilder("/uclibc").flag("-muclibc");
1198 
1199  auto SoftFloat = MultilibBuilder("/soft-float").flag("-msoft-float");
1200 
1201  auto Nan2008 = MultilibBuilder("/nan2008").flag("-mnan=2008");
1202 
1203  auto DefaultFloat = MultilibBuilder("")
1204  .flag("-msoft-float", /*Disallow=*/true)
1205  .flag("-mnan=2008", /*Disallow=*/true);
1206 
1207  auto BigEndian =
1208  MultilibBuilder("").flag("-EB").flag("-EL", /*Disallow=*/true);
1209 
1210  auto LittleEndian =
1211  MultilibBuilder("/el").flag("-EL").flag("-EB", /*Disallow=*/true);
1212 
1213  // Note that this one's osSuffix is ""
1214  auto MAbi64 = MultilibBuilder("")
1215  .gccSuffix("/64")
1216  .includeSuffix("/64")
1217  .flag("-mabi=n64")
1218  .flag("-mabi=n32", /*Disallow=*/true)
1219  .flag("-m32", /*Disallow=*/true);
1220 
1221  CSMipsMultilibs =
1222  MultilibSetBuilder()
1223  .Either(MArchMips16, MArchMicroMips, MArchDefault)
1224  .Maybe(UCLibc)
1225  .Either(SoftFloat, Nan2008, DefaultFloat)
1226  .FilterOut("/micromips/nan2008")
1227  .FilterOut("/mips16/nan2008")
1228  .Either(BigEndian, LittleEndian)
1229  .Maybe(MAbi64)
1230  .FilterOut("/mips16.*/64")
1231  .FilterOut("/micromips.*/64")
1232  .makeMultilibSet()
1233  .FilterOut(NonExistent)
1234  .setIncludeDirsCallback([](const Multilib &M) {
1235  std::vector<std::string> Dirs({"/include"});
1236  if (StringRef(M.includeSuffix()).starts_with("/uclibc"))
1237  Dirs.push_back(
1238  "/../../../../mips-linux-gnu/libc/uclibc/usr/include");
1239  else
1240  Dirs.push_back("/../../../../mips-linux-gnu/libc/usr/include");
1241  return Dirs;
1242  });
1243  }
1244 
1245  MultilibSet DebianMipsMultilibs;
1246  {
1247  MultilibBuilder MAbiN32 =
1248  MultilibBuilder().gccSuffix("/n32").includeSuffix("/n32").flag(
1249  "-mabi=n32");
1250 
1251  MultilibBuilder M64 = MultilibBuilder()
1252  .gccSuffix("/64")
1253  .includeSuffix("/64")
1254  .flag("-m64")
1255  .flag("-m32", /*Disallow=*/true)
1256  .flag("-mabi=n32", /*Disallow=*/true);
1257 
1258  MultilibBuilder M32 = MultilibBuilder()
1259  .gccSuffix("/32")
1260  .flag("-m64", /*Disallow=*/true)
1261  .flag("-m32")
1262  .flag("-mabi=n32", /*Disallow=*/true);
1263 
1264  DebianMipsMultilibs = MultilibSetBuilder()
1265  .Either(M32, M64, MAbiN32)
1266  .makeMultilibSet()
1267  .FilterOut(NonExistent);
1268  }
1269 
1270  // Sort candidates. Toolchain that best meets the directories tree goes first.
1271  // Then select the first toolchains matches command line flags.
1272  MultilibSet *Candidates[] = {&CSMipsMultilibs, &DebianMipsMultilibs};
1273  if (CSMipsMultilibs.size() < DebianMipsMultilibs.size())
1274  std::iter_swap(Candidates, Candidates + 1);
1275  for (const MultilibSet *Candidate : Candidates) {
1276  if (Candidate->select(Flags, Result.SelectedMultilibs)) {
1277  if (Candidate == &DebianMipsMultilibs)
1278  Result.BiarchSibling = Multilib();
1279  Result.Multilibs = *Candidate;
1280  return true;
1281  }
1282  }
1283  return false;
1284 }
1285 
1286 static bool findMipsAndroidMultilibs(llvm::vfs::FileSystem &VFS, StringRef Path,
1287  const Multilib::flags_list &Flags,
1288  FilterNonExistent &NonExistent,
1289  DetectedMultilibs &Result) {
1290 
1291  MultilibSet AndroidMipsMultilibs =
1292  MultilibSetBuilder()
1293  .Maybe(MultilibBuilder("/mips-r2", {}, {}).flag("-march=mips32r2"))
1294  .Maybe(MultilibBuilder("/mips-r6", {}, {}).flag("-march=mips32r6"))
1295  .makeMultilibSet()
1296  .FilterOut(NonExistent);
1297 
1298  MultilibSet AndroidMipselMultilibs =
1299  MultilibSetBuilder()
1300  .Either(MultilibBuilder().flag("-march=mips32"),
1301  MultilibBuilder("/mips-r2", "", "/mips-r2")
1302  .flag("-march=mips32r2"),
1303  MultilibBuilder("/mips-r6", "", "/mips-r6")
1304  .flag("-march=mips32r6"))
1305  .makeMultilibSet()
1306  .FilterOut(NonExistent);
1307 
1308  MultilibSet AndroidMips64elMultilibs =
1309  MultilibSetBuilder()
1310  .Either(MultilibBuilder().flag("-march=mips64r6"),
1311  MultilibBuilder("/32/mips-r1", "", "/mips-r1")
1312  .flag("-march=mips32"),
1313  MultilibBuilder("/32/mips-r2", "", "/mips-r2")
1314  .flag("-march=mips32r2"),
1315  MultilibBuilder("/32/mips-r6", "", "/mips-r6")
1316  .flag("-march=mips32r6"))
1317  .makeMultilibSet()
1318  .FilterOut(NonExistent);
1319 
1320  MultilibSet *MS = &AndroidMipsMultilibs;
1321  if (VFS.exists(Path + "/mips-r6"))
1322  MS = &AndroidMipselMultilibs;
1323  else if (VFS.exists(Path + "/32"))
1324  MS = &AndroidMips64elMultilibs;
1325  if (MS->select(Flags, Result.SelectedMultilibs)) {
1326  Result.Multilibs = *MS;
1327  return true;
1328  }
1329  return false;
1330 }
1331 
1332 static bool findMipsMuslMultilibs(const Multilib::flags_list &Flags,
1333  FilterNonExistent &NonExistent,
1334  DetectedMultilibs &Result) {
1335  // Musl toolchain multilibs
1336  MultilibSet MuslMipsMultilibs;
1337  {
1338  auto MArchMipsR2 = MultilibBuilder("")
1339  .osSuffix("/mips-r2-hard-musl")
1340  .flag("-EB")
1341  .flag("-EL", /*Disallow=*/true)
1342  .flag("-march=mips32r2");
1343 
1344  auto MArchMipselR2 = MultilibBuilder("/mipsel-r2-hard-musl")
1345  .flag("-EB", /*Disallow=*/true)
1346  .flag("-EL")
1347  .flag("-march=mips32r2");
1348 
1349  MuslMipsMultilibs = MultilibSetBuilder()
1350  .Either(MArchMipsR2, MArchMipselR2)
1351  .makeMultilibSet();
1352 
1353  // Specify the callback that computes the include directories.
1354  MuslMipsMultilibs.setIncludeDirsCallback([](const Multilib &M) {
1355  return std::vector<std::string>(
1356  {"/../sysroot" + M.osSuffix() + "/usr/include"});
1357  });
1358  }
1359  if (MuslMipsMultilibs.select(Flags, Result.SelectedMultilibs)) {
1360  Result.Multilibs = MuslMipsMultilibs;
1361  return true;
1362  }
1363  return false;
1364 }
1365 
1366 static bool findMipsMtiMultilibs(const Multilib::flags_list &Flags,
1367  FilterNonExistent &NonExistent,
1368  DetectedMultilibs &Result) {
1369  // CodeScape MTI toolchain v1.2 and early.
1370  MultilibSet MtiMipsMultilibsV1;
1371  {
1372  auto MArchMips32 = MultilibBuilder("/mips32")
1373  .flag("-m32")
1374  .flag("-m64", /*Disallow=*/true)
1375  .flag("-mmicromips", /*Disallow=*/true)
1376  .flag("-march=mips32");
1377 
1378  auto MArchMicroMips = MultilibBuilder("/micromips")
1379  .flag("-m32")
1380  .flag("-m64", /*Disallow=*/true)
1381  .flag("-mmicromips");
1382 
1383  auto MArchMips64r2 = MultilibBuilder("/mips64r2")
1384  .flag("-m32", /*Disallow=*/true)
1385  .flag("-m64")
1386  .flag("-march=mips64r2");
1387 
1388  auto MArchMips64 = MultilibBuilder("/mips64")
1389  .flag("-m32", /*Disallow=*/true)
1390  .flag("-m64")
1391  .flag("-march=mips64r2", /*Disallow=*/true);
1392 
1393  auto MArchDefault = MultilibBuilder("")
1394  .flag("-m32")
1395  .flag("-m64", /*Disallow=*/true)
1396  .flag("-mmicromips", /*Disallow=*/true)
1397  .flag("-march=mips32r2");
1398 
1399  auto Mips16 = MultilibBuilder("/mips16").flag("-mips16");
1400 
1401  auto UCLibc = MultilibBuilder("/uclibc").flag("-muclibc");
1402 
1403  auto MAbi64 = MultilibBuilder("/64")
1404  .flag("-mabi=n64")
1405  .flag("-mabi=n32", /*Disallow=*/true)
1406  .flag("-m32", /*Disallow=*/true);
1407 
1408  auto BigEndian =
1409  MultilibBuilder("").flag("-EB").flag("-EL", /*Disallow=*/true);
1410 
1411  auto LittleEndian =
1412  MultilibBuilder("/el").flag("-EL").flag("-EB", /*Disallow=*/true);
1413 
1414  auto SoftFloat = MultilibBuilder("/sof").flag("-msoft-float");
1415 
1416  auto Nan2008 = MultilibBuilder("/nan2008").flag("-mnan=2008");
1417 
1418  MtiMipsMultilibsV1 =
1419  MultilibSetBuilder()
1420  .Either(MArchMips32, MArchMicroMips, MArchMips64r2, MArchMips64,
1421  MArchDefault)
1422  .Maybe(UCLibc)
1423  .Maybe(Mips16)
1424  .FilterOut("/mips64/mips16")
1425  .FilterOut("/mips64r2/mips16")
1426  .FilterOut("/micromips/mips16")
1427  .Maybe(MAbi64)
1428  .FilterOut("/micromips/64")
1429  .FilterOut("/mips32/64")
1430  .FilterOut("^/64")
1431  .FilterOut("/mips16/64")
1432  .Either(BigEndian, LittleEndian)
1433  .Maybe(SoftFloat)
1434  .Maybe(Nan2008)
1435  .FilterOut(".*sof/nan2008")
1436  .makeMultilibSet()
1437  .FilterOut(NonExistent)
1438  .setIncludeDirsCallback([](const Multilib &M) {
1439  std::vector<std::string> Dirs({"/include"});
1440  if (StringRef(M.includeSuffix()).starts_with("/uclibc"))
1441  Dirs.push_back("/../../../../sysroot/uclibc/usr/include");
1442  else
1443  Dirs.push_back("/../../../../sysroot/usr/include");
1444  return Dirs;
1445  });
1446  }
1447 
1448  // CodeScape IMG toolchain starting from v1.3.
1449  MultilibSet MtiMipsMultilibsV2;
1450  {
1451  auto BeHard = MultilibBuilder("/mips-r2-hard")
1452  .flag("-EB")
1453  .flag("-msoft-float", /*Disallow=*/true)
1454  .flag("-mnan=2008", /*Disallow=*/true)
1455  .flag("-muclibc", /*Disallow=*/true);
1456  auto BeSoft = MultilibBuilder("/mips-r2-soft")
1457  .flag("-EB")
1458  .flag("-msoft-float")
1459  .flag("-mnan=2008", /*Disallow=*/true);
1460  auto ElHard = MultilibBuilder("/mipsel-r2-hard")
1461  .flag("-EL")
1462  .flag("-msoft-float", /*Disallow=*/true)
1463  .flag("-mnan=2008", /*Disallow=*/true)
1464  .flag("-muclibc", /*Disallow=*/true);
1465  auto ElSoft = MultilibBuilder("/mipsel-r2-soft")
1466  .flag("-EL")
1467  .flag("-msoft-float")
1468  .flag("-mnan=2008", /*Disallow=*/true)
1469  .flag("-mmicromips", /*Disallow=*/true);
1470  auto BeHardNan = MultilibBuilder("/mips-r2-hard-nan2008")
1471  .flag("-EB")
1472  .flag("-msoft-float", /*Disallow=*/true)
1473  .flag("-mnan=2008")
1474  .flag("-muclibc", /*Disallow=*/true);
1475  auto ElHardNan = MultilibBuilder("/mipsel-r2-hard-nan2008")
1476  .flag("-EL")
1477  .flag("-msoft-float", /*Disallow=*/true)
1478  .flag("-mnan=2008")
1479  .flag("-muclibc", /*Disallow=*/true)
1480  .flag("-mmicromips", /*Disallow=*/true);
1481  auto BeHardNanUclibc = MultilibBuilder("/mips-r2-hard-nan2008-uclibc")
1482  .flag("-EB")
1483  .flag("-msoft-float", /*Disallow=*/true)
1484  .flag("-mnan=2008")
1485  .flag("-muclibc");
1486  auto ElHardNanUclibc = MultilibBuilder("/mipsel-r2-hard-nan2008-uclibc")
1487  .flag("-EL")
1488  .flag("-msoft-float", /*Disallow=*/true)
1489  .flag("-mnan=2008")
1490  .flag("-muclibc");
1491  auto BeHardUclibc = MultilibBuilder("/mips-r2-hard-uclibc")
1492  .flag("-EB")
1493  .flag("-msoft-float", /*Disallow=*/true)
1494  .flag("-mnan=2008", /*Disallow=*/true)
1495  .flag("-muclibc");
1496  auto ElHardUclibc = MultilibBuilder("/mipsel-r2-hard-uclibc")
1497  .flag("-EL")
1498  .flag("-msoft-float", /*Disallow=*/true)
1499  .flag("-mnan=2008", /*Disallow=*/true)
1500  .flag("-muclibc");
1501  auto ElMicroHardNan = MultilibBuilder("/micromipsel-r2-hard-nan2008")
1502  .flag("-EL")
1503  .flag("-msoft-float", /*Disallow=*/true)
1504  .flag("-mnan=2008")
1505  .flag("-mmicromips");
1506  auto ElMicroSoft = MultilibBuilder("/micromipsel-r2-soft")
1507  .flag("-EL")
1508  .flag("-msoft-float")
1509  .flag("-mnan=2008", /*Disallow=*/true)
1510  .flag("-mmicromips");
1511 
1512  auto O32 = MultilibBuilder("/lib")
1513  .osSuffix("")
1514  .flag("-mabi=n32", /*Disallow=*/true)
1515  .flag("-mabi=n64", /*Disallow=*/true);
1516  auto N32 = MultilibBuilder("/lib32")
1517  .osSuffix("")
1518  .flag("-mabi=n32")
1519  .flag("-mabi=n64", /*Disallow=*/true);
1520  auto N64 = MultilibBuilder("/lib64")
1521  .osSuffix("")
1522  .flag("-mabi=n32", /*Disallow=*/true)
1523  .flag("-mabi=n64");
1524 
1525  MtiMipsMultilibsV2 =
1526  MultilibSetBuilder()
1527  .Either({BeHard, BeSoft, ElHard, ElSoft, BeHardNan, ElHardNan,
1528  BeHardNanUclibc, ElHardNanUclibc, BeHardUclibc,
1529  ElHardUclibc, ElMicroHardNan, ElMicroSoft})
1530  .Either(O32, N32, N64)
1531  .makeMultilibSet()
1532  .FilterOut(NonExistent)
1533  .setIncludeDirsCallback([](const Multilib &M) {
1534  return std::vector<std::string>({"/../../../../sysroot" +
1535  M.includeSuffix() +
1536  "/../usr/include"});
1537  })
1538  .setFilePathsCallback([](const Multilib &M) {
1539  return std::vector<std::string>(
1540  {"/../../../../mips-mti-linux-gnu/lib" + M.gccSuffix()});
1541  });
1542  }
1543  for (auto *Candidate : {&MtiMipsMultilibsV1, &MtiMipsMultilibsV2}) {
1544  if (Candidate->select(Flags, Result.SelectedMultilibs)) {
1545  Result.Multilibs = *Candidate;
1546  return true;
1547  }
1548  }
1549  return false;
1550 }
1551 
1552 static bool findMipsImgMultilibs(const Multilib::flags_list &Flags,
1553  FilterNonExistent &NonExistent,
1554  DetectedMultilibs &Result) {
1555  // CodeScape IMG toolchain v1.2 and early.
1556  MultilibSet ImgMultilibsV1;
1557  {
1558  auto Mips64r6 = MultilibBuilder("/mips64r6")
1559  .flag("-m64")
1560  .flag("-m32", /*Disallow=*/true);
1561 
1562  auto LittleEndian =
1563  MultilibBuilder("/el").flag("-EL").flag("-EB", /*Disallow=*/true);
1564 
1565  auto MAbi64 = MultilibBuilder("/64")
1566  .flag("-mabi=n64")
1567  .flag("-mabi=n32", /*Disallow=*/true)
1568  .flag("-m32", /*Disallow=*/true);
1569 
1570  ImgMultilibsV1 =
1571  MultilibSetBuilder()
1572  .Maybe(Mips64r6)
1573  .Maybe(MAbi64)
1574  .Maybe(LittleEndian)
1575  .makeMultilibSet()
1576  .FilterOut(NonExistent)
1577  .setIncludeDirsCallback([](const Multilib &M) {
1578  return std::vector<std::string>(
1579  {"/include", "/../../../../sysroot/usr/include"});
1580  });
1581  }
1582 
1583  // CodeScape IMG toolchain starting from v1.3.
1584  MultilibSet ImgMultilibsV2;
1585  {
1586  auto BeHard = MultilibBuilder("/mips-r6-hard")
1587  .flag("-EB")
1588  .flag("-msoft-float", /*Disallow=*/true)
1589  .flag("-mmicromips", /*Disallow=*/true);
1590  auto BeSoft = MultilibBuilder("/mips-r6-soft")
1591  .flag("-EB")
1592  .flag("-msoft-float")
1593  .flag("-mmicromips", /*Disallow=*/true);
1594  auto ElHard = MultilibBuilder("/mipsel-r6-hard")
1595  .flag("-EL")
1596  .flag("-msoft-float", /*Disallow=*/true)
1597  .flag("-mmicromips", /*Disallow=*/true);
1598  auto ElSoft = MultilibBuilder("/mipsel-r6-soft")
1599  .flag("-EL")
1600  .flag("-msoft-float")
1601  .flag("-mmicromips", /*Disallow=*/true);
1602  auto BeMicroHard = MultilibBuilder("/micromips-r6-hard")
1603  .flag("-EB")
1604  .flag("-msoft-float", /*Disallow=*/true)
1605  .flag("-mmicromips");
1606  auto BeMicroSoft = MultilibBuilder("/micromips-r6-soft")
1607  .flag("-EB")
1608  .flag("-msoft-float")
1609  .flag("-mmicromips");
1610  auto ElMicroHard = MultilibBuilder("/micromipsel-r6-hard")
1611  .flag("-EL")
1612  .flag("-msoft-float", /*Disallow=*/true)
1613  .flag("-mmicromips");
1614  auto ElMicroSoft = MultilibBuilder("/micromipsel-r6-soft")
1615  .flag("-EL")
1616  .flag("-msoft-float")
1617  .flag("-mmicromips");
1618 
1619  auto O32 = MultilibBuilder("/lib")
1620  .osSuffix("")
1621  .flag("-mabi=n32", /*Disallow=*/true)
1622  .flag("-mabi=n64", /*Disallow=*/true);
1623  auto N32 = MultilibBuilder("/lib32")
1624  .osSuffix("")
1625  .flag("-mabi=n32")
1626  .flag("-mabi=n64", /*Disallow=*/true);
1627  auto N64 = MultilibBuilder("/lib64")
1628  .osSuffix("")
1629  .flag("-mabi=n32", /*Disallow=*/true)
1630  .flag("-mabi=n64");
1631 
1632  ImgMultilibsV2 =
1633  MultilibSetBuilder()
1634  .Either({BeHard, BeSoft, ElHard, ElSoft, BeMicroHard, BeMicroSoft,
1635  ElMicroHard, ElMicroSoft})
1636  .Either(O32, N32, N64)
1637  .makeMultilibSet()
1638  .FilterOut(NonExistent)
1639  .setIncludeDirsCallback([](const Multilib &M) {
1640  return std::vector<std::string>({"/../../../../sysroot" +
1641  M.includeSuffix() +
1642  "/../usr/include"});
1643  })
1644  .setFilePathsCallback([](const Multilib &M) {
1645  return std::vector<std::string>(
1646  {"/../../../../mips-img-linux-gnu/lib" + M.gccSuffix()});
1647  });
1648  }
1649  for (auto *Candidate : {&ImgMultilibsV1, &ImgMultilibsV2}) {
1650  if (Candidate->select(Flags, Result.SelectedMultilibs)) {
1651  Result.Multilibs = *Candidate;
1652  return true;
1653  }
1654  }
1655  return false;
1656 }
1657 
1658 bool clang::driver::findMIPSMultilibs(const Driver &D,
1659  const llvm::Triple &TargetTriple,
1660  StringRef Path, const ArgList &Args,
1661  DetectedMultilibs &Result) {
1662  FilterNonExistent NonExistent(Path, "/crtbegin.o", D.getVFS());
1663 
1664  StringRef CPUName;
1665  StringRef ABIName;
1666  tools::mips::getMipsCPUAndABI(Args, TargetTriple, CPUName, ABIName);
1667 
1668  llvm::Triple::ArchType TargetArch = TargetTriple.getArch();
1669 
1670  Multilib::flags_list Flags;
1671  addMultilibFlag(TargetTriple.isMIPS32(), "-m32", Flags);
1672  addMultilibFlag(TargetTriple.isMIPS64(), "-m64", Flags);
1673  addMultilibFlag(isMips16(Args), "-mips16", Flags);
1674  addMultilibFlag(CPUName == "mips32", "-march=mips32", Flags);
1675  addMultilibFlag(CPUName == "mips32r2" || CPUName == "mips32r3" ||
1676  CPUName == "mips32r5" || CPUName == "p5600",
1677  "-march=mips32r2", Flags);
1678  addMultilibFlag(CPUName == "mips32r6", "-march=mips32r6", Flags);
1679  addMultilibFlag(CPUName == "mips64", "-march=mips64", Flags);
1680  addMultilibFlag(CPUName == "mips64r2" || CPUName == "mips64r3" ||
1681  CPUName == "mips64r5" || CPUName == "octeon" ||
1682  CPUName == "octeon+",
1683  "-march=mips64r2", Flags);
1684  addMultilibFlag(CPUName == "mips64r6", "-march=mips64r6", Flags);
1685  addMultilibFlag(isMicroMips(Args), "-mmicromips", Flags);
1686  addMultilibFlag(tools::mips::isUCLibc(Args), "-muclibc", Flags);
1687  addMultilibFlag(tools::mips::isNaN2008(D, Args, TargetTriple), "-mnan=2008",
1688  Flags);
1689  addMultilibFlag(ABIName == "n32", "-mabi=n32", Flags);
1690  addMultilibFlag(ABIName == "n64", "-mabi=n64", Flags);
1691  addMultilibFlag(isSoftFloatABI(Args), "-msoft-float", Flags);
1692  addMultilibFlag(!isSoftFloatABI(Args), "-mhard-float", Flags);
1693  addMultilibFlag(isMipsEL(TargetArch), "-EL", Flags);
1694  addMultilibFlag(!isMipsEL(TargetArch), "-EB", Flags);
1695 
1696  if (TargetTriple.isAndroid())
1697  return findMipsAndroidMultilibs(D.getVFS(), Path, Flags, NonExistent,
1698  Result);
1699 
1700  if (TargetTriple.getVendor() == llvm::Triple::MipsTechnologies &&
1701  TargetTriple.getOS() == llvm::Triple::Linux &&
1702  TargetTriple.getEnvironment() == llvm::Triple::UnknownEnvironment)
1703  return findMipsMuslMultilibs(Flags, NonExistent, Result);
1704 
1705  if (TargetTriple.getVendor() == llvm::Triple::MipsTechnologies &&
1706  TargetTriple.getOS() == llvm::Triple::Linux &&
1707  TargetTriple.isGNUEnvironment())
1708  return findMipsMtiMultilibs(Flags, NonExistent, Result);
1709 
1710  if (TargetTriple.getVendor() == llvm::Triple::ImaginationTechnologies &&
1711  TargetTriple.getOS() == llvm::Triple::Linux &&
1712  TargetTriple.isGNUEnvironment())
1713  return findMipsImgMultilibs(Flags, NonExistent, Result);
1714 
1715  if (findMipsCsMultilibs(Flags, NonExistent, Result))
1716  return true;
1717 
1718  // Fallback to the regular toolchain-tree structure.
1719  Multilib Default;
1720  Result.Multilibs.push_back(Default);
1721  Result.Multilibs.FilterOut(NonExistent);
1722 
1723  if (Result.Multilibs.select(Flags, Result.SelectedMultilibs)) {
1724  Result.BiarchSibling = Multilib();
1725  return true;
1726  }
1727 
1728  return false;
1729 }
1730 
1731 static void findAndroidArmMultilibs(const Driver &D,
1732  const llvm::Triple &TargetTriple,
1733  StringRef Path, const ArgList &Args,
1734  DetectedMultilibs &Result) {
1735  // Find multilibs with subdirectories like armv7-a, thumb, armv7-a/thumb.
1736  FilterNonExistent NonExistent(Path, "/crtbegin.o", D.getVFS());
1737  MultilibBuilder ArmV7Multilib = MultilibBuilder("/armv7-a")
1738  .flag("-march=armv7-a")
1739  .flag("-mthumb", /*Disallow=*/true);
1740  MultilibBuilder ThumbMultilib = MultilibBuilder("/thumb")
1741  .flag("-march=armv7-a", /*Disallow=*/true)
1742  .flag("-mthumb");
1743  MultilibBuilder ArmV7ThumbMultilib =
1744  MultilibBuilder("/armv7-a/thumb").flag("-march=armv7-a").flag("-mthumb");
1745  MultilibBuilder DefaultMultilib =
1746  MultilibBuilder("")
1747  .flag("-march=armv7-a", /*Disallow=*/true)
1748  .flag("-mthumb", /*Disallow=*/true);
1749  MultilibSet AndroidArmMultilibs =
1750  MultilibSetBuilder()
1751  .Either(ThumbMultilib, ArmV7Multilib, ArmV7ThumbMultilib,
1752  DefaultMultilib)
1753  .makeMultilibSet()
1754  .FilterOut(NonExistent);
1755 
1756  Multilib::flags_list Flags;
1757  llvm::StringRef Arch = Args.getLastArgValue(options::OPT_march_EQ);
1758  bool IsArmArch = TargetTriple.getArch() == llvm::Triple::arm;
1759  bool IsThumbArch = TargetTriple.getArch() == llvm::Triple::thumb;
1760  bool IsV7SubArch = TargetTriple.getSubArch() == llvm::Triple::ARMSubArch_v7;
1761  bool IsThumbMode = IsThumbArch ||
1762  Args.hasFlag(options::OPT_mthumb, options::OPT_mno_thumb, false) ||
1763  (IsArmArch && llvm::ARM::parseArchISA(Arch) == llvm::ARM::ISAKind::THUMB);
1764  bool IsArmV7Mode = (IsArmArch || IsThumbArch) &&
1765  (llvm::ARM::parseArchVersion(Arch) == 7 ||
1766  (IsArmArch && Arch == "" && IsV7SubArch));
1767  addMultilibFlag(IsArmV7Mode, "-march=armv7-a", Flags);
1768  addMultilibFlag(IsThumbMode, "-mthumb", Flags);
1769 
1770  if (AndroidArmMultilibs.select(Flags, Result.SelectedMultilibs))
1771  Result.Multilibs = AndroidArmMultilibs;
1772 }
1773 
1774 static bool findMSP430Multilibs(const Driver &D,
1775  const llvm::Triple &TargetTriple,
1776  StringRef Path, const ArgList &Args,
1777  DetectedMultilibs &Result) {
1778  FilterNonExistent NonExistent(Path, "/crtbegin.o", D.getVFS());
1779  MultilibBuilder WithoutExceptions =
1780  MultilibBuilder("/430").flag("-exceptions", /*Disallow=*/true);
1781  MultilibBuilder WithExceptions =
1782  MultilibBuilder("/430/exceptions").flag("-exceptions");
1783 
1784  // FIXME: when clang starts to support msp430x ISA additional logic
1785  // to select between multilib must be implemented
1786  // MultilibBuilder MSP430xMultilib = MultilibBuilder("/large");
1787 
1788  Result.Multilibs.push_back(WithoutExceptions.makeMultilib());
1789  Result.Multilibs.push_back(WithExceptions.makeMultilib());
1790  Result.Multilibs.FilterOut(NonExistent);
1791 
1792  Multilib::flags_list Flags;
1793  addMultilibFlag(Args.hasFlag(options::OPT_fexceptions,
1794  options::OPT_fno_exceptions, false),
1795  "-exceptions", Flags);
1796  if (Result.Multilibs.select(Flags, Result.SelectedMultilibs))
1797  return true;
1798 
1799  return false;
1800 }
1801 
1802 static void findCSKYMultilibs(const Driver &D, const llvm::Triple &TargetTriple,
1803  StringRef Path, const ArgList &Args,
1804  DetectedMultilibs &Result) {
1805  FilterNonExistent NonExistent(Path, "/crtbegin.o", D.getVFS());
1806 
1807  tools::csky::FloatABI TheFloatABI = tools::csky::getCSKYFloatABI(D, Args);
1808  std::optional<llvm::StringRef> Res =
1809  tools::csky::getCSKYArchName(D, Args, TargetTriple);
1810 
1811  if (!Res)
1812  return;
1813  auto ARCHName = *Res;
1814 
1815  Multilib::flags_list Flags;
1816  addMultilibFlag(TheFloatABI == tools::csky::FloatABI::Hard, "-hard-fp",
1817  Flags);
1818  addMultilibFlag(TheFloatABI == tools::csky::FloatABI::SoftFP, "-soft-fp",
1819  Flags);
1820  addMultilibFlag(TheFloatABI == tools::csky::FloatABI::Soft, "-soft", Flags);
1821  addMultilibFlag(ARCHName == "ck801", "-march=ck801", Flags);
1822  addMultilibFlag(ARCHName == "ck802", "-march=ck802", Flags);
1823  addMultilibFlag(ARCHName == "ck803", "-march=ck803", Flags);
1824  addMultilibFlag(ARCHName == "ck804", "-march=ck804", Flags);
1825  addMultilibFlag(ARCHName == "ck805", "-march=ck805", Flags);
1826  addMultilibFlag(ARCHName == "ck807", "-march=ck807", Flags);
1827  addMultilibFlag(ARCHName == "ck810", "-march=ck810", Flags);
1828  addMultilibFlag(ARCHName == "ck810v", "-march=ck810v", Flags);
1829  addMultilibFlag(ARCHName == "ck860", "-march=ck860", Flags);
1830  addMultilibFlag(ARCHName == "ck860v", "-march=ck860v", Flags);
1831 
1832  bool isBigEndian = false;
1833  if (Arg *A = Args.getLastArg(options::OPT_mlittle_endian,
1834  options::OPT_mbig_endian))
1835  isBigEndian = !A->getOption().matches(options::OPT_mlittle_endian);
1836  addMultilibFlag(isBigEndian, "-EB", Flags);
1837 
1838  auto HardFloat = MultilibBuilder("/hard-fp").flag("-hard-fp");
1839  auto SoftFpFloat = MultilibBuilder("/soft-fp").flag("-soft-fp");
1840  auto SoftFloat = MultilibBuilder("").flag("-soft");
1841  auto Arch801 = MultilibBuilder("/ck801").flag("-march=ck801");
1842  auto Arch802 = MultilibBuilder("/ck802").flag("-march=ck802");
1843  auto Arch803 = MultilibBuilder("/ck803").flag("-march=ck803");
1844  // CK804 use the same library as CK803
1845  auto Arch804 = MultilibBuilder("/ck803").flag("-march=ck804");
1846  auto Arch805 = MultilibBuilder("/ck805").flag("-march=ck805");
1847  auto Arch807 = MultilibBuilder("/ck807").flag("-march=ck807");
1848  auto Arch810 = MultilibBuilder("").flag("-march=ck810");
1849  auto Arch810v = MultilibBuilder("/ck810v").flag("-march=ck810v");
1850  auto Arch860 = MultilibBuilder("/ck860").flag("-march=ck860");
1851  auto Arch860v = MultilibBuilder("/ck860v").flag("-march=ck860v");
1852  auto BigEndian = MultilibBuilder("/big").flag("-EB");
1853 
1854  MultilibSet CSKYMultilibs =
1855  MultilibSetBuilder()
1856  .Maybe(BigEndian)
1857  .Either({Arch801, Arch802, Arch803, Arch804, Arch805, Arch807,
1858  Arch810, Arch810v, Arch860, Arch860v})
1859  .Either(HardFloat, SoftFpFloat, SoftFloat)
1860  .makeMultilibSet()
1861  .FilterOut(NonExistent);
1862 
1863  if (CSKYMultilibs.select(Flags, Result.SelectedMultilibs))
1864  Result.Multilibs = CSKYMultilibs;
1865 }
1866 
1867 /// Extend the multi-lib re-use selection mechanism for RISC-V.
1868 /// This function will try to re-use multi-lib if they are compatible.
1869 /// Definition of compatible:
1870 /// - ABI must be the same.
1871 /// - multi-lib is a subset of current arch, e.g. multi-lib=march=rv32im
1872 /// is a subset of march=rv32imc.
1873 /// - march that contains atomic extension can't reuse multi-lib that
1874 /// doesn't have atomic, vice versa. e.g. multi-lib=march=rv32im and
1875 /// march=rv32ima are not compatible, because software and hardware
1876 /// atomic operation can't work together correctly.
1877 static bool
1878 selectRISCVMultilib(const MultilibSet &RISCVMultilibSet, StringRef Arch,
1879  const Multilib::flags_list &Flags,
1880  llvm::SmallVectorImpl<Multilib> &SelectedMultilibs) {
1881  // Try to find the perfect matching multi-lib first.
1882  if (RISCVMultilibSet.select(Flags, SelectedMultilibs))
1883  return true;
1884 
1885  Multilib::flags_list NewFlags;
1886  std::vector<MultilibBuilder> NewMultilibs;
1887 
1888  llvm::Expected<std::unique_ptr<llvm::RISCVISAInfo>> ParseResult =
1889  llvm::RISCVISAInfo::parseArchString(
1890  Arch, /*EnableExperimentalExtension=*/true,
1891  /*ExperimentalExtensionVersionCheck=*/false);
1892  // Ignore any error here, we assume it will be handled in another place.
1893  if (llvm::errorToBool(ParseResult.takeError()))
1894  return false;
1895 
1896  auto &ISAInfo = *ParseResult;
1897 
1898  addMultilibFlag(ISAInfo->getXLen() == 32, "-m32", NewFlags);
1899  addMultilibFlag(ISAInfo->getXLen() == 64, "-m64", NewFlags);
1900 
1901  // Collect all flags except march=*
1902  for (StringRef Flag : Flags) {
1903  if (Flag.starts_with("!march=") || Flag.starts_with("-march="))
1904  continue;
1905 
1906  NewFlags.push_back(Flag.str());
1907  }
1908 
1909  llvm::StringSet<> AllArchExts;
1910  // Reconstruct multi-lib list, and break march option into separated
1911  // extension. e.g. march=rv32im -> +i +m
1912  for (const auto &M : RISCVMultilibSet) {
1913  bool Skip = false;
1914 
1915  MultilibBuilder NewMultilib =
1916  MultilibBuilder(M.gccSuffix(), M.osSuffix(), M.includeSuffix());
1917  for (StringRef Flag : M.flags()) {
1918  // Add back all flags except -march.
1919  if (!Flag.consume_front("-march=")) {
1920  NewMultilib.flag(Flag);
1921  continue;
1922  }
1923 
1924  // Break down -march into individual extension.
1925  llvm::Expected<std::unique_ptr<llvm::RISCVISAInfo>> MLConfigParseResult =
1926  llvm::RISCVISAInfo::parseArchString(
1927  Flag, /*EnableExperimentalExtension=*/true,
1928  /*ExperimentalExtensionVersionCheck=*/false);
1929  // Ignore any error here, we assume it will handled in another place.
1930  if (llvm::errorToBool(MLConfigParseResult.takeError())) {
1931  // We might get a parsing error if rv32e in the list, we could just skip
1932  // that and process the rest of multi-lib configs.
1933  Skip = true;
1934  continue;
1935  }
1936  auto &MLConfigISAInfo = *MLConfigParseResult;
1937 
1938  for (auto &MLConfigArchExt : MLConfigISAInfo->getExtensions()) {
1939  auto ExtName = MLConfigArchExt.first;
1940  NewMultilib.flag(Twine("-", ExtName).str());
1941 
1942  if (AllArchExts.insert(ExtName).second) {
1943  addMultilibFlag(ISAInfo->hasExtension(ExtName),
1944  Twine("-", ExtName).str(), NewFlags);
1945  }
1946  }
1947 
1948  // Check the XLEN explicitly.
1949  if (MLConfigISAInfo->getXLen() == 32) {
1950  NewMultilib.flag("-m32");
1951  NewMultilib.flag("-m64", /*Disallow*/ true);
1952  } else {
1953  NewMultilib.flag("-m32", /*Disallow*/ true);
1954  NewMultilib.flag("-m64");
1955  }
1956 
1957  // Atomic extension must be explicitly checked, soft and hard atomic
1958  // operation never co-work correctly.
1959  if (!MLConfigISAInfo->hasExtension("a"))
1960  NewMultilib.flag("-a", /*Disallow*/ true);
1961  }
1962 
1963  if (Skip)
1964  continue;
1965 
1966  NewMultilibs.emplace_back(NewMultilib);
1967  }
1968 
1969  // Build an internal used only multi-lib list, used for checking any
1970  // compatible multi-lib.
1971  MultilibSet NewRISCVMultilibs =
1972  MultilibSetBuilder().Either(NewMultilibs).makeMultilibSet();
1973 
1974  if (NewRISCVMultilibs.select(NewFlags, SelectedMultilibs))
1975  for (const Multilib &NewSelectedM : SelectedMultilibs)
1976  for (const auto &M : RISCVMultilibSet)
1977  // Look up the corresponding multi-lib entry in original multi-lib set.
1978  if (M.gccSuffix() == NewSelectedM.gccSuffix())
1979  return true;
1980 
1981  return false;
1982 }
1983 
1984 static void findRISCVBareMetalMultilibs(const Driver &D,
1985  const llvm::Triple &TargetTriple,
1986  StringRef Path, const ArgList &Args,
1987  DetectedMultilibs &Result) {
1988  FilterNonExistent NonExistent(Path, "/crtbegin.o", D.getVFS());
1989  struct RiscvMultilib {
1990  StringRef march;
1991  StringRef mabi;
1992  };
1993  // currently only support the set of multilibs like riscv-gnu-toolchain does.
1994  // TODO: support MULTILIB_REUSE
1995  constexpr RiscvMultilib RISCVMultilibSet[] = {
1996  {"rv32i", "ilp32"}, {"rv32im", "ilp32"}, {"rv32iac", "ilp32"},
1997  {"rv32imac", "ilp32"}, {"rv32imafc", "ilp32f"}, {"rv64imac", "lp64"},
1998  {"rv64imafdc", "lp64d"}};
1999 
2000  std::vector<MultilibBuilder> Ms;
2001  for (auto Element : RISCVMultilibSet) {
2002  // multilib path rule is ${march}/${mabi}
2003  Ms.emplace_back(
2004  MultilibBuilder(
2005  (Twine(Element.march) + "/" + Twine(Element.mabi)).str())
2006  .flag(Twine("-march=", Element.march).str())
2007  .flag(Twine("-mabi=", Element.mabi).str()));
2008  }
2009  MultilibSet RISCVMultilibs =
2010  MultilibSetBuilder()
2011  .Either(Ms)
2012  .makeMultilibSet()
2013  .FilterOut(NonExistent)
2014  .setFilePathsCallback([](const Multilib &M) {
2015  return std::vector<std::string>(
2016  {M.gccSuffix(),
2017  "/../../../../riscv64-unknown-elf/lib" + M.gccSuffix(),
2018  "/../../../../riscv32-unknown-elf/lib" + M.gccSuffix()});
2019  });
2020 
2021  Multilib::flags_list Flags;
2022  llvm::StringSet<> Added_ABIs;
2023  StringRef ABIName = tools::riscv::getRISCVABI(Args, TargetTriple);
2024  StringRef MArch = tools::riscv::getRISCVArch(Args, TargetTriple);
2025  for (auto Element : RISCVMultilibSet) {
2026  addMultilibFlag(MArch == Element.march,
2027  Twine("-march=", Element.march).str().c_str(), Flags);
2028  if (!Added_ABIs.count(Element.mabi)) {
2029  Added_ABIs.insert(Element.mabi);
2030  addMultilibFlag(ABIName == Element.mabi,
2031  Twine("-mabi=", Element.mabi).str().c_str(), Flags);
2032  }
2033  }
2034 
2035  if (selectRISCVMultilib(RISCVMultilibs, MArch, Flags,
2036  Result.SelectedMultilibs))
2037  Result.Multilibs = RISCVMultilibs;
2038 }
2039 
2040 static void findRISCVMultilibs(const Driver &D,
2041  const llvm::Triple &TargetTriple, StringRef Path,
2042  const ArgList &Args, DetectedMultilibs &Result) {
2043  if (TargetTriple.getOS() == llvm::Triple::UnknownOS)
2044  return findRISCVBareMetalMultilibs(D, TargetTriple, Path, Args, Result);
2045 
2046  FilterNonExistent NonExistent(Path, "/crtbegin.o", D.getVFS());
2047  MultilibBuilder Ilp32 =
2048  MultilibBuilder("lib32/ilp32").flag("-m32").flag("-mabi=ilp32");
2049  MultilibBuilder Ilp32f =
2050  MultilibBuilder("lib32/ilp32f").flag("-m32").flag("-mabi=ilp32f");
2051  MultilibBuilder Ilp32d =
2052  MultilibBuilder("lib32/ilp32d").flag("-m32").flag("-mabi=ilp32d");
2053  MultilibBuilder Lp64 =
2054  MultilibBuilder("lib64/lp64").flag("-m64").flag("-mabi=lp64");
2055  MultilibBuilder Lp64f =
2056  MultilibBuilder("lib64/lp64f").flag("-m64").flag("-mabi=lp64f");
2057  MultilibBuilder Lp64d =
2058  MultilibBuilder("lib64/lp64d").flag("-m64").flag("-mabi=lp64d");
2059  MultilibSet RISCVMultilibs =
2060  MultilibSetBuilder()
2061  .Either({Ilp32, Ilp32f, Ilp32d, Lp64, Lp64f, Lp64d})
2062  .makeMultilibSet()
2063  .FilterOut(NonExistent);
2064 
2065  Multilib::flags_list Flags;
2066  bool IsRV64 = TargetTriple.getArch() == llvm::Triple::riscv64;
2067  StringRef ABIName = tools::riscv::getRISCVABI(Args, TargetTriple);
2068 
2069  addMultilibFlag(!IsRV64, "-m32", Flags);
2070  addMultilibFlag(IsRV64, "-m64", Flags);
2071  addMultilibFlag(ABIName == "ilp32", "-mabi=ilp32", Flags);
2072  addMultilibFlag(ABIName == "ilp32f", "-mabi=ilp32f", Flags);
2073  addMultilibFlag(ABIName == "ilp32d", "-mabi=ilp32d", Flags);
2074  addMultilibFlag(ABIName == "lp64", "-mabi=lp64", Flags);
2075  addMultilibFlag(ABIName == "lp64f", "-mabi=lp64f", Flags);
2076  addMultilibFlag(ABIName == "lp64d", "-mabi=lp64d", Flags);
2077 
2078  if (RISCVMultilibs.select(Flags, Result.SelectedMultilibs))
2079  Result.Multilibs = RISCVMultilibs;
2080 }
2081 
2082 static bool findBiarchMultilibs(const Driver &D,
2083  const llvm::Triple &TargetTriple,
2084  StringRef Path, const ArgList &Args,
2085  bool NeedsBiarchSuffix,
2086  DetectedMultilibs &Result) {
2087  MultilibBuilder DefaultBuilder;
2088 
2089  // Some versions of SUSE and Fedora on ppc64 put 32-bit libs
2090  // in what would normally be GCCInstallPath and put the 64-bit
2091  // libs in a subdirectory named 64. The simple logic we follow is that
2092  // *if* there is a subdirectory of the right name with crtbegin.o in it,
2093  // we use that. If not, and if not a biarch triple alias, we look for
2094  // crtbegin.o without the subdirectory.
2095 
2096  StringRef Suff64 = "/64";
2097  // Solaris uses platform-specific suffixes instead of /64.
2098  if (TargetTriple.isOSSolaris()) {
2099  switch (TargetTriple.getArch()) {
2100  case llvm::Triple::x86:
2101  case llvm::Triple::x86_64:
2102  Suff64 = "/amd64";
2103  break;
2104  case llvm::Triple::sparc:
2105  case llvm::Triple::sparcv9:
2106  Suff64 = "/sparcv9";
2107  break;
2108  default:
2109  break;
2110  }
2111  }
2112 
2113  Multilib Alt64 = MultilibBuilder()
2114  .gccSuffix(Suff64)
2115  .includeSuffix(Suff64)
2116  .flag("-m32", /*Disallow=*/true)
2117  .flag("-m64")
2118  .flag("-mx32", /*Disallow=*/true)
2119  .makeMultilib();
2120  Multilib Alt32 = MultilibBuilder()
2121  .gccSuffix("/32")
2122  .includeSuffix("/32")
2123  .flag("-m32")
2124  .flag("-m64", /*Disallow=*/true)
2125  .flag("-mx32", /*Disallow=*/true)
2126  .makeMultilib();
2127  Multilib Altx32 = MultilibBuilder()
2128  .gccSuffix("/x32")
2129  .includeSuffix("/x32")
2130  .flag("-m32", /*Disallow=*/true)
2131  .flag("-m64", /*Disallow=*/true)
2132  .flag("-mx32")
2133  .makeMultilib();
2134  Multilib Alt32sparc = MultilibBuilder()
2135  .gccSuffix("/sparcv8plus")
2136  .includeSuffix("/sparcv8plus")
2137  .flag("-m32")
2138  .flag("-m64", /*Disallow=*/true)
2139  .makeMultilib();
2140 
2141  // GCC toolchain for IAMCU doesn't have crtbegin.o, so look for libgcc.a.
2142  FilterNonExistent NonExistent(
2143  Path, TargetTriple.isOSIAMCU() ? "/libgcc.a" : "/crtbegin.o", D.getVFS());
2144 
2145  // Determine default multilib from: 32, 64, x32
2146  // Also handle cases such as 64 on 32, 32 on 64, etc.
2147  enum { UNKNOWN, WANT32, WANT64, WANTX32 } Want = UNKNOWN;
2148  const bool IsX32 = TargetTriple.isX32();
2149  if (TargetTriple.isArch32Bit() && !NonExistent(Alt32))
2150  Want = WANT64;
2151  if (TargetTriple.isArch32Bit() && !NonExistent(Alt32sparc))
2152  Want = WANT64;
2153  else if (TargetTriple.isArch64Bit() && IsX32 && !NonExistent(Altx32))
2154  Want = WANT64;
2155  else if (TargetTriple.isArch64Bit() && !IsX32 && !NonExistent(Alt64))
2156  Want = WANT32;
2157  else if (TargetTriple.isArch64Bit() && !NonExistent(Alt32sparc))
2158  Want = WANT64;
2159  else {
2160  if (TargetTriple.isArch32Bit())
2161  Want = NeedsBiarchSuffix ? WANT64 : WANT32;
2162  else if (IsX32)
2163  Want = NeedsBiarchSuffix ? WANT64 : WANTX32;
2164  else
2165  Want = NeedsBiarchSuffix ? WANT32 : WANT64;
2166  }
2167 
2168  if (Want == WANT32)
2169  DefaultBuilder.flag("-m32")
2170  .flag("-m64", /*Disallow=*/true)
2171  .flag("-mx32", /*Disallow=*/true);
2172  else if (Want == WANT64)
2173  DefaultBuilder.flag("-m32", /*Disallow=*/true)
2174  .flag("-m64")
2175  .flag("-mx32", /*Disallow=*/true);
2176  else if (Want == WANTX32)
2177  DefaultBuilder.flag("-m32", /*Disallow=*/true)
2178  .flag("-m64", /*Disallow=*/true)
2179  .flag("-mx32");
2180  else
2181  return false;
2182 
2183  Multilib Default = DefaultBuilder.makeMultilib();
2184 
2185  Result.Multilibs.push_back(Default);
2186  Result.Multilibs.push_back(Alt64);
2187  Result.Multilibs.push_back(Alt32);
2188  Result.Multilibs.push_back(Altx32);
2189  Result.Multilibs.push_back(Alt32sparc);
2190 
2191  Result.Multilibs.FilterOut(NonExistent);
2192 
2193  Multilib::flags_list Flags;
2194  addMultilibFlag(TargetTriple.isArch64Bit() && !IsX32, "-m64", Flags);
2195  addMultilibFlag(TargetTriple.isArch32Bit(), "-m32", Flags);
2196  addMultilibFlag(TargetTriple.isArch64Bit() && IsX32, "-mx32", Flags);
2197 
2198  if (!Result.Multilibs.select(Flags, Result.SelectedMultilibs))
2199  return false;
2200 
2201  if (Result.SelectedMultilibs.back() == Alt64 ||
2202  Result.SelectedMultilibs.back() == Alt32 ||
2203  Result.SelectedMultilibs.back() == Altx32 ||
2204  Result.SelectedMultilibs.back() == Alt32sparc)
2205  Result.BiarchSibling = Default;
2206 
2207  return true;
2208 }
2209 
2210 /// Generic_GCC - A tool chain using the 'gcc' command to perform
2211 /// all subcommands; this relies on gcc translating the majority of
2212 /// command line options.
2213 
2214 /// Less-than for GCCVersion, implementing a Strict Weak Ordering.
2215 bool Generic_GCC::GCCVersion::isOlderThan(int RHSMajor, int RHSMinor,
2216  int RHSPatch,
2217  StringRef RHSPatchSuffix) const {
2218  if (Major != RHSMajor)
2219  return Major < RHSMajor;
2220  if (Minor != RHSMinor) {
2221  // Note that versions without a specified minor sort higher than those with
2222  // a minor.
2223  if (RHSMinor == -1)
2224  return true;
2225  if (Minor == -1)
2226  return false;
2227  return Minor < RHSMinor;
2228  }
2229  if (Patch != RHSPatch) {
2230  // Note that versions without a specified patch sort higher than those with
2231  // a patch.
2232  if (RHSPatch == -1)
2233  return true;
2234  if (Patch == -1)
2235  return false;
2236 
2237  // Otherwise just sort on the patch itself.
2238  return Patch < RHSPatch;
2239  }
2240  if (PatchSuffix != RHSPatchSuffix) {
2241  // Sort empty suffixes higher.
2242  if (RHSPatchSuffix.empty())
2243  return true;
2244  if (PatchSuffix.empty())
2245  return false;
2246 
2247  // Provide a lexicographic sort to make this a total ordering.
2248  return PatchSuffix < RHSPatchSuffix;
2249  }
2250 
2251  // The versions are equal.
2252  return false;
2253 }
2254 
2255 /// Parse a GCCVersion object out of a string of text.
2256 ///
2257 /// This is the primary means of forming GCCVersion objects.
2258 /*static*/
2259 Generic_GCC::GCCVersion Generic_GCC::GCCVersion::Parse(StringRef VersionText) {
2260  const GCCVersion BadVersion = {VersionText.str(), -1, -1, -1, "", "", ""};
2261  std::pair<StringRef, StringRef> First = VersionText.split('.');
2262  std::pair<StringRef, StringRef> Second = First.second.split('.');
2263 
2264  StringRef MajorStr = First.first;
2265  StringRef MinorStr = Second.first;
2266  StringRef PatchStr = Second.second;
2267 
2268  GCCVersion GoodVersion = {VersionText.str(), -1, -1, -1, "", "", ""};
2269 
2270  // Parse version number strings such as:
2271  // 5
2272  // 4.4
2273  // 4.4-patched
2274  // 4.4.0
2275  // 4.4.x
2276  // 4.4.2-rc4
2277  // 4.4.x-patched
2278  // 10-win32
2279  // Split on '.', handle 1, 2 or 3 such segments. Each segment must contain
2280  // purely a number, except for the last one, where a non-number suffix
2281  // is stored in PatchSuffix. The third segment is allowed to not contain
2282  // a number at all.
2283 
2284  auto TryParseLastNumber = [&](StringRef Segment, int &Number,
2285  std::string &OutStr) -> bool {
2286  // Look for a number prefix and parse that, and split out any trailing
2287  // string into GoodVersion.PatchSuffix.
2288 
2289  if (size_t EndNumber = Segment.find_first_not_of("0123456789")) {
2290  StringRef NumberStr = Segment.slice(0, EndNumber);
2291  if (NumberStr.getAsInteger(10, Number) || Number < 0)
2292  return false;
2293  OutStr = NumberStr;
2294  GoodVersion.PatchSuffix = Segment.substr(EndNumber);
2295  return true;
2296  }
2297  return false;
2298  };
2299  auto TryParseNumber = [](StringRef Segment, int &Number) -> bool {
2300  if (Segment.getAsInteger(10, Number) || Number < 0)
2301  return false;
2302  return true;
2303  };
2304 
2305  if (MinorStr.empty()) {
2306  // If no minor string, major is the last segment
2307  if (!TryParseLastNumber(MajorStr, GoodVersion.Major, GoodVersion.MajorStr))
2308  return BadVersion;
2309  return GoodVersion;
2310  }
2311 
2312  if (!TryParseNumber(MajorStr, GoodVersion.Major))
2313  return BadVersion;
2314  GoodVersion.MajorStr = MajorStr;
2315 
2316  if (PatchStr.empty()) {
2317  // If no patch string, minor is the last segment
2318  if (!TryParseLastNumber(MinorStr, GoodVersion.Minor, GoodVersion.MinorStr))
2319  return BadVersion;
2320  return GoodVersion;
2321  }
2322 
2323  if (!TryParseNumber(MinorStr, GoodVersion.Minor))
2324  return BadVersion;
2325  GoodVersion.MinorStr = MinorStr;
2326 
2327  // For the last segment, tolerate a missing number.
2328  std::string DummyStr;
2329  TryParseLastNumber(PatchStr, GoodVersion.Patch, DummyStr);
2330  return GoodVersion;
2331 }
2332 
2333 static llvm::StringRef getGCCToolchainDir(const ArgList &Args,
2334  llvm::StringRef SysRoot) {
2335  const Arg *A = Args.getLastArg(clang::driver::options::OPT_gcc_toolchain);
2336  if (A)
2337  return A->getValue();
2338 
2339  // If we have a SysRoot, ignore GCC_INSTALL_PREFIX.
2340  // GCC_INSTALL_PREFIX specifies the gcc installation for the default
2341  // sysroot and is likely not valid with a different sysroot.
2342  if (!SysRoot.empty())
2343  return "";
2344 
2345  return GCC_INSTALL_PREFIX;
2346 }
2347 
2348 /// Initialize a GCCInstallationDetector from the driver.
2349 ///
2350 /// This performs all of the autodetection and sets up the various paths.
2351 /// Once constructed, a GCCInstallationDetector is essentially immutable.
2352 ///
2353 /// FIXME: We shouldn't need an explicit TargetTriple parameter here, and
2354 /// should instead pull the target out of the driver. This is currently
2355 /// necessary because the driver doesn't store the final version of the target
2356 /// triple.
2357 void Generic_GCC::GCCInstallationDetector::init(
2358  const llvm::Triple &TargetTriple, const ArgList &Args) {
2359  llvm::Triple BiarchVariantTriple = TargetTriple.isArch32Bit()
2360  ? TargetTriple.get64BitArchVariant()
2361  : TargetTriple.get32BitArchVariant();
2362  // The library directories which may contain GCC installations.
2363  SmallVector<StringRef, 4> CandidateLibDirs, CandidateBiarchLibDirs;
2364  // The compatible GCC triples for this particular architecture.
2365  SmallVector<StringRef, 16> CandidateTripleAliases;
2366  SmallVector<StringRef, 16> CandidateBiarchTripleAliases;
2367  // Add some triples that we want to check first.
2368  CandidateTripleAliases.push_back(TargetTriple.str());
2369  std::string TripleNoVendor = TargetTriple.getArchName().str() + "-" +
2370  TargetTriple.getOSAndEnvironmentName().str();
2371  if (TargetTriple.getVendor() == llvm::Triple::UnknownVendor)
2372  CandidateTripleAliases.push_back(TripleNoVendor);
2373 
2374  CollectLibDirsAndTriples(TargetTriple, BiarchVariantTriple, CandidateLibDirs,
2375  CandidateTripleAliases, CandidateBiarchLibDirs,
2376  CandidateBiarchTripleAliases);
2377 
2378  // If --gcc-install-dir= is specified, skip filesystem detection.
2379  if (const Arg *A =
2380  Args.getLastArg(clang::driver::options::OPT_gcc_install_dir_EQ);
2381  A && A->getValue()[0]) {
2382  StringRef InstallDir = A->getValue();
2383  if (!ScanGCCForMultilibs(TargetTriple, Args, InstallDir, false)) {
2384  D.Diag(diag::err_drv_invalid_gcc_install_dir) << InstallDir;
2385  } else {
2386  (void)InstallDir.consume_back("/");
2387  StringRef VersionText = llvm::sys::path::filename(InstallDir);
2388  StringRef TripleText =
2389  llvm::sys::path::filename(llvm::sys::path::parent_path(InstallDir));
2390 
2391  Version = GCCVersion::Parse(VersionText);
2392  GCCTriple.setTriple(TripleText);
2393  GCCInstallPath = std::string(InstallDir);
2394  GCCParentLibPath = GCCInstallPath + "/../../..";
2395  IsValid = true;
2396  }
2397  return;
2398  }
2399 
2400  // If --gcc-triple is specified use this instead of trying to
2401  // auto-detect a triple.
2402  if (const Arg *A =
2403  Args.getLastArg(clang::driver::options::OPT_gcc_triple_EQ)) {
2404  StringRef GCCTriple = A->getValue();
2405  CandidateTripleAliases.clear();
2406  CandidateTripleAliases.push_back(GCCTriple);
2407  }
2408 
2409  // Compute the set of prefixes for our search.
2410  SmallVector<std::string, 8> Prefixes;
2411  StringRef GCCToolchainDir = getGCCToolchainDir(Args, D.SysRoot);
2412  if (GCCToolchainDir != "") {
2413  if (GCCToolchainDir.back() == '/')
2414  GCCToolchainDir = GCCToolchainDir.drop_back(); // remove the /
2415 
2416  Prefixes.push_back(std::string(GCCToolchainDir));
2417  } else {
2418  // If we have a SysRoot, try that first.
2419  if (!D.SysRoot.empty()) {
2420  Prefixes.push_back(D.SysRoot);
2421  AddDefaultGCCPrefixes(TargetTriple, Prefixes, D.SysRoot);
2422  }
2423 
2424  // Then look for gcc installed alongside clang.
2425  Prefixes.push_back(D.Dir + "/..");
2426 
2427  // Next, look for prefix(es) that correspond to distribution-supplied gcc
2428  // installations.
2429  if (D.SysRoot.empty()) {
2430  // Typically /usr.
2431  AddDefaultGCCPrefixes(TargetTriple, Prefixes, D.SysRoot);
2432  }
2433 
2434  // Try to respect gcc-config on Gentoo if --gcc-toolchain is not provided.
2435  // This avoids accidentally enforcing the system GCC version when using a
2436  // custom toolchain.
2437  SmallVector<StringRef, 16> GentooTestTriples;
2438  // Try to match an exact triple as target triple first.
2439  // e.g. crossdev -S x86_64-gentoo-linux-gnu will install gcc libs for
2440  // x86_64-gentoo-linux-gnu. But "clang -target x86_64-gentoo-linux-gnu"
2441  // may pick the libraries for x86_64-pc-linux-gnu even when exact matching
2442  // triple x86_64-gentoo-linux-gnu is present.
2443  GentooTestTriples.push_back(TargetTriple.str());
2444  GentooTestTriples.append(CandidateTripleAliases.begin(),
2445  CandidateTripleAliases.end());
2446  if (ScanGentooConfigs(TargetTriple, Args, GentooTestTriples,
2447  CandidateBiarchTripleAliases))
2448  return;
2449  }
2450 
2451  // Loop over the various components which exist and select the best GCC
2452  // installation available. GCC installs are ranked by version number.
2453  const GCCVersion VersionZero = GCCVersion::Parse("0.0.0");
2454  Version = VersionZero;
2455  for (const std::string &Prefix : Prefixes) {
2456  auto &VFS = D.getVFS();
2457  if (!VFS.exists(Prefix))
2458  continue;
2459  for (StringRef Suffix : CandidateLibDirs) {
2460  const std::string LibDir = concat(Prefix, Suffix);
2461  if (!VFS.exists(LibDir))
2462  continue;
2463  // Maybe filter out <libdir>/gcc and <libdir>/gcc-cross.
2464  bool GCCDirExists = VFS.exists(LibDir + "/gcc");
2465  bool GCCCrossDirExists = VFS.exists(LibDir + "/gcc-cross");
2466  for (StringRef Candidate : CandidateTripleAliases)
2467  ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate, false,
2468  GCCDirExists, GCCCrossDirExists);
2469  }
2470  for (StringRef Suffix : CandidateBiarchLibDirs) {
2471  const std::string LibDir = Prefix + Suffix.str();
2472  if (!VFS.exists(LibDir))
2473  continue;
2474  bool GCCDirExists = VFS.exists(LibDir + "/gcc");
2475  bool GCCCrossDirExists = VFS.exists(LibDir + "/gcc-cross");
2476  for (StringRef Candidate : CandidateBiarchTripleAliases)
2477  ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate, true,
2478  GCCDirExists, GCCCrossDirExists);
2479  }
2480 
2481  // Skip other prefixes once a GCC installation is found.
2482  if (Version > VersionZero)
2483  break;
2484  }
2485 }
2486 
2487 void Generic_GCC::GCCInstallationDetector::print(raw_ostream &OS) const {
2488  for (const auto &InstallPath : CandidateGCCInstallPaths)
2489  OS << "Found candidate GCC installation: " << InstallPath << "\n";
2490 
2491  if (!GCCInstallPath.empty())
2492  OS << "Selected GCC installation: " << GCCInstallPath << "\n";
2493 
2494  for (const auto &Multilib : Multilibs)
2495  OS << "Candidate multilib: " << Multilib << "\n";
2496 
2497  if (Multilibs.size() != 0 || !SelectedMultilib.isDefault())
2498  OS << "Selected multilib: " << SelectedMultilib << "\n";
2499 }
2500 
2501 bool Generic_GCC::GCCInstallationDetector::getBiarchSibling(Multilib &M) const {
2502  if (BiarchSibling) {
2503  M = *BiarchSibling;
2504  return true;
2505  }
2506  return false;
2507 }
2508 
2509 void Generic_GCC::GCCInstallationDetector::AddDefaultGCCPrefixes(
2510  const llvm::Triple &TargetTriple, SmallVectorImpl<std::string> &Prefixes,
2511  StringRef SysRoot) {
2512 
2513  if (TargetTriple.isOSHaiku()) {
2514  Prefixes.push_back(concat(SysRoot, "/boot/system/develop/tools"));
2515  return;
2516  }
2517 
2518  if (TargetTriple.isOSSolaris()) {
2519  // Solaris is a special case.
2520  // The GCC installation is under
2521  // /usr/gcc/<major>.<minor>/lib/gcc/<triple>/<major>.<minor>.<patch>/
2522  // so we need to find those /usr/gcc/*/lib/gcc libdirs and go with
2523  // /usr/gcc/<version> as a prefix.
2524 
2525  SmallVector<std::pair<GCCVersion, std::string>, 8> SolarisPrefixes;
2526  std::string PrefixDir = concat(SysRoot, "/usr/gcc");
2527  std::error_code EC;
2528  for (llvm::vfs::directory_iterator LI = D.getVFS().dir_begin(PrefixDir, EC),
2529  LE;
2530  !EC && LI != LE; LI = LI.increment(EC)) {
2531  StringRef VersionText = llvm::sys::path::filename(LI->path());
2532  GCCVersion CandidateVersion = GCCVersion::Parse(VersionText);
2533 
2534  // Filter out obviously bad entries.
2535  if (CandidateVersion.Major == -1 || CandidateVersion.isOlderThan(4, 1, 1))
2536  continue;
2537 
2538  std::string CandidatePrefix = PrefixDir + "/" + VersionText.str();
2539  std::string CandidateLibPath = CandidatePrefix + "/lib/gcc";
2540  if (!D.getVFS().exists(CandidateLibPath))
2541  continue;
2542 
2543  SolarisPrefixes.emplace_back(
2544  std::make_pair(CandidateVersion, CandidatePrefix));
2545  }
2546  // Sort in reverse order so GCCInstallationDetector::init picks the latest.
2547  std::sort(SolarisPrefixes.rbegin(), SolarisPrefixes.rend());
2548  for (auto p : SolarisPrefixes)
2549  Prefixes.emplace_back(p.second);
2550  return;
2551  }
2552 
2553  // For Linux, if --sysroot is not specified, look for RHEL/CentOS devtoolsets
2554  // and gcc-toolsets.
2555  if (SysRoot.empty() && TargetTriple.getOS() == llvm::Triple::Linux &&
2556  D.getVFS().exists("/opt/rh")) {
2557  // TODO: We may want to remove this, since the functionality
2558  // can be achieved using config files.
2559  Prefixes.push_back("/opt/rh/gcc-toolset-12/root/usr");
2560  Prefixes.push_back("/opt/rh/gcc-toolset-11/root/usr");
2561  Prefixes.push_back("/opt/rh/gcc-toolset-10/root/usr");
2562  Prefixes.push_back("/opt/rh/devtoolset-12/root/usr");
2563  Prefixes.push_back("/opt/rh/devtoolset-11/root/usr");
2564  Prefixes.push_back("/opt/rh/devtoolset-10/root/usr");
2565  Prefixes.push_back("/opt/rh/devtoolset-9/root/usr");
2566  Prefixes.push_back("/opt/rh/devtoolset-8/root/usr");
2567  Prefixes.push_back("/opt/rh/devtoolset-7/root/usr");
2568  Prefixes.push_back("/opt/rh/devtoolset-6/root/usr");
2569  Prefixes.push_back("/opt/rh/devtoolset-4/root/usr");
2570  Prefixes.push_back("/opt/rh/devtoolset-3/root/usr");
2571  Prefixes.push_back("/opt/rh/devtoolset-2/root/usr");
2572  }
2573 
2574  // Fall back to /usr which is used by most non-Solaris systems.
2575  Prefixes.push_back(concat(SysRoot, "/usr"));
2576 }
2577 
2578 /*static*/ void Generic_GCC::GCCInstallationDetector::CollectLibDirsAndTriples(
2579  const llvm::Triple &TargetTriple, const llvm::Triple &BiarchTriple,
2580  SmallVectorImpl<StringRef> &LibDirs,
2581  SmallVectorImpl<StringRef> &TripleAliases,
2582  SmallVectorImpl<StringRef> &BiarchLibDirs,
2583  SmallVectorImpl<StringRef> &BiarchTripleAliases) {
2584  // Declare a bunch of static data sets that we'll select between below. These
2585  // are specifically designed to always refer to string literals to avoid any
2586  // lifetime or initialization issues.
2587  //
2588  // The *Triples variables hard code some triples so that, for example,
2589  // --target=aarch64 (incomplete triple) can detect lib/aarch64-linux-gnu.
2590  // They are not needed when the user has correct LLVM_DEFAULT_TARGET_TRIPLE
2591  // and always uses the full --target (e.g. --target=aarch64-linux-gnu). The
2592  // lists should shrink over time. Please don't add more elements to *Triples.
2593  static const char *const AArch64LibDirs[] = {"/lib64", "/lib"};
2594  static const char *const AArch64Triples[] = {
2595  "aarch64-none-linux-gnu", "aarch64-linux-gnu", "aarch64-redhat-linux",
2596  "aarch64-suse-linux"};
2597  static const char *const AArch64beLibDirs[] = {"/lib"};
2598  static const char *const AArch64beTriples[] = {"aarch64_be-none-linux-gnu",
2599  "aarch64_be-linux-gnu"};
2600 
2601  static const char *const ARMLibDirs[] = {"/lib"};
2602  static const char *const ARMTriples[] = {"arm-linux-gnueabi"};
2603  static const char *const ARMHFTriples[] = {"arm-linux-gnueabihf",
2604  "armv7hl-redhat-linux-gnueabi",
2605  "armv6hl-suse-linux-gnueabi",
2606  "armv7hl-suse-linux-gnueabi"};
2607  static const char *const ARMebLibDirs[] = {"/lib"};
2608  static const char *const ARMebTriples[] = {"armeb-linux-gnueabi"};
2609  static const char *const ARMebHFTriples[] = {
2610  "armeb-linux-gnueabihf", "armebv7hl-redhat-linux-gnueabi"};
2611 
2612  static const char *const AVRLibDirs[] = {"/lib"};
2613  static const char *const AVRTriples[] = {"avr"};
2614 
2615  static const char *const CSKYLibDirs[] = {"/lib"};
2616  static const char *const CSKYTriples[] = {
2617  "csky-linux-gnuabiv2", "csky-linux-uclibcabiv2", "csky-elf-noneabiv2"};
2618 
2619  static const char *const X86_64LibDirs[] = {"/lib64", "/lib"};
2620  static const char *const X86_64Triples[] = {
2621  "x86_64-linux-gnu", "x86_64-unknown-linux-gnu",
2622  "x86_64-pc-linux-gnu", "x86_64-redhat-linux6E",
2623  "x86_64-redhat-linux", "x86_64-suse-linux",
2624  "x86_64-manbo-linux-gnu", "x86_64-linux-gnu",
2625  "x86_64-slackware-linux", "x86_64-unknown-linux",
2626  "x86_64-amazon-linux"};
2627  static const char *const X32Triples[] = {"x86_64-linux-gnux32",
2628  "x86_64-pc-linux-gnux32"};
2629  static const char *const X32LibDirs[] = {"/libx32", "/lib"};
2630  static const char *const X86LibDirs[] = {"/lib32", "/lib"};
2631  static const char *const X86Triples[] = {
2632  "i586-linux-gnu", "i686-linux-gnu", "i686-pc-linux-gnu",
2633  "i386-redhat-linux6E", "i686-redhat-linux", "i386-redhat-linux",
2634  "i586-suse-linux", "i686-montavista-linux",
2635  };
2636 
2637  static const char *const LoongArch64LibDirs[] = {"/lib64", "/lib"};
2638  static const char *const LoongArch64Triples[] = {
2639  "loongarch64-linux-gnu", "loongarch64-unknown-linux-gnu"};
2640 
2641  static const char *const M68kLibDirs[] = {"/lib"};
2642  static const char *const M68kTriples[] = {
2643  "m68k-linux-gnu", "m68k-unknown-linux-gnu", "m68k-suse-linux"};
2644 
2645  static const char *const MIPSLibDirs[] = {"/libo32", "/lib"};
2646  static const char *const MIPSTriples[] = {
2647  "mips-linux-gnu", "mips-mti-linux", "mips-mti-linux-gnu",
2648  "mips-img-linux-gnu", "mipsisa32r6-linux-gnu"};
2649  static const char *const MIPSELLibDirs[] = {"/libo32", "/lib"};
2650  static const char *const MIPSELTriples[] = {
2651  "mipsel-linux-gnu", "mips-img-linux-gnu", "mipsisa32r6el-linux-gnu"};
2652 
2653  static const char *const MIPS64LibDirs[] = {"/lib64", "/lib"};
2654  static const char *const MIPS64Triples[] = {
2655  "mips64-linux-gnu", "mips-mti-linux-gnu",
2656  "mips-img-linux-gnu", "mips64-linux-gnuabi64",
2657  "mipsisa64r6-linux-gnu", "mipsisa64r6-linux-gnuabi64"};
2658  static const char *const MIPS64ELLibDirs[] = {"/lib64", "/lib"};
2659  static const char *const MIPS64ELTriples[] = {
2660  "mips64el-linux-gnu", "mips-mti-linux-gnu",
2661  "mips-img-linux-gnu", "mips64el-linux-gnuabi64",
2662  "mipsisa64r6el-linux-gnu", "mipsisa64r6el-linux-gnuabi64"};
2663 
2664  static const char *const MIPSN32LibDirs[] = {"/lib32"};
2665  static const char *const MIPSN32Triples[] = {"mips64-linux-gnuabin32",
2666  "mipsisa64r6-linux-gnuabin32"};
2667  static const char *const MIPSN32ELLibDirs[] = {"/lib32"};
2668  static const char *const MIPSN32ELTriples[] = {
2669  "mips64el-linux-gnuabin32", "mipsisa64r6el-linux-gnuabin32"};
2670 
2671  static const char *const MSP430LibDirs[] = {"/lib"};
2672  static const char *const MSP430Triples[] = {"msp430-elf"};
2673 
2674  static const char *const PPCLibDirs[] = {"/lib32", "/lib"};
2675  static const char *const PPCTriples[] = {
2676  "powerpc-linux-gnu", "powerpc-unknown-linux-gnu", "powerpc-linux-gnuspe",
2677  // On 32-bit PowerPC systems running SUSE Linux, gcc is configured as a
2678  // 64-bit compiler which defaults to "-m32", hence "powerpc64-suse-linux".
2679  "powerpc64-suse-linux", "powerpc-montavista-linuxspe"};
2680  static const char *const PPCLELibDirs[] = {"/lib32", "/lib"};
2681  static const char *const PPCLETriples[] = {"powerpcle-linux-gnu",
2682  "powerpcle-unknown-linux-gnu",
2683  "powerpcle-linux-musl"};
2684 
2685  static const char *const PPC64LibDirs[] = {"/lib64", "/lib"};
2686  static const char *const PPC64Triples[] = {
2687  "powerpc64-linux-gnu", "powerpc64-unknown-linux-gnu",
2688  "powerpc64-suse-linux", "ppc64-redhat-linux"};
2689  static const char *const PPC64LELibDirs[] = {"/lib64", "/lib"};
2690  static const char *const PPC64LETriples[] = {
2691  "powerpc64le-linux-gnu", "powerpc64le-unknown-linux-gnu",
2692  "powerpc64le-none-linux-gnu", "powerpc64le-suse-linux",
2693  "ppc64le-redhat-linux"};
2694 
2695  static const char *const RISCV32LibDirs[] = {"/lib32", "/lib"};
2696  static const char *const RISCV32Triples[] = {"riscv32-unknown-linux-gnu",
2697  "riscv32-linux-gnu",
2698  "riscv32-unknown-elf"};
2699  static const char *const RISCV64LibDirs[] = {"/lib64", "/lib"};
2700  static const char *const RISCV64Triples[] = {"riscv64-unknown-linux-gnu",
2701  "riscv64-linux-gnu",
2702  "riscv64-unknown-elf"};
2703 
2704  static const char *const SPARCv8LibDirs[] = {"/lib32", "/lib"};
2705  static const char *const SPARCv8Triples[] = {"sparc-linux-gnu",
2706  "sparcv8-linux-gnu"};
2707  static const char *const SPARCv9LibDirs[] = {"/lib64", "/lib"};
2708  static const char *const SPARCv9Triples[] = {"sparc64-linux-gnu",
2709  "sparcv9-linux-gnu"};
2710 
2711  static const char *const SystemZLibDirs[] = {"/lib64", "/lib"};
2712  static const char *const SystemZTriples[] = {
2713  "s390x-linux-gnu", "s390x-unknown-linux-gnu", "s390x-ibm-linux-gnu",
2714  "s390x-suse-linux", "s390x-redhat-linux"};
2715 
2716 
2717  using std::begin;
2718  using std::end;
2719 
2720  if (TargetTriple.isOSSolaris()) {
2721  static const char *const SolarisLibDirs[] = {"/lib"};
2722  static const char *const SolarisSparcV8Triples[] = {
2723  "sparc-sun-solaris2.11"};
2724  static const char *const SolarisSparcV9Triples[] = {
2725  "sparcv9-sun-solaris2.11"};
2726  static const char *const SolarisX86Triples[] = {"i386-pc-solaris2.11"};
2727  static const char *const SolarisX86_64Triples[] = {"x86_64-pc-solaris2.11"};
2728  LibDirs.append(begin(SolarisLibDirs), end(SolarisLibDirs));
2729  BiarchLibDirs.append(begin(SolarisLibDirs), end(SolarisLibDirs));
2730  switch (TargetTriple.getArch()) {
2731  case llvm::Triple::x86:
2732  TripleAliases.append(begin(SolarisX86Triples), end(SolarisX86Triples));
2733  BiarchTripleAliases.append(begin(SolarisX86_64Triples),
2734  end(SolarisX86_64Triples));
2735  break;
2736  case llvm::Triple::x86_64:
2737  TripleAliases.append(begin(SolarisX86_64Triples),
2738  end(SolarisX86_64Triples));
2739  BiarchTripleAliases.append(begin(SolarisX86Triples),
2740  end(SolarisX86Triples));
2741  break;
2742  case llvm::Triple::sparc:
2743  TripleAliases.append(begin(SolarisSparcV8Triples),
2744  end(SolarisSparcV8Triples));
2745  BiarchTripleAliases.append(begin(SolarisSparcV9Triples),
2746  end(SolarisSparcV9Triples));
2747  break;
2748  case llvm::Triple::sparcv9:
2749  TripleAliases.append(begin(SolarisSparcV9Triples),
2750  end(SolarisSparcV9Triples));
2751  BiarchTripleAliases.append(begin(SolarisSparcV8Triples),
2752  end(SolarisSparcV8Triples));
2753  break;
2754  default:
2755  break;
2756  }
2757  return;
2758  }
2759 
2760  // Android targets should not use GNU/Linux tools or libraries.
2761  if (TargetTriple.isAndroid()) {
2762  static const char *const AArch64AndroidTriples[] = {
2763  "aarch64-linux-android"};
2764  static const char *const ARMAndroidTriples[] = {"arm-linux-androideabi"};
2765  static const char *const X86AndroidTriples[] = {"i686-linux-android"};
2766  static const char *const X86_64AndroidTriples[] = {"x86_64-linux-android"};
2767 
2768  switch (TargetTriple.getArch()) {
2769  case llvm::Triple::aarch64:
2770  LibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs));
2771  TripleAliases.append(begin(AArch64AndroidTriples),
2772  end(AArch64AndroidTriples));
2773  break;
2774  case llvm::Triple::arm:
2775  case llvm::Triple::thumb:
2776  LibDirs.append(begin(ARMLibDirs), end(ARMLibDirs));
2777  TripleAliases.append(begin(ARMAndroidTriples), end(ARMAndroidTriples));
2778  break;
2779  case llvm::Triple::x86_64:
2780  LibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
2781  TripleAliases.append(begin(X86_64AndroidTriples),
2782  end(X86_64AndroidTriples));
2783  BiarchLibDirs.append(begin(X86LibDirs), end(X86LibDirs));
2784  BiarchTripleAliases.append(begin(X86AndroidTriples),
2785  end(X86AndroidTriples));
2786  break;
2787  case llvm::Triple::x86:
2788  LibDirs.append(begin(X86LibDirs), end(X86LibDirs));
2789  TripleAliases.append(begin(X86AndroidTriples), end(X86AndroidTriples));
2790  BiarchLibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
2791  BiarchTripleAliases.append(begin(X86_64AndroidTriples),
2792  end(X86_64AndroidTriples));
2793  break;
2794  default:
2795  break;
2796  }
2797 
2798  return;
2799  }
2800 
2801  if (TargetTriple.isOSHurd()) {
2802  switch (TargetTriple.getArch()) {
2803  case llvm::Triple::x86_64:
2804  LibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
2805  TripleAliases.push_back("x86_64-gnu");
2806  break;
2807  case llvm::Triple::x86:
2808  LibDirs.append(begin(X86LibDirs), end(X86LibDirs));
2809  TripleAliases.push_back("i686-gnu");
2810  break;
2811  default:
2812  break;
2813  }
2814 
2815  return;
2816  }
2817 
2818  switch (TargetTriple.getArch()) {
2819  case llvm::Triple::aarch64:
2820  LibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs));
2821  TripleAliases.append(begin(AArch64Triples), end(AArch64Triples));
2822  BiarchLibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs));
2823  BiarchTripleAliases.append(begin(AArch64Triples), end(AArch64Triples));
2824  break;
2825  case llvm::Triple::aarch64_be:
2826  LibDirs.append(begin(AArch64beLibDirs), end(AArch64beLibDirs));
2827  TripleAliases.append(begin(AArch64beTriples), end(AArch64beTriples));
2828  BiarchLibDirs.append(begin(AArch64beLibDirs), end(AArch64beLibDirs));
2829  BiarchTripleAliases.append(begin(AArch64beTriples), end(AArch64beTriples));
2830  break;
2831  case llvm::Triple::arm:
2832  case llvm::Triple::thumb:
2833  LibDirs.append(begin(ARMLibDirs), end(ARMLibDirs));
2834  if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF ||
2835  TargetTriple.getEnvironment() == llvm::Triple::MuslEABIHF ||
2836  TargetTriple.getEnvironment() == llvm::Triple::EABIHF) {
2837  TripleAliases.append(begin(ARMHFTriples), end(ARMHFTriples));
2838  } else {
2839  TripleAliases.append(begin(ARMTriples), end(ARMTriples));
2840  }
2841  break;
2842  case llvm::Triple::armeb:
2843  case llvm::Triple::thumbeb:
2844  LibDirs.append(begin(ARMebLibDirs), end(ARMebLibDirs));
2845  if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF ||
2846  TargetTriple.getEnvironment() == llvm::Triple::MuslEABIHF ||
2847  TargetTriple.getEnvironment() == llvm::Triple::EABIHF) {
2848  TripleAliases.append(begin(ARMebHFTriples), end(ARMebHFTriples));
2849  } else {
2850  TripleAliases.append(begin(ARMebTriples), end(ARMebTriples));
2851  }
2852  break;
2853  case llvm::Triple::avr:
2854  LibDirs.append(begin(AVRLibDirs), end(AVRLibDirs));
2855  TripleAliases.append(begin(AVRTriples), end(AVRTriples));
2856  break;
2857  case llvm::Triple::csky:
2858  LibDirs.append(begin(CSKYLibDirs), end(CSKYLibDirs));
2859  TripleAliases.append(begin(CSKYTriples), end(CSKYTriples));
2860  break;
2861  case llvm::Triple::x86_64:
2862  if (TargetTriple.isX32()) {
2863  LibDirs.append(begin(X32LibDirs), end(X32LibDirs));
2864  TripleAliases.append(begin(X32Triples), end(X32Triples));
2865  BiarchLibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
2866  BiarchTripleAliases.append(begin(X86_64Triples), end(X86_64Triples));
2867  } else {
2868  LibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
2869  TripleAliases.append(begin(X86_64Triples), end(X86_64Triples));
2870  BiarchLibDirs.append(begin(X32LibDirs), end(X32LibDirs));
2871  BiarchTripleAliases.append(begin(X32Triples), end(X32Triples));
2872  }
2873  BiarchLibDirs.append(begin(X86LibDirs), end(X86LibDirs));
2874  BiarchTripleAliases.append(begin(X86Triples), end(X86Triples));
2875  break;
2876  case llvm::Triple::x86:
2877  LibDirs.append(begin(X86LibDirs), end(X86LibDirs));
2878  // MCU toolchain is 32 bit only and its triple alias is TargetTriple
2879  // itself, which will be appended below.
2880  if (!TargetTriple.isOSIAMCU()) {
2881  TripleAliases.append(begin(X86Triples), end(X86Triples));
2882  BiarchLibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
2883  BiarchTripleAliases.append(begin(X86_64Triples), end(X86_64Triples));
2884  BiarchLibDirs.append(begin(X32LibDirs), end(X32LibDirs));
2885  BiarchTripleAliases.append(begin(X32Triples), end(X32Triples));
2886  }
2887  break;
2888  // TODO: Handle loongarch32.
2889  case llvm::Triple::loongarch64:
2890  LibDirs.append(begin(LoongArch64LibDirs), end(LoongArch64LibDirs));
2891  TripleAliases.append(begin(LoongArch64Triples), end(LoongArch64Triples));
2892  break;
2893  case llvm::Triple::m68k:
2894  LibDirs.append(begin(M68kLibDirs), end(M68kLibDirs));
2895  TripleAliases.append(begin(M68kTriples), end(M68kTriples));
2896  break;
2897  case llvm::Triple::mips:
2898  LibDirs.append(begin(MIPSLibDirs), end(MIPSLibDirs));
2899  TripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
2900  BiarchLibDirs.append(begin(MIPS64LibDirs), end(MIPS64LibDirs));
2901  BiarchTripleAliases.append(begin(MIPS64Triples), end(MIPS64Triples));
2902  BiarchLibDirs.append(begin(MIPSN32LibDirs), end(MIPSN32LibDirs));
2903  BiarchTripleAliases.append(begin(MIPSN32Triples), end(MIPSN32Triples));
2904  break;
2905  case llvm::Triple::mipsel:
2906  LibDirs.append(begin(MIPSELLibDirs), end(MIPSELLibDirs));
2907  TripleAliases.append(begin(MIPSELTriples), end(MIPSELTriples));
2908  TripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
2909  BiarchLibDirs.append(begin(MIPS64ELLibDirs), end(MIPS64ELLibDirs));
2910  BiarchTripleAliases.append(begin(MIPS64ELTriples), end(MIPS64ELTriples));
2911  BiarchLibDirs.append(begin(MIPSN32ELLibDirs), end(MIPSN32ELLibDirs));
2912  BiarchTripleAliases.append(begin(MIPSN32ELTriples), end(MIPSN32ELTriples));
2913  break;
2914  case llvm::Triple::mips64:
2915  LibDirs.append(begin(MIPS64LibDirs), end(MIPS64LibDirs));
2916  TripleAliases.append(begin(MIPS64Triples), end(MIPS64Triples));
2917  BiarchLibDirs.append(begin(MIPSLibDirs), end(MIPSLibDirs));
2918  BiarchTripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
2919  BiarchLibDirs.append(begin(MIPSN32LibDirs), end(MIPSN32LibDirs));
2920  BiarchTripleAliases.append(begin(MIPSN32Triples), end(MIPSN32Triples));
2921  break;
2922  case llvm::Triple::mips64el:
2923  LibDirs.append(begin(MIPS64ELLibDirs), end(MIPS64ELLibDirs));
2924  TripleAliases.append(begin(MIPS64ELTriples), end(MIPS64ELTriples));
2925  BiarchLibDirs.append(begin(MIPSELLibDirs), end(MIPSELLibDirs));
2926  BiarchTripleAliases.append(begin(MIPSELTriples), end(MIPSELTriples));
2927  BiarchLibDirs.append(begin(MIPSN32ELLibDirs), end(MIPSN32ELLibDirs));
2928  BiarchTripleAliases.append(begin(MIPSN32ELTriples), end(MIPSN32ELTriples));
2929  BiarchTripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
2930  break;
2931  case llvm::Triple::msp430:
2932  LibDirs.append(begin(MSP430LibDirs), end(MSP430LibDirs));
2933  TripleAliases.append(begin(MSP430Triples), end(MSP430Triples));
2934  break;
2935  case llvm::Triple::ppc:
2936  LibDirs.append(begin(PPCLibDirs), end(PPCLibDirs));
2937  TripleAliases.append(begin(PPCTriples), end(PPCTriples));
2938  BiarchLibDirs.append(begin(PPC64LibDirs), end(PPC64LibDirs));
2939  BiarchTripleAliases.append(begin(PPC64Triples), end(PPC64Triples));
2940  break;
2941  case llvm::Triple::ppcle:
2942  LibDirs.append(begin(PPCLELibDirs), end(PPCLELibDirs));
2943  TripleAliases.append(begin(PPCLETriples), end(PPCLETriples));
2944  BiarchLibDirs.append(begin(PPC64LELibDirs), end(PPC64LELibDirs));
2945  BiarchTripleAliases.append(begin(PPC64LETriples), end(PPC64LETriples));
2946  break;
2947  case llvm::Triple::ppc64:
2948  LibDirs.append(begin(PPC64LibDirs), end(PPC64LibDirs));
2949  TripleAliases.append(begin(PPC64Triples), end(PPC64Triples));
2950  BiarchLibDirs.append(begin(PPCLibDirs), end(PPCLibDirs));
2951  BiarchTripleAliases.append(begin(PPCTriples), end(PPCTriples));
2952  break;
2953  case llvm::Triple::ppc64le:
2954  LibDirs.append(begin(PPC64LELibDirs), end(PPC64LELibDirs));
2955  TripleAliases.append(begin(PPC64LETriples), end(PPC64LETriples));
2956  BiarchLibDirs.append(begin(PPCLELibDirs), end(PPCLELibDirs));
2957  BiarchTripleAliases.append(begin(PPCLETriples), end(PPCLETriples));
2958  break;
2959  case llvm::Triple::riscv32:
2960  LibDirs.append(begin(RISCV32LibDirs), end(RISCV32LibDirs));
2961  TripleAliases.append(begin(RISCV32Triples), end(RISCV32Triples));
2962  BiarchLibDirs.append(begin(RISCV64LibDirs), end(RISCV64LibDirs));
2963  BiarchTripleAliases.append(begin(RISCV64Triples), end(RISCV64Triples));
2964  break;
2965  case llvm::Triple::riscv64:
2966  LibDirs.append(begin(RISCV64LibDirs), end(RISCV64LibDirs));
2967  TripleAliases.append(begin(RISCV64Triples), end(RISCV64Triples));
2968  BiarchLibDirs.append(begin(RISCV32LibDirs), end(RISCV32LibDirs));
2969  BiarchTripleAliases.append(begin(RISCV32Triples), end(RISCV32Triples));
2970  break;
2971  case llvm::Triple::sparc:
2972  case llvm::Triple::sparcel:
2973  LibDirs.append(begin(SPARCv8LibDirs), end(SPARCv8LibDirs));
2974  TripleAliases.append(begin(SPARCv8Triples), end(SPARCv8Triples));
2975  BiarchLibDirs.append(begin(SPARCv9LibDirs), end(SPARCv9LibDirs));
2976  BiarchTripleAliases.append(begin(SPARCv9Triples), end(SPARCv9Triples));
2977  break;
2978  case llvm::Triple::sparcv9:
2979  LibDirs.append(begin(SPARCv9LibDirs), end(SPARCv9LibDirs));
2980  TripleAliases.append(begin(SPARCv9Triples), end(SPARCv9Triples));
2981  BiarchLibDirs.append(begin(SPARCv8LibDirs), end(SPARCv8LibDirs));
2982  BiarchTripleAliases.append(begin(SPARCv8Triples), end(SPARCv8Triples));
2983  break;
2984  case llvm::Triple::systemz:
2985  LibDirs.append(begin(SystemZLibDirs), end(SystemZLibDirs));
2986  TripleAliases.append(begin(SystemZTriples), end(SystemZTriples));
2987  break;
2988  default:
2989  // By default, just rely on the standard lib directories and the original
2990  // triple.
2991  break;
2992  }
2993 
2994  // Also include the multiarch variant if it's different.
2995  if (TargetTriple.str() != BiarchTriple.str())
2996  BiarchTripleAliases.push_back(BiarchTriple.str());
2997 }
2998 
2999 bool Generic_GCC::GCCInstallationDetector::ScanGCCForMultilibs(
3000  const llvm::Triple &TargetTriple, const ArgList &Args,
3001  StringRef Path, bool NeedsBiarchSuffix) {
3002  llvm::Triple::ArchType TargetArch = TargetTriple.getArch();
3003  DetectedMultilibs Detected;
3004 
3005  // Android standalone toolchain could have multilibs for ARM and Thumb.
3006  // Debian mips multilibs behave more like the rest of the biarch ones,
3007  // so handle them there
3008  if (isArmOrThumbArch(TargetArch) && TargetTriple.isAndroid()) {
3009  // It should also work without multilibs in a simplified toolchain.
3010  findAndroidArmMultilibs(D, TargetTriple, Path, Args, Detected);
3011  } else if (TargetTriple.isCSKY()) {
3012  findCSKYMultilibs(D, TargetTriple, Path, Args, Detected);
3013  } else if (TargetTriple.isMIPS()) {
3014  if (!findMIPSMultilibs(D, TargetTriple, Path, Args, Detected))
3015  return false;
3016  } else if (TargetTriple.isRISCV()) {
3017  findRISCVMultilibs(D, TargetTriple, Path, Args, Detected);
3018  } else if (isMSP430(TargetArch)) {
3019  findMSP430Multilibs(D, TargetTriple, Path, Args, Detected);
3020  } else if (TargetArch == llvm::Triple::avr) {
3021  // AVR has no multilibs.
3022  } else if (!findBiarchMultilibs(D, TargetTriple, Path, Args,
3023  NeedsBiarchSuffix, Detected)) {
3024  return false;
3025  }
3026 
3027  Multilibs = Detected.Multilibs;
3028  SelectedMultilib = Detected.SelectedMultilibs.empty()
3029  ? Multilib()
3030  : Detected.SelectedMultilibs.back();
3031  BiarchSibling = Detected.BiarchSibling;
3032 
3033  return true;
3034 }
3035 
3036 void Generic_GCC::GCCInstallationDetector::ScanLibDirForGCCTriple(
3037  const llvm::Triple &TargetTriple, const ArgList &Args,
3038  const std::string &LibDir, StringRef CandidateTriple,
3039  bool NeedsBiarchSuffix, bool GCCDirExists, bool GCCCrossDirExists) {
3040  // Locations relative to the system lib directory where GCC's triple-specific
3041  // directories might reside.
3042  struct GCCLibSuffix {
3043  // Path from system lib directory to GCC triple-specific directory.
3044  std::string LibSuffix;
3045  // Path from GCC triple-specific directory back to system lib directory.
3046  // This is one '..' component per component in LibSuffix.
3047  StringRef ReversePath;
3048  // Whether this library suffix is relevant for the triple.
3049  bool Active;
3050  } Suffixes[] = {
3051  // This is the normal place.
3052  {"gcc/" + CandidateTriple.str(), "../..", GCCDirExists},
3053 
3054  // Debian puts cross-compilers in gcc-cross.
3055  {"gcc-cross/" + CandidateTriple.str(), "../..", GCCCrossDirExists},
3056 
3057  // The Freescale PPC SDK has the gcc libraries in
3058  // <sysroot>/usr/lib/<triple>/x.y.z so have a look there as well. Only do
3059  // this on Freescale triples, though, since some systems put a *lot* of
3060  // files in that location, not just GCC installation data.
3061  {CandidateTriple.str(), "..",
3062  TargetTriple.getVendor() == llvm::Triple::Freescale ||
3063  TargetTriple.getVendor() == llvm::Triple::OpenEmbedded}};
3064 
3065  for (auto &Suffix : Suffixes) {
3066  if (!Suffix.Active)
3067  continue;
3068 
3069  StringRef LibSuffix = Suffix.LibSuffix;
3070  std::error_code EC;
3071  for (llvm::vfs::directory_iterator
3072  LI = D.getVFS().dir_begin(LibDir + "/" + LibSuffix, EC),
3073  LE;
3074  !EC && LI != LE; LI = LI.increment(EC)) {
3075  StringRef VersionText = llvm::sys::path::filename(LI->path());
3076  GCCVersion CandidateVersion = GCCVersion::Parse(VersionText);
3077  if (CandidateVersion.Major != -1) // Filter obviously bad entries.
3078  if (!CandidateGCCInstallPaths.insert(std::string(LI->path())).second)
3079  continue; // Saw this path before; no need to look at it again.
3080  if (CandidateVersion.isOlderThan(4, 1, 1))
3081  continue;
3082  if (CandidateVersion <= Version)
3083  continue;
3084 
3085  if (!ScanGCCForMultilibs(TargetTriple, Args, LI->path(),
3086  NeedsBiarchSuffix))
3087  continue;
3088 
3089  Version = CandidateVersion;
3090  GCCTriple.setTriple(CandidateTriple);
3091  // FIXME: We hack together the directory name here instead of
3092  // using LI to ensure stable path separators across Windows and
3093  // Linux.
3094  GCCInstallPath = (LibDir + "/" + LibSuffix + "/" + VersionText).str();
3095  GCCParentLibPath = (GCCInstallPath + "/../" + Suffix.ReversePath).str();
3096  IsValid = true;
3097  }
3098  }
3099 }
3100 
3101 bool Generic_GCC::GCCInstallationDetector::ScanGentooConfigs(
3102  const llvm::Triple &TargetTriple, const ArgList &Args,
3103  const SmallVectorImpl<StringRef> &CandidateTriples,
3104  const SmallVectorImpl<StringRef> &CandidateBiarchTriples) {
3105  if (!D.getVFS().exists(concat(D.SysRoot, GentooConfigDir)))
3106  return false;
3107 
3108  for (StringRef CandidateTriple : CandidateTriples) {
3109  if (ScanGentooGccConfig(TargetTriple, Args, CandidateTriple))
3110  return true;
3111  }
3112 
3113  for (StringRef CandidateTriple : CandidateBiarchTriples) {
3114  if (ScanGentooGccConfig(TargetTriple, Args, CandidateTriple, true))
3115  return true;
3116  }
3117  return false;
3118 }
3119 
3120 bool Generic_GCC::GCCInstallationDetector::ScanGentooGccConfig(
3121  const llvm::Triple &TargetTriple, const ArgList &Args,
3122  StringRef CandidateTriple, bool NeedsBiarchSuffix) {
3123  llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> File =
3124  D.getVFS().getBufferForFile(concat(D.SysRoot, GentooConfigDir,
3125  "/config-" + CandidateTriple.str()));
3126  if (File) {
3127  SmallVector<StringRef, 2> Lines;
3128  File.get()->getBuffer().split(Lines, "\n");
3129  for (StringRef Line : Lines) {
3130  Line = Line.trim();
3131  // CURRENT=triple-version
3132  if (!Line.consume_front("CURRENT="))
3133  continue;
3134  // Process the config file pointed to by CURRENT.
3135  llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> ConfigFile =
3136  D.getVFS().getBufferForFile(
3137  concat(D.SysRoot, GentooConfigDir, "/" + Line));
3138  std::pair<StringRef, StringRef> ActiveVersion = Line.rsplit('-');
3139  // List of paths to scan for libraries.
3140  SmallVector<StringRef, 4> GentooScanPaths;
3141  // Scan the Config file to find installed GCC libraries path.
3142  // Typical content of the GCC config file:
3143  // LDPATH="/usr/lib/gcc/x86_64-pc-linux-gnu/4.9.x:/usr/lib/gcc/
3144  // (continued from previous line) x86_64-pc-linux-gnu/4.9.x/32"
3145  // MANPATH="/usr/share/gcc-data/x86_64-pc-linux-gnu/4.9.x/man"
3146  // INFOPATH="/usr/share/gcc-data/x86_64-pc-linux-gnu/4.9.x/info"
3147  // STDCXX_INCDIR="/usr/lib/gcc/x86_64-pc-linux-gnu/4.9.x/include/g++-v4"
3148  // We are looking for the paths listed in LDPATH=... .
3149  if (ConfigFile) {
3150  SmallVector<StringRef, 2> ConfigLines;
3151  ConfigFile.get()->getBuffer().split(ConfigLines, "\n");
3152  for (StringRef ConfLine : ConfigLines) {
3153  ConfLine = ConfLine.trim();
3154  if (ConfLine.consume_front("LDPATH=")) {
3155  // Drop '"' from front and back if present.
3156  ConfLine.consume_back("\"");
3157  ConfLine.consume_front("\"");
3158  // Get all paths sperated by ':'
3159  ConfLine.split(GentooScanPaths, ':', -1, /*AllowEmpty*/ false);
3160  }
3161  }
3162  }
3163  // Test the path based on the version in /etc/env.d/gcc/config-{tuple}.
3164  std::string basePath = "/usr/lib/gcc/" + ActiveVersion.first.str() + "/"
3165  + ActiveVersion.second.str();
3166  GentooScanPaths.push_back(StringRef(basePath));
3167 
3168  // Scan all paths for GCC libraries.
3169  for (const auto &GentooScanPath : GentooScanPaths) {
3170  std::string GentooPath = concat(D.SysRoot, GentooScanPath);
3171  if (D.getVFS().exists(GentooPath + "/crtbegin.o")) {
3172  if (!ScanGCCForMultilibs(TargetTriple, Args, GentooPath,
3173  NeedsBiarchSuffix))
3174  continue;
3175 
3176  Version = GCCVersion::Parse(ActiveVersion.second);
3177  GCCInstallPath = GentooPath;
3178  GCCParentLibPath = GentooPath + std::string("/../../..");
3179  GCCTriple.setTriple(ActiveVersion.first);
3180  IsValid = true;
3181  return true;
3182  }
3183  }
3184  }
3185  }
3186 
3187  return false;
3188 }
3189 
3190 Generic_GCC::Generic_GCC(const Driver &D, const llvm::Triple &Triple,
3191  const ArgList &Args)
3192  : ToolChain(D, Triple, Args), GCCInstallation(D),
3193  CudaInstallation(D, Triple, Args), RocmInstallation(D, Triple, Args) {
3194  getProgramPaths().push_back(getDriver().Dir);
3195 }
3196 
3197 Generic_GCC::~Generic_GCC() {}
3198 
3199 Tool *Generic_GCC::getTool(Action::ActionClass AC) const {
3200  switch (AC) {
3201  case Action::PreprocessJobClass:
3202  if (!Preprocess)
3203  Preprocess.reset(new clang::driver::tools::gcc::Preprocessor(*this));
3204  return Preprocess.get();
3205  case Action::CompileJobClass:
3206  if (!Compile)
3207  Compile.reset(new tools::gcc::Compiler(*this));
3208  return Compile.get();
3209  default:
3210  return ToolChain::getTool(AC);
3211  }
3212 }
3213 
3214 Tool *Generic_GCC::buildAssembler() const {
3215  return new tools::gnutools::Assembler(*this);
3216 }
3217 
3218 Tool *Generic_GCC::buildLinker() const { return new tools::gcc::Linker(*this); }
3219 
3220 void Generic_GCC::printVerboseInfo(raw_ostream &OS) const {
3221  // Print the information about how we detected the GCC installation.
3222  GCCInstallation.print(OS);
3223  CudaInstallation->print(OS);
3224  RocmInstallation->print(OS);
3225 }
3226 
3227 ToolChain::UnwindTableLevel
3228 Generic_GCC::getDefaultUnwindTableLevel(const ArgList &Args) const {
3229  switch (getArch()) {
3230  case llvm::Triple::aarch64:
3231  case llvm::Triple::aarch64_be:
3232  case llvm::Triple::ppc:
3233  case llvm::Triple::ppcle:
3234  case llvm::Triple::ppc64:
3235  case llvm::Triple::ppc64le:
3236  case llvm::Triple::riscv32:
3237  case llvm::Triple::riscv64:
3238  case llvm::Triple::x86:
3239  case llvm::Triple::x86_64:
3240  return UnwindTableLevel::Asynchronous;
3241  default:
3242  return UnwindTableLevel::None;
3243  }
3244 }
3245 
3246 bool Generic_GCC::isPICDefault() const {
3247  switch (getArch()) {
3248  case llvm::Triple::x86_64:
3249  return getTriple().isOSWindows();
3250  case llvm::Triple::mips64:
3251  case llvm::Triple::mips64el:
3252  return true;
3253  default:
3254  return false;
3255  }
3256 }
3257 
3258 bool Generic_GCC::isPIEDefault(const llvm::opt::ArgList &Args) const {
3259  return false;
3260 }
3261 
3262 bool Generic_GCC::isPICDefaultForced() const {
3263  return getArch() == llvm::Triple::x86_64 && getTriple().isOSWindows();
3264 }
3265 
3266 bool Generic_GCC::IsIntegratedAssemblerDefault() const {
3267  switch (getTriple().getArch()) {
3268  case llvm::Triple::nvptx:
3269  case llvm::Triple::nvptx64:
3270  case llvm::Triple::xcore:
3271  return false;
3272  default:
3273  return true;
3274  }
3275 }
3276 
3277 void Generic_GCC::PushPPaths(ToolChain::path_list &PPaths) {
3278  // Cross-compiling binutils and GCC installations (vanilla and openSUSE at
3279  // least) put various tools in a triple-prefixed directory off of the parent
3280  // of the GCC installation. We use the GCC triple here to ensure that we end
3281  // up with tools that support the same amount of cross compiling as the
3282  // detected GCC installation. For example, if we find a GCC installation
3283  // targeting x86_64, but it is a bi-arch GCC installation, it can also be
3284  // used to target i386.
3285  if (GCCInstallation.isValid()) {
3286  PPaths.push_back(Twine(GCCInstallation.getParentLibPath() + "/../" +
3287  GCCInstallation.getTriple().str() + "/bin")
3288  .str());
3289  }
3290 }
3291 
3292 void Generic_GCC::AddMultilibPaths(const Driver &D,
3293  const std::string &SysRoot,
3294  const std::string &OSLibDir,
3295  const std::string &MultiarchTriple,
3296  path_list &Paths) {
3297  // Add the multilib suffixed paths where they are available.
3298  if (GCCInstallation.isValid()) {
3299  assert(!SelectedMultilibs.empty());
3300  const llvm::Triple &GCCTriple = GCCInstallation.getTriple();
3301  const std::string &LibPath =
3302  std::string(GCCInstallation.getParentLibPath());
3303 
3304  // Sourcery CodeBench MIPS toolchain holds some libraries under
3305  // a biarch-like suffix of the GCC installation.
3306  if (const auto &PathsCallback = Multilibs.filePathsCallback())
3307  for (const auto &Path : PathsCallback(SelectedMultilibs.back()))
3308  addPathIfExists(D, GCCInstallation.getInstallPath() + Path, Paths);
3309 
3310  // Add lib/gcc/$triple/$version, with an optional /multilib suffix.
3311  addPathIfExists(D,
3312  GCCInstallation.getInstallPath() +
3313  SelectedMultilibs.back().gccSuffix(),
3314  Paths);
3315 
3316  // Add lib/gcc/$triple/$libdir
3317  // For GCC built with --enable-version-specific-runtime-libs.
3318  addPathIfExists(D, GCCInstallation.getInstallPath() + "/../" + OSLibDir,
3319  Paths);
3320 
3321  // GCC cross compiling toolchains will install target libraries which ship
3322  // as part of the toolchain under <prefix>/<triple>/<libdir> rather than as
3323  // any part of the GCC installation in
3324  // <prefix>/<libdir>/gcc/<triple>/<version>. This decision is somewhat
3325  // debatable, but is the reality today. We need to search this tree even
3326  // when we have a sysroot somewhere else. It is the responsibility of
3327  // whomever is doing the cross build targeting a sysroot using a GCC
3328  // installation that is *not* within the system root to ensure two things:
3329  //
3330  // 1) Any DSOs that are linked in from this tree or from the install path
3331  // above must be present on the system root and found via an
3332  // appropriate rpath.
3333  // 2) There must not be libraries installed into
3334  // <prefix>/<triple>/<libdir> unless they should be preferred over
3335  // those within the system root.
3336  //
3337  // Note that this matches the GCC behavior. See the below comment for where
3338  // Clang diverges from GCC's behavior.
3339  addPathIfExists(D,
3340  LibPath + "/../" + GCCTriple.str() + "/lib/../" + OSLibDir +
3341  SelectedMultilibs.back().osSuffix(),
3342  Paths);
3343 
3344  // If the GCC installation we found is inside of the sysroot, we want to
3345  // prefer libraries installed in the parent prefix of the GCC installation.
3346  // It is important to *not* use these paths when the GCC installation is
3347  // outside of the system root as that can pick up unintended libraries.
3348  // This usually happens when there is an external cross compiler on the
3349  // host system, and a more minimal sysroot available that is the target of
3350  // the cross. Note that GCC does include some of these directories in some
3351  // configurations but this seems somewhere between questionable and simply
3352  // a bug.
3353  if (StringRef(LibPath).starts_with(SysRoot))
3354  addPathIfExists(D, LibPath + "/../" + OSLibDir, Paths);
3355  }
3356 }
3357 
3358 void Generic_GCC::AddMultiarchPaths(const Driver &D,
3359  const std::string &SysRoot,
3360  const std::string &OSLibDir,
3361  path_list &Paths) {
3362  if (GCCInstallation.isValid()) {
3363  const std::string &LibPath =
3364  std::string(GCCInstallation.getParentLibPath());
3365  const llvm::Triple &GCCTriple = GCCInstallation.getTriple();
3366  const Multilib &Multilib = GCCInstallation.getMultilib();
3367  addPathIfExists(
3368  D, LibPath + "/../" + GCCTriple.str() + "/lib" + Multilib.osSuffix(),
3369  Paths);
3370  }
3371 }
3372 
3373 void Generic_GCC::AddMultilibIncludeArgs(const ArgList &DriverArgs,
3374  ArgStringList &CC1Args) const {
3375  // Add include directories specific to the selected multilib set and multilib.
3376  if (!GCCInstallation.isValid())
3377  return;
3378  // gcc TOOL_INCLUDE_DIR.
3379  const llvm::Triple &GCCTriple = GCCInstallation.getTriple();
3380  std::string LibPath(GCCInstallation.getParentLibPath());
3381  addSystemInclude(DriverArgs, CC1Args,
3382  Twine(LibPath) + "/../" + GCCTriple.str() + "/include");
3383 
3384  const auto &Callback = Multilibs.includeDirsCallback();
3385  if (Callback) {
3386  for (const auto &Path : Callback(GCCInstallation.getMultilib()))
3387  addExternCSystemIncludeIfExists(DriverArgs, CC1Args,
3388  GCCInstallation.getInstallPath() + Path);
3389  }
3390 }
3391 
3392 void Generic_GCC::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
3393  ArgStringList &CC1Args) const {
3394  if (DriverArgs.hasArg(options::OPT_nostdinc, options::OPT_nostdincxx,
3395  options::OPT_nostdlibinc))
3396  return;
3397 
3398  switch (GetCXXStdlibType(DriverArgs)) {
3399  case ToolChain::CST_Libcxx:
3400  addLibCxxIncludePaths(DriverArgs, CC1Args);
3401  break;
3402 
3403  case ToolChain::CST_Libstdcxx:
3404  addLibStdCxxIncludePaths(DriverArgs, CC1Args);
3405  break;
3406  }
3407 }
3408 
3409 void
3410 Generic_GCC::addLibCxxIncludePaths(const llvm::opt::ArgList &DriverArgs,
3411  llvm::opt::ArgStringList &CC1Args) const {
3412  const Driver &D = getDriver();
3413  std::string SysRoot = computeSysRoot();
3414  if (SysRoot.empty())
3415  SysRoot = llvm::sys::path::get_separator();
3416 
3417  auto AddIncludePath = [&](StringRef Path, bool TargetDirRequired = false) {
3418  std::string Version = detectLibcxxVersion(Path);
3419  if (Version.empty())
3420  return false;
3421 
3422  // First add the per-target include path if it exists.
3423  bool TargetDirExists = false;
3424  std::optional<std::string> TargetIncludeDir = getTargetSubDirPath(Path);
3425  if (TargetIncludeDir) {
3426  SmallString<128> TargetDir(*TargetIncludeDir);
3427  llvm::sys::path::append(TargetDir, "c++", Version);
3428  if (D.getVFS().exists(TargetDir)) {
3429  addSystemInclude(DriverArgs, CC1Args, TargetDir);
3430  TargetDirExists = true;
3431  }
3432  }
3433  if (TargetDirRequired && !TargetDirExists)
3434  return false;
3435 
3436  // Second add the generic one.
3437  SmallString<128> GenericDir(Path);
3438  llvm::sys::path::append(GenericDir, "c++", Version);
3439  addSystemInclude(DriverArgs, CC1Args, GenericDir);
3440  return true;
3441  };
3442 
3443  // Android only uses the libc++ headers installed alongside the toolchain if
3444  // they contain an Android-specific target include path, otherwise they're
3445  // incompatible with the NDK libraries.
3446  SmallString<128> DriverIncludeDir(getDriver().Dir);
3447  llvm::sys::path::append(DriverIncludeDir, "..", "include");
3448  if (AddIncludePath(DriverIncludeDir,
3449  /*TargetDirRequired=*/getTriple().isAndroid()))
3450  return;
3451  // If this is a development, non-installed, clang, libcxx will
3452  // not be found at ../include/c++ but it likely to be found at
3453  // one of the following two locations:
3454  SmallString<128> UsrLocalIncludeDir(SysRoot);
3455  llvm::sys::path::append(UsrLocalIncludeDir, "usr", "local", "include");
3456  if (AddIncludePath(UsrLocalIncludeDir))
3457  return;
3458  SmallString<128> UsrIncludeDir(SysRoot);
3459  llvm::sys::path::append(UsrIncludeDir, "usr", "include");
3460  if (AddIncludePath(UsrIncludeDir))
3461  return;
3462 }
3463 
3464 bool Generic_GCC::addLibStdCXXIncludePaths(Twine IncludeDir, StringRef Triple,
3465  Twine IncludeSuffix,
3466  const llvm::opt::ArgList &DriverArgs,
3467  llvm::opt::ArgStringList &CC1Args,
3468  bool DetectDebian) const {
3469  if (!getVFS().exists(IncludeDir))
3470  return false;
3471 
3472  // Debian native gcc uses g++-multiarch-incdir.diff which uses
3473  // include/x86_64-linux-gnu/c++/10$IncludeSuffix instead of
3474  // include/c++/10/x86_64-linux-gnu$IncludeSuffix.
3475  std::string Dir = IncludeDir.str();
3476  StringRef Include =
3477  llvm::sys::path::parent_path(llvm::sys::path::parent_path(Dir));
3478  std::string Path =
3479  (Include + "/" + Triple + Dir.substr(Include.size()) + IncludeSuffix)
3480  .str();
3481  if (DetectDebian && !getVFS().exists(Path))
3482  return false;
3483 
3484  // GPLUSPLUS_INCLUDE_DIR
3485  addSystemInclude(DriverArgs, CC1Args, IncludeDir);
3486  // GPLUSPLUS_TOOL_INCLUDE_DIR. If Triple is not empty, add a target-dependent
3487  // include directory.
3488  if (DetectDebian)
3489  addSystemInclude(DriverArgs, CC1Args, Path);
3490  else if (!Triple.empty())
3491  addSystemInclude(DriverArgs, CC1Args,
3492  IncludeDir + "/" + Triple + IncludeSuffix);
3493  // GPLUSPLUS_BACKWARD_INCLUDE_DIR
3494  addSystemInclude(DriverArgs, CC1Args, IncludeDir + "/backward");
3495  return true;
3496 }
3497 
3498 bool Generic_GCC::addGCCLibStdCxxIncludePaths(
3499  const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args,
3500  StringRef DebianMultiarch) const {
3501  assert(GCCInstallation.isValid());
3502 
3503  // By default, look for the C++ headers in an include directory adjacent to
3504  // the lib directory of the GCC installation. Note that this is expect to be
3505  // equivalent to '/usr/include/c++/X.Y' in almost all cases.
3506  StringRef LibDir = GCCInstallation.getParentLibPath();
3507  StringRef InstallDir = GCCInstallation.getInstallPath();
3508  StringRef TripleStr = GCCInstallation.getTriple().str();
3509  const Multilib &Multilib = GCCInstallation.getMultilib();
3510  const GCCVersion &Version = GCCInstallation.getVersion();
3511 
3512  // Try /../$triple/include/c++/$version (gcc --print-multiarch is not empty).
3513  if (addLibStdCXXIncludePaths(
3514  LibDir.str() + "/../" + TripleStr + "/include/c++/" + Version.Text,
3515  TripleStr, Multilib.includeSuffix(), DriverArgs, CC1Args))
3516  return true;
3517 
3518  // Try /gcc/$triple/$version/include/c++/ (gcc --print-multiarch is not
3519  // empty). Like above but for GCC built with
3520  // --enable-version-specific-runtime-libs.
3521  if (addLibStdCXXIncludePaths(LibDir.str() + "/gcc/" + TripleStr + "/" +
3522  Version.Text + "/include/c++/",
3523  TripleStr, Multilib.includeSuffix(), DriverArgs,
3524  CC1Args))
3525  return true;
3526 
3527  // Detect Debian g++-multiarch-incdir.diff.
3528  if (addLibStdCXXIncludePaths(LibDir.str() + "/../include/c++/" + Version.Text,
3529  DebianMultiarch, Multilib.includeSuffix(),
3530  DriverArgs, CC1Args, /*Debian=*/true))
3531  return true;
3532 
3533  // Try /../include/c++/$version (gcc --print-multiarch is empty).
3534  if (addLibStdCXXIncludePaths(LibDir.str() + "/../include/c++/" + Version.Text,
3535  TripleStr, Multilib.includeSuffix(), DriverArgs,
3536  CC1Args))
3537  return true;
3538 
3539  // Otherwise, fall back on a bunch of options which don't use multiarch
3540  // layouts for simplicity.
3541  const std::string LibStdCXXIncludePathCandidates[] = {
3542  // Gentoo is weird and places its headers inside the GCC install,
3543  // so if the first attempt to find the headers fails, try these patterns.
3544  InstallDir.str() + "/include/g++-v" + Version.Text,
3545  InstallDir.str() + "/include/g++-v" + Version.MajorStr + "." +
3546  Version.MinorStr,
3547  InstallDir.str() + "/include/g++-v" + Version.MajorStr,
3548  };
3549 
3550  for (const auto &IncludePath : LibStdCXXIncludePathCandidates) {
3551  if (addLibStdCXXIncludePaths(IncludePath, TripleStr,
3552  Multilib.includeSuffix(), DriverArgs, CC1Args))
3553  return true;
3554  }
3555  return false;
3556 }
3557 
3558 void
3559 Generic_GCC::addLibStdCxxIncludePaths(const llvm::opt::ArgList &DriverArgs,
3560  llvm::opt::ArgStringList &CC1Args) const {
3561  if (GCCInstallation.isValid()) {
3562  addGCCLibStdCxxIncludePaths(DriverArgs, CC1Args,
3563  GCCInstallation.getTriple().str());
3564  }
3565 }
3566 
3567 llvm::opt::DerivedArgList *
3568 Generic_GCC::TranslateArgs(const llvm::opt::DerivedArgList &Args, StringRef,
3569  Action::OffloadKind DeviceOffloadKind) const {
3570 
3571  // If this tool chain is used for an OpenMP offloading device we have to make
3572  // sure we always generate a shared library regardless of the commands the
3573  // user passed to the host. This is required because the runtime library
3574  // is required to load the device image dynamically at run time.
3575  if (DeviceOffloadKind == Action::OFK_OpenMP) {
3576  DerivedArgList *DAL = new DerivedArgList(Args.getBaseArgs());
3577  const OptTable &Opts = getDriver().getOpts();
3578 
3579  // Request the shared library. Given that these options are decided
3580  // implicitly, they do not refer to any base argument.
3581  DAL->AddFlagArg(/*BaseArg=*/nullptr, Opts.getOption(options::OPT_shared));
3582  DAL->AddFlagArg(/*BaseArg=*/nullptr, Opts.getOption(options::OPT_fPIC));
3583 
3584  // Filter all the arguments we don't care passing to the offloading
3585  // toolchain as they can mess up with the creation of a shared library.
3586  for (auto *A : Args) {
3587  switch ((options::ID)A->getOption().getID()) {
3588  default:
3589  DAL->append(A);
3590  break;
3591  case options::OPT_shared:
3592  case options::OPT_dynamic:
3593  case options::OPT_static:
3594  case options::OPT_fPIC:
3595  case options::OPT_fno_PIC:
3596  case options::OPT_fpic:
3597  case options::OPT_fno_pic:
3598  case options::OPT_fPIE:
3599  case options::OPT_fno_PIE:
3600  case options::OPT_fpie:
3601  case options::OPT_fno_pie:
3602  break;
3603  }
3604  }
3605  return DAL;
3606  }
3607  return nullptr;
3608 }
3609 
3610 void Generic_ELF::anchor() {}
3611 
3612 void Generic_ELF::addClangTargetOptions(const ArgList &DriverArgs,
3613  ArgStringList &CC1Args,
3614  Action::OffloadKind) const {
3615  if (!DriverArgs.hasFlag(options::OPT_fuse_init_array,
3616  options::OPT_fno_use_init_array, true))
3617  CC1Args.push_back("-fno-use-init-array");
3618 }
P
StringRef P
Definition: ASTMatchersInternal.cpp:564
Suffixes
static constexpr CPUSuffix Suffixes[]
Definition: Hexagon.cpp:231
IsStatic
bool IsStatic
Definition: Format.cpp:2988
findCSKYMultilibs
static void findCSKYMultilibs(const Driver &D, const llvm::Triple &TargetTriple, StringRef Path, const ArgList &Args, DetectedMultilibs &Result)
Definition: Gnu.cpp:1802
findAndroidArmMultilibs
static void findAndroidArmMultilibs(const Driver &D, const llvm::Triple &TargetTriple, StringRef Path, const ArgList &Args, DetectedMultilibs &Result)
Definition: Gnu.cpp:1731
findRISCVMultilibs
static void findRISCVMultilibs(const Driver &D, const llvm::Triple &TargetTriple, StringRef Path, const ArgList &Args, DetectedMultilibs &Result)
Definition: Gnu.cpp:2040
isArmOrThumbArch
static bool isArmOrThumbArch(llvm::Triple::ArchType Arch)
Definition: Gnu.cpp:1160
normalizeCPUNamesForAssembler
static void normalizeCPUNamesForAssembler(const ArgList &Args, ArgStringList &CmdArgs)
Definition: Gnu.cpp:56
findBiarchMultilibs
static bool findBiarchMultilibs(const Driver &D, const llvm::Triple &TargetTriple, StringRef Path, const ArgList &Args, bool NeedsBiarchSuffix, DetectedMultilibs &Result)
Definition: Gnu.cpp:2082
isMips16
static bool isMips16(const ArgList &Args)
Definition: Gnu.cpp:1168
getGCCToolchainDir
static llvm::StringRef getGCCToolchainDir(const ArgList &Args, llvm::StringRef SysRoot)
Definition: Gnu.cpp:2333
findMSP430Multilibs
static bool findMSP430Multilibs(const Driver &D, const llvm::Triple &TargetTriple, StringRef Path, const ArgList &Args, DetectedMultilibs &Result)
Definition: Gnu.cpp:1774
getStatic
static bool getStatic(const ArgList &Args)
Definition: Gnu.cpp:308
selectRISCVMultilib
static bool selectRISCVMultilib(const MultilibSet &RISCVMultilibSet, StringRef Arch, const Multilib::flags_list &Flags, llvm::SmallVectorImpl< Multilib > &SelectedMultilibs)
Extend the multi-lib re-use selection mechanism for RISC-V.
Definition: Gnu.cpp:1878
findMipsCsMultilibs
static bool findMipsCsMultilibs(const Multilib::flags_list &Flags, FilterNonExistent &NonExistent, DetectedMultilibs &Result)
Definition: Gnu.cpp:1182
findMipsMtiMultilibs
static bool findMipsMtiMultilibs(const Multilib::flags_list &Flags, FilterNonExistent &NonExistent, DetectedMultilibs &Result)
Definition: Gnu.cpp:1366
isMipsEL
static bool isMipsEL(llvm::Triple::ArchType Arch)
Definition: Gnu.cpp:1164
findMipsMuslMultilibs
static bool findMipsMuslMultilibs(const Multilib::flags_list &Flags, FilterNonExistent &NonExistent, DetectedMultilibs &Result)
Definition: Gnu.cpp:1332
findRISCVBareMetalMultilibs
static void findRISCVBareMetalMultilibs(const Driver &D, const llvm::Triple &TargetTriple, StringRef Path, const ArgList &Args, DetectedMultilibs &Result)
Definition: Gnu.cpp:1984
findMipsAndroidMultilibs
static bool findMipsAndroidMultilibs(llvm::vfs::FileSystem &VFS, StringRef Path, const Multilib::flags_list &Flags, FilterNonExistent &NonExistent, DetectedMultilibs &Result)
Definition: Gnu.cpp:1286
isMSP430
static bool isMSP430(llvm::Triple::ArchType Arch)
Definition: Gnu.cpp:1178
isSoftFloatABI
static bool isSoftFloatABI(const ArgList &Args)
Definition: Gnu.cpp:1149
findMipsImgMultilibs
static bool findMipsImgMultilibs(const Multilib::flags_list &Flags, FilterNonExistent &NonExistent, DetectedMultilibs &Result)
Definition: Gnu.cpp:1552
getLDMOption
static const char * getLDMOption(const llvm::Triple &T, const ArgList &Args)
Definition: Gnu.cpp:224
getStaticPIE
static bool getStaticPIE(const ArgList &Args, const ToolChain &TC)
Definition: Gnu.cpp:296
forwardToGCC
static bool forwardToGCC(const Option &O)
Definition: Gnu.cpp:46
isMicroMips
static bool isMicroMips(const ArgList &Args)
Definition: Gnu.cpp:1173
clang::driver::Action::getType
types::ID getType() const
Definition: Action.h:160
clang::driver::Action::isHostOffloading
bool isHostOffloading(unsigned int OKind) const
Check if this action have any offload kinds.
Definition: Action.h:230
clang::driver::Action::isDeviceOffloading
bool isDeviceOffloading(OffloadKind OKind) const
Definition: Action.h:233
clang::driver::Action::isOffloading
bool isOffloading(OffloadKind OKind) const
Definition: Action.h:236
clang::driver::Compilation
Compilation - A set of tasks to perform for a single driver invocation.
Definition: Compilation.h:45
clang::driver::Driver
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
Definition: Driver.h:77
clang::driver::Driver::SysRoot
std::string SysRoot
sysroot, if present
Definition: Driver.h:182
clang::driver::Driver::getCCCGenericGCCName
const std::string & getCCCGenericGCCName() const
Name to use when invoking gcc/g++.
Definition: Driver.h:395
clang::driver::Driver::getVFS
llvm::vfs::FileSystem & getVFS() const
Definition: Driver.h:405
clang::driver::Driver::DyldPrefix
std::string DyldPrefix
Dynamic loader prefix, if present.
Definition: Driver.h:185
clang::driver::Driver::Diag
DiagnosticBuilder Diag(unsigned DiagID) const
Definition: Driver.h:146
clang::driver::Driver::getLTOMode
LTOKind getLTOMode(bool IsOffload=false) const
Get the specific kind of LTO being performed.
Definition: Driver.h:739
clang::driver::Driver::getOpts
const llvm::opt::OptTable & getOpts() const
Definition: Driver.h:401
clang::driver::Driver::isUsingLTO
bool isUsingLTO(bool IsOffload=false) const
Returns true if we are performing any kind of LTO.
Definition: Driver.h:734
clang::driver::Driver::Dir
std::string Dir
The path the driver executable was in, as invoked from the command line.
Definition: Driver.h:157
clang::driver::Driver::IsFlangMode
bool IsFlangMode() const
Whether the driver should invoke flang for fortran inputs.
Definition: Driver.h:228
clang::driver::Driver::CCCIsCXX
bool CCCIsCXX() const
Whether the driver should follow g++ like behavior.
Definition: Driver.h:215
clang::driver::InputInfo
InputInfo - Wrapper for information about an input source.
Definition: InputInfo.h:22
clang::driver::InputInfo::getFilename
const char * getFilename() const
Definition: InputInfo.h:83
clang::driver::InputInfo::isNothing
bool isNothing() const
Definition: InputInfo.h:74
clang::driver::InputInfo::isFilename
bool isFilename() const
Definition: InputInfo.h:75
clang::driver::MultilibBuilder
This corresponds to a single GCC multilib, or a segment of one controlled by a command line flag.
Definition: MultilibBuilder.h:22
clang::driver::MultilibBuilder::flag
MultilibBuilder & flag(StringRef Flag, bool Disallow=false)
Add a flag to the flags list Flag must be a flag accepted by the driver.
Definition: MultilibBuilder.cpp:89
clang::driver::MultilibBuilder::osSuffix
const std::string & osSuffix() const
Get the detected os path suffix for the multi-arch target variant.
Definition: MultilibBuilder.h:52
clang::driver::MultilibBuilder::gccSuffix
const std::string & gccSuffix() const
Get the detected GCC installation path suffix for the multi-arch target variant.
Definition: MultilibBuilder.h:41
clang::driver::MultilibSetBuilder
This class can be used to create a MultilibSet, and contains helper functions to add combinations of ...
Definition: MultilibBuilder.h:96
clang::driver::MultilibSetBuilder::Maybe
MultilibSetBuilder & Maybe(const MultilibBuilder &M)
Add an optional Multilib segment.
Definition: MultilibBuilder.cpp:98
clang::driver::MultilibSetBuilder::FilterOut
MultilibSetBuilder & FilterOut(const char *Regex)
Filter out those Multilibs whose gccSuffix matches the given expression.
Definition: MultilibBuilder.cpp:176
clang::driver::MultilibSetBuilder::Either
MultilibSetBuilder & Either(const MultilibBuilder &M1, const MultilibBuilder &M2)
Add a set of mutually incompatible Multilib segments.
Definition: MultilibBuilder.cpp:108
clang::driver::MultilibSet
See also MultilibSetBuilder for combining multilibs into a set.
Definition: Multilib.h:92
clang::driver::MultilibSet::includeDirsCallback
const IncludeDirsFunc & includeDirsCallback() const
Definition: Multilib.h:150
clang::driver::MultilibSet::size
unsigned size() const
Definition: Multilib.h:135
clang::driver::MultilibSet::FilterOut
MultilibSet & FilterOut(FilterCallback F)
Filter out some subset of the Multilibs using a user defined callback.
Definition: Multilib.cpp:90
clang::driver::MultilibSet::select
bool select(const Multilib::flags_list &Flags, llvm::SmallVectorImpl< Multilib > &) const
Select compatible variants,.
Definition: Multilib.cpp:97
clang::driver::MultilibSet::filePathsCallback
const IncludeDirsFunc & filePathsCallback() const
Definition: Multilib.h:157
clang::driver::MultilibSet::setIncludeDirsCallback
MultilibSet & setIncludeDirsCallback(IncludeDirsFunc F)
Definition: Multilib.h:145
clang::driver::MultilibSet::setFilePathsCallback
MultilibSet & setFilePathsCallback(IncludeDirsFunc F)
Definition: Multilib.h:152
clang::driver::Multilib
This corresponds to a single GCC Multilib, or a segment of one controlled by a command line flag.
Definition: Multilib.h:32
clang::driver::Multilib::gccSuffix
const std::string & gccSuffix() const
Get the detected GCC installation path suffix for the multi-arch target variant.
Definition: Multilib.h:61
clang::driver::Multilib::flags_list
std::vector< std::string > flags_list
Definition: Multilib.h:34
clang::driver::Multilib::osSuffix
const std::string & osSuffix() const
Get the detected os path suffix for the multi-arch target variant.
Definition: Multilib.h:65
clang::driver::Multilib::isDefault
bool isDefault() const
Check whether the default is selected.
Definition: Multilib.h:83
clang::driver::Multilib::includeSuffix
const std::string & includeSuffix() const
Get the include directory suffix.
Definition: Multilib.h:69
clang::driver::ToolChain
ToolChain - Access to tools for a single platform.
Definition: ToolChain.h:92
clang::driver::ToolChain::getDriver
const Driver & getDriver() const
Definition: ToolChain.h:269
clang::driver::ToolChain::addSystemInclude
static void addSystemInclude(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args, const Twine &Path)
Utility function to add a system include directory to CC1 arguments.
Definition: ToolChain.cpp:1247
clang::driver::ToolChain::computeSysRoot
virtual std::string computeSysRoot() const
Return the sysroot, possibly searching for a default sysroot using target-specific logic.
Definition: ToolChain.cpp:1133
clang::driver::ToolChain::GetRuntimeLibType
virtual RuntimeLibType GetRuntimeLibType(const llvm::opt::ArgList &Args) const
Definition: ToolChain.cpp:1159
clang::driver::ToolChain::ShouldLinkCXXStdlib
bool ShouldLinkCXXStdlib(const llvm::opt::ArgList &Args) const
Returns if the C++ standard library should be linked in.
Definition: ToolChain.cpp:1349
clang::driver::ToolChain::GetFilePath
std::string GetFilePath(const char *Name) const
Definition: ToolChain.cpp:938
clang::driver::ToolChain::getArch
llvm::Triple::ArchType getArch() const
Definition: ToolChain.h:285
clang::driver::ToolChain::getTriple
const llvm::Triple & getTriple() const
Definition: ToolChain.h:271
clang::driver::ToolChain::detectLibcxxVersion
virtual std::string detectLibcxxVersion(StringRef IncludePath) const
Definition: ToolChain.cpp:1294
clang::driver::ToolChain::getVFS
llvm::vfs::FileSystem & getVFS() const
Definition: ToolChain.cpp:142
clang::driver::ToolChain::isPIEDefault
virtual bool isPIEDefault(const llvm::opt::ArgList &Args) const =0
Test whether this toolchain defaults to PIE.
clang::driver::ToolChain::addFastMathRuntimeIfAvailable
bool addFastMathRuntimeIfAvailable(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const
AddFastMathRuntimeIfAvailable - If a runtime library exists that sets global flags for unsafe floatin...
Definition: ToolChain.cpp:1422
clang::driver::ToolChain::addExternCSystemIncludeIfExists
static void addExternCSystemIncludeIfExists(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args, const Twine &Path)
Definition: ToolChain.cpp:1269
clang::driver::ToolChain::AddCXXStdlibLibArgs
virtual void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const
AddCXXStdlibLibArgs - Add the system specific linker arguments to use for the given C++ standard libr...
Definition: ToolChain.cpp:1355
clang::driver::ToolChain::getTargetSubDirPath
std::optional< std::string > getTargetSubDirPath(StringRef BaseDir) const
Find the target-specific subdirectory for the current target triple under BaseDir,...
Definition: ToolChain.cpp:833
clang::driver::ToolChain::GetLinkerPath
std::string GetLinkerPath(bool *LinkerIsLLD=nullptr) const
Returns the linker path, respecting the -fuse-ld= argument to determine the linker suffix or name.
Definition: ToolChain.cpp:946
clang::driver::ToolChain::getCompilerRT
virtual std::string getCompilerRT(const llvm::opt::ArgList &Args, StringRef Component, FileType Type=ToolChain::FT_Static) const
Definition: ToolChain.cpp:751
clang::driver::ToolChain::AddFilePathLibArgs
void AddFilePathLibArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const
AddFilePathLibArgs - Add each thing in getFilePaths() as a "-L" option.
Definition: ToolChain.cpp:1374
clang::driver::ToolChain::getProgramPaths
path_list & getProgramPaths()
Definition: ToolChain.h:314
clang::driver::ToolChain::GetCXXStdlibType
virtual CXXStdlibType GetCXXStdlibType(const llvm::opt::ArgList &Args) const
Definition: ToolChain.cpp:1221
clang::driver::ToolChain::SelectedMultilibs
llvm::SmallVector< Multilib > SelectedMultilibs
Definition: ToolChain.h:217
clang::driver::ToolChain::getTool
virtual Tool * getTool(Action::ActionClass AC) const
Definition: ToolChain.cpp:581
clang::driver::Tool
Tool - Information on a specific compilation tool.
Definition: Tool.h:32
clang::driver::toolchains::Generic_ELF
Definition: Gnu.h:369
clang::driver::toolchains::Generic_ELF::addClangTargetOptions
void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args, Action::OffloadKind DeviceOffloadKind) const override
Add options that need to be passed to cc1 for this target.
Definition: Gnu.cpp:3612
clang::driver::toolchains::Generic_GCC::GCCInstallationDetector::print
void print(raw_ostream &OS) const
Print information about the detected GCC installation.
Definition: Gnu.cpp:2487
clang::driver::toolchains::Generic_GCC::GCCInstallationDetector::isValid
bool isValid() const
Check whether we detected a valid GCC install.
Definition: Gnu.h:230
clang::driver::toolchains::Generic_GCC::GCCInstallationDetector::getTriple
const llvm::Triple & getTriple() const
Get the GCC triple for the detected install.
Definition: Gnu.h:233
clang::driver::toolchains::Generic_GCC::GCCInstallationDetector::getBiarchSibling
bool getBiarchSibling(Multilib &M) const
Get the biarch sibling multilib (if it exists).
Definition: Gnu.cpp:2501
clang::driver::toolchains::Generic_GCC::GCCInstallationDetector::getMultilib
const Multilib & getMultilib() const
Get the detected Multilib.
Definition: Gnu.h:242
clang::driver::toolchains::Generic_GCC::GCCInstallationDetector::init
void init(const llvm::Triple &TargetTriple, const llvm::opt::ArgList &Args)
Initialize a GCCInstallationDetector from the driver.
Definition: Gnu.cpp:2357
clang::driver::toolchains::Generic_GCC::GCCInstallationDetector::getParentLibPath
StringRef getParentLibPath() const
Get the detected GCC parent lib path.
Definition: Gnu.h:239
clang::driver::toolchains::Generic_GCC::GCCInstallationDetector::getInstallPath
StringRef getInstallPath() const
Get the detected GCC installation path.
Definition: Gnu.h:236
clang::driver::toolchains::Generic_GCC::GCCInstallationDetector::getVersion
const GCCVersion & getVersion() const
Get the detected GCC version string.
Definition: Gnu.h:252
clang::driver::toolchains::Generic_GCC::TranslateArgs
llvm::opt::DerivedArgList * TranslateArgs(const llvm::opt::DerivedArgList &Args, StringRef BoundArch, Action::OffloadKind DeviceOffloadKind) const override
TranslateArgs - Create a new derived argument list for any argument translations this ToolChain may w...
Definition: Gnu.cpp:3568
clang::driver::toolchains::Generic_GCC::AddMultilibPaths
void AddMultilibPaths(const Driver &D, const std::string &SysRoot, const std::string &OSLibDir, const std::string &MultiarchTriple, path_list &Paths)
Definition: Gnu.cpp:3292
clang::driver::toolchains::Generic_GCC::addGCCLibStdCxxIncludePaths
bool addGCCLibStdCxxIncludePaths(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args, StringRef DebianMultiarch) const
Definition: Gnu.cpp:3498
clang::driver::toolchains::Generic_GCC::CudaInstallation
LazyDetector< CudaInstallationDetector > CudaInstallation
Definition: Gnu.h:295
clang::driver::toolchains::Generic_GCC::PushPPaths
void PushPPaths(ToolChain::path_list &PPaths)
Definition: Gnu.cpp:3277
clang::driver::toolchains::Generic_GCC::getTool
Tool * getTool(Action::ActionClass AC) const override
Definition: Gnu.cpp:3199
clang::driver::toolchains::Generic_GCC::Generic_GCC
Generic_GCC(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args)
Definition: Gnu.cpp:3190
clang::driver::toolchains::Generic_GCC::GCCInstallation
GCCInstallationDetector GCCInstallation
Definition: Gnu.h:294
clang::driver::toolchains::Generic_GCC::AddMultilibIncludeArgs
void AddMultilibIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const
Definition: Gnu.cpp:3373
clang::driver::toolchains::Generic_GCC::IsIntegratedAssemblerDefault
bool IsIntegratedAssemblerDefault() const override
IsIntegratedAssemblerDefault - Does this tool chain enable -integrated-as by default.
Definition: Gnu.cpp:3266
clang::driver::toolchains::Generic_GCC::AddClangCXXStdlibIncludeArgs
void AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override
AddClangCXXStdlibIncludeArgs - Add the clang -cc1 level arguments to set the include paths to use for...
Definition: Gnu.cpp:3392
clang::driver::toolchains::Generic_GCC::buildLinker
Tool * buildLinker() const override
Definition: Gnu.cpp:3218
clang::driver::toolchains::Generic_GCC::isPICDefaultForced
bool isPICDefaultForced() const override
Tests whether this toolchain forces its default for PIC, PIE or non-PIC.
Definition: Gnu.cpp:3262
clang::driver::toolchains::Generic_GCC::isPIEDefault
bool isPIEDefault(const llvm::opt::ArgList &Args) const override
Test whether this toolchain defaults to PIE.
Definition: Gnu.cpp:3258
clang::driver::toolchains::Generic_GCC::printVerboseInfo
void printVerboseInfo(raw_ostream &OS) const override
Dispatch to the specific toolchain for verbose printing.
Definition: Gnu.cpp:3220
clang::driver::toolchains::Generic_GCC::~Generic_GCC
~Generic_GCC() override
Definition: Gnu.cpp:3197
clang::driver::toolchains::Generic_GCC::AddMultiarchPaths
void AddMultiarchPaths(const Driver &D, const std::string &SysRoot, const std::string &OSLibDir, path_list &Paths)
Definition: Gnu.cpp:3358
clang::driver::toolchains::Generic_GCC::buildAssembler
Tool * buildAssembler() const override
Definition: Gnu.cpp:3214
clang::driver::toolchains::Generic_GCC::getDefaultUnwindTableLevel
UnwindTableLevel getDefaultUnwindTableLevel(const llvm::opt::ArgList &Args) const override
How detailed should the unwind tables be by default.
Definition: Gnu.cpp:3228
clang::driver::toolchains::Generic_GCC::addLibStdCXXIncludePaths
bool addLibStdCXXIncludePaths(Twine IncludeDir, StringRef Triple, Twine IncludeSuffix, const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args, bool DetectDebian=false) const
Definition: Gnu.cpp:3464
clang::driver::toolchains::Generic_GCC::isPICDefault
bool isPICDefault() const override
Test whether this toolchain defaults to PIC.
Definition: Gnu.cpp:3246
clang::driver::toolchains::Generic_GCC::addLibCxxIncludePaths
virtual void addLibCxxIncludePaths(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const
Definition: Gnu.cpp:3410
clang::driver::toolchains::Generic_GCC::RocmInstallation
LazyDetector< RocmInstallationDetector > RocmInstallation
Definition: Gnu.h:296
clang::driver::toolchains::Generic_GCC::addLibStdCxxIncludePaths
virtual void addLibStdCxxIncludePaths(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const
Definition: Gnu.cpp:3559
clang::driver::tools::gcc::Common::ConstructJob
void ConstructJob(Compilation &C, const JobAction &JA, const InputInfo &Output, const InputInfoList &Inputs, const llvm::opt::ArgList &TCArgs, const char *LinkingOutput) const override
ConstructJob - Construct jobs to perform the action JA, writing to Output and with Inputs,...
Definition: Gnu.cpp:69
clang::driver::tools::gcc::Compiler::RenderExtraToolArgs
void RenderExtraToolArgs(const JobAction &JA, llvm::opt::ArgStringList &CmdArgs) const override
RenderExtraToolArgs - Render any arguments necessary to force the particular tool mode.
Definition: Gnu.cpp:191
clang::driver::tools::gcc::Linker::RenderExtraToolArgs
void RenderExtraToolArgs(const JobAction &JA, llvm::opt::ArgStringList &CmdArgs) const override
RenderExtraToolArgs - Render any arguments necessary to force the particular tool mode.
Definition: Gnu.cpp:219
clang::driver::tools::gcc::Preprocessor::RenderExtraToolArgs
void RenderExtraToolArgs(const JobAction &JA, llvm::opt::ArgStringList &CmdArgs) const override
RenderExtraToolArgs - Render any arguments necessary to force the particular tool mode.
Definition: Gnu.cpp:186
clang::driver::tools::gnutools::Assembler::ConstructJob
void ConstructJob(Compilation &C, const JobAction &JA, const InputInfo &Output, const InputInfoList &Inputs, const llvm::opt::ArgList &TCArgs, const char *LinkingOutput) const override
ConstructJob - Construct jobs to perform the action JA, writing to Output and with Inputs,...
Definition: Gnu.cpp:822
clang::driver::tools::gnutools::Linker::ConstructJob
void ConstructJob(Compilation &C, const JobAction &JA, const InputInfo &Output, const InputInfoList &Inputs, const llvm::opt::ArgList &TCArgs, const char *LinkingOutput) const override
ConstructJob - Construct jobs to perform the action JA, writing to Output and with Inputs,...
Definition: Gnu.cpp:393
clang::driver::tools::gnutools::StaticLibTool::ConstructJob
void ConstructJob(Compilation &C, const JobAction &JA, const InputInfo &Output, const InputInfoList &Inputs, const llvm::opt::ArgList &TCArgs, const char *LinkingOutput) const override
ConstructJob - Construct jobs to perform the action JA, writing to Output and with Inputs,...
Definition: Gnu.cpp:349
clang::driver::tools::arm::appendBE8LinkFlag
void appendBE8LinkFlag(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs, const llvm::Triple &Triple)
clang::driver::tools::arm::getARMFloatABI
FloatABI getARMFloatABI(const ToolChain &TC, const llvm::opt::ArgList &Args)
clang::driver::tools::arm::isARMBigEndian
bool isARMBigEndian(const llvm::Triple &Triple, const llvm::opt::ArgList &Args)
clang::driver::tools::csky::getCSKYFloatABI
FloatABI getCSKYFloatABI(const Driver &D, const llvm::opt::ArgList &Args)
clang::driver::tools::csky::getCSKYArchName
std::optional< llvm::StringRef > getCSKYArchName(const Driver &D, const llvm::opt::ArgList &Args, const llvm::Triple &Triple)
clang::driver::tools::loongarch::getLoongArchABI
StringRef getLoongArchABI(const Driver &D, const llvm::opt::ArgList &Args, const llvm::Triple &Triple)
clang::driver::tools::mips::getGnuCompatibleMipsABIName
StringRef getGnuCompatibleMipsABIName(StringRef ABI)
Definition: Mips.cpp:137
clang::driver::tools::mips::isNaN2008
bool isNaN2008(const Driver &D, const llvm::opt::ArgList &Args, const llvm::Triple &Triple)
clang::driver::tools::mips::hasMipsAbiArg
bool hasMipsAbiArg(const llvm::opt::ArgList &Args, const char *Value)
clang::driver::tools::mips::getMipsFloatABI
mips::FloatABI getMipsFloatABI(const Driver &D, const llvm::opt::ArgList &Args, const llvm::Triple &Triple)
clang::driver::tools::mips::shouldUseFPXX
bool shouldUseFPXX(const llvm::opt::ArgList &Args, const llvm::Triple &Triple, StringRef CPUName, StringRef ABIName, mips::FloatABI FloatABI)
clang::driver::tools::mips::isUCLibc
bool isUCLibc(const llvm::opt::ArgList &Args)
clang::driver::tools::mips::getMipsCPUAndABI
void getMipsCPUAndABI(const llvm::opt::ArgList &Args, const llvm::Triple &Triple, StringRef &CPUName, StringRef &ABIName)
clang::driver::tools::ppc::getPPCAsmModeForCPU
const char * getPPCAsmModeForCPU(StringRef Name)
Definition: PPC.cpp:95
clang::driver::tools::riscv::getRISCVABI
StringRef getRISCVABI(const llvm::opt::ArgList &Args, const llvm::Triple &Triple)
clang::driver::tools::riscv::getRISCVArch
StringRef getRISCVArch(const llvm::opt::ArgList &Args, const llvm::Triple &Triple)
Definition: RISCV.cpp:251
clang::driver::tools::sparc::getSparcAsmModeForCPU
const char * getSparcAsmModeForCPU(llvm::StringRef Name, const llvm::Triple &Triple)
clang::driver::tools::systemz::getSystemZTargetCPU
std::string getSystemZTargetCPU(const llvm::opt::ArgList &Args)
clang::driver::tools::ParsePICArgs
std::tuple< llvm::Reloc::Model, unsigned, bool > ParsePICArgs(const ToolChain &ToolChain, const llvm::opt::ArgList &Args)
clang::driver::tools::SplitDebugName
const char * SplitDebugName(const JobAction &JA, const llvm::opt::ArgList &Args, const InputInfo &Input, const InputInfo &Output)
clang::driver::tools::getCPUName
std::string getCPUName(const Driver &D, const llvm::opt::ArgList &Args, const llvm::Triple &T, bool FromAs=false)
clang::driver::tools::addHIPRuntimeLibArgs
void addHIPRuntimeLibArgs(const ToolChain &TC, Compilation &C, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs)
Definition: CommonArgs.cpp:2741
clang::driver::tools::addMultilibFlag
void addMultilibFlag(bool Enabled, const StringRef Flag, Multilib::flags_list &Flags)
Flag must be a flag accepted by the driver.
Definition: CommonArgs.cpp:2214
clang::driver::tools::linkXRayRuntimeDeps
void linkXRayRuntimeDeps(const ToolChain &TC, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs)
clang::driver::tools::AddRunTimeLibs
void AddRunTimeLibs(const ToolChain &TC, const Driver &D, llvm::opt::ArgStringList &CmdArgs, const llvm::opt::ArgList &Args)
clang::driver::tools::SplitDebugInfo
void SplitDebugInfo(const ToolChain &TC, Compilation &C, const Tool &T, const JobAction &JA, const llvm::opt::ArgList &Args, const InputInfo &Output, const char *OutFile)
clang::driver::tools::linkSanitizerRuntimeDeps
void linkSanitizerRuntimeDeps(const ToolChain &TC, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs)
clang::driver::tools::addSanitizerRuntimes
bool addSanitizerRuntimes(const ToolChain &TC, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs)
clang::driver::tools::addXRayRuntime
bool addXRayRuntime(const ToolChain &TC, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs)
clang::driver::tools::AddAssemblerKPIC
void AddAssemblerKPIC(const ToolChain &ToolChain, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs)
clang::driver::tools::addPathIfExists
void addPathIfExists(const Driver &D, const Twine &Path, ToolChain::path_list &Paths)
Definition: CommonArgs.cpp:290
clang::driver::tools::addFortranRuntimeLibraryPath
void addFortranRuntimeLibraryPath(const ToolChain &TC, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs)
Adds the path for the Fortran runtime libraries to CmdArgs.
clang::driver::tools::addLinkerCompressDebugSectionsOption
void addLinkerCompressDebugSectionsOption(const ToolChain &TC, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs)
Definition: CommonArgs.cpp:452
clang::driver::tools::addLTOOptions
void addLTOOptions(const ToolChain &ToolChain, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs, const InputInfo &Output, const InputInfo &Input, bool IsThinLTO)
clang::driver::tools::addOpenMPRuntime
bool addOpenMPRuntime(const Compilation &C, llvm::opt::ArgStringList &CmdArgs, const ToolChain &TC, const llvm::opt::ArgList &Args, bool ForceStaticHostRuntime=false, bool IsOffloadingHost=false, bool GompNeedsRT=false)
Returns true, if an OpenMP runtime has been added.
clang::driver::tools::claimNoWarnArgs
void claimNoWarnArgs(const llvm::opt::ArgList &Args)
clang::driver::tools::AddLinkerInputs
void AddLinkerInputs(const ToolChain &TC, const InputInfoList &Inputs, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs, const JobAction &JA)
clang::driver::tools::getDwarfVersion
unsigned getDwarfVersion(const ToolChain &TC, const llvm::opt::ArgList &Args)
Definition: CommonArgs.cpp:2021
clang::driver::tools::addFortranRuntimeLibs
void addFortranRuntimeLibs(const ToolChain &TC, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs)
Adds Fortran runtime libraries to CmdArgs.
clang::driver::types::isLLVMIR
bool isLLVMIR(ID Id)
Is this LLVM IR.
Definition: Types.cpp:256
clang::driver::types::getTypeName
const char * getTypeName(ID Id)
getTypeName - Return the name of the type for Id.
Definition: Types.cpp:52
clang::driver::types::canTypeBeUserSpecified
bool canTypeBeUserSpecified(ID Id)
canTypeBeUserSpecified - Can this type be specified on the command line (by the type name); this is u...
Definition: Types.cpp:105
clang::driver::findMIPSMultilibs
bool findMIPSMultilibs(const Driver &D, const llvm::Triple &TargetTriple, StringRef Path, const llvm::opt::ArgList &Args, DetectedMultilibs &Result)
clang::interp::LE
bool LE(InterpState &S, CodePtr OpPC)
Definition: Interp.h:883
clang::transformer::remove
ASTEdit remove(RangeSelector S)
Removes the source selected by S.
Definition: RewriteRule.cpp:162
clang
The JSON file list parser is used to communicate input to InstallAPI.
Definition: CalledOnceCheck.h:17
clang::T
const FunctionProtoType * T
Definition: RecursiveASTVisitor.h:1355
clang::driver::DetectedMultilibs::Multilibs
MultilibSet Multilibs
The set of multilibs that the detected installation supports.
Definition: Gnu.h:24
clang::driver::DetectedMultilibs::BiarchSibling
std::optional< Multilib > BiarchSibling
On Biarch systems, this corresponds to the default multilib when targeting the non-default multilib.
Definition: Gnu.h:31
clang::driver::DetectedMultilibs::SelectedMultilibs
llvm::SmallVector< Multilib > SelectedMultilibs
The multilibs appropriate for the given flags.
Definition: Gnu.h:27
clang::driver::ResponseFileSupport::None
static constexpr ResponseFileSupport None()
Returns a ResponseFileSupport indicating that response files are not supported.
Definition: Job.h:79
clang::driver::ResponseFileSupport::AtFileCurCP
static constexpr ResponseFileSupport AtFileCurCP()
Definition: Job.h:93
clang::driver::toolchains::Generic_GCC::GCCVersion
Struct to store and manipulate GCC versions.
Definition: Gnu.h:168
clang::driver::toolchains::Generic_GCC::GCCVersion::MajorStr
std::string MajorStr
The text of the parsed major, and major+minor versions.
Definition: Gnu.h:176
clang::driver::toolchains::Generic_GCC::GCCVersion::isOlderThan
bool isOlderThan(int RHSMajor, int RHSMinor, int RHSPatch, StringRef RHSPatchSuffix=StringRef()) const
Generic_GCC - A tool chain using the 'gcc' command to perform all subcommands; this relies on gcc tra...
Definition: Gnu.cpp:2215
clang::driver::toolchains::Generic_GCC::GCCVersion::MinorStr
std::string MinorStr
Definition: Gnu.h:176
clang::driver::toolchains::Generic_GCC::GCCVersion::Minor
int Minor
Definition: Gnu.h:173
clang::driver::toolchains::Generic_GCC::GCCVersion::Patch
int Patch
Definition: Gnu.h:173
clang::driver::toolchains::Generic_GCC::GCCVersion::PatchSuffix
std::string PatchSuffix
Any textual suffix on the patch number.
Definition: Gnu.h:179
clang::driver::toolchains::Generic_GCC::GCCVersion::Major
int Major
The parsed major, minor, and patch numbers.
Definition: Gnu.h:173
clang::driver::toolchains::Generic_GCC::GCCVersion::Text
std::string Text
The unparsed text of the version.
Definition: Gnu.h:170
clang::driver::toolchains::Generic_GCC::GCCVersion::Parse
static GCCVersion Parse(StringRef VersionText)
Parse a GCCVersion object out of a string of text.
Definition: Gnu.cpp:2259
Generated on Fri Jun 28 2024 01:36:56 for clang by doxygen 1.9.1