[Driver] Move detectLibcxxIncludePath to ToolChain
[lldb.git] / clang / lib / Driver / ToolChains / Gnu.cpp
1 //===--- Gnu.cpp - Gnu Tool and ToolChain Implementations -------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 #include "Gnu.h"
10 #include "Arch/ARM.h"
11 #include "Arch/Mips.h"
12 #include "Arch/PPC.h"
13 #include "Arch/RISCV.h"
14 #include "Arch/Sparc.h"
15 #include "Arch/SystemZ.h"
16 #include "CommonArgs.h"
17 #include "Linux.h"
18 #include "clang/Config/config.h" // for GCC_INSTALL_PREFIX
19 #include "clang/Driver/Compilation.h"
20 #include "clang/Driver/Driver.h"
21 #include "clang/Driver/DriverDiagnostic.h"
22 #include "clang/Driver/Options.h"
23 #include "clang/Driver/Tool.h"
24 #include "clang/Driver/ToolChain.h"
25 #include "llvm/Option/ArgList.h"
26 #include "llvm/Support/CodeGen.h"
27 #include "llvm/Support/Path.h"
28 #include "llvm/Support/TargetParser.h"
29 #include "llvm/Support/VirtualFileSystem.h"
30 #include <system_error>
31
32 using namespace clang::driver;
33 using namespace clang::driver::toolchains;
34 using namespace clang;
35 using namespace llvm::opt;
36
37 using tools::addMultilibFlag;
38 using tools::addPathIfExists;
39
40 static bool forwardToGCC(const Option &O) {
41   // LinkerInput options have been forwarded. Don't duplicate.
42   if (O.hasFlag(options::LinkerInput))
43     return false;
44   return O.matches(options::OPT_Link_Group) || O.hasFlag(options::LinkOption);
45 }
46
47 // Switch CPU names not recognized by GNU assembler to a close CPU that it does
48 // recognize, instead of a lower march from being picked in the absence of a cpu
49 // flag.
50 static void normalizeCPUNamesForAssembler(const ArgList &Args,
51                                           ArgStringList &CmdArgs) {
52   if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
53     StringRef CPUArg(A->getValue());
54     if (CPUArg.equals_lower("krait"))
55       CmdArgs.push_back("-mcpu=cortex-a15");
56     else if(CPUArg.equals_lower("kryo"))
57       CmdArgs.push_back("-mcpu=cortex-a57");
58     else
59       Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ);
60   }
61 }
62
63 void tools::gcc::Common::ConstructJob(Compilation &C, const JobAction &JA,
64                                       const InputInfo &Output,
65                                       const InputInfoList &Inputs,
66                                       const ArgList &Args,
67                                       const char *LinkingOutput) const {
68   const Driver &D = getToolChain().getDriver();
69   ArgStringList CmdArgs;
70
71   for (const auto &A : Args) {
72     if (forwardToGCC(A->getOption())) {
73       // It is unfortunate that we have to claim here, as this means
74       // we will basically never report anything interesting for
75       // platforms using a generic gcc, even if we are just using gcc
76       // to get to the assembler.
77       A->claim();
78
79       A->render(Args, CmdArgs);
80     }
81   }
82
83   RenderExtraToolArgs(JA, CmdArgs);
84
85   // If using a driver driver, force the arch.
86   if (getToolChain().getTriple().isOSDarwin()) {
87     CmdArgs.push_back("-arch");
88     CmdArgs.push_back(
89         Args.MakeArgString(getToolChain().getDefaultUniversalArchName()));
90   }
91
92   // Try to force gcc to match the tool chain we want, if we recognize
93   // the arch.
94   //
95   // FIXME: The triple class should directly provide the information we want
96   // here.
97   switch (getToolChain().getArch()) {
98   default:
99     break;
100   case llvm::Triple::x86:
101   case llvm::Triple::ppc:
102     CmdArgs.push_back("-m32");
103     break;
104   case llvm::Triple::x86_64:
105   case llvm::Triple::ppc64:
106   case llvm::Triple::ppc64le:
107     CmdArgs.push_back("-m64");
108     break;
109   case llvm::Triple::sparcel:
110     CmdArgs.push_back("-EL");
111     break;
112   }
113
114   if (Output.isFilename()) {
115     CmdArgs.push_back("-o");
116     CmdArgs.push_back(Output.getFilename());
117   } else {
118     assert(Output.isNothing() && "Unexpected output");
119     CmdArgs.push_back("-fsyntax-only");
120   }
121
122   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
123
124   // Only pass -x if gcc will understand it; otherwise hope gcc
125   // understands the suffix correctly. The main use case this would go
126   // wrong in is for linker inputs if they happened to have an odd
127   // suffix; really the only way to get this to happen is a command
128   // like '-x foobar a.c' which will treat a.c like a linker input.
129   //
130   // FIXME: For the linker case specifically, can we safely convert
131   // inputs into '-Wl,' options?
132   for (const auto &II : Inputs) {
133     // Don't try to pass LLVM or AST inputs to a generic gcc.
134     if (types::isLLVMIR(II.getType()))
135       D.Diag(clang::diag::err_drv_no_linker_llvm_support)
136           << getToolChain().getTripleString();
137     else if (II.getType() == types::TY_AST)
138       D.Diag(diag::err_drv_no_ast_support) << getToolChain().getTripleString();
139     else if (II.getType() == types::TY_ModuleFile)
140       D.Diag(diag::err_drv_no_module_support)
141           << getToolChain().getTripleString();
142
143     if (types::canTypeBeUserSpecified(II.getType())) {
144       CmdArgs.push_back("-x");
145       CmdArgs.push_back(types::getTypeName(II.getType()));
146     }
147
148     if (II.isFilename())
149       CmdArgs.push_back(II.getFilename());
150     else {
151       const Arg &A = II.getInputArg();
152
153       // Reverse translate some rewritten options.
154       if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
155         CmdArgs.push_back("-lstdc++");
156         continue;
157       }
158
159       // Don't render as input, we need gcc to do the translations.
160       A.render(Args, CmdArgs);
161     }
162   }
163
164   const std::string &customGCCName = D.getCCCGenericGCCName();
165   const char *GCCName;
166   if (!customGCCName.empty())
167     GCCName = customGCCName.c_str();
168   else if (D.CCCIsCXX()) {
169     GCCName = "g++";
170   } else
171     GCCName = "gcc";
172
173   const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
174   C.addCommand(std::make_unique<Command>(
175       JA, *this, ResponseFileSupport::AtFileCurCP(), Exec, CmdArgs, Inputs));
176 }
177
178 void tools::gcc::Preprocessor::RenderExtraToolArgs(
179     const JobAction &JA, ArgStringList &CmdArgs) const {
180   CmdArgs.push_back("-E");
181 }
182
183 void tools::gcc::Compiler::RenderExtraToolArgs(const JobAction &JA,
184                                                ArgStringList &CmdArgs) const {
185   const Driver &D = getToolChain().getDriver();
186
187   switch (JA.getType()) {
188   // If -flto, etc. are present then make sure not to force assembly output.
189   case types::TY_LLVM_IR:
190   case types::TY_LTO_IR:
191   case types::TY_LLVM_BC:
192   case types::TY_LTO_BC:
193     CmdArgs.push_back("-c");
194     break;
195   // We assume we've got an "integrated" assembler in that gcc will produce an
196   // object file itself.
197   case types::TY_Object:
198     CmdArgs.push_back("-c");
199     break;
200   case types::TY_PP_Asm:
201     CmdArgs.push_back("-S");
202     break;
203   case types::TY_Nothing:
204     CmdArgs.push_back("-fsyntax-only");
205     break;
206   default:
207     D.Diag(diag::err_drv_invalid_gcc_output_type) << getTypeName(JA.getType());
208   }
209 }
210
211 void tools::gcc::Linker::RenderExtraToolArgs(const JobAction &JA,
212                                              ArgStringList &CmdArgs) const {
213   // The types are (hopefully) good enough.
214 }
215
216 // On Arm the endianness of the output file is determined by the target and
217 // can be overridden by the pseudo-target flags '-mlittle-endian'/'-EL' and
218 // '-mbig-endian'/'-EB'. Unlike other targets the flag does not result in a
219 // normalized triple so we must handle the flag here.
220 static bool isArmBigEndian(const llvm::Triple &Triple,
221                            const ArgList &Args) {
222   bool IsBigEndian = false;
223   switch (Triple.getArch()) {
224   case llvm::Triple::armeb:
225   case llvm::Triple::thumbeb:
226     IsBigEndian = true;
227     LLVM_FALLTHROUGH;
228   case llvm::Triple::arm:
229   case llvm::Triple::thumb:
230     if (Arg *A = Args.getLastArg(options::OPT_mlittle_endian,
231                                options::OPT_mbig_endian))
232       IsBigEndian = !A->getOption().matches(options::OPT_mlittle_endian);
233     break;
234   default:
235     break;
236   }
237   return IsBigEndian;
238 }
239
240 static const char *getLDMOption(const llvm::Triple &T, const ArgList &Args) {
241   switch (T.getArch()) {
242   case llvm::Triple::x86:
243     if (T.isOSIAMCU())
244       return "elf_iamcu";
245     return "elf_i386";
246   case llvm::Triple::aarch64:
247     return "aarch64linux";
248   case llvm::Triple::aarch64_be:
249     return "aarch64linuxb";
250   case llvm::Triple::arm:
251   case llvm::Triple::thumb:
252   case llvm::Triple::armeb:
253   case llvm::Triple::thumbeb:
254     return isArmBigEndian(T, Args) ? "armelfb_linux_eabi" : "armelf_linux_eabi";
255   case llvm::Triple::ppc:
256     return "elf32ppclinux";
257   case llvm::Triple::ppc64:
258     return "elf64ppc";
259   case llvm::Triple::ppc64le:
260     return "elf64lppc";
261   case llvm::Triple::riscv32:
262     return "elf32lriscv";
263   case llvm::Triple::riscv64:
264     return "elf64lriscv";
265   case llvm::Triple::sparc:
266   case llvm::Triple::sparcel:
267     return "elf32_sparc";
268   case llvm::Triple::sparcv9:
269     return "elf64_sparc";
270   case llvm::Triple::mips:
271     return "elf32btsmip";
272   case llvm::Triple::mipsel:
273     return "elf32ltsmip";
274   case llvm::Triple::mips64:
275     if (tools::mips::hasMipsAbiArg(Args, "n32") ||
276         T.getEnvironment() == llvm::Triple::GNUABIN32)
277       return "elf32btsmipn32";
278     return "elf64btsmip";
279   case llvm::Triple::mips64el:
280     if (tools::mips::hasMipsAbiArg(Args, "n32") ||
281         T.getEnvironment() == llvm::Triple::GNUABIN32)
282       return "elf32ltsmipn32";
283     return "elf64ltsmip";
284   case llvm::Triple::systemz:
285     return "elf64_s390";
286   case llvm::Triple::x86_64:
287     if (T.getEnvironment() == llvm::Triple::GNUX32)
288       return "elf32_x86_64";
289     return "elf_x86_64";
290   case llvm::Triple::ve:
291     return "elf64ve";
292   default:
293     return nullptr;
294   }
295 }
296
297 static bool getPIE(const ArgList &Args, const ToolChain &TC) {
298   if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_static) ||
299       Args.hasArg(options::OPT_r) || Args.hasArg(options::OPT_static_pie))
300     return false;
301
302   Arg *A = Args.getLastArg(options::OPT_pie, options::OPT_no_pie,
303                            options::OPT_nopie);
304   if (!A)
305     return TC.isPIEDefault();
306   return A->getOption().matches(options::OPT_pie);
307 }
308
309 static bool getStaticPIE(const ArgList &Args, const ToolChain &TC) {
310   bool HasStaticPIE = Args.hasArg(options::OPT_static_pie);
311   // -no-pie is an alias for -nopie. So, handling -nopie takes care of
312   // -no-pie as well.
313   if (HasStaticPIE && Args.hasArg(options::OPT_nopie)) {
314     const Driver &D = TC.getDriver();
315     const llvm::opt::OptTable &Opts = D.getOpts();
316     const char *StaticPIEName = Opts.getOptionName(options::OPT_static_pie);
317     const char *NoPIEName = Opts.getOptionName(options::OPT_nopie);
318     D.Diag(diag::err_drv_cannot_mix_options) << StaticPIEName << NoPIEName;
319   }
320   return HasStaticPIE;
321 }
322
323 static bool getStatic(const ArgList &Args) {
324   return Args.hasArg(options::OPT_static) &&
325       !Args.hasArg(options::OPT_static_pie);
326 }
327
328 void tools::gnutools::StaticLibTool::ConstructJob(
329     Compilation &C, const JobAction &JA, const InputInfo &Output,
330     const InputInfoList &Inputs, const ArgList &Args,
331     const char *LinkingOutput) const {
332   const Driver &D = getToolChain().getDriver();
333
334   // Silence warning for "clang -g foo.o -o foo"
335   Args.ClaimAllArgs(options::OPT_g_Group);
336   // and "clang -emit-llvm foo.o -o foo"
337   Args.ClaimAllArgs(options::OPT_emit_llvm);
338   // and for "clang -w foo.o -o foo". Other warning options are already
339   // handled somewhere else.
340   Args.ClaimAllArgs(options::OPT_w);
341   // Silence warnings when linking C code with a C++ '-stdlib' argument.
342   Args.ClaimAllArgs(options::OPT_stdlib_EQ);
343
344   // ar tool command "llvm-ar <options> <output_file> <input_files>".
345   ArgStringList CmdArgs;
346   // Create and insert file members with a deterministic index.
347   CmdArgs.push_back("rcsD");
348   CmdArgs.push_back(Output.getFilename());
349
350   for (const auto &II : Inputs) {
351     if (II.isFilename()) {
352        CmdArgs.push_back(II.getFilename());
353     }
354   }
355
356   // Delete old output archive file if it already exists before generating a new
357   // archive file.
358   auto OutputFileName = Output.getFilename();
359   if (Output.isFilename() && llvm::sys::fs::exists(OutputFileName)) {
360     if (std::error_code EC = llvm::sys::fs::remove(OutputFileName)) {
361       D.Diag(diag::err_drv_unable_to_remove_file) << EC.message();
362       return;
363     }
364   }
365
366   const char *Exec = Args.MakeArgString(getToolChain().GetStaticLibToolPath());
367   C.addCommand(std::make_unique<Command>(
368       JA, *this, ResponseFileSupport::AtFileCurCP(), Exec, CmdArgs, Inputs));
369 }
370
371 void tools::gnutools::Linker::ConstructJob(Compilation &C, const JobAction &JA,
372                                            const InputInfo &Output,
373                                            const InputInfoList &Inputs,
374                                            const ArgList &Args,
375                                            const char *LinkingOutput) const {
376   // FIXME: The Linker class constructor takes a ToolChain and not a
377   // Generic_ELF, so the static_cast might return a reference to a invalid
378   // instance (see PR45061). Ideally, the Linker constructor needs to take a
379   // Generic_ELF instead.
380   const toolchains::Generic_ELF &ToolChain =
381       static_cast<const toolchains::Generic_ELF &>(getToolChain());
382   const Driver &D = ToolChain.getDriver();
383
384   const llvm::Triple &Triple = getToolChain().getEffectiveTriple();
385
386   const llvm::Triple::ArchType Arch = ToolChain.getArch();
387   const bool isAndroid = ToolChain.getTriple().isAndroid();
388   const bool IsIAMCU = ToolChain.getTriple().isOSIAMCU();
389   const bool IsVE = ToolChain.getTriple().isVE();
390   const bool IsPIE = getPIE(Args, ToolChain);
391   const bool IsStaticPIE = getStaticPIE(Args, ToolChain);
392   const bool IsStatic = getStatic(Args);
393   const bool HasCRTBeginEndFiles =
394       ToolChain.getTriple().hasEnvironment() ||
395       (ToolChain.getTriple().getVendor() != llvm::Triple::MipsTechnologies);
396
397   ArgStringList CmdArgs;
398
399   // Silence warning for "clang -g foo.o -o foo"
400   Args.ClaimAllArgs(options::OPT_g_Group);
401   // and "clang -emit-llvm foo.o -o foo"
402   Args.ClaimAllArgs(options::OPT_emit_llvm);
403   // and for "clang -w foo.o -o foo". Other warning options are already
404   // handled somewhere else.
405   Args.ClaimAllArgs(options::OPT_w);
406
407   if (!D.SysRoot.empty())
408     CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
409
410   if (IsPIE)
411     CmdArgs.push_back("-pie");
412
413   if (IsStaticPIE) {
414     CmdArgs.push_back("-static");
415     CmdArgs.push_back("-pie");
416     CmdArgs.push_back("--no-dynamic-linker");
417     CmdArgs.push_back("-z");
418     CmdArgs.push_back("text");
419   }
420
421   if (ToolChain.isNoExecStackDefault()) {
422     CmdArgs.push_back("-z");
423     CmdArgs.push_back("noexecstack");
424   }
425
426   if (Args.hasArg(options::OPT_rdynamic))
427     CmdArgs.push_back("-export-dynamic");
428
429   if (Args.hasArg(options::OPT_s))
430     CmdArgs.push_back("-s");
431
432   if (Triple.isARM() || Triple.isThumb() || Triple.isAArch64()) {
433     bool IsBigEndian = isArmBigEndian(Triple, Args);
434     if (IsBigEndian)
435       arm::appendBE8LinkFlag(Args, CmdArgs, Triple);
436     IsBigEndian = IsBigEndian || Arch == llvm::Triple::aarch64_be;
437     CmdArgs.push_back(IsBigEndian ? "-EB" : "-EL");
438   }
439
440   // Most Android ARM64 targets should enable the linker fix for erratum
441   // 843419. Only non-Cortex-A53 devices are allowed to skip this flag.
442   if (Arch == llvm::Triple::aarch64 && isAndroid) {
443     std::string CPU = getCPUName(Args, Triple);
444     if (CPU.empty() || CPU == "generic" || CPU == "cortex-a53")
445       CmdArgs.push_back("--fix-cortex-a53-843419");
446   }
447
448   // Android does not allow shared text relocations. Emit a warning if the
449   // user's code contains any.
450   if (isAndroid)
451       CmdArgs.push_back("--warn-shared-textrel");
452
453   ToolChain.addExtraOpts(CmdArgs);
454
455   CmdArgs.push_back("--eh-frame-hdr");
456
457   if (const char *LDMOption = getLDMOption(ToolChain.getTriple(), Args)) {
458     CmdArgs.push_back("-m");
459     CmdArgs.push_back(LDMOption);
460   } else {
461     D.Diag(diag::err_target_unknown_triple) << Triple.str();
462     return;
463   }
464
465   if (IsStatic) {
466     if (Arch == llvm::Triple::arm || Arch == llvm::Triple::armeb ||
467         Arch == llvm::Triple::thumb || Arch == llvm::Triple::thumbeb)
468       CmdArgs.push_back("-Bstatic");
469     else
470       CmdArgs.push_back("-static");
471   } else if (Args.hasArg(options::OPT_shared)) {
472     CmdArgs.push_back("-shared");
473   }
474
475   if (!IsStatic) {
476     if (Args.hasArg(options::OPT_rdynamic))
477       CmdArgs.push_back("-export-dynamic");
478
479     if (!Args.hasArg(options::OPT_shared) && !IsStaticPIE) {
480       CmdArgs.push_back("-dynamic-linker");
481       CmdArgs.push_back(Args.MakeArgString(Twine(D.DyldPrefix) +
482                                            ToolChain.getDynamicLinker(Args)));
483     }
484   }
485
486   CmdArgs.push_back("-o");
487   CmdArgs.push_back(Output.getFilename());
488
489   if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
490     if (!isAndroid && !IsIAMCU) {
491       const char *crt1 = nullptr;
492       if (!Args.hasArg(options::OPT_shared)) {
493         if (Args.hasArg(options::OPT_pg))
494           crt1 = "gcrt1.o";
495         else if (IsPIE)
496           crt1 = "Scrt1.o";
497         else if (IsStaticPIE)
498           crt1 = "rcrt1.o";
499         else
500           crt1 = "crt1.o";
501       }
502       if (crt1)
503         CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
504
505       CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
506     }
507
508     if (IsVE) {
509       CmdArgs.push_back("-z");
510       CmdArgs.push_back("max-page-size=0x4000000");
511     }
512
513     if (IsIAMCU)
514       CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crt0.o")));
515     else if (HasCRTBeginEndFiles) {
516       std::string P;
517       if (ToolChain.GetRuntimeLibType(Args) == ToolChain::RLT_CompilerRT &&
518           !isAndroid) {
519         std::string crtbegin = ToolChain.getCompilerRT(Args, "crtbegin",
520                                                        ToolChain::FT_Object);
521         if (ToolChain.getVFS().exists(crtbegin))
522           P = crtbegin;
523       }
524       if (P.empty()) {
525         const char *crtbegin;
526         if (IsStatic)
527           crtbegin = isAndroid ? "crtbegin_static.o" : "crtbeginT.o";
528         else if (Args.hasArg(options::OPT_shared))
529           crtbegin = isAndroid ? "crtbegin_so.o" : "crtbeginS.o";
530         else if (IsPIE || IsStaticPIE)
531           crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbeginS.o";
532         else
533           crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbegin.o";
534         P = ToolChain.GetFilePath(crtbegin);
535       }
536       CmdArgs.push_back(Args.MakeArgString(P));
537     }
538
539     // Add crtfastmath.o if available and fast math is enabled.
540     ToolChain.addFastMathRuntimeIfAvailable(Args, CmdArgs);
541   }
542
543   Args.AddAllArgs(CmdArgs, options::OPT_L);
544   Args.AddAllArgs(CmdArgs, options::OPT_u);
545
546   ToolChain.AddFilePathLibArgs(Args, CmdArgs);
547
548   if (D.isUsingLTO()) {
549     assert(!Inputs.empty() && "Must have at least one input.");
550     addLTOOptions(ToolChain, Args, CmdArgs, Output, Inputs[0],
551                   D.getLTOMode() == LTOK_Thin);
552   }
553
554   if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
555     CmdArgs.push_back("--no-demangle");
556
557   bool NeedsSanitizerDeps = addSanitizerRuntimes(ToolChain, Args, CmdArgs);
558   bool NeedsXRayDeps = addXRayRuntime(ToolChain, Args, CmdArgs);
559   addLinkerCompressDebugSectionsOption(ToolChain, Args, CmdArgs);
560   AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs, JA);
561   // The profile runtime also needs access to system libraries.
562   getToolChain().addProfileRTLibs(Args, CmdArgs);
563
564   if (D.CCCIsCXX() &&
565       !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
566     if (ToolChain.ShouldLinkCXXStdlib(Args)) {
567       bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
568                                  !Args.hasArg(options::OPT_static);
569       if (OnlyLibstdcxxStatic)
570         CmdArgs.push_back("-Bstatic");
571       ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
572       if (OnlyLibstdcxxStatic)
573         CmdArgs.push_back("-Bdynamic");
574     }
575     CmdArgs.push_back("-lm");
576   }
577   // Silence warnings when linking C code with a C++ '-stdlib' argument.
578   Args.ClaimAllArgs(options::OPT_stdlib_EQ);
579
580   if (!Args.hasArg(options::OPT_nostdlib)) {
581     if (!Args.hasArg(options::OPT_nodefaultlibs)) {
582       if (IsStatic || IsStaticPIE)
583         CmdArgs.push_back("--start-group");
584
585       if (NeedsSanitizerDeps)
586         linkSanitizerRuntimeDeps(ToolChain, CmdArgs);
587
588       if (NeedsXRayDeps)
589         linkXRayRuntimeDeps(ToolChain, CmdArgs);
590
591       bool WantPthread = Args.hasArg(options::OPT_pthread) ||
592                          Args.hasArg(options::OPT_pthreads);
593
594       // Use the static OpenMP runtime with -static-openmp
595       bool StaticOpenMP = Args.hasArg(options::OPT_static_openmp) &&
596                           !Args.hasArg(options::OPT_static);
597
598       // FIXME: Only pass GompNeedsRT = true for platforms with libgomp that
599       // require librt. Most modern Linux platforms do, but some may not.
600       if (addOpenMPRuntime(CmdArgs, ToolChain, Args, StaticOpenMP,
601                            JA.isHostOffloading(Action::OFK_OpenMP),
602                            /* GompNeedsRT= */ true))
603         // OpenMP runtimes implies pthreads when using the GNU toolchain.
604         // FIXME: Does this really make sense for all GNU toolchains?
605         WantPthread = true;
606
607       AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
608
609       if (WantPthread && !isAndroid)
610         CmdArgs.push_back("-lpthread");
611
612       if (Args.hasArg(options::OPT_fsplit_stack))
613         CmdArgs.push_back("--wrap=pthread_create");
614
615       if (!Args.hasArg(options::OPT_nolibc))
616         CmdArgs.push_back("-lc");
617
618       // Add IAMCU specific libs, if needed.
619       if (IsIAMCU)
620         CmdArgs.push_back("-lgloss");
621
622       if (IsStatic || IsStaticPIE)
623         CmdArgs.push_back("--end-group");
624       else
625         AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
626
627       // Add IAMCU specific libs (outside the group), if needed.
628       if (IsIAMCU) {
629         CmdArgs.push_back("--as-needed");
630         CmdArgs.push_back("-lsoftfp");
631         CmdArgs.push_back("--no-as-needed");
632       }
633     }
634
635     if (!Args.hasArg(options::OPT_nostartfiles) && !IsIAMCU) {
636       if (HasCRTBeginEndFiles) {
637         std::string P;
638         if (ToolChain.GetRuntimeLibType(Args) == ToolChain::RLT_CompilerRT &&
639             !isAndroid) {
640           std::string crtend = ToolChain.getCompilerRT(Args, "crtend",
641                                                        ToolChain::FT_Object);
642           if (ToolChain.getVFS().exists(crtend))
643             P = crtend;
644         }
645         if (P.empty()) {
646           const char *crtend;
647           if (Args.hasArg(options::OPT_shared))
648             crtend = isAndroid ? "crtend_so.o" : "crtendS.o";
649           else if (IsPIE || IsStaticPIE)
650             crtend = isAndroid ? "crtend_android.o" : "crtendS.o";
651           else
652             crtend = isAndroid ? "crtend_android.o" : "crtend.o";
653           P = ToolChain.GetFilePath(crtend);
654         }
655         CmdArgs.push_back(Args.MakeArgString(P));
656       }
657       if (!isAndroid)
658         CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
659     }
660   }
661
662   Args.AddAllArgs(CmdArgs, options::OPT_T);
663
664   const char *Exec = Args.MakeArgString(ToolChain.GetLinkerPath());
665   C.addCommand(std::make_unique<Command>(
666       JA, *this, ResponseFileSupport::AtFileCurCP(), Exec, CmdArgs, Inputs));
667 }
668
669 void tools::gnutools::Assembler::ConstructJob(Compilation &C,
670                                               const JobAction &JA,
671                                               const InputInfo &Output,
672                                               const InputInfoList &Inputs,
673                                               const ArgList &Args,
674                                               const char *LinkingOutput) const {
675   const auto &D = getToolChain().getDriver();
676
677   claimNoWarnArgs(Args);
678
679   ArgStringList CmdArgs;
680
681   llvm::Reloc::Model RelocationModel;
682   unsigned PICLevel;
683   bool IsPIE;
684   const char *DefaultAssembler = "as";
685   std::tie(RelocationModel, PICLevel, IsPIE) =
686       ParsePICArgs(getToolChain(), Args);
687
688   if (const Arg *A = Args.getLastArg(options::OPT_gz, options::OPT_gz_EQ)) {
689     if (A->getOption().getID() == options::OPT_gz) {
690       CmdArgs.push_back("--compress-debug-sections");
691     } else {
692       StringRef Value = A->getValue();
693       if (Value == "none" || Value == "zlib" || Value == "zlib-gnu") {
694         CmdArgs.push_back(
695             Args.MakeArgString("--compress-debug-sections=" + Twine(Value)));
696       } else {
697         D.Diag(diag::err_drv_unsupported_option_argument)
698             << A->getOption().getName() << Value;
699       }
700     }
701   }
702
703   if (getToolChain().isNoExecStackDefault()) {
704       CmdArgs.push_back("--noexecstack");
705   }
706
707   switch (getToolChain().getArch()) {
708   default:
709     break;
710   // Add --32/--64 to make sure we get the format we want.
711   // This is incomplete
712   case llvm::Triple::x86:
713     CmdArgs.push_back("--32");
714     break;
715   case llvm::Triple::x86_64:
716     if (getToolChain().getTriple().getEnvironment() == llvm::Triple::GNUX32)
717       CmdArgs.push_back("--x32");
718     else
719       CmdArgs.push_back("--64");
720     break;
721   case llvm::Triple::ppc: {
722     CmdArgs.push_back("-a32");
723     CmdArgs.push_back("-mppc");
724     CmdArgs.push_back(
725       ppc::getPPCAsmModeForCPU(getCPUName(Args, getToolChain().getTriple())));
726     break;
727   }
728   case llvm::Triple::ppc64: {
729     CmdArgs.push_back("-a64");
730     CmdArgs.push_back("-mppc64");
731     CmdArgs.push_back(
732       ppc::getPPCAsmModeForCPU(getCPUName(Args, getToolChain().getTriple())));
733     break;
734   }
735   case llvm::Triple::ppc64le: {
736     CmdArgs.push_back("-a64");
737     CmdArgs.push_back("-mppc64");
738     CmdArgs.push_back("-mlittle-endian");
739     CmdArgs.push_back(
740       ppc::getPPCAsmModeForCPU(getCPUName(Args, getToolChain().getTriple())));
741     break;
742   }
743   case llvm::Triple::riscv32:
744   case llvm::Triple::riscv64: {
745     StringRef ABIName = riscv::getRISCVABI(Args, getToolChain().getTriple());
746     CmdArgs.push_back("-mabi");
747     CmdArgs.push_back(ABIName.data());
748     StringRef MArchName = riscv::getRISCVArch(Args, getToolChain().getTriple());
749     CmdArgs.push_back("-march");
750     CmdArgs.push_back(MArchName.data());
751     break;
752   }
753   case llvm::Triple::sparc:
754   case llvm::Triple::sparcel: {
755     CmdArgs.push_back("-32");
756     std::string CPU = getCPUName(Args, getToolChain().getTriple());
757     CmdArgs.push_back(
758         sparc::getSparcAsmModeForCPU(CPU, getToolChain().getTriple()));
759     AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
760     break;
761   }
762   case llvm::Triple::sparcv9: {
763     CmdArgs.push_back("-64");
764     std::string CPU = getCPUName(Args, getToolChain().getTriple());
765     CmdArgs.push_back(
766         sparc::getSparcAsmModeForCPU(CPU, getToolChain().getTriple()));
767     AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
768     break;
769   }
770   case llvm::Triple::arm:
771   case llvm::Triple::armeb:
772   case llvm::Triple::thumb:
773   case llvm::Triple::thumbeb: {
774     const llvm::Triple &Triple2 = getToolChain().getTriple();
775     CmdArgs.push_back(isArmBigEndian(Triple2, Args) ? "-EB" : "-EL");
776     switch (Triple2.getSubArch()) {
777     case llvm::Triple::ARMSubArch_v7:
778       CmdArgs.push_back("-mfpu=neon");
779       break;
780     case llvm::Triple::ARMSubArch_v8:
781       CmdArgs.push_back("-mfpu=crypto-neon-fp-armv8");
782       break;
783     default:
784       break;
785     }
786
787     switch (arm::getARMFloatABI(getToolChain(), Args)) {
788     case arm::FloatABI::Invalid: llvm_unreachable("must have an ABI!");
789     case arm::FloatABI::Soft:
790       CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=soft"));
791       break;
792     case arm::FloatABI::SoftFP:
793       CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=softfp"));
794       break;
795     case arm::FloatABI::Hard:
796       CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=hard"));
797       break;
798     }
799
800     Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
801     normalizeCPUNamesForAssembler(Args, CmdArgs);
802
803     Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ);
804     break;
805   }
806   case llvm::Triple::aarch64:
807   case llvm::Triple::aarch64_be: {
808     CmdArgs.push_back(
809         getToolChain().getArch() == llvm::Triple::aarch64_be ? "-EB" : "-EL");
810     Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
811     normalizeCPUNamesForAssembler(Args, CmdArgs);
812
813     break;
814   }
815   case llvm::Triple::mips:
816   case llvm::Triple::mipsel:
817   case llvm::Triple::mips64:
818   case llvm::Triple::mips64el: {
819     StringRef CPUName;
820     StringRef ABIName;
821     mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
822     ABIName = mips::getGnuCompatibleMipsABIName(ABIName);
823
824     CmdArgs.push_back("-march");
825     CmdArgs.push_back(CPUName.data());
826
827     CmdArgs.push_back("-mabi");
828     CmdArgs.push_back(ABIName.data());
829
830     // -mno-shared should be emitted unless -fpic, -fpie, -fPIC, -fPIE,
831     // or -mshared (not implemented) is in effect.
832     if (RelocationModel == llvm::Reloc::Static)
833       CmdArgs.push_back("-mno-shared");
834
835     // LLVM doesn't support -mplt yet and acts as if it is always given.
836     // However, -mplt has no effect with the N64 ABI.
837     if (ABIName != "64" && !Args.hasArg(options::OPT_mno_abicalls))
838       CmdArgs.push_back("-call_nonpic");
839
840     if (getToolChain().getTriple().isLittleEndian())
841       CmdArgs.push_back("-EL");
842     else
843       CmdArgs.push_back("-EB");
844
845     if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
846       if (StringRef(A->getValue()) == "2008")
847         CmdArgs.push_back(Args.MakeArgString("-mnan=2008"));
848     }
849
850     // Add the last -mfp32/-mfpxx/-mfp64 or -mfpxx if it is enabled by default.
851     if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfpxx,
852                                  options::OPT_mfp64)) {
853       A->claim();
854       A->render(Args, CmdArgs);
855     } else if (mips::shouldUseFPXX(
856                    Args, getToolChain().getTriple(), CPUName, ABIName,
857                    mips::getMipsFloatABI(getToolChain().getDriver(), Args,
858                                          getToolChain().getTriple())))
859       CmdArgs.push_back("-mfpxx");
860
861     // Pass on -mmips16 or -mno-mips16. However, the assembler equivalent of
862     // -mno-mips16 is actually -no-mips16.
863     if (Arg *A =
864             Args.getLastArg(options::OPT_mips16, options::OPT_mno_mips16)) {
865       if (A->getOption().matches(options::OPT_mips16)) {
866         A->claim();
867         A->render(Args, CmdArgs);
868       } else {
869         A->claim();
870         CmdArgs.push_back("-no-mips16");
871       }
872     }
873
874     Args.AddLastArg(CmdArgs, options::OPT_mmicromips,
875                     options::OPT_mno_micromips);
876     Args.AddLastArg(CmdArgs, options::OPT_mdsp, options::OPT_mno_dsp);
877     Args.AddLastArg(CmdArgs, options::OPT_mdspr2, options::OPT_mno_dspr2);
878
879     if (Arg *A = Args.getLastArg(options::OPT_mmsa, options::OPT_mno_msa)) {
880       // Do not use AddLastArg because not all versions of MIPS assembler
881       // support -mmsa / -mno-msa options.
882       if (A->getOption().matches(options::OPT_mmsa))
883         CmdArgs.push_back(Args.MakeArgString("-mmsa"));
884     }
885
886     Args.AddLastArg(CmdArgs, options::OPT_mhard_float,
887                     options::OPT_msoft_float);
888
889     Args.AddLastArg(CmdArgs, options::OPT_mdouble_float,
890                     options::OPT_msingle_float);
891
892     Args.AddLastArg(CmdArgs, options::OPT_modd_spreg,
893                     options::OPT_mno_odd_spreg);
894
895     AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
896     break;
897   }
898   case llvm::Triple::systemz: {
899     // Always pass an -march option, since our default of z10 is later
900     // than the GNU assembler's default.
901     std::string CPUName = systemz::getSystemZTargetCPU(Args);
902     CmdArgs.push_back(Args.MakeArgString("-march=" + CPUName));
903     break;
904   }
905   case llvm::Triple::ve:
906     DefaultAssembler = "nas";
907   }
908
909   for (const Arg *A : Args.filtered(options::OPT_ffile_prefix_map_EQ,
910                                     options::OPT_fdebug_prefix_map_EQ)) {
911     StringRef Map = A->getValue();
912     if (Map.find('=') == StringRef::npos)
913       D.Diag(diag::err_drv_invalid_argument_to_option)
914           << Map << A->getOption().getName();
915     else {
916       CmdArgs.push_back(Args.MakeArgString("--debug-prefix-map"));
917       CmdArgs.push_back(Args.MakeArgString(Map));
918     }
919     A->claim();
920   }
921
922   Args.AddAllArgs(CmdArgs, options::OPT_I);
923   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
924
925   CmdArgs.push_back("-o");
926   CmdArgs.push_back(Output.getFilename());
927
928   for (const auto &II : Inputs)
929     CmdArgs.push_back(II.getFilename());
930
931   const char *Exec =
932       Args.MakeArgString(getToolChain().GetProgramPath(DefaultAssembler));
933   C.addCommand(std::make_unique<Command>(
934       JA, *this, ResponseFileSupport::AtFileCurCP(), Exec, CmdArgs, Inputs));
935
936   // Handle the debug info splitting at object creation time if we're
937   // creating an object.
938   // TODO: Currently only works on linux with newer objcopy.
939   if (Args.hasArg(options::OPT_gsplit_dwarf) &&
940       getToolChain().getTriple().isOSLinux())
941     SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
942                    SplitDebugName(JA, Args, Inputs[0], Output));
943 }
944
945 namespace {
946 // Filter to remove Multilibs that don't exist as a suffix to Path
947 class FilterNonExistent {
948   StringRef Base, File;
949   llvm::vfs::FileSystem &VFS;
950
951 public:
952   FilterNonExistent(StringRef Base, StringRef File, llvm::vfs::FileSystem &VFS)
953       : Base(Base), File(File), VFS(VFS) {}
954   bool operator()(const Multilib &M) {
955     return !VFS.exists(Base + M.gccSuffix() + File);
956   }
957 };
958 } // end anonymous namespace
959
960 static bool isSoftFloatABI(const ArgList &Args) {
961   Arg *A = Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float,
962                            options::OPT_mfloat_abi_EQ);
963   if (!A)
964     return false;
965
966   return A->getOption().matches(options::OPT_msoft_float) ||
967          (A->getOption().matches(options::OPT_mfloat_abi_EQ) &&
968           A->getValue() == StringRef("soft"));
969 }
970
971 static bool isArmOrThumbArch(llvm::Triple::ArchType Arch) {
972   return Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb;
973 }
974
975 static bool isMipsEL(llvm::Triple::ArchType Arch) {
976   return Arch == llvm::Triple::mipsel || Arch == llvm::Triple::mips64el;
977 }
978
979 static bool isMips16(const ArgList &Args) {
980   Arg *A = Args.getLastArg(options::OPT_mips16, options::OPT_mno_mips16);
981   return A && A->getOption().matches(options::OPT_mips16);
982 }
983
984 static bool isMicroMips(const ArgList &Args) {
985   Arg *A = Args.getLastArg(options::OPT_mmicromips, options::OPT_mno_micromips);
986   return A && A->getOption().matches(options::OPT_mmicromips);
987 }
988
989 static bool isMSP430(llvm::Triple::ArchType Arch) {
990   return Arch == llvm::Triple::msp430;
991 }
992
993 static Multilib makeMultilib(StringRef commonSuffix) {
994   return Multilib(commonSuffix, commonSuffix, commonSuffix);
995 }
996
997 static bool findMipsCsMultilibs(const Multilib::flags_list &Flags,
998                                 FilterNonExistent &NonExistent,
999                                 DetectedMultilibs &Result) {
1000   // Check for Code Sourcery toolchain multilibs
1001   MultilibSet CSMipsMultilibs;
1002   {
1003     auto MArchMips16 = makeMultilib("/mips16").flag("+m32").flag("+mips16");
1004
1005     auto MArchMicroMips =
1006         makeMultilib("/micromips").flag("+m32").flag("+mmicromips");
1007
1008     auto MArchDefault = makeMultilib("").flag("-mips16").flag("-mmicromips");
1009
1010     auto UCLibc = makeMultilib("/uclibc").flag("+muclibc");
1011
1012     auto SoftFloat = makeMultilib("/soft-float").flag("+msoft-float");
1013
1014     auto Nan2008 = makeMultilib("/nan2008").flag("+mnan=2008");
1015
1016     auto DefaultFloat =
1017         makeMultilib("").flag("-msoft-float").flag("-mnan=2008");
1018
1019     auto BigEndian = makeMultilib("").flag("+EB").flag("-EL");
1020
1021     auto LittleEndian = makeMultilib("/el").flag("+EL").flag("-EB");
1022
1023     // Note that this one's osSuffix is ""
1024     auto MAbi64 = makeMultilib("")
1025                       .gccSuffix("/64")
1026                       .includeSuffix("/64")
1027                       .flag("+mabi=n64")
1028                       .flag("-mabi=n32")
1029                       .flag("-m32");
1030
1031     CSMipsMultilibs =
1032         MultilibSet()
1033             .Either(MArchMips16, MArchMicroMips, MArchDefault)
1034             .Maybe(UCLibc)
1035             .Either(SoftFloat, Nan2008, DefaultFloat)
1036             .FilterOut("/micromips/nan2008")
1037             .FilterOut("/mips16/nan2008")
1038             .Either(BigEndian, LittleEndian)
1039             .Maybe(MAbi64)
1040             .FilterOut("/mips16.*/64")
1041             .FilterOut("/micromips.*/64")
1042             .FilterOut(NonExistent)
1043             .setIncludeDirsCallback([](const Multilib &M) {
1044               std::vector<std::string> Dirs({"/include"});
1045               if (StringRef(M.includeSuffix()).startswith("/uclibc"))
1046                 Dirs.push_back(
1047                     "/../../../../mips-linux-gnu/libc/uclibc/usr/include");
1048               else
1049                 Dirs.push_back("/../../../../mips-linux-gnu/libc/usr/include");
1050               return Dirs;
1051             });
1052   }
1053
1054   MultilibSet DebianMipsMultilibs;
1055   {
1056     Multilib MAbiN32 =
1057         Multilib().gccSuffix("/n32").includeSuffix("/n32").flag("+mabi=n32");
1058
1059     Multilib M64 = Multilib()
1060                        .gccSuffix("/64")
1061                        .includeSuffix("/64")
1062                        .flag("+m64")
1063                        .flag("-m32")
1064                        .flag("-mabi=n32");
1065
1066     Multilib M32 = Multilib().flag("-m64").flag("+m32").flag("-mabi=n32");
1067
1068     DebianMipsMultilibs =
1069         MultilibSet().Either(M32, M64, MAbiN32).FilterOut(NonExistent);
1070   }
1071
1072   // Sort candidates. Toolchain that best meets the directories tree goes first.
1073   // Then select the first toolchains matches command line flags.
1074   MultilibSet *Candidates[] = {&CSMipsMultilibs, &DebianMipsMultilibs};
1075   if (CSMipsMultilibs.size() < DebianMipsMultilibs.size())
1076     std::iter_swap(Candidates, Candidates + 1);
1077   for (const MultilibSet *Candidate : Candidates) {
1078     if (Candidate->select(Flags, Result.SelectedMultilib)) {
1079       if (Candidate == &DebianMipsMultilibs)
1080         Result.BiarchSibling = Multilib();
1081       Result.Multilibs = *Candidate;
1082       return true;
1083     }
1084   }
1085   return false;
1086 }
1087
1088 static bool findMipsAndroidMultilibs(llvm::vfs::FileSystem &VFS, StringRef Path,
1089                                      const Multilib::flags_list &Flags,
1090                                      FilterNonExistent &NonExistent,
1091                                      DetectedMultilibs &Result) {
1092
1093   MultilibSet AndroidMipsMultilibs =
1094       MultilibSet()
1095           .Maybe(Multilib("/mips-r2").flag("+march=mips32r2"))
1096           .Maybe(Multilib("/mips-r6").flag("+march=mips32r6"))
1097           .FilterOut(NonExistent);
1098
1099   MultilibSet AndroidMipselMultilibs =
1100       MultilibSet()
1101           .Either(Multilib().flag("+march=mips32"),
1102                   Multilib("/mips-r2", "", "/mips-r2").flag("+march=mips32r2"),
1103                   Multilib("/mips-r6", "", "/mips-r6").flag("+march=mips32r6"))
1104           .FilterOut(NonExistent);
1105
1106   MultilibSet AndroidMips64elMultilibs =
1107       MultilibSet()
1108           .Either(
1109               Multilib().flag("+march=mips64r6"),
1110               Multilib("/32/mips-r1", "", "/mips-r1").flag("+march=mips32"),
1111               Multilib("/32/mips-r2", "", "/mips-r2").flag("+march=mips32r2"),
1112               Multilib("/32/mips-r6", "", "/mips-r6").flag("+march=mips32r6"))
1113           .FilterOut(NonExistent);
1114
1115   MultilibSet *MS = &AndroidMipsMultilibs;
1116   if (VFS.exists(Path + "/mips-r6"))
1117     MS = &AndroidMipselMultilibs;
1118   else if (VFS.exists(Path + "/32"))
1119     MS = &AndroidMips64elMultilibs;
1120   if (MS->select(Flags, Result.SelectedMultilib)) {
1121     Result.Multilibs = *MS;
1122     return true;
1123   }
1124   return false;
1125 }
1126
1127 static bool findMipsMuslMultilibs(const Multilib::flags_list &Flags,
1128                                   FilterNonExistent &NonExistent,
1129                                   DetectedMultilibs &Result) {
1130   // Musl toolchain multilibs
1131   MultilibSet MuslMipsMultilibs;
1132   {
1133     auto MArchMipsR2 = makeMultilib("")
1134                            .osSuffix("/mips-r2-hard-musl")
1135                            .flag("+EB")
1136                            .flag("-EL")
1137                            .flag("+march=mips32r2");
1138
1139     auto MArchMipselR2 = makeMultilib("/mipsel-r2-hard-musl")
1140                              .flag("-EB")
1141                              .flag("+EL")
1142                              .flag("+march=mips32r2");
1143
1144     MuslMipsMultilibs = MultilibSet().Either(MArchMipsR2, MArchMipselR2);
1145
1146     // Specify the callback that computes the include directories.
1147     MuslMipsMultilibs.setIncludeDirsCallback([](const Multilib &M) {
1148       return std::vector<std::string>(
1149           {"/../sysroot" + M.osSuffix() + "/usr/include"});
1150     });
1151   }
1152   if (MuslMipsMultilibs.select(Flags, Result.SelectedMultilib)) {
1153     Result.Multilibs = MuslMipsMultilibs;
1154     return true;
1155   }
1156   return false;
1157 }
1158
1159 static bool findMipsMtiMultilibs(const Multilib::flags_list &Flags,
1160                                  FilterNonExistent &NonExistent,
1161                                  DetectedMultilibs &Result) {
1162   // CodeScape MTI toolchain v1.2 and early.
1163   MultilibSet MtiMipsMultilibsV1;
1164   {
1165     auto MArchMips32 = makeMultilib("/mips32")
1166                            .flag("+m32")
1167                            .flag("-m64")
1168                            .flag("-mmicromips")
1169                            .flag("+march=mips32");
1170
1171     auto MArchMicroMips = makeMultilib("/micromips")
1172                               .flag("+m32")
1173                               .flag("-m64")
1174                               .flag("+mmicromips");
1175
1176     auto MArchMips64r2 = makeMultilib("/mips64r2")
1177                              .flag("-m32")
1178                              .flag("+m64")
1179                              .flag("+march=mips64r2");
1180
1181     auto MArchMips64 = makeMultilib("/mips64").flag("-m32").flag("+m64").flag(
1182         "-march=mips64r2");
1183
1184     auto MArchDefault = makeMultilib("")
1185                             .flag("+m32")
1186                             .flag("-m64")
1187                             .flag("-mmicromips")
1188                             .flag("+march=mips32r2");
1189
1190     auto Mips16 = makeMultilib("/mips16").flag("+mips16");
1191
1192     auto UCLibc = makeMultilib("/uclibc").flag("+muclibc");
1193
1194     auto MAbi64 =
1195         makeMultilib("/64").flag("+mabi=n64").flag("-mabi=n32").flag("-m32");
1196
1197     auto BigEndian = makeMultilib("").flag("+EB").flag("-EL");
1198
1199     auto LittleEndian = makeMultilib("/el").flag("+EL").flag("-EB");
1200
1201     auto SoftFloat = makeMultilib("/sof").flag("+msoft-float");
1202
1203     auto Nan2008 = makeMultilib("/nan2008").flag("+mnan=2008");
1204
1205     MtiMipsMultilibsV1 =
1206         MultilibSet()
1207             .Either(MArchMips32, MArchMicroMips, MArchMips64r2, MArchMips64,
1208                     MArchDefault)
1209             .Maybe(UCLibc)
1210             .Maybe(Mips16)
1211             .FilterOut("/mips64/mips16")
1212             .FilterOut("/mips64r2/mips16")
1213             .FilterOut("/micromips/mips16")
1214             .Maybe(MAbi64)
1215             .FilterOut("/micromips/64")
1216             .FilterOut("/mips32/64")
1217             .FilterOut("^/64")
1218             .FilterOut("/mips16/64")
1219             .Either(BigEndian, LittleEndian)
1220             .Maybe(SoftFloat)
1221             .Maybe(Nan2008)
1222             .FilterOut(".*sof/nan2008")
1223             .FilterOut(NonExistent)
1224             .setIncludeDirsCallback([](const Multilib &M) {
1225               std::vector<std::string> Dirs({"/include"});
1226               if (StringRef(M.includeSuffix()).startswith("/uclibc"))
1227                 Dirs.push_back("/../../../../sysroot/uclibc/usr/include");
1228               else
1229                 Dirs.push_back("/../../../../sysroot/usr/include");
1230               return Dirs;
1231             });
1232   }
1233
1234   // CodeScape IMG toolchain starting from v1.3.
1235   MultilibSet MtiMipsMultilibsV2;
1236   {
1237     auto BeHard = makeMultilib("/mips-r2-hard")
1238                       .flag("+EB")
1239                       .flag("-msoft-float")
1240                       .flag("-mnan=2008")
1241                       .flag("-muclibc");
1242     auto BeSoft = makeMultilib("/mips-r2-soft")
1243                       .flag("+EB")
1244                       .flag("+msoft-float")
1245                       .flag("-mnan=2008");
1246     auto ElHard = makeMultilib("/mipsel-r2-hard")
1247                       .flag("+EL")
1248                       .flag("-msoft-float")
1249                       .flag("-mnan=2008")
1250                       .flag("-muclibc");
1251     auto ElSoft = makeMultilib("/mipsel-r2-soft")
1252                       .flag("+EL")
1253                       .flag("+msoft-float")
1254                       .flag("-mnan=2008")
1255                       .flag("-mmicromips");
1256     auto BeHardNan = makeMultilib("/mips-r2-hard-nan2008")
1257                          .flag("+EB")
1258                          .flag("-msoft-float")
1259                          .flag("+mnan=2008")
1260                          .flag("-muclibc");
1261     auto ElHardNan = makeMultilib("/mipsel-r2-hard-nan2008")
1262                          .flag("+EL")
1263                          .flag("-msoft-float")
1264                          .flag("+mnan=2008")
1265                          .flag("-muclibc")
1266                          .flag("-mmicromips");
1267     auto BeHardNanUclibc = makeMultilib("/mips-r2-hard-nan2008-uclibc")
1268                                .flag("+EB")
1269                                .flag("-msoft-float")
1270                                .flag("+mnan=2008")
1271                                .flag("+muclibc");
1272     auto ElHardNanUclibc = makeMultilib("/mipsel-r2-hard-nan2008-uclibc")
1273                                .flag("+EL")
1274                                .flag("-msoft-float")
1275                                .flag("+mnan=2008")
1276                                .flag("+muclibc");
1277     auto BeHardUclibc = makeMultilib("/mips-r2-hard-uclibc")
1278                             .flag("+EB")
1279                             .flag("-msoft-float")
1280                             .flag("-mnan=2008")
1281                             .flag("+muclibc");
1282     auto ElHardUclibc = makeMultilib("/mipsel-r2-hard-uclibc")
1283                             .flag("+EL")
1284                             .flag("-msoft-float")
1285                             .flag("-mnan=2008")
1286                             .flag("+muclibc");
1287     auto ElMicroHardNan = makeMultilib("/micromipsel-r2-hard-nan2008")
1288                               .flag("+EL")
1289                               .flag("-msoft-float")
1290                               .flag("+mnan=2008")
1291                               .flag("+mmicromips");
1292     auto ElMicroSoft = makeMultilib("/micromipsel-r2-soft")
1293                            .flag("+EL")
1294                            .flag("+msoft-float")
1295                            .flag("-mnan=2008")
1296                            .flag("+mmicromips");
1297
1298     auto O32 =
1299         makeMultilib("/lib").osSuffix("").flag("-mabi=n32").flag("-mabi=n64");
1300     auto N32 =
1301         makeMultilib("/lib32").osSuffix("").flag("+mabi=n32").flag("-mabi=n64");
1302     auto N64 =
1303         makeMultilib("/lib64").osSuffix("").flag("-mabi=n32").flag("+mabi=n64");
1304
1305     MtiMipsMultilibsV2 =
1306         MultilibSet()
1307             .Either({BeHard, BeSoft, ElHard, ElSoft, BeHardNan, ElHardNan,
1308                      BeHardNanUclibc, ElHardNanUclibc, BeHardUclibc,
1309                      ElHardUclibc, ElMicroHardNan, ElMicroSoft})
1310             .Either(O32, N32, N64)
1311             .FilterOut(NonExistent)
1312             .setIncludeDirsCallback([](const Multilib &M) {
1313               return std::vector<std::string>({"/../../../../sysroot" +
1314                                                M.includeSuffix() +
1315                                                "/../usr/include"});
1316             })
1317             .setFilePathsCallback([](const Multilib &M) {
1318               return std::vector<std::string>(
1319                   {"/../../../../mips-mti-linux-gnu/lib" + M.gccSuffix()});
1320             });
1321   }
1322   for (auto Candidate : {&MtiMipsMultilibsV1, &MtiMipsMultilibsV2}) {
1323     if (Candidate->select(Flags, Result.SelectedMultilib)) {
1324       Result.Multilibs = *Candidate;
1325       return true;
1326     }
1327   }
1328   return false;
1329 }
1330
1331 static bool findMipsImgMultilibs(const Multilib::flags_list &Flags,
1332                                  FilterNonExistent &NonExistent,
1333                                  DetectedMultilibs &Result) {
1334   // CodeScape IMG toolchain v1.2 and early.
1335   MultilibSet ImgMultilibsV1;
1336   {
1337     auto Mips64r6 = makeMultilib("/mips64r6").flag("+m64").flag("-m32");
1338
1339     auto LittleEndian = makeMultilib("/el").flag("+EL").flag("-EB");
1340
1341     auto MAbi64 =
1342         makeMultilib("/64").flag("+mabi=n64").flag("-mabi=n32").flag("-m32");
1343
1344     ImgMultilibsV1 =
1345         MultilibSet()
1346             .Maybe(Mips64r6)
1347             .Maybe(MAbi64)
1348             .Maybe(LittleEndian)
1349             .FilterOut(NonExistent)
1350             .setIncludeDirsCallback([](const Multilib &M) {
1351               return std::vector<std::string>(
1352                   {"/include", "/../../../../sysroot/usr/include"});
1353             });
1354   }
1355
1356   // CodeScape IMG toolchain starting from v1.3.
1357   MultilibSet ImgMultilibsV2;
1358   {
1359     auto BeHard = makeMultilib("/mips-r6-hard")
1360                       .flag("+EB")
1361                       .flag("-msoft-float")
1362                       .flag("-mmicromips");
1363     auto BeSoft = makeMultilib("/mips-r6-soft")
1364                       .flag("+EB")
1365                       .flag("+msoft-float")
1366                       .flag("-mmicromips");
1367     auto ElHard = makeMultilib("/mipsel-r6-hard")
1368                       .flag("+EL")
1369                       .flag("-msoft-float")
1370                       .flag("-mmicromips");
1371     auto ElSoft = makeMultilib("/mipsel-r6-soft")
1372                       .flag("+EL")
1373                       .flag("+msoft-float")
1374                       .flag("-mmicromips");
1375     auto BeMicroHard = makeMultilib("/micromips-r6-hard")
1376                            .flag("+EB")
1377                            .flag("-msoft-float")
1378                            .flag("+mmicromips");
1379     auto BeMicroSoft = makeMultilib("/micromips-r6-soft")
1380                            .flag("+EB")
1381                            .flag("+msoft-float")
1382                            .flag("+mmicromips");
1383     auto ElMicroHard = makeMultilib("/micromipsel-r6-hard")
1384                            .flag("+EL")
1385                            .flag("-msoft-float")
1386                            .flag("+mmicromips");
1387     auto ElMicroSoft = makeMultilib("/micromipsel-r6-soft")
1388                            .flag("+EL")
1389                            .flag("+msoft-float")
1390                            .flag("+mmicromips");
1391
1392     auto O32 =
1393         makeMultilib("/lib").osSuffix("").flag("-mabi=n32").flag("-mabi=n64");
1394     auto N32 =
1395         makeMultilib("/lib32").osSuffix("").flag("+mabi=n32").flag("-mabi=n64");
1396     auto N64 =
1397         makeMultilib("/lib64").osSuffix("").flag("-mabi=n32").flag("+mabi=n64");
1398
1399     ImgMultilibsV2 =
1400         MultilibSet()
1401             .Either({BeHard, BeSoft, ElHard, ElSoft, BeMicroHard, BeMicroSoft,
1402                      ElMicroHard, ElMicroSoft})
1403             .Either(O32, N32, N64)
1404             .FilterOut(NonExistent)
1405             .setIncludeDirsCallback([](const Multilib &M) {
1406               return std::vector<std::string>({"/../../../../sysroot" +
1407                                                M.includeSuffix() +
1408                                                "/../usr/include"});
1409             })
1410             .setFilePathsCallback([](const Multilib &M) {
1411               return std::vector<std::string>(
1412                   {"/../../../../mips-img-linux-gnu/lib" + M.gccSuffix()});
1413             });
1414   }
1415   for (auto Candidate : {&ImgMultilibsV1, &ImgMultilibsV2}) {
1416     if (Candidate->select(Flags, Result.SelectedMultilib)) {
1417       Result.Multilibs = *Candidate;
1418       return true;
1419     }
1420   }
1421   return false;
1422 }
1423
1424 bool clang::driver::findMIPSMultilibs(const Driver &D,
1425                                       const llvm::Triple &TargetTriple,
1426                                       StringRef Path, const ArgList &Args,
1427                                       DetectedMultilibs &Result) {
1428   FilterNonExistent NonExistent(Path, "/crtbegin.o", D.getVFS());
1429
1430   StringRef CPUName;
1431   StringRef ABIName;
1432   tools::mips::getMipsCPUAndABI(Args, TargetTriple, CPUName, ABIName);
1433
1434   llvm::Triple::ArchType TargetArch = TargetTriple.getArch();
1435
1436   Multilib::flags_list Flags;
1437   addMultilibFlag(TargetTriple.isMIPS32(), "m32", Flags);
1438   addMultilibFlag(TargetTriple.isMIPS64(), "m64", Flags);
1439   addMultilibFlag(isMips16(Args), "mips16", Flags);
1440   addMultilibFlag(CPUName == "mips32", "march=mips32", Flags);
1441   addMultilibFlag(CPUName == "mips32r2" || CPUName == "mips32r3" ||
1442                       CPUName == "mips32r5" || CPUName == "p5600",
1443                   "march=mips32r2", Flags);
1444   addMultilibFlag(CPUName == "mips32r6", "march=mips32r6", Flags);
1445   addMultilibFlag(CPUName == "mips64", "march=mips64", Flags);
1446   addMultilibFlag(CPUName == "mips64r2" || CPUName == "mips64r3" ||
1447                       CPUName == "mips64r5" || CPUName == "octeon" ||
1448                       CPUName == "octeon+",
1449                   "march=mips64r2", Flags);
1450   addMultilibFlag(CPUName == "mips64r6", "march=mips64r6", Flags);
1451   addMultilibFlag(isMicroMips(Args), "mmicromips", Flags);
1452   addMultilibFlag(tools::mips::isUCLibc(Args), "muclibc", Flags);
1453   addMultilibFlag(tools::mips::isNaN2008(Args, TargetTriple), "mnan=2008",
1454                   Flags);
1455   addMultilibFlag(ABIName == "n32", "mabi=n32", Flags);
1456   addMultilibFlag(ABIName == "n64", "mabi=n64", Flags);
1457   addMultilibFlag(isSoftFloatABI(Args), "msoft-float", Flags);
1458   addMultilibFlag(!isSoftFloatABI(Args), "mhard-float", Flags);
1459   addMultilibFlag(isMipsEL(TargetArch), "EL", Flags);
1460   addMultilibFlag(!isMipsEL(TargetArch), "EB", Flags);
1461
1462   if (TargetTriple.isAndroid())
1463     return findMipsAndroidMultilibs(D.getVFS(), Path, Flags, NonExistent,
1464                                     Result);
1465
1466   if (TargetTriple.getVendor() == llvm::Triple::MipsTechnologies &&
1467       TargetTriple.getOS() == llvm::Triple::Linux &&
1468       TargetTriple.getEnvironment() == llvm::Triple::UnknownEnvironment)
1469     return findMipsMuslMultilibs(Flags, NonExistent, Result);
1470
1471   if (TargetTriple.getVendor() == llvm::Triple::MipsTechnologies &&
1472       TargetTriple.getOS() == llvm::Triple::Linux &&
1473       TargetTriple.isGNUEnvironment())
1474     return findMipsMtiMultilibs(Flags, NonExistent, Result);
1475
1476   if (TargetTriple.getVendor() == llvm::Triple::ImaginationTechnologies &&
1477       TargetTriple.getOS() == llvm::Triple::Linux &&
1478       TargetTriple.isGNUEnvironment())
1479     return findMipsImgMultilibs(Flags, NonExistent, Result);
1480
1481   if (findMipsCsMultilibs(Flags, NonExistent, Result))
1482     return true;
1483
1484   // Fallback to the regular toolchain-tree structure.
1485   Multilib Default;
1486   Result.Multilibs.push_back(Default);
1487   Result.Multilibs.FilterOut(NonExistent);
1488
1489   if (Result.Multilibs.select(Flags, Result.SelectedMultilib)) {
1490     Result.BiarchSibling = Multilib();
1491     return true;
1492   }
1493
1494   return false;
1495 }
1496
1497 static void findAndroidArmMultilibs(const Driver &D,
1498                                     const llvm::Triple &TargetTriple,
1499                                     StringRef Path, const ArgList &Args,
1500                                     DetectedMultilibs &Result) {
1501   // Find multilibs with subdirectories like armv7-a, thumb, armv7-a/thumb.
1502   FilterNonExistent NonExistent(Path, "/crtbegin.o", D.getVFS());
1503   Multilib ArmV7Multilib = makeMultilib("/armv7-a")
1504                                .flag("+march=armv7-a")
1505                                .flag("-mthumb");
1506   Multilib ThumbMultilib = makeMultilib("/thumb")
1507                                .flag("-march=armv7-a")
1508                                .flag("+mthumb");
1509   Multilib ArmV7ThumbMultilib = makeMultilib("/armv7-a/thumb")
1510                                .flag("+march=armv7-a")
1511                                .flag("+mthumb");
1512   Multilib DefaultMultilib = makeMultilib("")
1513                                .flag("-march=armv7-a")
1514                                .flag("-mthumb");
1515   MultilibSet AndroidArmMultilibs =
1516       MultilibSet()
1517           .Either(ThumbMultilib, ArmV7Multilib,
1518                   ArmV7ThumbMultilib, DefaultMultilib)
1519           .FilterOut(NonExistent);
1520
1521   Multilib::flags_list Flags;
1522   llvm::StringRef Arch = Args.getLastArgValue(options::OPT_march_EQ);
1523   bool IsArmArch = TargetTriple.getArch() == llvm::Triple::arm;
1524   bool IsThumbArch = TargetTriple.getArch() == llvm::Triple::thumb;
1525   bool IsV7SubArch = TargetTriple.getSubArch() == llvm::Triple::ARMSubArch_v7;
1526   bool IsThumbMode = IsThumbArch ||
1527       Args.hasFlag(options::OPT_mthumb, options::OPT_mno_thumb, false) ||
1528       (IsArmArch && llvm::ARM::parseArchISA(Arch) == llvm::ARM::ISAKind::THUMB);
1529   bool IsArmV7Mode = (IsArmArch || IsThumbArch) &&
1530       (llvm::ARM::parseArchVersion(Arch) == 7 ||
1531        (IsArmArch && Arch == "" && IsV7SubArch));
1532   addMultilibFlag(IsArmV7Mode, "march=armv7-a", Flags);
1533   addMultilibFlag(IsThumbMode, "mthumb", Flags);
1534
1535   if (AndroidArmMultilibs.select(Flags, Result.SelectedMultilib))
1536     Result.Multilibs = AndroidArmMultilibs;
1537 }
1538
1539 static bool findMSP430Multilibs(const Driver &D,
1540                                 const llvm::Triple &TargetTriple,
1541                                 StringRef Path, const ArgList &Args,
1542                                 DetectedMultilibs &Result) {
1543   FilterNonExistent NonExistent(Path, "/crtbegin.o", D.getVFS());
1544   Multilib WithoutExceptions = makeMultilib("/430").flag("-exceptions");
1545   Multilib WithExceptions = makeMultilib("/430/exceptions").flag("+exceptions");
1546
1547   // FIXME: when clang starts to support msp430x ISA additional logic
1548   // to select between multilib must be implemented
1549   // Multilib MSP430xMultilib = makeMultilib("/large");
1550
1551   Result.Multilibs.push_back(WithoutExceptions);
1552   Result.Multilibs.push_back(WithExceptions);
1553   Result.Multilibs.FilterOut(NonExistent);
1554
1555   Multilib::flags_list Flags;
1556   addMultilibFlag(Args.hasFlag(options::OPT_fexceptions,
1557                                options::OPT_fno_exceptions, false),
1558                   "exceptions", Flags);
1559   if (Result.Multilibs.select(Flags, Result.SelectedMultilib))
1560     return true;
1561
1562   return false;
1563 }
1564
1565 static void findRISCVBareMetalMultilibs(const Driver &D,
1566                                         const llvm::Triple &TargetTriple,
1567                                         StringRef Path, const ArgList &Args,
1568                                         DetectedMultilibs &Result) {
1569   FilterNonExistent NonExistent(Path, "/crtbegin.o", D.getVFS());
1570   struct RiscvMultilib {
1571     StringRef march;
1572     StringRef mabi;
1573   };
1574   // currently only support the set of multilibs like riscv-gnu-toolchain does.
1575   // TODO: support MULTILIB_REUSE
1576   constexpr RiscvMultilib RISCVMultilibSet[] = {
1577       {"rv32i", "ilp32"},     {"rv32im", "ilp32"},     {"rv32iac", "ilp32"},
1578       {"rv32imac", "ilp32"},  {"rv32imafc", "ilp32f"}, {"rv64imac", "lp64"},
1579       {"rv64imafdc", "lp64d"}};
1580
1581   std::vector<Multilib> Ms;
1582   for (auto Element : RISCVMultilibSet) {
1583     // multilib path rule is ${march}/${mabi}
1584     Ms.emplace_back(
1585         makeMultilib((Twine(Element.march) + "/" + Twine(Element.mabi)).str())
1586             .flag(Twine("+march=", Element.march).str())
1587             .flag(Twine("+mabi=", Element.mabi).str()));
1588   }
1589   MultilibSet RISCVMultilibs =
1590       MultilibSet()
1591           .Either(ArrayRef<Multilib>(Ms))
1592           .FilterOut(NonExistent)
1593           .setFilePathsCallback([](const Multilib &M) {
1594             return std::vector<std::string>(
1595                 {M.gccSuffix(),
1596                  "/../../../../riscv64-unknown-elf/lib" + M.gccSuffix(),
1597                  "/../../../../riscv32-unknown-elf/lib" + M.gccSuffix()});
1598           });
1599
1600
1601   Multilib::flags_list Flags;
1602   llvm::StringSet<> Added_ABIs;
1603   StringRef ABIName = tools::riscv::getRISCVABI(Args, TargetTriple);
1604   StringRef MArch = tools::riscv::getRISCVArch(Args, TargetTriple);
1605   for (auto Element : RISCVMultilibSet) {
1606     addMultilibFlag(MArch == Element.march,
1607                     Twine("march=", Element.march).str().c_str(), Flags);
1608     if (!Added_ABIs.count(Element.mabi)) {
1609       Added_ABIs.insert(Element.mabi);
1610       addMultilibFlag(ABIName == Element.mabi,
1611                       Twine("mabi=", Element.mabi).str().c_str(), Flags);
1612     }
1613   }
1614
1615   if (RISCVMultilibs.select(Flags, Result.SelectedMultilib))
1616     Result.Multilibs = RISCVMultilibs;
1617 }
1618
1619 static void findRISCVMultilibs(const Driver &D,
1620                                const llvm::Triple &TargetTriple, StringRef Path,
1621                                const ArgList &Args, DetectedMultilibs &Result) {
1622   if (TargetTriple.getOS() == llvm::Triple::UnknownOS)
1623     return findRISCVBareMetalMultilibs(D, TargetTriple, Path, Args, Result);
1624
1625   FilterNonExistent NonExistent(Path, "/crtbegin.o", D.getVFS());
1626   Multilib Ilp32 = makeMultilib("lib32/ilp32").flag("+m32").flag("+mabi=ilp32");
1627   Multilib Ilp32f =
1628       makeMultilib("lib32/ilp32f").flag("+m32").flag("+mabi=ilp32f");
1629   Multilib Ilp32d =
1630       makeMultilib("lib32/ilp32d").flag("+m32").flag("+mabi=ilp32d");
1631   Multilib Lp64 = makeMultilib("lib64/lp64").flag("+m64").flag("+mabi=lp64");
1632   Multilib Lp64f = makeMultilib("lib64/lp64f").flag("+m64").flag("+mabi=lp64f");
1633   Multilib Lp64d = makeMultilib("lib64/lp64d").flag("+m64").flag("+mabi=lp64d");
1634   MultilibSet RISCVMultilibs =
1635       MultilibSet()
1636           .Either({Ilp32, Ilp32f, Ilp32d, Lp64, Lp64f, Lp64d})
1637           .FilterOut(NonExistent);
1638
1639   Multilib::flags_list Flags;
1640   bool IsRV64 = TargetTriple.getArch() == llvm::Triple::riscv64;
1641   StringRef ABIName = tools::riscv::getRISCVABI(Args, TargetTriple);
1642
1643   addMultilibFlag(!IsRV64, "m32", Flags);
1644   addMultilibFlag(IsRV64, "m64", Flags);
1645   addMultilibFlag(ABIName == "ilp32", "mabi=ilp32", Flags);
1646   addMultilibFlag(ABIName == "ilp32f", "mabi=ilp32f", Flags);
1647   addMultilibFlag(ABIName == "ilp32d", "mabi=ilp32d", Flags);
1648   addMultilibFlag(ABIName == "lp64", "mabi=lp64", Flags);
1649   addMultilibFlag(ABIName == "lp64f", "mabi=lp64f", Flags);
1650   addMultilibFlag(ABIName == "lp64d", "mabi=lp64d", Flags);
1651
1652   if (RISCVMultilibs.select(Flags, Result.SelectedMultilib))
1653     Result.Multilibs = RISCVMultilibs;
1654 }
1655
1656 static bool findBiarchMultilibs(const Driver &D,
1657                                 const llvm::Triple &TargetTriple,
1658                                 StringRef Path, const ArgList &Args,
1659                                 bool NeedsBiarchSuffix,
1660                                 DetectedMultilibs &Result) {
1661   Multilib Default;
1662
1663   // Some versions of SUSE and Fedora on ppc64 put 32-bit libs
1664   // in what would normally be GCCInstallPath and put the 64-bit
1665   // libs in a subdirectory named 64. The simple logic we follow is that
1666   // *if* there is a subdirectory of the right name with crtbegin.o in it,
1667   // we use that. If not, and if not a biarch triple alias, we look for
1668   // crtbegin.o without the subdirectory.
1669
1670   StringRef Suff64 = "/64";
1671   // Solaris uses platform-specific suffixes instead of /64.
1672   if (TargetTriple.getOS() == llvm::Triple::Solaris) {
1673     switch (TargetTriple.getArch()) {
1674     case llvm::Triple::x86:
1675     case llvm::Triple::x86_64:
1676       Suff64 = "/amd64";
1677       break;
1678     case llvm::Triple::sparc:
1679     case llvm::Triple::sparcv9:
1680       Suff64 = "/sparcv9";
1681       break;
1682     default:
1683       break;
1684     }
1685   }
1686
1687   Multilib Alt64 = Multilib()
1688                        .gccSuffix(Suff64)
1689                        .includeSuffix(Suff64)
1690                        .flag("-m32")
1691                        .flag("+m64")
1692                        .flag("-mx32");
1693   Multilib Alt32 = Multilib()
1694                        .gccSuffix("/32")
1695                        .includeSuffix("/32")
1696                        .flag("+m32")
1697                        .flag("-m64")
1698                        .flag("-mx32");
1699   Multilib Altx32 = Multilib()
1700                         .gccSuffix("/x32")
1701                         .includeSuffix("/x32")
1702                         .flag("-m32")
1703                         .flag("-m64")
1704                         .flag("+mx32");
1705
1706   // GCC toolchain for IAMCU doesn't have crtbegin.o, so look for libgcc.a.
1707   FilterNonExistent NonExistent(
1708       Path, TargetTriple.isOSIAMCU() ? "/libgcc.a" : "/crtbegin.o", D.getVFS());
1709
1710   // Determine default multilib from: 32, 64, x32
1711   // Also handle cases such as 64 on 32, 32 on 64, etc.
1712   enum { UNKNOWN, WANT32, WANT64, WANTX32 } Want = UNKNOWN;
1713   const bool IsX32 = TargetTriple.getEnvironment() == llvm::Triple::GNUX32;
1714   if (TargetTriple.isArch32Bit() && !NonExistent(Alt32))
1715     Want = WANT64;
1716   else if (TargetTriple.isArch64Bit() && IsX32 && !NonExistent(Altx32))
1717     Want = WANT64;
1718   else if (TargetTriple.isArch64Bit() && !IsX32 && !NonExistent(Alt64))
1719     Want = WANT32;
1720   else {
1721     if (TargetTriple.isArch32Bit())
1722       Want = NeedsBiarchSuffix ? WANT64 : WANT32;
1723     else if (IsX32)
1724       Want = NeedsBiarchSuffix ? WANT64 : WANTX32;
1725     else
1726       Want = NeedsBiarchSuffix ? WANT32 : WANT64;
1727   }
1728
1729   if (Want == WANT32)
1730     Default.flag("+m32").flag("-m64").flag("-mx32");
1731   else if (Want == WANT64)
1732     Default.flag("-m32").flag("+m64").flag("-mx32");
1733   else if (Want == WANTX32)
1734     Default.flag("-m32").flag("-m64").flag("+mx32");
1735   else
1736     return false;
1737
1738   Result.Multilibs.push_back(Default);
1739   Result.Multilibs.push_back(Alt64);
1740   Result.Multilibs.push_back(Alt32);
1741   Result.Multilibs.push_back(Altx32);
1742
1743   Result.Multilibs.FilterOut(NonExistent);
1744
1745   Multilib::flags_list Flags;
1746   addMultilibFlag(TargetTriple.isArch64Bit() && !IsX32, "m64", Flags);
1747   addMultilibFlag(TargetTriple.isArch32Bit(), "m32", Flags);
1748   addMultilibFlag(TargetTriple.isArch64Bit() && IsX32, "mx32", Flags);
1749
1750   if (!Result.Multilibs.select(Flags, Result.SelectedMultilib))
1751     return false;
1752
1753   if (Result.SelectedMultilib == Alt64 || Result.SelectedMultilib == Alt32 ||
1754       Result.SelectedMultilib == Altx32)
1755     Result.BiarchSibling = Default;
1756
1757   return true;
1758 }
1759
1760 /// Generic_GCC - A tool chain using the 'gcc' command to perform
1761 /// all subcommands; this relies on gcc translating the majority of
1762 /// command line options.
1763
1764 /// Less-than for GCCVersion, implementing a Strict Weak Ordering.
1765 bool Generic_GCC::GCCVersion::isOlderThan(int RHSMajor, int RHSMinor,
1766                                           int RHSPatch,
1767                                           StringRef RHSPatchSuffix) const {
1768   if (Major != RHSMajor)
1769     return Major < RHSMajor;
1770   if (Minor != RHSMinor)
1771     return Minor < RHSMinor;
1772   if (Patch != RHSPatch) {
1773     // Note that versions without a specified patch sort higher than those with
1774     // a patch.
1775     if (RHSPatch == -1)
1776       return true;
1777     if (Patch == -1)
1778       return false;
1779
1780     // Otherwise just sort on the patch itself.
1781     return Patch < RHSPatch;
1782   }
1783   if (PatchSuffix != RHSPatchSuffix) {
1784     // Sort empty suffixes higher.
1785     if (RHSPatchSuffix.empty())
1786       return true;
1787     if (PatchSuffix.empty())
1788       return false;
1789
1790     // Provide a lexicographic sort to make this a total ordering.
1791     return PatchSuffix < RHSPatchSuffix;
1792   }
1793
1794   // The versions are equal.
1795   return false;
1796 }
1797
1798 /// Parse a GCCVersion object out of a string of text.
1799 ///
1800 /// This is the primary means of forming GCCVersion objects.
1801 /*static*/
1802 Generic_GCC::GCCVersion Generic_GCC::GCCVersion::Parse(StringRef VersionText) {
1803   const GCCVersion BadVersion = {VersionText.str(), -1, -1, -1, "", "", ""};
1804   std::pair<StringRef, StringRef> First = VersionText.split('.');
1805   std::pair<StringRef, StringRef> Second = First.second.split('.');
1806
1807   GCCVersion GoodVersion = {VersionText.str(), -1, -1, -1, "", "", ""};
1808   if (First.first.getAsInteger(10, GoodVersion.Major) || GoodVersion.Major < 0)
1809     return BadVersion;
1810   GoodVersion.MajorStr = First.first.str();
1811   if (First.second.empty())
1812     return GoodVersion;
1813   StringRef MinorStr = Second.first;
1814   if (Second.second.empty()) {
1815     if (size_t EndNumber = MinorStr.find_first_not_of("0123456789")) {
1816       GoodVersion.PatchSuffix = std::string(MinorStr.substr(EndNumber));
1817       MinorStr = MinorStr.slice(0, EndNumber);
1818     }
1819   }
1820   if (MinorStr.getAsInteger(10, GoodVersion.Minor) || GoodVersion.Minor < 0)
1821     return BadVersion;
1822   GoodVersion.MinorStr = MinorStr.str();
1823
1824   // First look for a number prefix and parse that if present. Otherwise just
1825   // stash the entire patch string in the suffix, and leave the number
1826   // unspecified. This covers versions strings such as:
1827   //   5        (handled above)
1828   //   4.4
1829   //   4.4-patched
1830   //   4.4.0
1831   //   4.4.x
1832   //   4.4.2-rc4
1833   //   4.4.x-patched
1834   // And retains any patch number it finds.
1835   StringRef PatchText = Second.second;
1836   if (!PatchText.empty()) {
1837     if (size_t EndNumber = PatchText.find_first_not_of("0123456789")) {
1838       // Try to parse the number and any suffix.
1839       if (PatchText.slice(0, EndNumber).getAsInteger(10, GoodVersion.Patch) ||
1840           GoodVersion.Patch < 0)
1841         return BadVersion;
1842       GoodVersion.PatchSuffix = std::string(PatchText.substr(EndNumber));
1843     }
1844   }
1845
1846   return GoodVersion;
1847 }
1848
1849 static llvm::StringRef getGCCToolchainDir(const ArgList &Args,
1850                                           llvm::StringRef SysRoot) {
1851   const Arg *A = Args.getLastArg(clang::driver::options::OPT_gcc_toolchain);
1852   if (A)
1853     return A->getValue();
1854
1855   // If we have a SysRoot, ignore GCC_INSTALL_PREFIX.
1856   // GCC_INSTALL_PREFIX specifies the gcc installation for the default
1857   // sysroot and is likely not valid with a different sysroot.
1858   if (!SysRoot.empty())
1859     return "";
1860
1861   return GCC_INSTALL_PREFIX;
1862 }
1863
1864 /// Initialize a GCCInstallationDetector from the driver.
1865 ///
1866 /// This performs all of the autodetection and sets up the various paths.
1867 /// Once constructed, a GCCInstallationDetector is essentially immutable.
1868 ///
1869 /// FIXME: We shouldn't need an explicit TargetTriple parameter here, and
1870 /// should instead pull the target out of the driver. This is currently
1871 /// necessary because the driver doesn't store the final version of the target
1872 /// triple.
1873 void Generic_GCC::GCCInstallationDetector::init(
1874     const llvm::Triple &TargetTriple, const ArgList &Args,
1875     ArrayRef<std::string> ExtraTripleAliases) {
1876   llvm::Triple BiarchVariantTriple = TargetTriple.isArch32Bit()
1877                                          ? TargetTriple.get64BitArchVariant()
1878                                          : TargetTriple.get32BitArchVariant();
1879   // The library directories which may contain GCC installations.
1880   SmallVector<StringRef, 4> CandidateLibDirs, CandidateBiarchLibDirs;
1881   // The compatible GCC triples for this particular architecture.
1882   SmallVector<StringRef, 16> CandidateTripleAliases;
1883   SmallVector<StringRef, 16> CandidateBiarchTripleAliases;
1884   CollectLibDirsAndTriples(TargetTriple, BiarchVariantTriple, CandidateLibDirs,
1885                            CandidateTripleAliases, CandidateBiarchLibDirs,
1886                            CandidateBiarchTripleAliases);
1887
1888   // Compute the set of prefixes for our search.
1889   SmallVector<std::string, 8> Prefixes(D.PrefixDirs.begin(),
1890                                        D.PrefixDirs.end());
1891
1892   StringRef GCCToolchainDir = getGCCToolchainDir(Args, D.SysRoot);
1893   if (GCCToolchainDir != "") {
1894     if (GCCToolchainDir.back() == '/')
1895       GCCToolchainDir = GCCToolchainDir.drop_back(); // remove the /
1896
1897     Prefixes.push_back(std::string(GCCToolchainDir));
1898   } else {
1899     // If we have a SysRoot, try that first.
1900     if (!D.SysRoot.empty()) {
1901       Prefixes.push_back(D.SysRoot);
1902       AddDefaultGCCPrefixes(TargetTriple, Prefixes, D.SysRoot);
1903     }
1904
1905     // Then look for gcc installed alongside clang.
1906     Prefixes.push_back(D.InstalledDir + "/..");
1907
1908     // Next, look for prefix(es) that correspond to distribution-supplied gcc
1909     // installations.
1910     if (D.SysRoot.empty()) {
1911       // Typically /usr.
1912       AddDefaultGCCPrefixes(TargetTriple, Prefixes, D.SysRoot);
1913     }
1914   }
1915
1916   // Try to respect gcc-config on Gentoo. However, do that only
1917   // if --gcc-toolchain is not provided or equal to the Gentoo install
1918   // in /usr. This avoids accidentally enforcing the system GCC version
1919   // when using a custom toolchain.
1920   if (GCCToolchainDir == "" || GCCToolchainDir == D.SysRoot + "/usr") {
1921     SmallVector<StringRef, 16> GentooTestTriples;
1922     // Try to match an exact triple as target triple first.
1923     // e.g. crossdev -S x86_64-gentoo-linux-gnu will install gcc libs for
1924     // x86_64-gentoo-linux-gnu. But "clang -target x86_64-gentoo-linux-gnu"
1925     // may pick the libraries for x86_64-pc-linux-gnu even when exact matching
1926     // triple x86_64-gentoo-linux-gnu is present.
1927     GentooTestTriples.push_back(TargetTriple.str());
1928     // Check rest of triples.
1929     GentooTestTriples.append(ExtraTripleAliases.begin(),
1930                              ExtraTripleAliases.end());
1931     GentooTestTriples.append(CandidateTripleAliases.begin(),
1932                              CandidateTripleAliases.end());
1933     if (ScanGentooConfigs(TargetTriple, Args, GentooTestTriples,
1934                           CandidateBiarchTripleAliases))
1935       return;
1936   }
1937
1938   // Loop over the various components which exist and select the best GCC
1939   // installation available. GCC installs are ranked by version number.
1940   Version = GCCVersion::Parse("0.0.0");
1941   for (const std::string &Prefix : Prefixes) {
1942     auto &VFS = D.getVFS();
1943     if (!VFS.exists(Prefix))
1944       continue;
1945     for (StringRef Suffix : CandidateLibDirs) {
1946       const std::string LibDir = Prefix + Suffix.str();
1947       if (!VFS.exists(LibDir))
1948         continue;
1949       // Maybe filter out <libdir>/gcc and <libdir>/gcc-cross.
1950       bool GCCDirExists = VFS.exists(LibDir + "/gcc");
1951       bool GCCCrossDirExists = VFS.exists(LibDir + "/gcc-cross");
1952       // Try to match the exact target triple first.
1953       ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, TargetTriple.str(),
1954                              false, GCCDirExists, GCCCrossDirExists);
1955       // Try rest of possible triples.
1956       for (StringRef Candidate : ExtraTripleAliases) // Try these first.
1957         ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate, false,
1958                                GCCDirExists, GCCCrossDirExists);
1959       for (StringRef Candidate : CandidateTripleAliases)
1960         ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate, false,
1961                                GCCDirExists, GCCCrossDirExists);
1962     }
1963     for (StringRef Suffix : CandidateBiarchLibDirs) {
1964       const std::string LibDir = Prefix + Suffix.str();
1965       if (!VFS.exists(LibDir))
1966         continue;
1967       bool GCCDirExists = VFS.exists(LibDir + "/gcc");
1968       bool GCCCrossDirExists = VFS.exists(LibDir + "/gcc-cross");
1969       for (StringRef Candidate : CandidateBiarchTripleAliases)
1970         ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate, true,
1971                                GCCDirExists, GCCCrossDirExists);
1972     }
1973   }
1974 }
1975
1976 void Generic_GCC::GCCInstallationDetector::print(raw_ostream &OS) const {
1977   for (const auto &InstallPath : CandidateGCCInstallPaths)
1978     OS << "Found candidate GCC installation: " << InstallPath << "\n";
1979
1980   if (!GCCInstallPath.empty())
1981     OS << "Selected GCC installation: " << GCCInstallPath << "\n";
1982
1983   for (const auto &Multilib : Multilibs)
1984     OS << "Candidate multilib: " << Multilib << "\n";
1985
1986   if (Multilibs.size() != 0 || !SelectedMultilib.isDefault())
1987     OS << "Selected multilib: " << SelectedMultilib << "\n";
1988 }
1989
1990 bool Generic_GCC::GCCInstallationDetector::getBiarchSibling(Multilib &M) const {
1991   if (BiarchSibling.hasValue()) {
1992     M = BiarchSibling.getValue();
1993     return true;
1994   }
1995   return false;
1996 }
1997
1998 void Generic_GCC::GCCInstallationDetector::AddDefaultGCCPrefixes(
1999     const llvm::Triple &TargetTriple, SmallVectorImpl<std::string> &Prefixes,
2000     StringRef SysRoot) {
2001   if (TargetTriple.getOS() == llvm::Triple::Solaris) {
2002     // Solaris is a special case.
2003     // The GCC installation is under
2004     //   /usr/gcc/<major>.<minor>/lib/gcc/<triple>/<major>.<minor>.<patch>/
2005     // so we need to find those /usr/gcc/*/lib/gcc libdirs and go with
2006     // /usr/gcc/<version> as a prefix.
2007
2008     std::string PrefixDir = SysRoot.str() + "/usr/gcc";
2009     std::error_code EC;
2010     for (llvm::vfs::directory_iterator LI = D.getVFS().dir_begin(PrefixDir, EC),
2011                                        LE;
2012          !EC && LI != LE; LI = LI.increment(EC)) {
2013       StringRef VersionText = llvm::sys::path::filename(LI->path());
2014       GCCVersion CandidateVersion = GCCVersion::Parse(VersionText);
2015
2016       // Filter out obviously bad entries.
2017       if (CandidateVersion.Major == -1 || CandidateVersion.isOlderThan(4, 1, 1))
2018         continue;
2019
2020       std::string CandidatePrefix = PrefixDir + "/" + VersionText.str();
2021       std::string CandidateLibPath = CandidatePrefix + "/lib/gcc";
2022       if (!D.getVFS().exists(CandidateLibPath))
2023         continue;
2024
2025       Prefixes.push_back(CandidatePrefix);
2026     }
2027     return;
2028   }
2029
2030   // Non-Solaris is much simpler - most systems just go with "/usr".
2031   if (SysRoot.empty() && TargetTriple.getOS() == llvm::Triple::Linux) {
2032     // Yet, still look for RHEL devtoolsets.
2033     Prefixes.push_back("/opt/rh/devtoolset-9/root/usr");
2034     Prefixes.push_back("/opt/rh/devtoolset-8/root/usr");
2035     Prefixes.push_back("/opt/rh/devtoolset-7/root/usr");
2036     Prefixes.push_back("/opt/rh/devtoolset-6/root/usr");
2037     Prefixes.push_back("/opt/rh/devtoolset-4/root/usr");
2038     Prefixes.push_back("/opt/rh/devtoolset-3/root/usr");
2039     Prefixes.push_back("/opt/rh/devtoolset-2/root/usr");
2040   }
2041   Prefixes.push_back(SysRoot.str() + "/usr");
2042 }
2043
2044 /*static*/ void Generic_GCC::GCCInstallationDetector::CollectLibDirsAndTriples(
2045     const llvm::Triple &TargetTriple, const llvm::Triple &BiarchTriple,
2046     SmallVectorImpl<StringRef> &LibDirs,
2047     SmallVectorImpl<StringRef> &TripleAliases,
2048     SmallVectorImpl<StringRef> &BiarchLibDirs,
2049     SmallVectorImpl<StringRef> &BiarchTripleAliases) {
2050   // Declare a bunch of static data sets that we'll select between below. These
2051   // are specifically designed to always refer to string literals to avoid any
2052   // lifetime or initialization issues.
2053   static const char *const AArch64LibDirs[] = {"/lib64", "/lib"};
2054   static const char *const AArch64Triples[] = {
2055       "aarch64-none-linux-gnu", "aarch64-linux-gnu", "aarch64-redhat-linux",
2056       "aarch64-suse-linux", "aarch64-linux-android"};
2057   static const char *const AArch64beLibDirs[] = {"/lib"};
2058   static const char *const AArch64beTriples[] = {"aarch64_be-none-linux-gnu",
2059                                                  "aarch64_be-linux-gnu"};
2060
2061   static const char *const ARMLibDirs[] = {"/lib"};
2062   static const char *const ARMTriples[] = {"arm-linux-gnueabi",
2063                                            "arm-linux-androideabi"};
2064   static const char *const ARMHFTriples[] = {"arm-linux-gnueabihf",
2065                                              "armv7hl-redhat-linux-gnueabi",
2066                                              "armv6hl-suse-linux-gnueabi",
2067                                              "armv7hl-suse-linux-gnueabi"};
2068   static const char *const ARMebLibDirs[] = {"/lib"};
2069   static const char *const ARMebTriples[] = {"armeb-linux-gnueabi",
2070                                              "armeb-linux-androideabi"};
2071   static const char *const ARMebHFTriples[] = {
2072       "armeb-linux-gnueabihf", "armebv7hl-redhat-linux-gnueabi"};
2073
2074   static const char *const AVRLibDirs[] = {"/lib"};
2075   static const char *const AVRTriples[] = {"avr"};
2076
2077   static const char *const X86_64LibDirs[] = {"/lib64", "/lib"};
2078   static const char *const X86_64Triples[] = {
2079       "x86_64-linux-gnu",       "x86_64-unknown-linux-gnu",
2080       "x86_64-pc-linux-gnu",    "x86_64-redhat-linux6E",
2081       "x86_64-redhat-linux",    "x86_64-suse-linux",
2082       "x86_64-manbo-linux-gnu", "x86_64-linux-gnu",
2083       "x86_64-slackware-linux", "x86_64-unknown-linux",
2084       "x86_64-amazon-linux",    "x86_64-linux-android"};
2085   static const char *const X32LibDirs[] = {"/libx32"};
2086   static const char *const X86LibDirs[] = {"/lib32", "/lib"};
2087   static const char *const X86Triples[] = {
2088       "i686-linux-gnu",       "i686-pc-linux-gnu",     "i486-linux-gnu",
2089       "i386-linux-gnu",       "i386-redhat-linux6E",   "i686-redhat-linux",
2090       "i586-redhat-linux",    "i386-redhat-linux",     "i586-suse-linux",
2091       "i486-slackware-linux", "i686-montavista-linux", "i586-linux-gnu",
2092       "i686-linux-android",   "i386-gnu",              "i486-gnu",
2093       "i586-gnu",             "i686-gnu"};
2094
2095   static const char *const MIPSLibDirs[] = {"/lib"};
2096   static const char *const MIPSTriples[] = {
2097       "mips-linux-gnu", "mips-mti-linux", "mips-mti-linux-gnu",
2098       "mips-img-linux-gnu", "mipsisa32r6-linux-gnu"};
2099   static const char *const MIPSELLibDirs[] = {"/lib"};
2100   static const char *const MIPSELTriples[] = {
2101       "mipsel-linux-gnu", "mips-img-linux-gnu", "mipsisa32r6el-linux-gnu",
2102       "mipsel-linux-android"};
2103
2104   static const char *const MIPS64LibDirs[] = {"/lib64", "/lib"};
2105   static const char *const MIPS64Triples[] = {
2106       "mips64-linux-gnu",      "mips-mti-linux-gnu",
2107       "mips-img-linux-gnu",    "mips64-linux-gnuabi64",
2108       "mipsisa64r6-linux-gnu", "mipsisa64r6-linux-gnuabi64"};
2109   static const char *const MIPS64ELLibDirs[] = {"/lib64", "/lib"};
2110   static const char *const MIPS64ELTriples[] = {
2111       "mips64el-linux-gnu",      "mips-mti-linux-gnu",
2112       "mips-img-linux-gnu",      "mips64el-linux-gnuabi64",
2113       "mipsisa64r6el-linux-gnu", "mipsisa64r6el-linux-gnuabi64",
2114       "mips64el-linux-android"};
2115
2116   static const char *const MIPSN32LibDirs[] = {"/lib32"};
2117   static const char *const MIPSN32Triples[] = {"mips64-linux-gnuabin32",
2118                                                "mipsisa64r6-linux-gnuabin32"};
2119   static const char *const MIPSN32ELLibDirs[] = {"/lib32"};
2120   static const char *const MIPSN32ELTriples[] = {
2121       "mips64el-linux-gnuabin32", "mipsisa64r6el-linux-gnuabin32"};
2122
2123   static const char *const MSP430LibDirs[] = {"/lib"};
2124   static const char *const MSP430Triples[] = {"msp430-elf"};
2125
2126   static const char *const PPCLibDirs[] = {"/lib32", "/lib"};
2127   static const char *const PPCTriples[] = {
2128       "powerpc-linux-gnu", "powerpc-unknown-linux-gnu", "powerpc-linux-gnuspe",
2129       // On 32-bit PowerPC systems running SUSE Linux, gcc is configured as a
2130       // 64-bit compiler which defaults to "-m32", hence "powerpc64-suse-linux".
2131       "powerpc64-suse-linux", "powerpc-montavista-linuxspe"};
2132   static const char *const PPC64LibDirs[] = {"/lib64", "/lib"};
2133   static const char *const PPC64Triples[] = {
2134       "powerpc64-linux-gnu", "powerpc64-unknown-linux-gnu",
2135       "powerpc64-suse-linux", "ppc64-redhat-linux"};
2136   static const char *const PPC64LELibDirs[] = {"/lib64", "/lib"};
2137   static const char *const PPC64LETriples[] = {
2138       "powerpc64le-linux-gnu", "powerpc64le-unknown-linux-gnu",
2139       "powerpc64le-suse-linux", "ppc64le-redhat-linux"};
2140
2141   static const char *const RISCV32LibDirs[] = {"/lib32", "/lib"};
2142   static const char *const RISCV32Triples[] = {"riscv32-unknown-linux-gnu",
2143                                                "riscv32-linux-gnu",
2144                                                "riscv32-unknown-elf"};
2145   static const char *const RISCV64LibDirs[] = {"/lib64", "/lib"};
2146   static const char *const RISCV64Triples[] = {"riscv64-unknown-linux-gnu",
2147                                                "riscv64-linux-gnu",
2148                                                "riscv64-unknown-elf",
2149                                                "riscv64-redhat-linux",
2150                                                "riscv64-suse-linux"};
2151
2152   static const char *const SPARCv8LibDirs[] = {"/lib32", "/lib"};
2153   static const char *const SPARCv8Triples[] = {"sparc-linux-gnu",
2154                                                "sparcv8-linux-gnu"};
2155   static const char *const SPARCv9LibDirs[] = {"/lib64", "/lib"};
2156   static const char *const SPARCv9Triples[] = {"sparc64-linux-gnu",
2157                                                "sparcv9-linux-gnu"};
2158
2159   static const char *const SystemZLibDirs[] = {"/lib64", "/lib"};
2160   static const char *const SystemZTriples[] = {
2161       "s390x-linux-gnu", "s390x-unknown-linux-gnu", "s390x-ibm-linux-gnu",
2162       "s390x-suse-linux", "s390x-redhat-linux"};
2163
2164
2165   using std::begin;
2166   using std::end;
2167
2168   if (TargetTriple.getOS() == llvm::Triple::Solaris) {
2169     static const char *const SolarisLibDirs[] = {"/lib"};
2170     static const char *const SolarisSparcV8Triples[] = {
2171         "sparc-sun-solaris2.11", "sparc-sun-solaris2.12"};
2172     static const char *const SolarisSparcV9Triples[] = {
2173         "sparcv9-sun-solaris2.11", "sparcv9-sun-solaris2.12"};
2174     static const char *const SolarisX86Triples[] = {"i386-pc-solaris2.11",
2175                                                     "i386-pc-solaris2.12"};
2176     static const char *const SolarisX86_64Triples[] = {"x86_64-pc-solaris2.11",
2177                                                        "x86_64-pc-solaris2.12"};
2178     LibDirs.append(begin(SolarisLibDirs), end(SolarisLibDirs));
2179     BiarchLibDirs.append(begin(SolarisLibDirs), end(SolarisLibDirs));
2180     switch (TargetTriple.getArch()) {
2181     case llvm::Triple::x86:
2182       TripleAliases.append(begin(SolarisX86Triples), end(SolarisX86Triples));
2183       BiarchTripleAliases.append(begin(SolarisX86_64Triples),
2184                                  end(SolarisX86_64Triples));
2185       break;
2186     case llvm::Triple::x86_64:
2187       TripleAliases.append(begin(SolarisX86_64Triples),
2188                            end(SolarisX86_64Triples));
2189       BiarchTripleAliases.append(begin(SolarisX86Triples),
2190                                  end(SolarisX86Triples));
2191       break;
2192     case llvm::Triple::sparc:
2193       TripleAliases.append(begin(SolarisSparcV8Triples),
2194                            end(SolarisSparcV8Triples));
2195       BiarchTripleAliases.append(begin(SolarisSparcV9Triples),
2196                                  end(SolarisSparcV9Triples));
2197       break;
2198     case llvm::Triple::sparcv9:
2199       TripleAliases.append(begin(SolarisSparcV9Triples),
2200                            end(SolarisSparcV9Triples));
2201       BiarchTripleAliases.append(begin(SolarisSparcV8Triples),
2202                                  end(SolarisSparcV8Triples));
2203       break;
2204     default:
2205       break;
2206     }
2207     return;
2208   }
2209
2210   // Android targets should not use GNU/Linux tools or libraries.
2211   if (TargetTriple.isAndroid()) {
2212     static const char *const AArch64AndroidTriples[] = {
2213         "aarch64-linux-android"};
2214     static const char *const ARMAndroidTriples[] = {"arm-linux-androideabi"};
2215     static const char *const MIPSELAndroidTriples[] = {"mipsel-linux-android"};
2216     static const char *const MIPS64ELAndroidTriples[] = {
2217         "mips64el-linux-android"};
2218     static const char *const X86AndroidTriples[] = {"i686-linux-android"};
2219     static const char *const X86_64AndroidTriples[] = {"x86_64-linux-android"};
2220
2221     switch (TargetTriple.getArch()) {
2222     case llvm::Triple::aarch64:
2223       LibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs));
2224       TripleAliases.append(begin(AArch64AndroidTriples),
2225                            end(AArch64AndroidTriples));
2226       break;
2227     case llvm::Triple::arm:
2228     case llvm::Triple::thumb:
2229       LibDirs.append(begin(ARMLibDirs), end(ARMLibDirs));
2230       TripleAliases.append(begin(ARMAndroidTriples), end(ARMAndroidTriples));
2231       break;
2232     case llvm::Triple::mipsel:
2233       LibDirs.append(begin(MIPSELLibDirs), end(MIPSELLibDirs));
2234       TripleAliases.append(begin(MIPSELAndroidTriples),
2235                            end(MIPSELAndroidTriples));
2236       BiarchLibDirs.append(begin(MIPS64ELLibDirs), end(MIPS64ELLibDirs));
2237       BiarchTripleAliases.append(begin(MIPS64ELAndroidTriples),
2238                                  end(MIPS64ELAndroidTriples));
2239       break;
2240     case llvm::Triple::mips64el:
2241       LibDirs.append(begin(MIPS64ELLibDirs), end(MIPS64ELLibDirs));
2242       TripleAliases.append(begin(MIPS64ELAndroidTriples),
2243                            end(MIPS64ELAndroidTriples));
2244       BiarchLibDirs.append(begin(MIPSELLibDirs), end(MIPSELLibDirs));
2245       BiarchTripleAliases.append(begin(MIPSELAndroidTriples),
2246                                  end(MIPSELAndroidTriples));
2247       break;
2248     case llvm::Triple::x86_64:
2249       LibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
2250       TripleAliases.append(begin(X86_64AndroidTriples),
2251                            end(X86_64AndroidTriples));
2252       BiarchLibDirs.append(begin(X86LibDirs), end(X86LibDirs));
2253       BiarchTripleAliases.append(begin(X86AndroidTriples),
2254                                  end(X86AndroidTriples));
2255       break;
2256     case llvm::Triple::x86:
2257       LibDirs.append(begin(X86LibDirs), end(X86LibDirs));
2258       TripleAliases.append(begin(X86AndroidTriples), end(X86AndroidTriples));
2259       BiarchLibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
2260       BiarchTripleAliases.append(begin(X86_64AndroidTriples),
2261                                  end(X86_64AndroidTriples));
2262       break;
2263     default:
2264       break;
2265     }
2266
2267     return;
2268   }
2269
2270   switch (TargetTriple.getArch()) {
2271   case llvm::Triple::aarch64:
2272     LibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs));
2273     TripleAliases.append(begin(AArch64Triples), end(AArch64Triples));
2274     BiarchLibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs));
2275     BiarchTripleAliases.append(begin(AArch64Triples), end(AArch64Triples));
2276     break;
2277   case llvm::Triple::aarch64_be:
2278     LibDirs.append(begin(AArch64beLibDirs), end(AArch64beLibDirs));
2279     TripleAliases.append(begin(AArch64beTriples), end(AArch64beTriples));
2280     BiarchLibDirs.append(begin(AArch64beLibDirs), end(AArch64beLibDirs));
2281     BiarchTripleAliases.append(begin(AArch64beTriples), end(AArch64beTriples));
2282     break;
2283   case llvm::Triple::arm:
2284   case llvm::Triple::thumb:
2285     LibDirs.append(begin(ARMLibDirs), end(ARMLibDirs));
2286     if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) {
2287       TripleAliases.append(begin(ARMHFTriples), end(ARMHFTriples));
2288     } else {
2289       TripleAliases.append(begin(ARMTriples), end(ARMTriples));
2290     }
2291     break;
2292   case llvm::Triple::armeb:
2293   case llvm::Triple::thumbeb:
2294     LibDirs.append(begin(ARMebLibDirs), end(ARMebLibDirs));
2295     if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) {
2296       TripleAliases.append(begin(ARMebHFTriples), end(ARMebHFTriples));
2297     } else {
2298       TripleAliases.append(begin(ARMebTriples), end(ARMebTriples));
2299     }
2300     break;
2301   case llvm::Triple::avr:
2302     LibDirs.append(begin(AVRLibDirs), end(AVRLibDirs));
2303     TripleAliases.append(begin(AVRTriples), end(AVRTriples));
2304     break;
2305   case llvm::Triple::x86_64:
2306     LibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
2307     TripleAliases.append(begin(X86_64Triples), end(X86_64Triples));
2308     // x32 is always available when x86_64 is available, so adding it as
2309     // secondary arch with x86_64 triples
2310     if (TargetTriple.getEnvironment() == llvm::Triple::GNUX32) {
2311       BiarchLibDirs.append(begin(X32LibDirs), end(X32LibDirs));
2312       BiarchTripleAliases.append(begin(X86_64Triples), end(X86_64Triples));
2313     } else {
2314       BiarchLibDirs.append(begin(X86LibDirs), end(X86LibDirs));
2315       BiarchTripleAliases.append(begin(X86Triples), end(X86Triples));
2316     }
2317     break;
2318   case llvm::Triple::x86:
2319     LibDirs.append(begin(X86LibDirs), end(X86LibDirs));
2320     // MCU toolchain is 32 bit only and its triple alias is TargetTriple
2321     // itself, which will be appended below.
2322     if (!TargetTriple.isOSIAMCU()) {
2323       TripleAliases.append(begin(X86Triples), end(X86Triples));
2324       BiarchLibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
2325       BiarchTripleAliases.append(begin(X86_64Triples), end(X86_64Triples));
2326     }
2327     break;
2328   case llvm::Triple::mips:
2329     LibDirs.append(begin(MIPSLibDirs), end(MIPSLibDirs));
2330     TripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
2331     BiarchLibDirs.append(begin(MIPS64LibDirs), end(MIPS64LibDirs));
2332     BiarchTripleAliases.append(begin(MIPS64Triples), end(MIPS64Triples));
2333     BiarchLibDirs.append(begin(MIPSN32LibDirs), end(MIPSN32LibDirs));
2334     BiarchTripleAliases.append(begin(MIPSN32Triples), end(MIPSN32Triples));
2335     break;
2336   case llvm::Triple::mipsel:
2337     LibDirs.append(begin(MIPSELLibDirs), end(MIPSELLibDirs));
2338     TripleAliases.append(begin(MIPSELTriples), end(MIPSELTriples));
2339     TripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
2340     BiarchLibDirs.append(begin(MIPS64ELLibDirs), end(MIPS64ELLibDirs));
2341     BiarchTripleAliases.append(begin(MIPS64ELTriples), end(MIPS64ELTriples));
2342     BiarchLibDirs.append(begin(MIPSN32ELLibDirs), end(MIPSN32ELLibDirs));
2343     BiarchTripleAliases.append(begin(MIPSN32ELTriples), end(MIPSN32ELTriples));
2344     break;
2345   case llvm::Triple::mips64:
2346     LibDirs.append(begin(MIPS64LibDirs), end(MIPS64LibDirs));
2347     TripleAliases.append(begin(MIPS64Triples), end(MIPS64Triples));
2348     BiarchLibDirs.append(begin(MIPSLibDirs), end(MIPSLibDirs));
2349     BiarchTripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
2350     BiarchLibDirs.append(begin(MIPSN32LibDirs), end(MIPSN32LibDirs));
2351     BiarchTripleAliases.append(begin(MIPSN32Triples), end(MIPSN32Triples));
2352     break;
2353   case llvm::Triple::mips64el:
2354     LibDirs.append(begin(MIPS64ELLibDirs), end(MIPS64ELLibDirs));
2355     TripleAliases.append(begin(MIPS64ELTriples), end(MIPS64ELTriples));
2356     BiarchLibDirs.append(begin(MIPSELLibDirs), end(MIPSELLibDirs));
2357     BiarchTripleAliases.append(begin(MIPSELTriples), end(MIPSELTriples));
2358     BiarchLibDirs.append(begin(MIPSN32ELLibDirs), end(MIPSN32ELLibDirs));
2359     BiarchTripleAliases.append(begin(MIPSN32ELTriples), end(MIPSN32ELTriples));
2360     BiarchTripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
2361     break;
2362   case llvm::Triple::msp430:
2363     LibDirs.append(begin(MSP430LibDirs), end(MSP430LibDirs));
2364     TripleAliases.append(begin(MSP430Triples), end(MSP430Triples));
2365     break;
2366   case llvm::Triple::ppc:
2367     LibDirs.append(begin(PPCLibDirs), end(PPCLibDirs));
2368     TripleAliases.append(begin(PPCTriples), end(PPCTriples));
2369     BiarchLibDirs.append(begin(PPC64LibDirs), end(PPC64LibDirs));
2370     BiarchTripleAliases.append(begin(PPC64Triples), end(PPC64Triples));
2371     break;
2372   case llvm::Triple::ppc64:
2373     LibDirs.append(begin(PPC64LibDirs), end(PPC64LibDirs));
2374     TripleAliases.append(begin(PPC64Triples), end(PPC64Triples));
2375     BiarchLibDirs.append(begin(PPCLibDirs), end(PPCLibDirs));
2376     BiarchTripleAliases.append(begin(PPCTriples), end(PPCTriples));
2377     break;
2378   case llvm::Triple::ppc64le:
2379     LibDirs.append(begin(PPC64LELibDirs), end(PPC64LELibDirs));
2380     TripleAliases.append(begin(PPC64LETriples), end(PPC64LETriples));
2381     break;
2382   case llvm::Triple::riscv32:
2383     LibDirs.append(begin(RISCV32LibDirs), end(RISCV32LibDirs));
2384     TripleAliases.append(begin(RISCV32Triples), end(RISCV32Triples));
2385     BiarchLibDirs.append(begin(RISCV64LibDirs), end(RISCV64LibDirs));
2386     BiarchTripleAliases.append(begin(RISCV64Triples), end(RISCV64Triples));
2387     break;
2388   case llvm::Triple::riscv64:
2389     LibDirs.append(begin(RISCV64LibDirs), end(RISCV64LibDirs));
2390     TripleAliases.append(begin(RISCV64Triples), end(RISCV64Triples));
2391     BiarchLibDirs.append(begin(RISCV32LibDirs), end(RISCV32LibDirs));
2392     BiarchTripleAliases.append(begin(RISCV32Triples), end(RISCV32Triples));
2393     break;
2394   case llvm::Triple::sparc:
2395   case llvm::Triple::sparcel:
2396     LibDirs.append(begin(SPARCv8LibDirs), end(SPARCv8LibDirs));
2397     TripleAliases.append(begin(SPARCv8Triples), end(SPARCv8Triples));
2398     BiarchLibDirs.append(begin(SPARCv9LibDirs), end(SPARCv9LibDirs));
2399     BiarchTripleAliases.append(begin(SPARCv9Triples), end(SPARCv9Triples));
2400     break;
2401   case llvm::Triple::sparcv9:
2402     LibDirs.append(begin(SPARCv9LibDirs), end(SPARCv9LibDirs));
2403     TripleAliases.append(begin(SPARCv9Triples), end(SPARCv9Triples));
2404     BiarchLibDirs.append(begin(SPARCv8LibDirs), end(SPARCv8LibDirs));
2405     BiarchTripleAliases.append(begin(SPARCv8Triples), end(SPARCv8Triples));
2406     break;
2407   case llvm::Triple::systemz:
2408     LibDirs.append(begin(SystemZLibDirs), end(SystemZLibDirs));
2409     TripleAliases.append(begin(SystemZTriples), end(SystemZTriples));
2410     break;
2411   default:
2412     // By default, just rely on the standard lib directories and the original
2413     // triple.
2414     break;
2415   }
2416
2417   // Always append the drivers target triple to the end, in case it doesn't
2418   // match any of our aliases.
2419   TripleAliases.push_back(TargetTriple.str());
2420
2421   // Also include the multiarch variant if it's different.
2422   if (TargetTriple.str() != BiarchTriple.str())
2423     BiarchTripleAliases.push_back(BiarchTriple.str());
2424 }
2425
2426 bool Generic_GCC::GCCInstallationDetector::ScanGCCForMultilibs(
2427     const llvm::Triple &TargetTriple, const ArgList &Args,
2428     StringRef Path, bool NeedsBiarchSuffix) {
2429   llvm::Triple::ArchType TargetArch = TargetTriple.getArch();
2430   DetectedMultilibs Detected;
2431
2432   // Android standalone toolchain could have multilibs for ARM and Thumb.
2433   // Debian mips multilibs behave more like the rest of the biarch ones,
2434   // so handle them there
2435   if (isArmOrThumbArch(TargetArch) && TargetTriple.isAndroid()) {
2436     // It should also work without multilibs in a simplified toolchain.
2437     findAndroidArmMultilibs(D, TargetTriple, Path, Args, Detected);
2438   } else if (TargetTriple.isMIPS()) {
2439     if (!findMIPSMultilibs(D, TargetTriple, Path, Args, Detected))
2440       return false;
2441   } else if (TargetTriple.isRISCV()) {
2442     findRISCVMultilibs(D, TargetTriple, Path, Args, Detected);
2443   } else if (isMSP430(TargetArch)) {
2444     findMSP430Multilibs(D, TargetTriple, Path, Args, Detected);
2445   } else if (TargetArch == llvm::Triple::avr) {
2446     // AVR has no multilibs.
2447   } else if (!findBiarchMultilibs(D, TargetTriple, Path, Args,
2448                                   NeedsBiarchSuffix, Detected)) {
2449     return false;
2450   }
2451
2452   Multilibs = Detected.Multilibs;
2453   SelectedMultilib = Detected.SelectedMultilib;
2454   BiarchSibling = Detected.BiarchSibling;
2455
2456   return true;
2457 }
2458
2459 void Generic_GCC::GCCInstallationDetector::ScanLibDirForGCCTriple(
2460     const llvm::Triple &TargetTriple, const ArgList &Args,
2461     const std::string &LibDir, StringRef CandidateTriple,
2462     bool NeedsBiarchSuffix, bool GCCDirExists, bool GCCCrossDirExists) {
2463   llvm::Triple::ArchType TargetArch = TargetTriple.getArch();
2464   // Locations relative to the system lib directory where GCC's triple-specific
2465   // directories might reside.
2466   struct GCCLibSuffix {
2467     // Path from system lib directory to GCC triple-specific directory.
2468     std::string LibSuffix;
2469     // Path from GCC triple-specific directory back to system lib directory.
2470     // This is one '..' component per component in LibSuffix.
2471     StringRef ReversePath;
2472     // Whether this library suffix is relevant for the triple.
2473     bool Active;
2474   } Suffixes[] = {
2475       // This is the normal place.
2476       {"gcc/" + CandidateTriple.str(), "../..", GCCDirExists},
2477
2478       // Debian puts cross-compilers in gcc-cross.
2479       {"gcc-cross/" + CandidateTriple.str(), "../..", GCCCrossDirExists},
2480
2481       // The Freescale PPC SDK has the gcc libraries in
2482       // <sysroot>/usr/lib/<triple>/x.y.z so have a look there as well. Only do
2483       // this on Freescale triples, though, since some systems put a *lot* of
2484       // files in that location, not just GCC installation data.
2485       {CandidateTriple.str(), "..",
2486        TargetTriple.getVendor() == llvm::Triple::Freescale ||
2487        TargetTriple.getVendor() == llvm::Triple::OpenEmbedded},
2488
2489       // Natively multiarch systems sometimes put the GCC triple-specific
2490       // directory within their multiarch lib directory, resulting in the
2491       // triple appearing twice.
2492       {CandidateTriple.str() + "/gcc/" + CandidateTriple.str(), "../../..",
2493        TargetTriple.getOS() != llvm::Triple::Solaris},
2494
2495       // Deal with cases (on Ubuntu) where the system architecture could be i386
2496       // but the GCC target architecture could be (say) i686.
2497       // FIXME: It may be worthwhile to generalize this and look for a second
2498       // triple.
2499       {"i386-linux-gnu/gcc/" + CandidateTriple.str(), "../../..",
2500        (TargetArch == llvm::Triple::x86 &&
2501         TargetTriple.getOS() != llvm::Triple::Solaris)},
2502       {"i386-gnu/gcc/" + CandidateTriple.str(), "../../..",
2503        (TargetArch == llvm::Triple::x86 &&
2504         TargetTriple.getOS() != llvm::Triple::Solaris)}};
2505
2506   for (auto &Suffix : Suffixes) {
2507     if (!Suffix.Active)
2508       continue;
2509
2510     StringRef LibSuffix = Suffix.LibSuffix;
2511     std::error_code EC;
2512     for (llvm::vfs::directory_iterator
2513              LI = D.getVFS().dir_begin(LibDir + "/" + LibSuffix, EC),
2514              LE;
2515          !EC && LI != LE; LI = LI.increment(EC)) {
2516       StringRef VersionText = llvm::sys::path::filename(LI->path());
2517       GCCVersion CandidateVersion = GCCVersion::Parse(VersionText);
2518       if (CandidateVersion.Major != -1) // Filter obviously bad entries.
2519         if (!CandidateGCCInstallPaths.insert(std::string(LI->path())).second)
2520           continue; // Saw this path before; no need to look at it again.
2521       if (CandidateVersion.isOlderThan(4, 1, 1))
2522         continue;
2523       if (CandidateVersion <= Version)
2524         continue;
2525
2526       if (!ScanGCCForMultilibs(TargetTriple, Args, LI->path(),
2527                                NeedsBiarchSuffix))
2528         continue;
2529
2530       Version = CandidateVersion;
2531       GCCTriple.setTriple(CandidateTriple);
2532       // FIXME: We hack together the directory name here instead of
2533       // using LI to ensure stable path separators across Windows and
2534       // Linux.
2535       GCCInstallPath = (LibDir + "/" + LibSuffix + "/" + VersionText).str();
2536       GCCParentLibPath = (GCCInstallPath + "/../" + Suffix.ReversePath).str();
2537       IsValid = true;
2538     }
2539   }
2540 }
2541
2542 bool Generic_GCC::GCCInstallationDetector::ScanGentooConfigs(
2543     const llvm::Triple &TargetTriple, const ArgList &Args,
2544     const SmallVectorImpl<StringRef> &CandidateTriples,
2545     const SmallVectorImpl<StringRef> &CandidateBiarchTriples) {
2546   if (!D.getVFS().exists(D.SysRoot + GentooConfigDir))
2547     return false;
2548
2549   for (StringRef CandidateTriple : CandidateTriples) {
2550     if (ScanGentooGccConfig(TargetTriple, Args, CandidateTriple))
2551       return true;
2552   }
2553
2554   for (StringRef CandidateTriple : CandidateBiarchTriples) {
2555     if (ScanGentooGccConfig(TargetTriple, Args, CandidateTriple, true))
2556       return true;
2557   }
2558   return false;
2559 }
2560
2561 bool Generic_GCC::GCCInstallationDetector::ScanGentooGccConfig(
2562     const llvm::Triple &TargetTriple, const ArgList &Args,
2563     StringRef CandidateTriple, bool NeedsBiarchSuffix) {
2564   llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> File =
2565       D.getVFS().getBufferForFile(D.SysRoot + GentooConfigDir + "/config-" +
2566                                   CandidateTriple.str());
2567   if (File) {
2568     SmallVector<StringRef, 2> Lines;
2569     File.get()->getBuffer().split(Lines, "\n");
2570     for (StringRef Line : Lines) {
2571       Line = Line.trim();
2572       // CURRENT=triple-version
2573       if (!Line.consume_front("CURRENT="))
2574         continue;
2575       // Process the config file pointed to by CURRENT.
2576       llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> ConfigFile =
2577           D.getVFS().getBufferForFile(D.SysRoot + GentooConfigDir + "/" +
2578                                       Line.str());
2579       std::pair<StringRef, StringRef> ActiveVersion = Line.rsplit('-');
2580       // List of paths to scan for libraries.
2581       SmallVector<StringRef, 4> GentooScanPaths;
2582       // Scan the Config file to find installed GCC libraries path.
2583       // Typical content of the GCC config file:
2584       // LDPATH="/usr/lib/gcc/x86_64-pc-linux-gnu/4.9.x:/usr/lib/gcc/
2585       // (continued from previous line) x86_64-pc-linux-gnu/4.9.x/32"
2586       // MANPATH="/usr/share/gcc-data/x86_64-pc-linux-gnu/4.9.x/man"
2587       // INFOPATH="/usr/share/gcc-data/x86_64-pc-linux-gnu/4.9.x/info"
2588       // STDCXX_INCDIR="/usr/lib/gcc/x86_64-pc-linux-gnu/4.9.x/include/g++-v4"
2589       // We are looking for the paths listed in LDPATH=... .
2590       if (ConfigFile) {
2591         SmallVector<StringRef, 2> ConfigLines;
2592         ConfigFile.get()->getBuffer().split(ConfigLines, "\n");
2593         for (StringRef ConfLine : ConfigLines) {
2594           ConfLine = ConfLine.trim();
2595           if (ConfLine.consume_front("LDPATH=")) {
2596             // Drop '"' from front and back if present.
2597             ConfLine.consume_back("\"");
2598             ConfLine.consume_front("\"");
2599             // Get all paths sperated by ':'
2600             ConfLine.split(GentooScanPaths, ':', -1, /*AllowEmpty*/ false);
2601           }
2602         }
2603       }
2604       // Test the path based on the version in /etc/env.d/gcc/config-{tuple}.
2605       std::string basePath = "/usr/lib/gcc/" + ActiveVersion.first.str() + "/"
2606           + ActiveVersion.second.str();
2607       GentooScanPaths.push_back(StringRef(basePath));
2608
2609       // Scan all paths for GCC libraries.
2610       for (const auto &GentooScanPath : GentooScanPaths) {
2611         std::string GentooPath = D.SysRoot + std::string(GentooScanPath);
2612         if (D.getVFS().exists(GentooPath + "/crtbegin.o")) {
2613           if (!ScanGCCForMultilibs(TargetTriple, Args, GentooPath,
2614                                    NeedsBiarchSuffix))
2615             continue;
2616
2617           Version = GCCVersion::Parse(ActiveVersion.second);
2618           GCCInstallPath = GentooPath;
2619           GCCParentLibPath = GentooPath + std::string("/../../..");
2620           GCCTriple.setTriple(ActiveVersion.first);
2621           IsValid = true;
2622           return true;
2623         }
2624       }
2625     }
2626   }
2627
2628   return false;
2629 }
2630
2631 Generic_GCC::Generic_GCC(const Driver &D, const llvm::Triple &Triple,
2632                          const ArgList &Args)
2633     : ToolChain(D, Triple, Args), GCCInstallation(D),
2634       CudaInstallation(D, Triple, Args), RocmInstallation(D, Triple, Args) {
2635   getProgramPaths().push_back(getDriver().getInstalledDir());
2636   if (getDriver().getInstalledDir() != getDriver().Dir)
2637     getProgramPaths().push_back(getDriver().Dir);
2638 }
2639
2640 Generic_GCC::~Generic_GCC() {}
2641
2642 Tool *Generic_GCC::getTool(Action::ActionClass AC) const {
2643   switch (AC) {
2644   case Action::PreprocessJobClass:
2645     if (!Preprocess)
2646       Preprocess.reset(new clang::driver::tools::gcc::Preprocessor(*this));
2647     return Preprocess.get();
2648   case Action::CompileJobClass:
2649     if (!Compile)
2650       Compile.reset(new tools::gcc::Compiler(*this));
2651     return Compile.get();
2652   default:
2653     return ToolChain::getTool(AC);
2654   }
2655 }
2656
2657 Tool *Generic_GCC::buildAssembler() const {
2658   return new tools::gnutools::Assembler(*this);
2659 }
2660
2661 Tool *Generic_GCC::buildLinker() const { return new tools::gcc::Linker(*this); }
2662
2663 void Generic_GCC::printVerboseInfo(raw_ostream &OS) const {
2664   // Print the information about how we detected the GCC installation.
2665   GCCInstallation.print(OS);
2666   CudaInstallation.print(OS);
2667   RocmInstallation.print(OS);
2668 }
2669
2670 bool Generic_GCC::IsUnwindTablesDefault(const ArgList &Args) const {
2671   return getArch() == llvm::Triple::x86_64;
2672 }
2673
2674 bool Generic_GCC::isPICDefault() const {
2675   switch (getArch()) {
2676   case llvm::Triple::x86_64:
2677     return getTriple().isOSWindows();
2678   case llvm::Triple::mips64:
2679   case llvm::Triple::mips64el:
2680     return true;
2681   default:
2682     return false;
2683   }
2684 }
2685
2686 bool Generic_GCC::isPIEDefault() const { return false; }
2687
2688 bool Generic_GCC::isPICDefaultForced() const {
2689   return getArch() == llvm::Triple::x86_64 && getTriple().isOSWindows();
2690 }
2691
2692 bool Generic_GCC::IsIntegratedAssemblerDefault() const {
2693   switch (getTriple().getArch()) {
2694   case llvm::Triple::x86:
2695   case llvm::Triple::x86_64:
2696   case llvm::Triple::aarch64:
2697   case llvm::Triple::aarch64_be:
2698   case llvm::Triple::arm:
2699   case llvm::Triple::armeb:
2700   case llvm::Triple::avr:
2701   case llvm::Triple::bpfel:
2702   case llvm::Triple::bpfeb:
2703   case llvm::Triple::thumb:
2704   case llvm::Triple::thumbeb:
2705   case llvm::Triple::ppc:
2706   case llvm::Triple::ppc64:
2707   case llvm::Triple::ppc64le:
2708   case llvm::Triple::riscv32:
2709   case llvm::Triple::riscv64:
2710   case llvm::Triple::systemz:
2711   case llvm::Triple::mips:
2712   case llvm::Triple::mipsel:
2713   case llvm::Triple::mips64:
2714   case llvm::Triple::mips64el:
2715   case llvm::Triple::msp430:
2716     return true;
2717   case llvm::Triple::sparc:
2718   case llvm::Triple::sparcel:
2719   case llvm::Triple::sparcv9:
2720     if (getTriple().isOSFreeBSD() || getTriple().isOSOpenBSD() ||
2721         getTriple().isOSSolaris())
2722       return true;
2723     return false;
2724   default:
2725     return false;
2726   }
2727 }
2728
2729 static void addMultilibsFilePaths(const Driver &D, const MultilibSet &Multilibs,
2730                                   const Multilib &Multilib,
2731                                   StringRef InstallPath,
2732                                   ToolChain::path_list &Paths) {
2733   if (const auto &PathsCallback = Multilibs.filePathsCallback())
2734     for (const auto &Path : PathsCallback(Multilib))
2735       addPathIfExists(D, InstallPath + Path, Paths);
2736 }
2737
2738 void Generic_GCC::PushPPaths(ToolChain::path_list &PPaths) {
2739   // Cross-compiling binutils and GCC installations (vanilla and openSUSE at
2740   // least) put various tools in a triple-prefixed directory off of the parent
2741   // of the GCC installation. We use the GCC triple here to ensure that we end
2742   // up with tools that support the same amount of cross compiling as the
2743   // detected GCC installation. For example, if we find a GCC installation
2744   // targeting x86_64, but it is a bi-arch GCC installation, it can also be
2745   // used to target i386.
2746   if (GCCInstallation.isValid()) {
2747     PPaths.push_back(Twine(GCCInstallation.getParentLibPath() + "/../" +
2748                            GCCInstallation.getTriple().str() + "/bin")
2749                          .str());
2750   }
2751 }
2752
2753 void Generic_GCC::AddMultilibPaths(const Driver &D,
2754                                    const std::string &SysRoot,
2755                                    const std::string &OSLibDir,
2756                                    const std::string &MultiarchTriple,
2757                                    path_list &Paths) {
2758   // Add the multilib suffixed paths where they are available.
2759   if (GCCInstallation.isValid()) {
2760     const llvm::Triple &GCCTriple = GCCInstallation.getTriple();
2761     const std::string &LibPath =
2762         std::string(GCCInstallation.getParentLibPath());
2763
2764     // Add toolchain / multilib specific file paths.
2765     addMultilibsFilePaths(D, Multilibs, SelectedMultilib,
2766                           GCCInstallation.getInstallPath(), Paths);
2767
2768     // Sourcery CodeBench MIPS toolchain holds some libraries under
2769     // a biarch-like suffix of the GCC installation.
2770     addPathIfExists(
2771         D, GCCInstallation.getInstallPath() + SelectedMultilib.gccSuffix(),
2772         Paths);
2773
2774     // GCC cross compiling toolchains will install target libraries which ship
2775     // as part of the toolchain under <prefix>/<triple>/<libdir> rather than as
2776     // any part of the GCC installation in
2777     // <prefix>/<libdir>/gcc/<triple>/<version>. This decision is somewhat
2778     // debatable, but is the reality today. We need to search this tree even
2779     // when we have a sysroot somewhere else. It is the responsibility of
2780     // whomever is doing the cross build targeting a sysroot using a GCC
2781     // installation that is *not* within the system root to ensure two things:
2782     //
2783     //  1) Any DSOs that are linked in from this tree or from the install path
2784     //     above must be present on the system root and found via an
2785     //     appropriate rpath.
2786     //  2) There must not be libraries installed into
2787     //     <prefix>/<triple>/<libdir> unless they should be preferred over
2788     //     those within the system root.
2789     //
2790     // Note that this matches the GCC behavior. See the below comment for where
2791     // Clang diverges from GCC's behavior.
2792     addPathIfExists(D,
2793                     LibPath + "/../" + GCCTriple.str() + "/lib/../" + OSLibDir +
2794                         SelectedMultilib.osSuffix(),
2795                     Paths);
2796
2797     // If the GCC installation we found is inside of the sysroot, we want to
2798     // prefer libraries installed in the parent prefix of the GCC installation.
2799     // It is important to *not* use these paths when the GCC installation is
2800     // outside of the system root as that can pick up unintended libraries.
2801     // This usually happens when there is an external cross compiler on the
2802     // host system, and a more minimal sysroot available that is the target of
2803     // the cross. Note that GCC does include some of these directories in some
2804     // configurations but this seems somewhere between questionable and simply
2805     // a bug.
2806     if (StringRef(LibPath).startswith(SysRoot)) {
2807       addPathIfExists(D, LibPath + "/" + MultiarchTriple, Paths);
2808       addPathIfExists(D, LibPath + "/../" + OSLibDir, Paths);
2809     }
2810   }
2811 }
2812
2813 void Generic_GCC::AddMultiarchPaths(const Driver &D,
2814                                     const std::string &SysRoot,
2815                                     const std::string &OSLibDir,
2816                                     path_list &Paths) {
2817   // Try walking via the GCC triple path in case of biarch or multiarch GCC
2818   // installations with strange symlinks.
2819   if (GCCInstallation.isValid()) {
2820     addPathIfExists(D,
2821                     SysRoot + "/usr/lib/" + GCCInstallation.getTriple().str() +
2822                         "/../../" + OSLibDir,
2823                     Paths);
2824
2825     // Add the 'other' biarch variant path
2826     Multilib BiarchSibling;
2827     if (GCCInstallation.getBiarchSibling(BiarchSibling)) {
2828       addPathIfExists(
2829           D, GCCInstallation.getInstallPath() + BiarchSibling.gccSuffix(),
2830                       Paths);
2831     }
2832
2833     // See comments above on the multilib variant for details of why this is
2834     // included even from outside the sysroot.
2835     const std::string &LibPath =
2836         std::string(GCCInstallation.getParentLibPath());
2837     const llvm::Triple &GCCTriple = GCCInstallation.getTriple();
2838     const Multilib &Multilib = GCCInstallation.getMultilib();
2839     addPathIfExists(
2840         D, LibPath + "/../" + GCCTriple.str() + "/lib" + Multilib.osSuffix(),
2841                     Paths);
2842
2843     // See comments above on the multilib variant for details of why this is
2844     // only included from within the sysroot.
2845     if (StringRef(LibPath).startswith(SysRoot))
2846       addPathIfExists(D, LibPath, Paths);
2847   }
2848 }
2849
2850 void Generic_GCC::AddMultilibIncludeArgs(const ArgList &DriverArgs,
2851                                          ArgStringList &CC1Args) const {
2852   // Add include directories specific to the selected multilib set and multilib.
2853   if (GCCInstallation.isValid()) {
2854     const auto &Callback = Multilibs.includeDirsCallback();
2855     if (Callback) {
2856       for (const auto &Path : Callback(GCCInstallation.getMultilib()))
2857         addExternCSystemIncludeIfExists(
2858             DriverArgs, CC1Args, GCCInstallation.getInstallPath() + Path);
2859     }
2860   }
2861 }
2862
2863 void Generic_GCC::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
2864                                                ArgStringList &CC1Args) const {
2865   if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
2866       DriverArgs.hasArg(options::OPT_nostdincxx))
2867     return;
2868
2869   switch (GetCXXStdlibType(DriverArgs)) {
2870   case ToolChain::CST_Libcxx:
2871     addLibCxxIncludePaths(DriverArgs, CC1Args);
2872     break;
2873
2874   case ToolChain::CST_Libstdcxx:
2875     addLibStdCxxIncludePaths(DriverArgs, CC1Args);
2876     break;
2877   }
2878 }
2879
2880 void
2881 Generic_GCC::addLibCxxIncludePaths(const llvm::opt::ArgList &DriverArgs,
2882                                    llvm::opt::ArgStringList &CC1Args) const {
2883   auto AddIncludePath = [&](std::string Path) {
2884     std::string IncludePath = detectLibcxxIncludePath(Path);
2885     if (IncludePath.empty() || !getVFS().exists(IncludePath))
2886       return false;
2887     addSystemInclude(DriverArgs, CC1Args, IncludePath);
2888     return true;
2889   };
2890   // Android never uses the libc++ headers installed alongside the toolchain,
2891   // which are generally incompatible with the NDK libraries anyway.
2892   if (!getTriple().isAndroid())
2893     if (AddIncludePath(getDriver().Dir + "/../include/c++"))
2894       return;
2895   // If this is a development, non-installed, clang, libcxx will
2896   // not be found at ../include/c++ but it likely to be found at
2897   // one of the following two locations:
2898   std::string SysRoot = computeSysRoot();
2899   if (AddIncludePath(SysRoot + "/usr/local/include/c++"))
2900     return;
2901   if (AddIncludePath(SysRoot + "/usr/include/c++"))
2902     return;
2903 }
2904
2905 /// Helper to add the variant paths of a libstdc++ installation.
2906 bool Generic_GCC::addLibStdCXXIncludePaths(
2907     Twine Base, Twine Suffix, StringRef GCCTriple, StringRef GCCMultiarchTriple,
2908     StringRef TargetMultiarchTriple, Twine IncludeSuffix,
2909     const ArgList &DriverArgs, ArgStringList &CC1Args) const {
2910   if (!getVFS().exists(Base + Suffix))
2911     return false;
2912
2913   addSystemInclude(DriverArgs, CC1Args, Base + Suffix);
2914
2915   // The vanilla GCC layout of libstdc++ headers uses a triple subdirectory. If
2916   // that path exists or we have neither a GCC nor target multiarch triple, use
2917   // this vanilla search path.
2918   if ((GCCMultiarchTriple.empty() && TargetMultiarchTriple.empty()) ||
2919       getVFS().exists(Base + Suffix + "/" + GCCTriple + IncludeSuffix)) {
2920     addSystemInclude(DriverArgs, CC1Args,
2921                      Base + Suffix + "/" + GCCTriple + IncludeSuffix);
2922   } else {
2923     // Otherwise try to use multiarch naming schemes which have normalized the
2924     // triples and put the triple before the suffix.
2925     //
2926     // GCC surprisingly uses *both* the GCC triple with a multilib suffix and
2927     // the target triple, so we support that here.
2928     addSystemInclude(DriverArgs, CC1Args,
2929                      Base + "/" + GCCMultiarchTriple + Suffix + IncludeSuffix);
2930     addSystemInclude(DriverArgs, CC1Args,
2931                      Base + "/" + TargetMultiarchTriple + Suffix);
2932   }
2933
2934   addSystemInclude(DriverArgs, CC1Args, Base + Suffix + "/backward");
2935   return true;
2936 }
2937
2938 bool
2939 Generic_GCC::addGCCLibStdCxxIncludePaths(const llvm::opt::ArgList &DriverArgs,
2940                                          llvm::opt::ArgStringList &CC1Args) const {
2941   // Use GCCInstallation to know where libstdc++ headers are installed.
2942   if (!GCCInstallation.isValid())
2943     return false;
2944
2945   // By default, look for the C++ headers in an include directory adjacent to
2946   // the lib directory of the GCC installation. Note that this is expect to be
2947   // equivalent to '/usr/include/c++/X.Y' in almost all cases.
2948   StringRef LibDir = GCCInstallation.getParentLibPath();
2949   StringRef InstallDir = GCCInstallation.getInstallPath();
2950   StringRef TripleStr = GCCInstallation.getTriple().str();
2951   const Multilib &Multilib = GCCInstallation.getMultilib();
2952   const std::string GCCMultiarchTriple = getMultiarchTriple(
2953       getDriver(), GCCInstallation.getTriple(), getDriver().SysRoot);
2954   const std::string TargetMultiarchTriple =
2955       getMultiarchTriple(getDriver(), getTriple(), getDriver().SysRoot);
2956   const GCCVersion &Version = GCCInstallation.getVersion();
2957
2958   // The primary search for libstdc++ supports multiarch variants.
2959   if (addLibStdCXXIncludePaths(LibDir.str() + "/../include",
2960                                "/c++/" + Version.Text, TripleStr,
2961                                GCCMultiarchTriple, TargetMultiarchTriple,
2962                                Multilib.includeSuffix(), DriverArgs, CC1Args))
2963     return true;
2964
2965   // Otherwise, fall back on a bunch of options which don't use multiarch
2966   // layouts for simplicity.
2967   const std::string LibStdCXXIncludePathCandidates[] = {
2968       // Gentoo is weird and places its headers inside the GCC install,
2969       // so if the first attempt to find the headers fails, try these patterns.
2970       InstallDir.str() + "/include/g++-v" + Version.Text,
2971       InstallDir.str() + "/include/g++-v" + Version.MajorStr + "." +
2972           Version.MinorStr,
2973       InstallDir.str() + "/include/g++-v" + Version.MajorStr,
2974   };
2975
2976   for (const auto &IncludePath : LibStdCXXIncludePathCandidates) {
2977     if (addLibStdCXXIncludePaths(IncludePath, /*Suffix*/ "", TripleStr,
2978                                  /*GCCMultiarchTriple*/ "",
2979                                  /*TargetMultiarchTriple*/ "",
2980                                  Multilib.includeSuffix(), DriverArgs, CC1Args))
2981       return true;
2982   }
2983   return false;
2984 }
2985
2986 void
2987 Generic_GCC::addLibStdCxxIncludePaths(const llvm::opt::ArgList &DriverArgs,
2988                                       llvm::opt::ArgStringList &CC1Args) const {
2989   addGCCLibStdCxxIncludePaths(DriverArgs, CC1Args);
2990 }
2991
2992 llvm::opt::DerivedArgList *
2993 Generic_GCC::TranslateArgs(const llvm::opt::DerivedArgList &Args, StringRef,
2994                            Action::OffloadKind DeviceOffloadKind) const {
2995
2996   // If this tool chain is used for an OpenMP offloading device we have to make
2997   // sure we always generate a shared library regardless of the commands the
2998   // user passed to the host. This is required because the runtime library
2999   // is required to load the device image dynamically at run time.
3000   if (DeviceOffloadKind == Action::OFK_OpenMP) {
3001     DerivedArgList *DAL = new DerivedArgList(Args.getBaseArgs());
3002     const OptTable &Opts = getDriver().getOpts();
3003
3004     // Request the shared library. Given that these options are decided
3005     // implicitly, they do not refer to any base argument.
3006     DAL->AddFlagArg(/*BaseArg=*/nullptr, Opts.getOption(options::OPT_shared));
3007     DAL->AddFlagArg(/*BaseArg=*/nullptr, Opts.getOption(options::OPT_fPIC));
3008
3009     // Filter all the arguments we don't care passing to the offloading
3010     // toolchain as they can mess up with the creation of a shared library.
3011     for (auto *A : Args) {
3012       switch ((options::ID)A->getOption().getID()) {
3013       default:
3014         DAL->append(A);
3015         break;
3016       case options::OPT_shared:
3017       case options::OPT_dynamic:
3018       case options::OPT_static:
3019       case options::OPT_fPIC:
3020       case options::OPT_fno_PIC:
3021       case options::OPT_fpic:
3022       case options::OPT_fno_pic:
3023       case options::OPT_fPIE:
3024       case options::OPT_fno_PIE:
3025       case options::OPT_fpie:
3026       case options::OPT_fno_pie:
3027         break;
3028       }
3029     }
3030     return DAL;
3031   }
3032   return nullptr;
3033 }
3034
3035 void Generic_ELF::anchor() {}
3036
3037 void Generic_ELF::addClangTargetOptions(const ArgList &DriverArgs,
3038                                         ArgStringList &CC1Args,
3039                                         Action::OffloadKind) const {
3040   if (!DriverArgs.hasFlag(options::OPT_fuse_init_array,
3041                           options::OPT_fno_use_init_array, true))
3042     CC1Args.push_back("-fno-use-init-array");
3043 }