1 //===--- Gnu.cpp - Gnu Tool and ToolChain Implementations -------*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "Gnu.h"
11 #include "Arch/ARM.h"
12 #include "Arch/Mips.h"
13 #include "Arch/PPC.h"
14 #include "Arch/RISCV.h"
15 #include "Arch/Sparc.h"
16 #include "Arch/SystemZ.h"
17 #include "CommonArgs.h"
18 #include "Linux.h"
19 #include "clang/Basic/VirtualFileSystem.h"
20 #include "clang/Config/config.h" // for GCC_INSTALL_PREFIX
21 #include "clang/Driver/Compilation.h"
22 #include "clang/Driver/Driver.h"
23 #include "clang/Driver/DriverDiagnostic.h"
24 #include "clang/Driver/Options.h"
25 #include "clang/Driver/Tool.h"
26 #include "llvm/Option/ArgList.h"
27 #include "llvm/Support/CodeGen.h"
28 #include "llvm/Support/Path.h"
29 #include "llvm/Support/TargetParser.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 void tools::GnuTool::anchor() {}
38 
39 static bool forwardToGCC(const Option &O) {
40   // Don't forward inputs from the original command line.  They are added from
41   // InputInfoList.
42   return O.getKind() != Option::InputClass &&
43          !O.hasFlag(options::DriverOption) && !O.hasFlag(options::LinkerInput);
44 }
45 
46 // Switch CPU names not recognized by GNU assembler to a close CPU that it does
47 // recognize, instead of a lower march from being picked in the absence of a cpu
48 // flag.
49 static void normalizeCPUNamesForAssembler(const ArgList &Args,
50                                           ArgStringList &CmdArgs) {
51   if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
52     StringRef CPUArg(A->getValue());
53     if (CPUArg.equals_lower("krait"))
54       CmdArgs.push_back("-mcpu=cortex-a15");
55     else if(CPUArg.equals_lower("kryo"))
56       CmdArgs.push_back("-mcpu=cortex-a57");
57     else
58       Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ);
59   }
60 }
61 
62 void tools::gcc::Common::ConstructJob(Compilation &C, const JobAction &JA,
63                                       const InputInfo &Output,
64                                       const InputInfoList &Inputs,
65                                       const ArgList &Args,
66                                       const char *LinkingOutput) const {
67   const Driver &D = getToolChain().getDriver();
68   ArgStringList CmdArgs;
69 
70   for (const auto &A : Args) {
71     if (forwardToGCC(A->getOption())) {
72       // It is unfortunate that we have to claim here, as this means
73       // we will basically never report anything interesting for
74       // platforms using a generic gcc, even if we are just using gcc
75       // to get to the assembler.
76       A->claim();
77 
78       // Don't forward any -g arguments to assembly steps.
79       if (isa<AssembleJobAction>(JA) &&
80           A->getOption().matches(options::OPT_g_Group))
81         continue;
82 
83       // Don't forward any -W arguments to assembly and link steps.
84       if ((isa<AssembleJobAction>(JA) || isa<LinkJobAction>(JA)) &&
85           A->getOption().matches(options::OPT_W_Group))
86         continue;
87 
88       A->render(Args, CmdArgs);
89     }
90   }
91 
92   RenderExtraToolArgs(JA, CmdArgs);
93 
94   // If using a driver driver, force the arch.
95   if (getToolChain().getTriple().isOSDarwin()) {
96     CmdArgs.push_back("-arch");
97     CmdArgs.push_back(
98         Args.MakeArgString(getToolChain().getDefaultUniversalArchName()));
99   }
100 
101   // Try to force gcc to match the tool chain we want, if we recognize
102   // the arch.
103   //
104   // FIXME: The triple class should directly provide the information we want
105   // here.
106   switch (getToolChain().getArch()) {
107   default:
108     break;
109   case llvm::Triple::x86:
110   case llvm::Triple::ppc:
111     CmdArgs.push_back("-m32");
112     break;
113   case llvm::Triple::x86_64:
114   case llvm::Triple::ppc64:
115   case llvm::Triple::ppc64le:
116     CmdArgs.push_back("-m64");
117     break;
118   case llvm::Triple::sparcel:
119     CmdArgs.push_back("-EL");
120     break;
121   }
122 
123   if (Output.isFilename()) {
124     CmdArgs.push_back("-o");
125     CmdArgs.push_back(Output.getFilename());
126   } else {
127     assert(Output.isNothing() && "Unexpected output");
128     CmdArgs.push_back("-fsyntax-only");
129   }
130 
131   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
132 
133   // Only pass -x if gcc will understand it; otherwise hope gcc
134   // understands the suffix correctly. The main use case this would go
135   // wrong in is for linker inputs if they happened to have an odd
136   // suffix; really the only way to get this to happen is a command
137   // like '-x foobar a.c' which will treat a.c like a linker input.
138   //
139   // FIXME: For the linker case specifically, can we safely convert
140   // inputs into '-Wl,' options?
141   for (const auto &II : Inputs) {
142     // Don't try to pass LLVM or AST inputs to a generic gcc.
143     if (types::isLLVMIR(II.getType()))
144       D.Diag(clang::diag::err_drv_no_linker_llvm_support)
145           << getToolChain().getTripleString();
146     else if (II.getType() == types::TY_AST)
147       D.Diag(diag::err_drv_no_ast_support) << getToolChain().getTripleString();
148     else if (II.getType() == types::TY_ModuleFile)
149       D.Diag(diag::err_drv_no_module_support)
150           << getToolChain().getTripleString();
151 
152     if (types::canTypeBeUserSpecified(II.getType())) {
153       CmdArgs.push_back("-x");
154       CmdArgs.push_back(types::getTypeName(II.getType()));
155     }
156 
157     if (II.isFilename())
158       CmdArgs.push_back(II.getFilename());
159     else {
160       const Arg &A = II.getInputArg();
161 
162       // Reverse translate some rewritten options.
163       if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) {
164         CmdArgs.push_back("-lstdc++");
165         continue;
166       }
167 
168       // Don't render as input, we need gcc to do the translations.
169       A.render(Args, CmdArgs);
170     }
171   }
172 
173   const std::string &customGCCName = D.getCCCGenericGCCName();
174   const char *GCCName;
175   if (!customGCCName.empty())
176     GCCName = customGCCName.c_str();
177   else if (D.CCCIsCXX()) {
178     GCCName = "g++";
179   } else
180     GCCName = "gcc";
181 
182   const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
183   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
184 }
185 
186 void tools::gcc::Preprocessor::RenderExtraToolArgs(
187     const JobAction &JA, ArgStringList &CmdArgs) const {
188   CmdArgs.push_back("-E");
189 }
190 
191 void tools::gcc::Compiler::RenderExtraToolArgs(const JobAction &JA,
192                                                ArgStringList &CmdArgs) const {
193   const Driver &D = getToolChain().getDriver();
194 
195   switch (JA.getType()) {
196   // If -flto, etc. are present then make sure not to force assembly output.
197   case types::TY_LLVM_IR:
198   case types::TY_LTO_IR:
199   case types::TY_LLVM_BC:
200   case types::TY_LTO_BC:
201     CmdArgs.push_back("-c");
202     break;
203   // We assume we've got an "integrated" assembler in that gcc will produce an
204   // object file itself.
205   case types::TY_Object:
206     CmdArgs.push_back("-c");
207     break;
208   case types::TY_PP_Asm:
209     CmdArgs.push_back("-S");
210     break;
211   case types::TY_Nothing:
212     CmdArgs.push_back("-fsyntax-only");
213     break;
214   default:
215     D.Diag(diag::err_drv_invalid_gcc_output_type) << getTypeName(JA.getType());
216   }
217 }
218 
219 void tools::gcc::Linker::RenderExtraToolArgs(const JobAction &JA,
220                                              ArgStringList &CmdArgs) const {
221   // The types are (hopefully) good enough.
222 }
223 
224 static bool addXRayRuntime(const ToolChain &TC, const ArgList &Args,
225                            ArgStringList &CmdArgs) {
226   // Do not add the XRay runtime to shared libraries.
227   if (Args.hasArg(options::OPT_shared))
228     return false;
229 
230   if (Args.hasFlag(options::OPT_fxray_instrument,
231                    options::OPT_fnoxray_instrument, false)) {
232     CmdArgs.push_back("-whole-archive");
233     CmdArgs.push_back(TC.getCompilerRTArgString(Args, "xray", false));
234     CmdArgs.push_back("-no-whole-archive");
235     return true;
236   }
237 
238   return false;
239 }
240 
241 static void linkXRayRuntimeDeps(const ToolChain &TC, const ArgList &Args,
242                                 ArgStringList &CmdArgs) {
243   CmdArgs.push_back("--no-as-needed");
244   CmdArgs.push_back("-lpthread");
245   CmdArgs.push_back("-lrt");
246   CmdArgs.push_back("-lm");
247 
248   if (TC.getTriple().getOS() != llvm::Triple::FreeBSD &&
249       TC.getTriple().getOS() != llvm::Triple::NetBSD)
250     CmdArgs.push_back("-ldl");
251 }
252 
253 static const char *getLDMOption(const llvm::Triple &T, const ArgList &Args) {
254   switch (T.getArch()) {
255   case llvm::Triple::x86:
256     if (T.isOSIAMCU())
257       return "elf_iamcu";
258     return "elf_i386";
259   case llvm::Triple::aarch64:
260     return "aarch64linux";
261   case llvm::Triple::aarch64_be:
262     return "aarch64_be_linux";
263   case llvm::Triple::arm:
264   case llvm::Triple::thumb:
265     return "armelf_linux_eabi";
266   case llvm::Triple::armeb:
267   case llvm::Triple::thumbeb:
268     return "armelfb_linux_eabi";
269   case llvm::Triple::ppc:
270     return "elf32ppclinux";
271   case llvm::Triple::ppc64:
272     return "elf64ppc";
273   case llvm::Triple::ppc64le:
274     return "elf64lppc";
275   case llvm::Triple::riscv32:
276     return "elf32lriscv";
277   case llvm::Triple::riscv64:
278     return "elf64lriscv";
279   case llvm::Triple::sparc:
280   case llvm::Triple::sparcel:
281     return "elf32_sparc";
282   case llvm::Triple::sparcv9:
283     return "elf64_sparc";
284   case llvm::Triple::mips:
285     return "elf32btsmip";
286   case llvm::Triple::mipsel:
287     return "elf32ltsmip";
288   case llvm::Triple::mips64:
289     if (tools::mips::hasMipsAbiArg(Args, "n32"))
290       return "elf32btsmipn32";
291     return "elf64btsmip";
292   case llvm::Triple::mips64el:
293     if (tools::mips::hasMipsAbiArg(Args, "n32"))
294       return "elf32ltsmipn32";
295     return "elf64ltsmip";
296   case llvm::Triple::systemz:
297     return "elf64_s390";
298   case llvm::Triple::x86_64:
299     if (T.getEnvironment() == llvm::Triple::GNUX32)
300       return "elf32_x86_64";
301     return "elf_x86_64";
302   default:
303     return nullptr;
304   }
305 }
306 
307 static bool getPIE(const ArgList &Args, const toolchains::Linux &ToolChain) {
308   if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_static))
309     return false;
310 
311   Arg *A = Args.getLastArg(options::OPT_pie, options::OPT_no_pie,
312                            options::OPT_nopie);
313   if (!A)
314     return ToolChain.isPIEDefault();
315   return A->getOption().matches(options::OPT_pie);
316 }
317 
318 void tools::gnutools::Linker::ConstructJob(Compilation &C, const JobAction &JA,
319                                            const InputInfo &Output,
320                                            const InputInfoList &Inputs,
321                                            const ArgList &Args,
322                                            const char *LinkingOutput) const {
323   const toolchains::Linux &ToolChain =
324       static_cast<const toolchains::Linux &>(getToolChain());
325   const Driver &D = ToolChain.getDriver();
326 
327   const llvm::Triple &Triple = getToolChain().getEffectiveTriple();
328 
329   const llvm::Triple::ArchType Arch = ToolChain.getArch();
330   const bool isAndroid = ToolChain.getTriple().isAndroid();
331   const bool IsIAMCU = ToolChain.getTriple().isOSIAMCU();
332   const bool IsPIE = getPIE(Args, ToolChain);
333   const bool HasCRTBeginEndFiles =
334       ToolChain.getTriple().hasEnvironment() ||
335       (ToolChain.getTriple().getVendor() != llvm::Triple::MipsTechnologies);
336 
337   ArgStringList CmdArgs;
338 
339   // Silence warning for "clang -g foo.o -o foo"
340   Args.ClaimAllArgs(options::OPT_g_Group);
341   // and "clang -emit-llvm foo.o -o foo"
342   Args.ClaimAllArgs(options::OPT_emit_llvm);
343   // and for "clang -w foo.o -o foo". Other warning options are already
344   // handled somewhere else.
345   Args.ClaimAllArgs(options::OPT_w);
346 
347   const char *Exec = Args.MakeArgString(ToolChain.GetLinkerPath());
348   if (llvm::sys::path::stem(Exec) == "lld") {
349     CmdArgs.push_back("-flavor");
350     CmdArgs.push_back("old-gnu");
351     CmdArgs.push_back("-target");
352     CmdArgs.push_back(Args.MakeArgString(getToolChain().getTripleString()));
353   }
354 
355   if (!D.SysRoot.empty())
356     CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
357 
358   if (IsPIE)
359     CmdArgs.push_back("-pie");
360 
361   if (Args.hasArg(options::OPT_rdynamic))
362     CmdArgs.push_back("-export-dynamic");
363 
364   if (Args.hasArg(options::OPT_s))
365     CmdArgs.push_back("-s");
366 
367   if (Arch == llvm::Triple::armeb || Arch == llvm::Triple::thumbeb)
368     arm::appendEBLinkFlags(Args, CmdArgs, Triple);
369 
370   // Most Android ARM64 targets should enable the linker fix for erratum
371   // 843419. Only non-Cortex-A53 devices are allowed to skip this flag.
372   if (Arch == llvm::Triple::aarch64 && isAndroid) {
373     std::string CPU = getCPUName(Args, Triple);
374     if (CPU.empty() || CPU == "generic" || CPU == "cortex-a53")
375       CmdArgs.push_back("--fix-cortex-a53-843419");
376   }
377 
378   for (const auto &Opt : ToolChain.ExtraOpts)
379     CmdArgs.push_back(Opt.c_str());
380 
381   CmdArgs.push_back("--eh-frame-hdr");
382 
383   if (const char *LDMOption = getLDMOption(ToolChain.getTriple(), Args)) {
384     CmdArgs.push_back("-m");
385     CmdArgs.push_back(LDMOption);
386   } else {
387     D.Diag(diag::err_target_unknown_triple) << Triple.str();
388     return;
389   }
390 
391   if (Args.hasArg(options::OPT_static)) {
392     if (Arch == llvm::Triple::arm || Arch == llvm::Triple::armeb ||
393         Arch == llvm::Triple::thumb || Arch == llvm::Triple::thumbeb)
394       CmdArgs.push_back("-Bstatic");
395     else
396       CmdArgs.push_back("-static");
397   } else if (Args.hasArg(options::OPT_shared)) {
398     CmdArgs.push_back("-shared");
399   }
400 
401   if (!Args.hasArg(options::OPT_static)) {
402     if (Args.hasArg(options::OPT_rdynamic))
403       CmdArgs.push_back("-export-dynamic");
404 
405     if (!Args.hasArg(options::OPT_shared)) {
406       const std::string Loader =
407           D.DyldPrefix + ToolChain.getDynamicLinker(Args);
408       CmdArgs.push_back("-dynamic-linker");
409       CmdArgs.push_back(Args.MakeArgString(Loader));
410     }
411   }
412 
413   CmdArgs.push_back("-o");
414   CmdArgs.push_back(Output.getFilename());
415 
416   if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
417     if (!isAndroid && !IsIAMCU) {
418       const char *crt1 = nullptr;
419       if (!Args.hasArg(options::OPT_shared)) {
420         if (Args.hasArg(options::OPT_pg))
421           crt1 = "gcrt1.o";
422         else if (IsPIE)
423           crt1 = "Scrt1.o";
424         else
425           crt1 = "crt1.o";
426       }
427       if (crt1)
428         CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1)));
429 
430       CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o")));
431     }
432 
433     if (IsIAMCU)
434       CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crt0.o")));
435     else {
436       const char *crtbegin;
437       if (Args.hasArg(options::OPT_static))
438         crtbegin = isAndroid ? "crtbegin_static.o" : "crtbeginT.o";
439       else if (Args.hasArg(options::OPT_shared))
440         crtbegin = isAndroid ? "crtbegin_so.o" : "crtbeginS.o";
441       else if (IsPIE)
442         crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbeginS.o";
443       else
444         crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbegin.o";
445 
446       if (HasCRTBeginEndFiles)
447         CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin)));
448     }
449 
450     // Add crtfastmath.o if available and fast math is enabled.
451     ToolChain.AddFastMathRuntimeIfAvailable(Args, CmdArgs);
452   }
453 
454   Args.AddAllArgs(CmdArgs, options::OPT_L);
455   Args.AddAllArgs(CmdArgs, options::OPT_u);
456 
457   ToolChain.AddFilePathLibArgs(Args, CmdArgs);
458 
459   if (D.isUsingLTO())
460     AddGoldPlugin(ToolChain, Args, CmdArgs, D.getLTOMode() == LTOK_Thin, D);
461 
462   if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
463     CmdArgs.push_back("--no-demangle");
464 
465   bool NeedsSanitizerDeps = addSanitizerRuntimes(ToolChain, Args, CmdArgs);
466   bool NeedsXRayDeps = addXRayRuntime(ToolChain, Args, CmdArgs);
467   AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs, JA);
468   // The profile runtime also needs access to system libraries.
469   getToolChain().addProfileRTLibs(Args, CmdArgs);
470 
471   if (D.CCCIsCXX() &&
472       !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
473     if (ToolChain.ShouldLinkCXXStdlib(Args)) {
474       bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
475                                  !Args.hasArg(options::OPT_static);
476       if (OnlyLibstdcxxStatic)
477         CmdArgs.push_back("-Bstatic");
478       ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
479       if (OnlyLibstdcxxStatic)
480         CmdArgs.push_back("-Bdynamic");
481     }
482     CmdArgs.push_back("-lm");
483   }
484   // Silence warnings when linking C code with a C++ '-stdlib' argument.
485   Args.ClaimAllArgs(options::OPT_stdlib_EQ);
486 
487   if (!Args.hasArg(options::OPT_nostdlib)) {
488     if (!Args.hasArg(options::OPT_nodefaultlibs)) {
489       if (Args.hasArg(options::OPT_static))
490         CmdArgs.push_back("--start-group");
491 
492       if (NeedsSanitizerDeps)
493         linkSanitizerRuntimeDeps(ToolChain, CmdArgs);
494 
495       if (NeedsXRayDeps)
496         linkXRayRuntimeDeps(ToolChain, Args, CmdArgs);
497 
498       bool WantPthread = Args.hasArg(options::OPT_pthread) ||
499                          Args.hasArg(options::OPT_pthreads);
500 
501       // FIXME: Only pass GompNeedsRT = true for platforms with libgomp that
502       // require librt. Most modern Linux platforms do, but some may not.
503       if (addOpenMPRuntime(CmdArgs, ToolChain, Args,
504                            JA.isHostOffloading(Action::OFK_OpenMP),
505                            /* GompNeedsRT= */ true))
506         // OpenMP runtimes implies pthreads when using the GNU toolchain.
507         // FIXME: Does this really make sense for all GNU toolchains?
508         WantPthread = true;
509 
510       AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
511 
512       if (WantPthread && !isAndroid)
513         CmdArgs.push_back("-lpthread");
514 
515       if (Args.hasArg(options::OPT_fsplit_stack))
516         CmdArgs.push_back("--wrap=pthread_create");
517 
518       CmdArgs.push_back("-lc");
519 
520       // Add IAMCU specific libs, if needed.
521       if (IsIAMCU)
522         CmdArgs.push_back("-lgloss");
523 
524       if (Args.hasArg(options::OPT_static))
525         CmdArgs.push_back("--end-group");
526       else
527         AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
528 
529       // Add IAMCU specific libs (outside the group), if needed.
530       if (IsIAMCU) {
531         CmdArgs.push_back("--as-needed");
532         CmdArgs.push_back("-lsoftfp");
533         CmdArgs.push_back("--no-as-needed");
534       }
535     }
536 
537     if (!Args.hasArg(options::OPT_nostartfiles) && !IsIAMCU) {
538       const char *crtend;
539       if (Args.hasArg(options::OPT_shared))
540         crtend = isAndroid ? "crtend_so.o" : "crtendS.o";
541       else if (IsPIE)
542         crtend = isAndroid ? "crtend_android.o" : "crtendS.o";
543       else
544         crtend = isAndroid ? "crtend_android.o" : "crtend.o";
545 
546       if (HasCRTBeginEndFiles)
547         CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend)));
548       if (!isAndroid)
549         CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
550     }
551   }
552 
553   // Add OpenMP offloading linker script args if required.
554   AddOpenMPLinkerScript(getToolChain(), C, Output, Inputs, Args, CmdArgs, JA);
555 
556   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
557 }
558 
559 void tools::gnutools::Assembler::ConstructJob(Compilation &C,
560                                               const JobAction &JA,
561                                               const InputInfo &Output,
562                                               const InputInfoList &Inputs,
563                                               const ArgList &Args,
564                                               const char *LinkingOutput) const {
565   const auto &D = getToolChain().getDriver();
566 
567   claimNoWarnArgs(Args);
568 
569   ArgStringList CmdArgs;
570 
571   llvm::Reloc::Model RelocationModel;
572   unsigned PICLevel;
573   bool IsPIE;
574   std::tie(RelocationModel, PICLevel, IsPIE) =
575       ParsePICArgs(getToolChain(), Args);
576 
577   if (const Arg *A = Args.getLastArg(options::OPT_gz, options::OPT_gz_EQ)) {
578     if (A->getOption().getID() == options::OPT_gz) {
579       CmdArgs.push_back("-compress-debug-sections");
580     } else {
581       StringRef Value = A->getValue();
582       if (Value == "none") {
583         CmdArgs.push_back("-compress-debug-sections=none");
584       } else if (Value == "zlib" || Value == "zlib-gnu") {
585         CmdArgs.push_back(
586             Args.MakeArgString("-compress-debug-sections=" + Twine(Value)));
587       } else {
588         D.Diag(diag::err_drv_unsupported_option_argument)
589             << A->getOption().getName() << Value;
590       }
591     }
592   }
593 
594   switch (getToolChain().getArch()) {
595   default:
596     break;
597   // Add --32/--64 to make sure we get the format we want.
598   // This is incomplete
599   case llvm::Triple::x86:
600     CmdArgs.push_back("--32");
601     break;
602   case llvm::Triple::x86_64:
603     if (getToolChain().getTriple().getEnvironment() == llvm::Triple::GNUX32)
604       CmdArgs.push_back("--x32");
605     else
606       CmdArgs.push_back("--64");
607     break;
608   case llvm::Triple::ppc: {
609     CmdArgs.push_back("-a32");
610     CmdArgs.push_back("-mppc");
611     CmdArgs.push_back(
612       ppc::getPPCAsmModeForCPU(getCPUName(Args, getToolChain().getTriple())));
613     break;
614   }
615   case llvm::Triple::ppc64: {
616     CmdArgs.push_back("-a64");
617     CmdArgs.push_back("-mppc64");
618     CmdArgs.push_back(
619       ppc::getPPCAsmModeForCPU(getCPUName(Args, getToolChain().getTriple())));
620     break;
621   }
622   case llvm::Triple::ppc64le: {
623     CmdArgs.push_back("-a64");
624     CmdArgs.push_back("-mppc64");
625     CmdArgs.push_back("-mlittle-endian");
626     CmdArgs.push_back(
627       ppc::getPPCAsmModeForCPU(getCPUName(Args, getToolChain().getTriple())));
628     break;
629   }
630   case llvm::Triple::riscv32:
631   case llvm::Triple::riscv64: {
632     StringRef ABIName = riscv::getRISCVABI(Args, getToolChain().getTriple());
633     CmdArgs.push_back("-mabi");
634     CmdArgs.push_back(ABIName.data());
635     if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
636       StringRef MArch = A->getValue();
637       CmdArgs.push_back("-march");
638       CmdArgs.push_back(MArch.data());
639     }
640     break;
641   }
642   case llvm::Triple::sparc:
643   case llvm::Triple::sparcel: {
644     CmdArgs.push_back("-32");
645     std::string CPU = getCPUName(Args, getToolChain().getTriple());
646     CmdArgs.push_back(sparc::getSparcAsmModeForCPU(CPU, getToolChain().getTriple()));
647     AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
648     break;
649   }
650   case llvm::Triple::sparcv9: {
651     CmdArgs.push_back("-64");
652     std::string CPU = getCPUName(Args, getToolChain().getTriple());
653     CmdArgs.push_back(sparc::getSparcAsmModeForCPU(CPU, getToolChain().getTriple()));
654     AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
655     break;
656   }
657   case llvm::Triple::arm:
658   case llvm::Triple::armeb:
659   case llvm::Triple::thumb:
660   case llvm::Triple::thumbeb: {
661     const llvm::Triple &Triple2 = getToolChain().getTriple();
662     switch (Triple2.getSubArch()) {
663     case llvm::Triple::ARMSubArch_v7:
664       CmdArgs.push_back("-mfpu=neon");
665       break;
666     case llvm::Triple::ARMSubArch_v8:
667       CmdArgs.push_back("-mfpu=crypto-neon-fp-armv8");
668       break;
669     default:
670       break;
671     }
672 
673     switch (arm::getARMFloatABI(getToolChain(), Args)) {
674     case arm::FloatABI::Invalid: llvm_unreachable("must have an ABI!");
675     case arm::FloatABI::Soft:
676       CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=soft"));
677       break;
678     case arm::FloatABI::SoftFP:
679       CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=softfp"));
680       break;
681     case arm::FloatABI::Hard:
682       CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=hard"));
683       break;
684     }
685 
686     Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
687     normalizeCPUNamesForAssembler(Args, CmdArgs);
688 
689     Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ);
690     break;
691   }
692   case llvm::Triple::aarch64:
693   case llvm::Triple::aarch64_be: {
694     Args.AddLastArg(CmdArgs, options::OPT_march_EQ);
695     normalizeCPUNamesForAssembler(Args, CmdArgs);
696 
697     break;
698   }
699   case llvm::Triple::mips:
700   case llvm::Triple::mipsel:
701   case llvm::Triple::mips64:
702   case llvm::Triple::mips64el: {
703     StringRef CPUName;
704     StringRef ABIName;
705     mips::getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName);
706     ABIName = mips::getGnuCompatibleMipsABIName(ABIName);
707 
708     CmdArgs.push_back("-march");
709     CmdArgs.push_back(CPUName.data());
710 
711     CmdArgs.push_back("-mabi");
712     CmdArgs.push_back(ABIName.data());
713 
714     // -mno-shared should be emitted unless -fpic, -fpie, -fPIC, -fPIE,
715     // or -mshared (not implemented) is in effect.
716     if (RelocationModel == llvm::Reloc::Static)
717       CmdArgs.push_back("-mno-shared");
718 
719     // LLVM doesn't support -mplt yet and acts as if it is always given.
720     // However, -mplt has no effect with the N64 ABI.
721     if (ABIName != "64" && !Args.hasArg(options::OPT_mno_abicalls))
722       CmdArgs.push_back("-call_nonpic");
723 
724     if (getToolChain().getArch() == llvm::Triple::mips ||
725         getToolChain().getArch() == llvm::Triple::mips64)
726       CmdArgs.push_back("-EB");
727     else
728       CmdArgs.push_back("-EL");
729 
730     if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) {
731       if (StringRef(A->getValue()) == "2008")
732         CmdArgs.push_back(Args.MakeArgString("-mnan=2008"));
733     }
734 
735     // Add the last -mfp32/-mfpxx/-mfp64 or -mfpxx if it is enabled by default.
736     if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfpxx,
737                                  options::OPT_mfp64)) {
738       A->claim();
739       A->render(Args, CmdArgs);
740     } else if (mips::shouldUseFPXX(
741                    Args, getToolChain().getTriple(), CPUName, ABIName,
742                    mips::getMipsFloatABI(getToolChain().getDriver(), Args)))
743       CmdArgs.push_back("-mfpxx");
744 
745     // Pass on -mmips16 or -mno-mips16. However, the assembler equivalent of
746     // -mno-mips16 is actually -no-mips16.
747     if (Arg *A =
748             Args.getLastArg(options::OPT_mips16, options::OPT_mno_mips16)) {
749       if (A->getOption().matches(options::OPT_mips16)) {
750         A->claim();
751         A->render(Args, CmdArgs);
752       } else {
753         A->claim();
754         CmdArgs.push_back("-no-mips16");
755       }
756     }
757 
758     Args.AddLastArg(CmdArgs, options::OPT_mmicromips,
759                     options::OPT_mno_micromips);
760     Args.AddLastArg(CmdArgs, options::OPT_mdsp, options::OPT_mno_dsp);
761     Args.AddLastArg(CmdArgs, options::OPT_mdspr2, options::OPT_mno_dspr2);
762 
763     if (Arg *A = Args.getLastArg(options::OPT_mmsa, options::OPT_mno_msa)) {
764       // Do not use AddLastArg because not all versions of MIPS assembler
765       // support -mmsa / -mno-msa options.
766       if (A->getOption().matches(options::OPT_mmsa))
767         CmdArgs.push_back(Args.MakeArgString("-mmsa"));
768     }
769 
770     Args.AddLastArg(CmdArgs, options::OPT_mhard_float,
771                     options::OPT_msoft_float);
772 
773     Args.AddLastArg(CmdArgs, options::OPT_mdouble_float,
774                     options::OPT_msingle_float);
775 
776     Args.AddLastArg(CmdArgs, options::OPT_modd_spreg,
777                     options::OPT_mno_odd_spreg);
778 
779     AddAssemblerKPIC(getToolChain(), Args, CmdArgs);
780     break;
781   }
782   case llvm::Triple::systemz: {
783     // Always pass an -march option, since our default of z10 is later
784     // than the GNU assembler's default.
785     StringRef CPUName = systemz::getSystemZTargetCPU(Args);
786     CmdArgs.push_back(Args.MakeArgString("-march=" + CPUName));
787     break;
788   }
789   }
790 
791   Args.AddAllArgs(CmdArgs, options::OPT_I);
792   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
793 
794   CmdArgs.push_back("-o");
795   CmdArgs.push_back(Output.getFilename());
796 
797   for (const auto &II : Inputs)
798     CmdArgs.push_back(II.getFilename());
799 
800   const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
801   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
802 
803   // Handle the debug info splitting at object creation time if we're
804   // creating an object.
805   // TODO: Currently only works on linux with newer objcopy.
806   if (Args.hasArg(options::OPT_gsplit_dwarf) &&
807       getToolChain().getTriple().isOSLinux())
808     SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
809                    SplitDebugName(Args, Inputs[0]));
810 }
811 
812 namespace {
813 // Filter to remove Multilibs that don't exist as a suffix to Path
814 class FilterNonExistent {
815   StringRef Base, File;
816   vfs::FileSystem &VFS;
817 
818 public:
819   FilterNonExistent(StringRef Base, StringRef File, vfs::FileSystem &VFS)
820       : Base(Base), File(File), VFS(VFS) {}
821   bool operator()(const Multilib &M) {
822     return !VFS.exists(Base + M.gccSuffix() + File);
823   }
824 };
825 } // end anonymous namespace
826 
827 static bool isSoftFloatABI(const ArgList &Args) {
828   Arg *A = Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float,
829                            options::OPT_mfloat_abi_EQ);
830   if (!A)
831     return false;
832 
833   return A->getOption().matches(options::OPT_msoft_float) ||
834          (A->getOption().matches(options::OPT_mfloat_abi_EQ) &&
835           A->getValue() == StringRef("soft"));
836 }
837 
838 /// \p Flag must be a flag accepted by the driver with its leading '-' removed,
839 //     otherwise '-print-multi-lib' will not emit them correctly.
840 static void addMultilibFlag(bool Enabled, const char *const Flag,
841                             std::vector<std::string> &Flags) {
842   if (Enabled)
843     Flags.push_back(std::string("+") + Flag);
844   else
845     Flags.push_back(std::string("-") + Flag);
846 }
847 
848 static bool isArmOrThumbArch(llvm::Triple::ArchType Arch) {
849   return Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb;
850 }
851 
852 static bool isMips32(llvm::Triple::ArchType Arch) {
853   return Arch == llvm::Triple::mips || Arch == llvm::Triple::mipsel;
854 }
855 
856 static bool isMips64(llvm::Triple::ArchType Arch) {
857   return Arch == llvm::Triple::mips64 || Arch == llvm::Triple::mips64el;
858 }
859 
860 static bool isMipsEL(llvm::Triple::ArchType Arch) {
861   return Arch == llvm::Triple::mipsel || Arch == llvm::Triple::mips64el;
862 }
863 
864 static bool isMips16(const ArgList &Args) {
865   Arg *A = Args.getLastArg(options::OPT_mips16, options::OPT_mno_mips16);
866   return A && A->getOption().matches(options::OPT_mips16);
867 }
868 
869 static bool isMicroMips(const ArgList &Args) {
870   Arg *A = Args.getLastArg(options::OPT_mmicromips, options::OPT_mno_micromips);
871   return A && A->getOption().matches(options::OPT_mmicromips);
872 }
873 
874 static bool isRISCV(llvm::Triple::ArchType Arch) {
875   return Arch == llvm::Triple::riscv32 || Arch == llvm::Triple::riscv64;
876 }
877 
878 static Multilib makeMultilib(StringRef commonSuffix) {
879   return Multilib(commonSuffix, commonSuffix, commonSuffix);
880 }
881 
882 static bool findMipsCsMultilibs(const Multilib::flags_list &Flags,
883                                 FilterNonExistent &NonExistent,
884                                 DetectedMultilibs &Result) {
885   // Check for Code Sourcery toolchain multilibs
886   MultilibSet CSMipsMultilibs;
887   {
888     auto MArchMips16 = makeMultilib("/mips16").flag("+m32").flag("+mips16");
889 
890     auto MArchMicroMips =
891         makeMultilib("/micromips").flag("+m32").flag("+mmicromips");
892 
893     auto MArchDefault = makeMultilib("").flag("-mips16").flag("-mmicromips");
894 
895     auto UCLibc = makeMultilib("/uclibc").flag("+muclibc");
896 
897     auto SoftFloat = makeMultilib("/soft-float").flag("+msoft-float");
898 
899     auto Nan2008 = makeMultilib("/nan2008").flag("+mnan=2008");
900 
901     auto DefaultFloat =
902         makeMultilib("").flag("-msoft-float").flag("-mnan=2008");
903 
904     auto BigEndian = makeMultilib("").flag("+EB").flag("-EL");
905 
906     auto LittleEndian = makeMultilib("/el").flag("+EL").flag("-EB");
907 
908     // Note that this one's osSuffix is ""
909     auto MAbi64 = makeMultilib("")
910                       .gccSuffix("/64")
911                       .includeSuffix("/64")
912                       .flag("+mabi=n64")
913                       .flag("-mabi=n32")
914                       .flag("-m32");
915 
916     CSMipsMultilibs =
917         MultilibSet()
918             .Either(MArchMips16, MArchMicroMips, MArchDefault)
919             .Maybe(UCLibc)
920             .Either(SoftFloat, Nan2008, DefaultFloat)
921             .FilterOut("/micromips/nan2008")
922             .FilterOut("/mips16/nan2008")
923             .Either(BigEndian, LittleEndian)
924             .Maybe(MAbi64)
925             .FilterOut("/mips16.*/64")
926             .FilterOut("/micromips.*/64")
927             .FilterOut(NonExistent)
928             .setIncludeDirsCallback([](const Multilib &M) {
929               std::vector<std::string> Dirs({"/include"});
930               if (StringRef(M.includeSuffix()).startswith("/uclibc"))
931                 Dirs.push_back(
932                     "/../../../../mips-linux-gnu/libc/uclibc/usr/include");
933               else
934                 Dirs.push_back("/../../../../mips-linux-gnu/libc/usr/include");
935               return Dirs;
936             });
937   }
938 
939   MultilibSet DebianMipsMultilibs;
940   {
941     Multilib MAbiN32 =
942         Multilib().gccSuffix("/n32").includeSuffix("/n32").flag("+mabi=n32");
943 
944     Multilib M64 = Multilib()
945                        .gccSuffix("/64")
946                        .includeSuffix("/64")
947                        .flag("+m64")
948                        .flag("-m32")
949                        .flag("-mabi=n32");
950 
951     Multilib M32 = Multilib().flag("-m64").flag("+m32").flag("-mabi=n32");
952 
953     DebianMipsMultilibs =
954         MultilibSet().Either(M32, M64, MAbiN32).FilterOut(NonExistent);
955   }
956 
957   // Sort candidates. Toolchain that best meets the directories tree goes first.
958   // Then select the first toolchains matches command line flags.
959   MultilibSet *Candidates[] = {&CSMipsMultilibs, &DebianMipsMultilibs};
960   if (CSMipsMultilibs.size() < DebianMipsMultilibs.size())
961     std::iter_swap(Candidates, Candidates + 1);
962   for (const MultilibSet *Candidate : Candidates) {
963     if (Candidate->select(Flags, Result.SelectedMultilib)) {
964       if (Candidate == &DebianMipsMultilibs)
965         Result.BiarchSibling = Multilib();
966       Result.Multilibs = *Candidate;
967       return true;
968     }
969   }
970   return false;
971 }
972 
973 static bool findMipsAndroidMultilibs(vfs::FileSystem &VFS, StringRef Path,
974                                      const Multilib::flags_list &Flags,
975                                      FilterNonExistent &NonExistent,
976                                      DetectedMultilibs &Result) {
977 
978   MultilibSet AndroidMipsMultilibs =
979       MultilibSet()
980           .Maybe(Multilib("/mips-r2").flag("+march=mips32r2"))
981           .Maybe(Multilib("/mips-r6").flag("+march=mips32r6"))
982           .FilterOut(NonExistent);
983 
984   MultilibSet AndroidMipselMultilibs =
985       MultilibSet()
986           .Either(Multilib().flag("+march=mips32"),
987                   Multilib("/mips-r2", "", "/mips-r2").flag("+march=mips32r2"),
988                   Multilib("/mips-r6", "", "/mips-r6").flag("+march=mips32r6"))
989           .FilterOut(NonExistent);
990 
991   MultilibSet AndroidMips64elMultilibs =
992       MultilibSet()
993           .Either(
994               Multilib().flag("+march=mips64r6"),
995               Multilib("/32/mips-r1", "", "/mips-r1").flag("+march=mips32"),
996               Multilib("/32/mips-r2", "", "/mips-r2").flag("+march=mips32r2"),
997               Multilib("/32/mips-r6", "", "/mips-r6").flag("+march=mips32r6"))
998           .FilterOut(NonExistent);
999 
1000   MultilibSet *MS = &AndroidMipsMultilibs;
1001   if (VFS.exists(Path + "/mips-r6"))
1002     MS = &AndroidMipselMultilibs;
1003   else if (VFS.exists(Path + "/32"))
1004     MS = &AndroidMips64elMultilibs;
1005   if (MS->select(Flags, Result.SelectedMultilib)) {
1006     Result.Multilibs = *MS;
1007     return true;
1008   }
1009   return false;
1010 }
1011 
1012 static bool findMipsMuslMultilibs(const Multilib::flags_list &Flags,
1013                                   FilterNonExistent &NonExistent,
1014                                   DetectedMultilibs &Result) {
1015   // Musl toolchain multilibs
1016   MultilibSet MuslMipsMultilibs;
1017   {
1018     auto MArchMipsR2 = makeMultilib("")
1019                            .osSuffix("/mips-r2-hard-musl")
1020                            .flag("+EB")
1021                            .flag("-EL")
1022                            .flag("+march=mips32r2");
1023 
1024     auto MArchMipselR2 = makeMultilib("/mipsel-r2-hard-musl")
1025                              .flag("-EB")
1026                              .flag("+EL")
1027                              .flag("+march=mips32r2");
1028 
1029     MuslMipsMultilibs = MultilibSet().Either(MArchMipsR2, MArchMipselR2);
1030 
1031     // Specify the callback that computes the include directories.
1032     MuslMipsMultilibs.setIncludeDirsCallback([](const Multilib &M) {
1033       return std::vector<std::string>(
1034           {"/../sysroot" + M.osSuffix() + "/usr/include"});
1035     });
1036   }
1037   if (MuslMipsMultilibs.select(Flags, Result.SelectedMultilib)) {
1038     Result.Multilibs = MuslMipsMultilibs;
1039     return true;
1040   }
1041   return false;
1042 }
1043 
1044 static bool findMipsMtiMultilibs(const Multilib::flags_list &Flags,
1045                                  FilterNonExistent &NonExistent,
1046                                  DetectedMultilibs &Result) {
1047   // CodeScape MTI toolchain v1.2 and early.
1048   MultilibSet MtiMipsMultilibsV1;
1049   {
1050     auto MArchMips32 = makeMultilib("/mips32")
1051                            .flag("+m32")
1052                            .flag("-m64")
1053                            .flag("-mmicromips")
1054                            .flag("+march=mips32");
1055 
1056     auto MArchMicroMips = makeMultilib("/micromips")
1057                               .flag("+m32")
1058                               .flag("-m64")
1059                               .flag("+mmicromips");
1060 
1061     auto MArchMips64r2 = makeMultilib("/mips64r2")
1062                              .flag("-m32")
1063                              .flag("+m64")
1064                              .flag("+march=mips64r2");
1065 
1066     auto MArchMips64 = makeMultilib("/mips64").flag("-m32").flag("+m64").flag(
1067         "-march=mips64r2");
1068 
1069     auto MArchDefault = makeMultilib("")
1070                             .flag("+m32")
1071                             .flag("-m64")
1072                             .flag("-mmicromips")
1073                             .flag("+march=mips32r2");
1074 
1075     auto Mips16 = makeMultilib("/mips16").flag("+mips16");
1076 
1077     auto UCLibc = makeMultilib("/uclibc").flag("+muclibc");
1078 
1079     auto MAbi64 =
1080         makeMultilib("/64").flag("+mabi=n64").flag("-mabi=n32").flag("-m32");
1081 
1082     auto BigEndian = makeMultilib("").flag("+EB").flag("-EL");
1083 
1084     auto LittleEndian = makeMultilib("/el").flag("+EL").flag("-EB");
1085 
1086     auto SoftFloat = makeMultilib("/sof").flag("+msoft-float");
1087 
1088     auto Nan2008 = makeMultilib("/nan2008").flag("+mnan=2008");
1089 
1090     MtiMipsMultilibsV1 =
1091         MultilibSet()
1092             .Either(MArchMips32, MArchMicroMips, MArchMips64r2, MArchMips64,
1093                     MArchDefault)
1094             .Maybe(UCLibc)
1095             .Maybe(Mips16)
1096             .FilterOut("/mips64/mips16")
1097             .FilterOut("/mips64r2/mips16")
1098             .FilterOut("/micromips/mips16")
1099             .Maybe(MAbi64)
1100             .FilterOut("/micromips/64")
1101             .FilterOut("/mips32/64")
1102             .FilterOut("^/64")
1103             .FilterOut("/mips16/64")
1104             .Either(BigEndian, LittleEndian)
1105             .Maybe(SoftFloat)
1106             .Maybe(Nan2008)
1107             .FilterOut(".*sof/nan2008")
1108             .FilterOut(NonExistent)
1109             .setIncludeDirsCallback([](const Multilib &M) {
1110               std::vector<std::string> Dirs({"/include"});
1111               if (StringRef(M.includeSuffix()).startswith("/uclibc"))
1112                 Dirs.push_back("/../../../../sysroot/uclibc/usr/include");
1113               else
1114                 Dirs.push_back("/../../../../sysroot/usr/include");
1115               return Dirs;
1116             });
1117   }
1118 
1119   // CodeScape IMG toolchain starting from v1.3.
1120   MultilibSet MtiMipsMultilibsV2;
1121   {
1122     auto BeHard = makeMultilib("/mips-r2-hard")
1123                       .flag("+EB")
1124                       .flag("-msoft-float")
1125                       .flag("-mnan=2008")
1126                       .flag("-muclibc");
1127     auto BeSoft = makeMultilib("/mips-r2-soft")
1128                       .flag("+EB")
1129                       .flag("+msoft-float")
1130                       .flag("-mnan=2008");
1131     auto ElHard = makeMultilib("/mipsel-r2-hard")
1132                       .flag("+EL")
1133                       .flag("-msoft-float")
1134                       .flag("-mnan=2008")
1135                       .flag("-muclibc");
1136     auto ElSoft = makeMultilib("/mipsel-r2-soft")
1137                       .flag("+EL")
1138                       .flag("+msoft-float")
1139                       .flag("-mnan=2008")
1140                       .flag("-mmicromips");
1141     auto BeHardNan = makeMultilib("/mips-r2-hard-nan2008")
1142                          .flag("+EB")
1143                          .flag("-msoft-float")
1144                          .flag("+mnan=2008")
1145                          .flag("-muclibc");
1146     auto ElHardNan = makeMultilib("/mipsel-r2-hard-nan2008")
1147                          .flag("+EL")
1148                          .flag("-msoft-float")
1149                          .flag("+mnan=2008")
1150                          .flag("-muclibc")
1151                          .flag("-mmicromips");
1152     auto BeHardNanUclibc = makeMultilib("/mips-r2-hard-nan2008-uclibc")
1153                                .flag("+EB")
1154                                .flag("-msoft-float")
1155                                .flag("+mnan=2008")
1156                                .flag("+muclibc");
1157     auto ElHardNanUclibc = makeMultilib("/mipsel-r2-hard-nan2008-uclibc")
1158                                .flag("+EL")
1159                                .flag("-msoft-float")
1160                                .flag("+mnan=2008")
1161                                .flag("+muclibc");
1162     auto BeHardUclibc = makeMultilib("/mips-r2-hard-uclibc")
1163                             .flag("+EB")
1164                             .flag("-msoft-float")
1165                             .flag("-mnan=2008")
1166                             .flag("+muclibc");
1167     auto ElHardUclibc = makeMultilib("/mipsel-r2-hard-uclibc")
1168                             .flag("+EL")
1169                             .flag("-msoft-float")
1170                             .flag("-mnan=2008")
1171                             .flag("+muclibc");
1172     auto ElMicroHardNan = makeMultilib("/micromipsel-r2-hard-nan2008")
1173                               .flag("+EL")
1174                               .flag("-msoft-float")
1175                               .flag("+mnan=2008")
1176                               .flag("+mmicromips");
1177     auto ElMicroSoft = makeMultilib("/micromipsel-r2-soft")
1178                            .flag("+EL")
1179                            .flag("+msoft-float")
1180                            .flag("-mnan=2008")
1181                            .flag("+mmicromips");
1182 
1183     auto O32 =
1184         makeMultilib("/lib").osSuffix("").flag("-mabi=n32").flag("-mabi=n64");
1185     auto N32 =
1186         makeMultilib("/lib32").osSuffix("").flag("+mabi=n32").flag("-mabi=n64");
1187     auto N64 =
1188         makeMultilib("/lib64").osSuffix("").flag("-mabi=n32").flag("+mabi=n64");
1189 
1190     MtiMipsMultilibsV2 =
1191         MultilibSet()
1192             .Either({BeHard, BeSoft, ElHard, ElSoft, BeHardNan, ElHardNan,
1193                      BeHardNanUclibc, ElHardNanUclibc, BeHardUclibc,
1194                      ElHardUclibc, ElMicroHardNan, ElMicroSoft})
1195             .Either(O32, N32, N64)
1196             .FilterOut(NonExistent)
1197             .setIncludeDirsCallback([](const Multilib &M) {
1198               return std::vector<std::string>({"/../../../../sysroot" +
1199                                                M.includeSuffix() +
1200                                                "/../usr/include"});
1201             })
1202             .setFilePathsCallback([](const Multilib &M) {
1203               return std::vector<std::string>(
1204                   {"/../../../../mips-mti-linux-gnu/lib" + M.gccSuffix()});
1205             });
1206   }
1207   for (auto Candidate : {&MtiMipsMultilibsV1, &MtiMipsMultilibsV2}) {
1208     if (Candidate->select(Flags, Result.SelectedMultilib)) {
1209       Result.Multilibs = *Candidate;
1210       return true;
1211     }
1212   }
1213   return false;
1214 }
1215 
1216 static bool findMipsImgMultilibs(const Multilib::flags_list &Flags,
1217                                  FilterNonExistent &NonExistent,
1218                                  DetectedMultilibs &Result) {
1219   // CodeScape IMG toolchain v1.2 and early.
1220   MultilibSet ImgMultilibsV1;
1221   {
1222     auto Mips64r6 = makeMultilib("/mips64r6").flag("+m64").flag("-m32");
1223 
1224     auto LittleEndian = makeMultilib("/el").flag("+EL").flag("-EB");
1225 
1226     auto MAbi64 =
1227         makeMultilib("/64").flag("+mabi=n64").flag("-mabi=n32").flag("-m32");
1228 
1229     ImgMultilibsV1 =
1230         MultilibSet()
1231             .Maybe(Mips64r6)
1232             .Maybe(MAbi64)
1233             .Maybe(LittleEndian)
1234             .FilterOut(NonExistent)
1235             .setIncludeDirsCallback([](const Multilib &M) {
1236               return std::vector<std::string>(
1237                   {"/include", "/../../../../sysroot/usr/include"});
1238             });
1239   }
1240 
1241   // CodeScape IMG toolchain starting from v1.3.
1242   MultilibSet ImgMultilibsV2;
1243   {
1244     auto BeHard = makeMultilib("/mips-r6-hard")
1245                       .flag("+EB")
1246                       .flag("-msoft-float")
1247                       .flag("-mmicromips");
1248     auto BeSoft = makeMultilib("/mips-r6-soft")
1249                       .flag("+EB")
1250                       .flag("+msoft-float")
1251                       .flag("-mmicromips");
1252     auto ElHard = makeMultilib("/mipsel-r6-hard")
1253                       .flag("+EL")
1254                       .flag("-msoft-float")
1255                       .flag("-mmicromips");
1256     auto ElSoft = makeMultilib("/mipsel-r6-soft")
1257                       .flag("+EL")
1258                       .flag("+msoft-float")
1259                       .flag("-mmicromips");
1260     auto BeMicroHard = makeMultilib("/micromips-r6-hard")
1261                            .flag("+EB")
1262                            .flag("-msoft-float")
1263                            .flag("+mmicromips");
1264     auto BeMicroSoft = makeMultilib("/micromips-r6-soft")
1265                            .flag("+EB")
1266                            .flag("+msoft-float")
1267                            .flag("+mmicromips");
1268     auto ElMicroHard = makeMultilib("/micromipsel-r6-hard")
1269                            .flag("+EL")
1270                            .flag("-msoft-float")
1271                            .flag("+mmicromips");
1272     auto ElMicroSoft = makeMultilib("/micromipsel-r6-soft")
1273                            .flag("+EL")
1274                            .flag("+msoft-float")
1275                            .flag("+mmicromips");
1276 
1277     auto O32 =
1278         makeMultilib("/lib").osSuffix("").flag("-mabi=n32").flag("-mabi=n64");
1279     auto N32 =
1280         makeMultilib("/lib32").osSuffix("").flag("+mabi=n32").flag("-mabi=n64");
1281     auto N64 =
1282         makeMultilib("/lib64").osSuffix("").flag("-mabi=n32").flag("+mabi=n64");
1283 
1284     ImgMultilibsV2 =
1285         MultilibSet()
1286             .Either({BeHard, BeSoft, ElHard, ElSoft, BeMicroHard, BeMicroSoft,
1287                      ElMicroHard, ElMicroSoft})
1288             .Either(O32, N32, N64)
1289             .FilterOut(NonExistent)
1290             .setIncludeDirsCallback([](const Multilib &M) {
1291               return std::vector<std::string>({"/../../../../sysroot" +
1292                                                M.includeSuffix() +
1293                                                "/../usr/include"});
1294             })
1295             .setFilePathsCallback([](const Multilib &M) {
1296               return std::vector<std::string>(
1297                   {"/../../../../mips-img-linux-gnu/lib" + M.gccSuffix()});
1298             });
1299   }
1300   for (auto Candidate : {&ImgMultilibsV1, &ImgMultilibsV2}) {
1301     if (Candidate->select(Flags, Result.SelectedMultilib)) {
1302       Result.Multilibs = *Candidate;
1303       return true;
1304     }
1305   }
1306   return false;
1307 }
1308 
1309 bool clang::driver::findMIPSMultilibs(const Driver &D,
1310                                       const llvm::Triple &TargetTriple,
1311                                       StringRef Path, const ArgList &Args,
1312                                       DetectedMultilibs &Result) {
1313   FilterNonExistent NonExistent(Path, "/crtbegin.o", D.getVFS());
1314 
1315   StringRef CPUName;
1316   StringRef ABIName;
1317   tools::mips::getMipsCPUAndABI(Args, TargetTriple, CPUName, ABIName);
1318 
1319   llvm::Triple::ArchType TargetArch = TargetTriple.getArch();
1320 
1321   Multilib::flags_list Flags;
1322   addMultilibFlag(isMips32(TargetArch), "m32", Flags);
1323   addMultilibFlag(isMips64(TargetArch), "m64", Flags);
1324   addMultilibFlag(isMips16(Args), "mips16", Flags);
1325   addMultilibFlag(CPUName == "mips32", "march=mips32", Flags);
1326   addMultilibFlag(CPUName == "mips32r2" || CPUName == "mips32r3" ||
1327                       CPUName == "mips32r5" || CPUName == "p5600",
1328                   "march=mips32r2", Flags);
1329   addMultilibFlag(CPUName == "mips32r6", "march=mips32r6", Flags);
1330   addMultilibFlag(CPUName == "mips64", "march=mips64", Flags);
1331   addMultilibFlag(CPUName == "mips64r2" || CPUName == "mips64r3" ||
1332                       CPUName == "mips64r5" || CPUName == "octeon",
1333                   "march=mips64r2", Flags);
1334   addMultilibFlag(CPUName == "mips64r6", "march=mips64r6", Flags);
1335   addMultilibFlag(isMicroMips(Args), "mmicromips", Flags);
1336   addMultilibFlag(tools::mips::isUCLibc(Args), "muclibc", Flags);
1337   addMultilibFlag(tools::mips::isNaN2008(Args, TargetTriple), "mnan=2008",
1338                   Flags);
1339   addMultilibFlag(ABIName == "n32", "mabi=n32", Flags);
1340   addMultilibFlag(ABIName == "n64", "mabi=n64", Flags);
1341   addMultilibFlag(isSoftFloatABI(Args), "msoft-float", Flags);
1342   addMultilibFlag(!isSoftFloatABI(Args), "mhard-float", Flags);
1343   addMultilibFlag(isMipsEL(TargetArch), "EL", Flags);
1344   addMultilibFlag(!isMipsEL(TargetArch), "EB", Flags);
1345 
1346   if (TargetTriple.isAndroid())
1347     return findMipsAndroidMultilibs(D.getVFS(), Path, Flags, NonExistent,
1348                                     Result);
1349 
1350   if (TargetTriple.getVendor() == llvm::Triple::MipsTechnologies &&
1351       TargetTriple.getOS() == llvm::Triple::Linux &&
1352       TargetTriple.getEnvironment() == llvm::Triple::UnknownEnvironment)
1353     return findMipsMuslMultilibs(Flags, NonExistent, Result);
1354 
1355   if (TargetTriple.getVendor() == llvm::Triple::MipsTechnologies &&
1356       TargetTriple.getOS() == llvm::Triple::Linux &&
1357       TargetTriple.isGNUEnvironment())
1358     return findMipsMtiMultilibs(Flags, NonExistent, Result);
1359 
1360   if (TargetTriple.getVendor() == llvm::Triple::ImaginationTechnologies &&
1361       TargetTriple.getOS() == llvm::Triple::Linux &&
1362       TargetTriple.isGNUEnvironment())
1363     return findMipsImgMultilibs(Flags, NonExistent, Result);
1364 
1365   if (findMipsCsMultilibs(Flags, NonExistent, Result))
1366     return true;
1367 
1368   // Fallback to the regular toolchain-tree structure.
1369   Multilib Default;
1370   Result.Multilibs.push_back(Default);
1371   Result.Multilibs.FilterOut(NonExistent);
1372 
1373   if (Result.Multilibs.select(Flags, Result.SelectedMultilib)) {
1374     Result.BiarchSibling = Multilib();
1375     return true;
1376   }
1377 
1378   return false;
1379 }
1380 
1381 static void findAndroidArmMultilibs(const Driver &D,
1382                                     const llvm::Triple &TargetTriple,
1383                                     StringRef Path, const ArgList &Args,
1384                                     DetectedMultilibs &Result) {
1385   // Find multilibs with subdirectories like armv7-a, thumb, armv7-a/thumb.
1386   FilterNonExistent NonExistent(Path, "/crtbegin.o", D.getVFS());
1387   Multilib ArmV7Multilib = makeMultilib("/armv7-a")
1388                                .flag("+march=armv7-a")
1389                                .flag("-mthumb");
1390   Multilib ThumbMultilib = makeMultilib("/thumb")
1391                                .flag("-march=armv7-a")
1392                                .flag("+mthumb");
1393   Multilib ArmV7ThumbMultilib = makeMultilib("/armv7-a/thumb")
1394                                .flag("+march=armv7-a")
1395                                .flag("+mthumb");
1396   Multilib DefaultMultilib = makeMultilib("")
1397                                .flag("-march=armv7-a")
1398                                .flag("-mthumb");
1399   MultilibSet AndroidArmMultilibs =
1400       MultilibSet()
1401           .Either(ThumbMultilib, ArmV7Multilib,
1402                   ArmV7ThumbMultilib, DefaultMultilib)
1403           .FilterOut(NonExistent);
1404 
1405   Multilib::flags_list Flags;
1406   llvm::StringRef Arch = Args.getLastArgValue(options::OPT_march_EQ);
1407   bool IsArmArch = TargetTriple.getArch() == llvm::Triple::arm;
1408   bool IsThumbArch = TargetTriple.getArch() == llvm::Triple::thumb;
1409   bool IsV7SubArch = TargetTriple.getSubArch() == llvm::Triple::ARMSubArch_v7;
1410   bool IsThumbMode = IsThumbArch ||
1411       Args.hasFlag(options::OPT_mthumb, options::OPT_mno_thumb, false) ||
1412       (IsArmArch && llvm::ARM::parseArchISA(Arch) == llvm::ARM::ISAKind::THUMB);
1413   bool IsArmV7Mode = (IsArmArch || IsThumbArch) &&
1414       (llvm::ARM::parseArchVersion(Arch) == 7 ||
1415        (IsArmArch && Arch == "" && IsV7SubArch));
1416   addMultilibFlag(IsArmV7Mode, "march=armv7-a", Flags);
1417   addMultilibFlag(IsThumbMode, "mthumb", Flags);
1418 
1419   if (AndroidArmMultilibs.select(Flags, Result.SelectedMultilib))
1420     Result.Multilibs = AndroidArmMultilibs;
1421 }
1422 
1423 static void findRISCVMultilibs(const Driver &D,
1424                                const llvm::Triple &TargetTriple, StringRef Path,
1425                                const ArgList &Args, DetectedMultilibs &Result) {
1426 
1427   FilterNonExistent NonExistent(Path, "/crtbegin.o", D.getVFS());
1428   Multilib Ilp32 = makeMultilib("lib32/ilp32").flag("+m32").flag("+mabi=ilp32");
1429   Multilib Ilp32f =
1430       makeMultilib("lib32/ilp32f").flag("+m32").flag("+mabi=ilp32f");
1431   Multilib Ilp32d =
1432       makeMultilib("lib32/ilp32d").flag("+m32").flag("+mabi=ilp32d");
1433   Multilib Lp64 = makeMultilib("lib64/lp64").flag("+m64").flag("+mabi=lp64");
1434   Multilib Lp64f = makeMultilib("lib64/lp64f").flag("+m64").flag("+mabi=lp64f");
1435   Multilib Lp64d = makeMultilib("lib64/lp64d").flag("+m64").flag("+mabi=lp64d");
1436   MultilibSet RISCVMultilibs =
1437       MultilibSet()
1438           .Either({Ilp32, Ilp32f, Ilp32d, Lp64, Lp64f, Lp64d})
1439           .FilterOut(NonExistent);
1440 
1441   Multilib::flags_list Flags;
1442   bool IsRV64 = TargetTriple.getArch() == llvm::Triple::riscv64;
1443   StringRef ABIName = tools::riscv::getRISCVABI(Args, TargetTriple);
1444 
1445   addMultilibFlag(!IsRV64, "m32", Flags);
1446   addMultilibFlag(IsRV64, "m64", Flags);
1447   addMultilibFlag(ABIName == "ilp32", "mabi=ilp32", Flags);
1448   addMultilibFlag(ABIName == "ilp32f", "mabi=ilp32f", Flags);
1449   addMultilibFlag(ABIName == "ilp32d", "mabi=ilp32d", Flags);
1450   addMultilibFlag(ABIName == "lp64", "mabi=lp64", Flags);
1451   addMultilibFlag(ABIName == "lp64f", "mabi=lp64f", Flags);
1452   addMultilibFlag(ABIName == "lp64d", "mabi=lp64d", Flags);
1453 
1454   if (RISCVMultilibs.select(Flags, Result.SelectedMultilib))
1455     Result.Multilibs = RISCVMultilibs;
1456 }
1457 
1458 static bool findBiarchMultilibs(const Driver &D,
1459                                 const llvm::Triple &TargetTriple,
1460                                 StringRef Path, const ArgList &Args,
1461                                 bool NeedsBiarchSuffix,
1462                                 DetectedMultilibs &Result) {
1463   Multilib Default;
1464 
1465   // Some versions of SUSE and Fedora on ppc64 put 32-bit libs
1466   // in what would normally be GCCInstallPath and put the 64-bit
1467   // libs in a subdirectory named 64. The simple logic we follow is that
1468   // *if* there is a subdirectory of the right name with crtbegin.o in it,
1469   // we use that. If not, and if not a biarch triple alias, we look for
1470   // crtbegin.o without the subdirectory.
1471 
1472   StringRef Suff64 = "/64";
1473   // Solaris uses platform-specific suffixes instead of /64.
1474   if (TargetTriple.getOS() == llvm::Triple::Solaris) {
1475     switch (TargetTriple.getArch()) {
1476     case llvm::Triple::x86:
1477     case llvm::Triple::x86_64:
1478       Suff64 = "/amd64";
1479       break;
1480     case llvm::Triple::sparc:
1481     case llvm::Triple::sparcv9:
1482       Suff64 = "/sparcv9";
1483       break;
1484     default:
1485       break;
1486     }
1487   }
1488 
1489   Multilib Alt64 = Multilib()
1490                        .gccSuffix(Suff64)
1491                        .includeSuffix(Suff64)
1492                        .flag("-m32")
1493                        .flag("+m64")
1494                        .flag("-mx32");
1495   Multilib Alt32 = Multilib()
1496                        .gccSuffix("/32")
1497                        .includeSuffix("/32")
1498                        .flag("+m32")
1499                        .flag("-m64")
1500                        .flag("-mx32");
1501   Multilib Altx32 = Multilib()
1502                         .gccSuffix("/x32")
1503                         .includeSuffix("/x32")
1504                         .flag("-m32")
1505                         .flag("-m64")
1506                         .flag("+mx32");
1507 
1508   // GCC toolchain for IAMCU doesn't have crtbegin.o, so look for libgcc.a.
1509   FilterNonExistent NonExistent(
1510       Path, TargetTriple.isOSIAMCU() ? "/libgcc.a" : "/crtbegin.o", D.getVFS());
1511 
1512   // Determine default multilib from: 32, 64, x32
1513   // Also handle cases such as 64 on 32, 32 on 64, etc.
1514   enum { UNKNOWN, WANT32, WANT64, WANTX32 } Want = UNKNOWN;
1515   const bool IsX32 = TargetTriple.getEnvironment() == llvm::Triple::GNUX32;
1516   if (TargetTriple.isArch32Bit() && !NonExistent(Alt32))
1517     Want = WANT64;
1518   else if (TargetTriple.isArch64Bit() && IsX32 && !NonExistent(Altx32))
1519     Want = WANT64;
1520   else if (TargetTriple.isArch64Bit() && !IsX32 && !NonExistent(Alt64))
1521     Want = WANT32;
1522   else {
1523     if (TargetTriple.isArch32Bit())
1524       Want = NeedsBiarchSuffix ? WANT64 : WANT32;
1525     else if (IsX32)
1526       Want = NeedsBiarchSuffix ? WANT64 : WANTX32;
1527     else
1528       Want = NeedsBiarchSuffix ? WANT32 : WANT64;
1529   }
1530 
1531   if (Want == WANT32)
1532     Default.flag("+m32").flag("-m64").flag("-mx32");
1533   else if (Want == WANT64)
1534     Default.flag("-m32").flag("+m64").flag("-mx32");
1535   else if (Want == WANTX32)
1536     Default.flag("-m32").flag("-m64").flag("+mx32");
1537   else
1538     return false;
1539 
1540   Result.Multilibs.push_back(Default);
1541   Result.Multilibs.push_back(Alt64);
1542   Result.Multilibs.push_back(Alt32);
1543   Result.Multilibs.push_back(Altx32);
1544 
1545   Result.Multilibs.FilterOut(NonExistent);
1546 
1547   Multilib::flags_list Flags;
1548   addMultilibFlag(TargetTriple.isArch64Bit() && !IsX32, "m64", Flags);
1549   addMultilibFlag(TargetTriple.isArch32Bit(), "m32", Flags);
1550   addMultilibFlag(TargetTriple.isArch64Bit() && IsX32, "mx32", Flags);
1551 
1552   if (!Result.Multilibs.select(Flags, Result.SelectedMultilib))
1553     return false;
1554 
1555   if (Result.SelectedMultilib == Alt64 || Result.SelectedMultilib == Alt32 ||
1556       Result.SelectedMultilib == Altx32)
1557     Result.BiarchSibling = Default;
1558 
1559   return true;
1560 }
1561 
1562 /// Generic_GCC - A tool chain using the 'gcc' command to perform
1563 /// all subcommands; this relies on gcc translating the majority of
1564 /// command line options.
1565 
1566 /// \brief Less-than for GCCVersion, implementing a Strict Weak Ordering.
1567 bool Generic_GCC::GCCVersion::isOlderThan(int RHSMajor, int RHSMinor,
1568                                           int RHSPatch,
1569                                           StringRef RHSPatchSuffix) const {
1570   if (Major != RHSMajor)
1571     return Major < RHSMajor;
1572   if (Minor != RHSMinor)
1573     return Minor < RHSMinor;
1574   if (Patch != RHSPatch) {
1575     // Note that versions without a specified patch sort higher than those with
1576     // a patch.
1577     if (RHSPatch == -1)
1578       return true;
1579     if (Patch == -1)
1580       return false;
1581 
1582     // Otherwise just sort on the patch itself.
1583     return Patch < RHSPatch;
1584   }
1585   if (PatchSuffix != RHSPatchSuffix) {
1586     // Sort empty suffixes higher.
1587     if (RHSPatchSuffix.empty())
1588       return true;
1589     if (PatchSuffix.empty())
1590       return false;
1591 
1592     // Provide a lexicographic sort to make this a total ordering.
1593     return PatchSuffix < RHSPatchSuffix;
1594   }
1595 
1596   // The versions are equal.
1597   return false;
1598 }
1599 
1600 /// \brief Parse a GCCVersion object out of a string of text.
1601 ///
1602 /// This is the primary means of forming GCCVersion objects.
1603 /*static*/
1604 Generic_GCC::GCCVersion Generic_GCC::GCCVersion::Parse(StringRef VersionText) {
1605   const GCCVersion BadVersion = {VersionText.str(), -1, -1, -1, "", "", ""};
1606   std::pair<StringRef, StringRef> First = VersionText.split('.');
1607   std::pair<StringRef, StringRef> Second = First.second.split('.');
1608 
1609   GCCVersion GoodVersion = {VersionText.str(), -1, -1, -1, "", "", ""};
1610   if (First.first.getAsInteger(10, GoodVersion.Major) || GoodVersion.Major < 0)
1611     return BadVersion;
1612   GoodVersion.MajorStr = First.first.str();
1613   if (First.second.empty())
1614     return GoodVersion;
1615   if (Second.first.getAsInteger(10, GoodVersion.Minor) || GoodVersion.Minor < 0)
1616     return BadVersion;
1617   GoodVersion.MinorStr = Second.first.str();
1618 
1619   // First look for a number prefix and parse that if present. Otherwise just
1620   // stash the entire patch string in the suffix, and leave the number
1621   // unspecified. This covers versions strings such as:
1622   //   5        (handled above)
1623   //   4.4
1624   //   4.4.0
1625   //   4.4.x
1626   //   4.4.2-rc4
1627   //   4.4.x-patched
1628   // And retains any patch number it finds.
1629   StringRef PatchText = GoodVersion.PatchSuffix = Second.second.str();
1630   if (!PatchText.empty()) {
1631     if (size_t EndNumber = PatchText.find_first_not_of("0123456789")) {
1632       // Try to parse the number and any suffix.
1633       if (PatchText.slice(0, EndNumber).getAsInteger(10, GoodVersion.Patch) ||
1634           GoodVersion.Patch < 0)
1635         return BadVersion;
1636       GoodVersion.PatchSuffix = PatchText.substr(EndNumber);
1637     }
1638   }
1639 
1640   return GoodVersion;
1641 }
1642 
1643 static llvm::StringRef getGCCToolchainDir(const ArgList &Args) {
1644   const Arg *A = Args.getLastArg(clang::driver::options::OPT_gcc_toolchain);
1645   if (A)
1646     return A->getValue();
1647   return GCC_INSTALL_PREFIX;
1648 }
1649 
1650 /// \brief Initialize a GCCInstallationDetector from the driver.
1651 ///
1652 /// This performs all of the autodetection and sets up the various paths.
1653 /// Once constructed, a GCCInstallationDetector is essentially immutable.
1654 ///
1655 /// FIXME: We shouldn't need an explicit TargetTriple parameter here, and
1656 /// should instead pull the target out of the driver. This is currently
1657 /// necessary because the driver doesn't store the final version of the target
1658 /// triple.
1659 void Generic_GCC::GCCInstallationDetector::init(
1660     const llvm::Triple &TargetTriple, const ArgList &Args,
1661     ArrayRef<std::string> ExtraTripleAliases) {
1662   llvm::Triple BiarchVariantTriple = TargetTriple.isArch32Bit()
1663                                          ? TargetTriple.get64BitArchVariant()
1664                                          : TargetTriple.get32BitArchVariant();
1665   // The library directories which may contain GCC installations.
1666   SmallVector<StringRef, 4> CandidateLibDirs, CandidateBiarchLibDirs;
1667   // The compatible GCC triples for this particular architecture.
1668   SmallVector<StringRef, 16> CandidateTripleAliases;
1669   SmallVector<StringRef, 16> CandidateBiarchTripleAliases;
1670   CollectLibDirsAndTriples(TargetTriple, BiarchVariantTriple, CandidateLibDirs,
1671                            CandidateTripleAliases, CandidateBiarchLibDirs,
1672                            CandidateBiarchTripleAliases);
1673 
1674   // Compute the set of prefixes for our search.
1675   SmallVector<std::string, 8> Prefixes(D.PrefixDirs.begin(),
1676                                        D.PrefixDirs.end());
1677 
1678   StringRef GCCToolchainDir = getGCCToolchainDir(Args);
1679   if (GCCToolchainDir != "") {
1680     if (GCCToolchainDir.back() == '/')
1681       GCCToolchainDir = GCCToolchainDir.drop_back(); // remove the /
1682 
1683     Prefixes.push_back(GCCToolchainDir);
1684   } else {
1685     // If we have a SysRoot, try that first.
1686     if (!D.SysRoot.empty()) {
1687       Prefixes.push_back(D.SysRoot);
1688       AddDefaultGCCPrefixes(TargetTriple, Prefixes, D.SysRoot);
1689     }
1690 
1691     // Then look for gcc installed alongside clang.
1692     Prefixes.push_back(D.InstalledDir + "/..");
1693 
1694     // Next, look for prefix(es) that correspond to distribution-supplied gcc
1695     // installations.
1696     if (D.SysRoot.empty()) {
1697       // Typically /usr.
1698       AddDefaultGCCPrefixes(TargetTriple, Prefixes, D.SysRoot);
1699     }
1700   }
1701 
1702   // Try to respect gcc-config on Gentoo. However, do that only
1703   // if --gcc-toolchain is not provided or equal to the Gentoo install
1704   // in /usr. This avoids accidentally enforcing the system GCC version
1705   // when using a custom toolchain.
1706   if (GCCToolchainDir == "" || GCCToolchainDir == D.SysRoot + "/usr") {
1707     for (StringRef CandidateTriple : ExtraTripleAliases) {
1708       if (ScanGentooGccConfig(TargetTriple, Args, CandidateTriple))
1709         return;
1710     }
1711     for (StringRef CandidateTriple : CandidateTripleAliases) {
1712       if (ScanGentooGccConfig(TargetTriple, Args, CandidateTriple))
1713         return;
1714     }
1715     for (StringRef CandidateTriple : CandidateBiarchTripleAliases) {
1716       if (ScanGentooGccConfig(TargetTriple, Args, CandidateTriple, true))
1717         return;
1718     }
1719   }
1720 
1721   // Loop over the various components which exist and select the best GCC
1722   // installation available. GCC installs are ranked by version number.
1723   Version = GCCVersion::Parse("0.0.0");
1724   for (const std::string &Prefix : Prefixes) {
1725     if (!D.getVFS().exists(Prefix))
1726       continue;
1727     for (StringRef Suffix : CandidateLibDirs) {
1728       const std::string LibDir = Prefix + Suffix.str();
1729       if (!D.getVFS().exists(LibDir))
1730         continue;
1731       for (StringRef Candidate : ExtraTripleAliases) // Try these first.
1732         ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate);
1733       for (StringRef Candidate : CandidateTripleAliases)
1734         ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate);
1735     }
1736     for (StringRef Suffix : CandidateBiarchLibDirs) {
1737       const std::string LibDir = Prefix + Suffix.str();
1738       if (!D.getVFS().exists(LibDir))
1739         continue;
1740       for (StringRef Candidate : CandidateBiarchTripleAliases)
1741         ScanLibDirForGCCTriple(TargetTriple, Args, LibDir, Candidate,
1742                                /*NeedsBiarchSuffix=*/ true);
1743     }
1744   }
1745 }
1746 
1747 void Generic_GCC::GCCInstallationDetector::print(raw_ostream &OS) const {
1748   for (const auto &InstallPath : CandidateGCCInstallPaths)
1749     OS << "Found candidate GCC installation: " << InstallPath << "\n";
1750 
1751   if (!GCCInstallPath.empty())
1752     OS << "Selected GCC installation: " << GCCInstallPath << "\n";
1753 
1754   for (const auto &Multilib : Multilibs)
1755     OS << "Candidate multilib: " << Multilib << "\n";
1756 
1757   if (Multilibs.size() != 0 || !SelectedMultilib.isDefault())
1758     OS << "Selected multilib: " << SelectedMultilib << "\n";
1759 }
1760 
1761 bool Generic_GCC::GCCInstallationDetector::getBiarchSibling(Multilib &M) const {
1762   if (BiarchSibling.hasValue()) {
1763     M = BiarchSibling.getValue();
1764     return true;
1765   }
1766   return false;
1767 }
1768 
1769 void Generic_GCC::GCCInstallationDetector::AddDefaultGCCPrefixes(
1770     const llvm::Triple &TargetTriple, SmallVectorImpl<std::string> &Prefixes,
1771     StringRef SysRoot) {
1772   if (TargetTriple.getOS() == llvm::Triple::Solaris) {
1773     // Solaris is a special case.
1774     // The GCC installation is under
1775     //   /usr/gcc/<major>.<minor>/lib/gcc/<triple>/<major>.<minor>.<patch>/
1776     // so we need to find those /usr/gcc/*/lib/gcc libdirs and go with
1777     // /usr/gcc/<version> as a prefix.
1778 
1779     std::string PrefixDir = SysRoot.str() + "/usr/gcc";
1780     std::error_code EC;
1781     for (vfs::directory_iterator LI = D.getVFS().dir_begin(PrefixDir, EC), LE;
1782          !EC && LI != LE; LI = LI.increment(EC)) {
1783       StringRef VersionText = llvm::sys::path::filename(LI->getName());
1784       GCCVersion CandidateVersion = GCCVersion::Parse(VersionText);
1785 
1786       // Filter out obviously bad entries.
1787       if (CandidateVersion.Major == -1 || CandidateVersion.isOlderThan(4, 1, 1))
1788         continue;
1789 
1790       std::string CandidatePrefix = PrefixDir + "/" + VersionText.str();
1791       std::string CandidateLibPath = CandidatePrefix + "/lib/gcc";
1792       if (!D.getVFS().exists(CandidateLibPath))
1793         continue;
1794 
1795       Prefixes.push_back(CandidatePrefix);
1796     }
1797     return;
1798   }
1799 
1800   // Non-Solaris is much simpler - most systems just go with "/usr".
1801   if (SysRoot.empty() && TargetTriple.getOS() == llvm::Triple::Linux) {
1802     // Yet, still look for RHEL devtoolsets.
1803     Prefixes.push_back("/opt/rh/devtoolset-6/root/usr");
1804     Prefixes.push_back("/opt/rh/devtoolset-4/root/usr");
1805     Prefixes.push_back("/opt/rh/devtoolset-3/root/usr");
1806     Prefixes.push_back("/opt/rh/devtoolset-2/root/usr");
1807   }
1808   Prefixes.push_back(SysRoot.str() + "/usr");
1809 }
1810 
1811 /*static*/ void Generic_GCC::GCCInstallationDetector::CollectLibDirsAndTriples(
1812     const llvm::Triple &TargetTriple, const llvm::Triple &BiarchTriple,
1813     SmallVectorImpl<StringRef> &LibDirs,
1814     SmallVectorImpl<StringRef> &TripleAliases,
1815     SmallVectorImpl<StringRef> &BiarchLibDirs,
1816     SmallVectorImpl<StringRef> &BiarchTripleAliases) {
1817   // Declare a bunch of static data sets that we'll select between below. These
1818   // are specifically designed to always refer to string literals to avoid any
1819   // lifetime or initialization issues.
1820   static const char *const AArch64LibDirs[] = {"/lib64", "/lib"};
1821   static const char *const AArch64Triples[] = {
1822       "aarch64-none-linux-gnu", "aarch64-linux-gnu", "aarch64-linux-android",
1823       "aarch64-redhat-linux", "aarch64-suse-linux"};
1824   static const char *const AArch64beLibDirs[] = {"/lib"};
1825   static const char *const AArch64beTriples[] = {"aarch64_be-none-linux-gnu",
1826                                                  "aarch64_be-linux-gnu"};
1827 
1828   static const char *const ARMLibDirs[] = {"/lib"};
1829   static const char *const ARMTriples[] = {"arm-linux-gnueabi",
1830                                            "arm-linux-androideabi"};
1831   static const char *const ARMHFTriples[] = {"arm-linux-gnueabihf",
1832                                              "armv7hl-redhat-linux-gnueabi",
1833                                              "armv6hl-suse-linux-gnueabi",
1834                                              "armv7hl-suse-linux-gnueabi"};
1835   static const char *const ARMebLibDirs[] = {"/lib"};
1836   static const char *const ARMebTriples[] = {"armeb-linux-gnueabi",
1837                                              "armeb-linux-androideabi"};
1838   static const char *const ARMebHFTriples[] = {
1839       "armeb-linux-gnueabihf", "armebv7hl-redhat-linux-gnueabi"};
1840 
1841   static const char *const X86_64LibDirs[] = {"/lib64", "/lib"};
1842   static const char *const X86_64Triples[] = {
1843       "x86_64-linux-gnu",       "x86_64-unknown-linux-gnu",
1844       "x86_64-pc-linux-gnu",    "x86_64-redhat-linux6E",
1845       "x86_64-redhat-linux",    "x86_64-suse-linux",
1846       "x86_64-manbo-linux-gnu", "x86_64-linux-gnu",
1847       "x86_64-slackware-linux", "x86_64-linux-android",
1848       "x86_64-unknown-linux"};
1849   static const char *const X32LibDirs[] = {"/libx32"};
1850   static const char *const X86LibDirs[] = {"/lib32", "/lib"};
1851   static const char *const X86Triples[] = {
1852       "i686-linux-gnu",       "i686-pc-linux-gnu",     "i486-linux-gnu",
1853       "i386-linux-gnu",       "i386-redhat-linux6E",   "i686-redhat-linux",
1854       "i586-redhat-linux",    "i386-redhat-linux",     "i586-suse-linux",
1855       "i486-slackware-linux", "i686-montavista-linux", "i686-linux-android",
1856       "i586-linux-gnu"};
1857 
1858   static const char *const MIPSLibDirs[] = {"/lib"};
1859   static const char *const MIPSTriples[] = {"mips-linux-gnu", "mips-mti-linux",
1860                                             "mips-mti-linux-gnu",
1861                                             "mips-img-linux-gnu"};
1862   static const char *const MIPSELLibDirs[] = {"/lib"};
1863   static const char *const MIPSELTriples[] = {"mipsel-linux-gnu",
1864                                               "mips-img-linux-gnu"};
1865 
1866   static const char *const MIPS64LibDirs[] = {"/lib64", "/lib"};
1867   static const char *const MIPS64Triples[] = {
1868       "mips64-linux-gnu", "mips-mti-linux-gnu", "mips-img-linux-gnu",
1869       "mips64-linux-gnuabi64"};
1870   static const char *const MIPS64ELLibDirs[] = {"/lib64", "/lib"};
1871   static const char *const MIPS64ELTriples[] = {
1872       "mips64el-linux-gnu", "mips-mti-linux-gnu", "mips-img-linux-gnu",
1873       "mips64el-linux-gnuabi64"};
1874 
1875   static const char *const MIPSELAndroidLibDirs[] = {"/lib", "/libr2",
1876                                                      "/libr6"};
1877   static const char *const MIPSELAndroidTriples[] = {"mipsel-linux-android"};
1878   static const char *const MIPS64ELAndroidLibDirs[] = {"/lib64", "/lib",
1879                                                        "/libr2", "/libr6"};
1880   static const char *const MIPS64ELAndroidTriples[] = {
1881       "mips64el-linux-android"};
1882 
1883   static const char *const PPCLibDirs[] = {"/lib32", "/lib"};
1884   static const char *const PPCTriples[] = {
1885       "powerpc-linux-gnu", "powerpc-unknown-linux-gnu", "powerpc-linux-gnuspe",
1886       "powerpc-suse-linux", "powerpc-montavista-linuxspe"};
1887   static const char *const PPC64LibDirs[] = {"/lib64", "/lib"};
1888   static const char *const PPC64Triples[] = {
1889       "powerpc64-linux-gnu", "powerpc64-unknown-linux-gnu",
1890       "powerpc64-suse-linux", "ppc64-redhat-linux"};
1891   static const char *const PPC64LELibDirs[] = {"/lib64", "/lib"};
1892   static const char *const PPC64LETriples[] = {
1893       "powerpc64le-linux-gnu", "powerpc64le-unknown-linux-gnu",
1894       "powerpc64le-suse-linux", "ppc64le-redhat-linux"};
1895 
1896   static const char *const RISCV32LibDirs[] = {"/lib", "/lib32"};
1897   static const char *const RISCVTriples[] = {"riscv32-unknown-linux-gnu",
1898                                              "riscv64-unknown-linux-gnu"};
1899 
1900   static const char *const SPARCv8LibDirs[] = {"/lib32", "/lib"};
1901   static const char *const SPARCv8Triples[] = {"sparc-linux-gnu",
1902                                                "sparcv8-linux-gnu"};
1903   static const char *const SPARCv9LibDirs[] = {"/lib64", "/lib"};
1904   static const char *const SPARCv9Triples[] = {"sparc64-linux-gnu",
1905                                                "sparcv9-linux-gnu"};
1906 
1907   static const char *const SystemZLibDirs[] = {"/lib64", "/lib"};
1908   static const char *const SystemZTriples[] = {
1909       "s390x-linux-gnu", "s390x-unknown-linux-gnu", "s390x-ibm-linux-gnu",
1910       "s390x-suse-linux", "s390x-redhat-linux"};
1911 
1912 
1913   using std::begin;
1914   using std::end;
1915 
1916   if (TargetTriple.getOS() == llvm::Triple::Solaris) {
1917     static const char *const SolarisLibDirs[] = {"/lib"};
1918     static const char *const SolarisSparcV8Triples[] = {
1919         "sparc-sun-solaris2.11", "sparc-sun-solaris2.12"};
1920     static const char *const SolarisSparcV9Triples[] = {
1921         "sparcv9-sun-solaris2.11", "sparcv9-sun-solaris2.12"};
1922     static const char *const SolarisX86Triples[] = {"i386-pc-solaris2.11",
1923                                                     "i386-pc-solaris2.12"};
1924     static const char *const SolarisX86_64Triples[] = {"x86_64-pc-solaris2.11",
1925                                                        "x86_64-pc-solaris2.12"};
1926     LibDirs.append(begin(SolarisLibDirs), end(SolarisLibDirs));
1927     BiarchLibDirs.append(begin(SolarisLibDirs), end(SolarisLibDirs));
1928     switch (TargetTriple.getArch()) {
1929     case llvm::Triple::x86:
1930       TripleAliases.append(begin(SolarisX86Triples), end(SolarisX86Triples));
1931       BiarchTripleAliases.append(begin(SolarisX86_64Triples),
1932                                  end(SolarisX86_64Triples));
1933       break;
1934     case llvm::Triple::x86_64:
1935       TripleAliases.append(begin(SolarisX86_64Triples),
1936                            end(SolarisX86_64Triples));
1937       BiarchTripleAliases.append(begin(SolarisX86Triples),
1938                                  end(SolarisX86Triples));
1939       break;
1940     case llvm::Triple::sparc:
1941       TripleAliases.append(begin(SolarisSparcV8Triples),
1942                            end(SolarisSparcV8Triples));
1943       BiarchTripleAliases.append(begin(SolarisSparcV9Triples),
1944                                  end(SolarisSparcV9Triples));
1945       break;
1946     case llvm::Triple::sparcv9:
1947       TripleAliases.append(begin(SolarisSparcV9Triples),
1948                            end(SolarisSparcV9Triples));
1949       BiarchTripleAliases.append(begin(SolarisSparcV8Triples),
1950                                  end(SolarisSparcV8Triples));
1951       break;
1952     default:
1953       break;
1954     }
1955     return;
1956   }
1957 
1958   switch (TargetTriple.getArch()) {
1959   case llvm::Triple::aarch64:
1960     LibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs));
1961     TripleAliases.append(begin(AArch64Triples), end(AArch64Triples));
1962     BiarchLibDirs.append(begin(AArch64LibDirs), end(AArch64LibDirs));
1963     BiarchTripleAliases.append(begin(AArch64Triples), end(AArch64Triples));
1964     break;
1965   case llvm::Triple::aarch64_be:
1966     LibDirs.append(begin(AArch64beLibDirs), end(AArch64beLibDirs));
1967     TripleAliases.append(begin(AArch64beTriples), end(AArch64beTriples));
1968     BiarchLibDirs.append(begin(AArch64beLibDirs), end(AArch64beLibDirs));
1969     BiarchTripleAliases.append(begin(AArch64beTriples), end(AArch64beTriples));
1970     break;
1971   case llvm::Triple::arm:
1972   case llvm::Triple::thumb:
1973     LibDirs.append(begin(ARMLibDirs), end(ARMLibDirs));
1974     if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) {
1975       TripleAliases.append(begin(ARMHFTriples), end(ARMHFTriples));
1976     } else {
1977       TripleAliases.append(begin(ARMTriples), end(ARMTriples));
1978     }
1979     break;
1980   case llvm::Triple::armeb:
1981   case llvm::Triple::thumbeb:
1982     LibDirs.append(begin(ARMebLibDirs), end(ARMebLibDirs));
1983     if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) {
1984       TripleAliases.append(begin(ARMebHFTriples), end(ARMebHFTriples));
1985     } else {
1986       TripleAliases.append(begin(ARMebTriples), end(ARMebTriples));
1987     }
1988     break;
1989   case llvm::Triple::x86_64:
1990     LibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
1991     TripleAliases.append(begin(X86_64Triples), end(X86_64Triples));
1992     // x32 is always available when x86_64 is available, so adding it as
1993     // secondary arch with x86_64 triples
1994     if (TargetTriple.getEnvironment() == llvm::Triple::GNUX32) {
1995       BiarchLibDirs.append(begin(X32LibDirs), end(X32LibDirs));
1996       BiarchTripleAliases.append(begin(X86_64Triples), end(X86_64Triples));
1997     } else {
1998       BiarchLibDirs.append(begin(X86LibDirs), end(X86LibDirs));
1999       BiarchTripleAliases.append(begin(X86Triples), end(X86Triples));
2000     }
2001     break;
2002   case llvm::Triple::x86:
2003     LibDirs.append(begin(X86LibDirs), end(X86LibDirs));
2004     // MCU toolchain is 32 bit only and its triple alias is TargetTriple
2005     // itself, which will be appended below.
2006     if (!TargetTriple.isOSIAMCU()) {
2007       TripleAliases.append(begin(X86Triples), end(X86Triples));
2008       BiarchLibDirs.append(begin(X86_64LibDirs), end(X86_64LibDirs));
2009       BiarchTripleAliases.append(begin(X86_64Triples), end(X86_64Triples));
2010     }
2011     break;
2012   case llvm::Triple::mips:
2013     LibDirs.append(begin(MIPSLibDirs), end(MIPSLibDirs));
2014     TripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
2015     BiarchLibDirs.append(begin(MIPS64LibDirs), end(MIPS64LibDirs));
2016     BiarchTripleAliases.append(begin(MIPS64Triples), end(MIPS64Triples));
2017     break;
2018   case llvm::Triple::mipsel:
2019     if (TargetTriple.isAndroid()) {
2020       LibDirs.append(begin(MIPSELAndroidLibDirs), end(MIPSELAndroidLibDirs));
2021       TripleAliases.append(begin(MIPSELAndroidTriples),
2022                            end(MIPSELAndroidTriples));
2023       BiarchLibDirs.append(begin(MIPS64ELAndroidLibDirs),
2024                            end(MIPS64ELAndroidLibDirs));
2025       BiarchTripleAliases.append(begin(MIPS64ELAndroidTriples),
2026                                  end(MIPS64ELAndroidTriples));
2027 
2028     } else {
2029       LibDirs.append(begin(MIPSELLibDirs), end(MIPSELLibDirs));
2030       TripleAliases.append(begin(MIPSELTriples), end(MIPSELTriples));
2031       TripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
2032       BiarchLibDirs.append(begin(MIPS64ELLibDirs), end(MIPS64ELLibDirs));
2033       BiarchTripleAliases.append(begin(MIPS64ELTriples), end(MIPS64ELTriples));
2034     }
2035     break;
2036   case llvm::Triple::mips64:
2037     LibDirs.append(begin(MIPS64LibDirs), end(MIPS64LibDirs));
2038     TripleAliases.append(begin(MIPS64Triples), end(MIPS64Triples));
2039     BiarchLibDirs.append(begin(MIPSLibDirs), end(MIPSLibDirs));
2040     BiarchTripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
2041     break;
2042   case llvm::Triple::mips64el:
2043     if (TargetTriple.isAndroid()) {
2044       LibDirs.append(begin(MIPS64ELAndroidLibDirs),
2045                      end(MIPS64ELAndroidLibDirs));
2046       TripleAliases.append(begin(MIPS64ELAndroidTriples),
2047                            end(MIPS64ELAndroidTriples));
2048       BiarchLibDirs.append(begin(MIPSELAndroidLibDirs),
2049                            end(MIPSELAndroidLibDirs));
2050       BiarchTripleAliases.append(begin(MIPSELAndroidTriples),
2051                                  end(MIPSELAndroidTriples));
2052 
2053     } else {
2054       LibDirs.append(begin(MIPS64ELLibDirs), end(MIPS64ELLibDirs));
2055       TripleAliases.append(begin(MIPS64ELTriples), end(MIPS64ELTriples));
2056       BiarchLibDirs.append(begin(MIPSELLibDirs), end(MIPSELLibDirs));
2057       BiarchTripleAliases.append(begin(MIPSELTriples), end(MIPSELTriples));
2058       BiarchTripleAliases.append(begin(MIPSTriples), end(MIPSTriples));
2059     }
2060     break;
2061   case llvm::Triple::ppc:
2062     LibDirs.append(begin(PPCLibDirs), end(PPCLibDirs));
2063     TripleAliases.append(begin(PPCTriples), end(PPCTriples));
2064     BiarchLibDirs.append(begin(PPC64LibDirs), end(PPC64LibDirs));
2065     BiarchTripleAliases.append(begin(PPC64Triples), end(PPC64Triples));
2066     break;
2067   case llvm::Triple::ppc64:
2068     LibDirs.append(begin(PPC64LibDirs), end(PPC64LibDirs));
2069     TripleAliases.append(begin(PPC64Triples), end(PPC64Triples));
2070     BiarchLibDirs.append(begin(PPCLibDirs), end(PPCLibDirs));
2071     BiarchTripleAliases.append(begin(PPCTriples), end(PPCTriples));
2072     break;
2073   case llvm::Triple::ppc64le:
2074     LibDirs.append(begin(PPC64LELibDirs), end(PPC64LELibDirs));
2075     TripleAliases.append(begin(PPC64LETriples), end(PPC64LETriples));
2076     break;
2077   case llvm::Triple::riscv32:
2078     LibDirs.append(begin(RISCV32LibDirs), end(RISCV32LibDirs));
2079     BiarchLibDirs.append(begin(RISCV32LibDirs), end(RISCV32LibDirs));
2080     TripleAliases.append(begin(RISCVTriples), end(RISCVTriples));
2081     BiarchTripleAliases.append(begin(RISCVTriples), end(RISCVTriples));
2082     break;
2083   case llvm::Triple::sparc:
2084   case llvm::Triple::sparcel:
2085     LibDirs.append(begin(SPARCv8LibDirs), end(SPARCv8LibDirs));
2086     TripleAliases.append(begin(SPARCv8Triples), end(SPARCv8Triples));
2087     BiarchLibDirs.append(begin(SPARCv9LibDirs), end(SPARCv9LibDirs));
2088     BiarchTripleAliases.append(begin(SPARCv9Triples), end(SPARCv9Triples));
2089     break;
2090   case llvm::Triple::sparcv9:
2091     LibDirs.append(begin(SPARCv9LibDirs), end(SPARCv9LibDirs));
2092     TripleAliases.append(begin(SPARCv9Triples), end(SPARCv9Triples));
2093     BiarchLibDirs.append(begin(SPARCv8LibDirs), end(SPARCv8LibDirs));
2094     BiarchTripleAliases.append(begin(SPARCv8Triples), end(SPARCv8Triples));
2095     break;
2096   case llvm::Triple::systemz:
2097     LibDirs.append(begin(SystemZLibDirs), end(SystemZLibDirs));
2098     TripleAliases.append(begin(SystemZTriples), end(SystemZTriples));
2099     break;
2100   default:
2101     // By default, just rely on the standard lib directories and the original
2102     // triple.
2103     break;
2104   }
2105 
2106   // Always append the drivers target triple to the end, in case it doesn't
2107   // match any of our aliases.
2108   TripleAliases.push_back(TargetTriple.str());
2109 
2110   // Also include the multiarch variant if it's different.
2111   if (TargetTriple.str() != BiarchTriple.str())
2112     BiarchTripleAliases.push_back(BiarchTriple.str());
2113 }
2114 
2115 bool Generic_GCC::GCCInstallationDetector::ScanGCCForMultilibs(
2116     const llvm::Triple &TargetTriple, const ArgList &Args,
2117     StringRef Path, bool NeedsBiarchSuffix) {
2118   llvm::Triple::ArchType TargetArch = TargetTriple.getArch();
2119   DetectedMultilibs Detected;
2120 
2121   // Android standalone toolchain could have multilibs for ARM and Thumb.
2122   // Debian mips multilibs behave more like the rest of the biarch ones,
2123   // so handle them there
2124   if (isArmOrThumbArch(TargetArch) && TargetTriple.isAndroid()) {
2125     // It should also work without multilibs in a simplified toolchain.
2126     findAndroidArmMultilibs(D, TargetTriple, Path, Args, Detected);
2127   } else if (tools::isMipsArch(TargetArch)) {
2128     if (!findMIPSMultilibs(D, TargetTriple, Path, Args, Detected))
2129       return false;
2130   } else if (isRISCV(TargetArch)) {
2131     findRISCVMultilibs(D, TargetTriple, Path, Args, Detected);
2132   } else if (!findBiarchMultilibs(D, TargetTriple, Path, Args,
2133                                   NeedsBiarchSuffix, Detected)) {
2134     return false;
2135   }
2136 
2137   Multilibs = Detected.Multilibs;
2138   SelectedMultilib = Detected.SelectedMultilib;
2139   BiarchSibling = Detected.BiarchSibling;
2140 
2141   return true;
2142 }
2143 
2144 void Generic_GCC::GCCInstallationDetector::ScanLibDirForGCCTriple(
2145     const llvm::Triple &TargetTriple, const ArgList &Args,
2146     const std::string &LibDir, StringRef CandidateTriple,
2147     bool NeedsBiarchSuffix) {
2148   llvm::Triple::ArchType TargetArch = TargetTriple.getArch();
2149   // Locations relative to the system lib directory where GCC's triple-specific
2150   // directories might reside.
2151   struct GCCLibSuffix {
2152     // Path from system lib directory to GCC triple-specific directory.
2153     std::string LibSuffix;
2154     // Path from GCC triple-specific directory back to system lib directory.
2155     // This is one '..' component per component in LibSuffix.
2156     StringRef ReversePath;
2157     // Whether this library suffix is relevant for the triple.
2158     bool Active;
2159   } Suffixes[] = {
2160       // This is the normal place.
2161       {"gcc/" + CandidateTriple.str(), "../..", true},
2162 
2163       // Debian puts cross-compilers in gcc-cross.
2164       {"gcc-cross/" + CandidateTriple.str(), "../..",
2165        TargetTriple.getOS() != llvm::Triple::Solaris},
2166 
2167       // The Freescale PPC SDK has the gcc libraries in
2168       // <sysroot>/usr/lib/<triple>/x.y.z so have a look there as well. Only do
2169       // this on Freescale triples, though, since some systems put a *lot* of
2170       // files in that location, not just GCC installation data.
2171       {CandidateTriple.str(), "..",
2172        TargetTriple.getVendor() == llvm::Triple::Freescale},
2173 
2174       // Natively multiarch systems sometimes put the GCC triple-specific
2175       // directory within their multiarch lib directory, resulting in the
2176       // triple appearing twice.
2177       {CandidateTriple.str() + "/gcc/" + CandidateTriple.str(), "../../..",
2178        TargetTriple.getOS() != llvm::Triple::Solaris},
2179 
2180       // Deal with cases (on Ubuntu) where the system architecture could be i386
2181       // but the GCC target architecture could be (say) i686.
2182       // FIXME: It may be worthwhile to generalize this and look for a second
2183       // triple.
2184       {"i386-linux-gnu/gcc/" + CandidateTriple.str(), "../../..",
2185        (TargetArch == llvm::Triple::x86 &&
2186         TargetTriple.getOS() != llvm::Triple::Solaris)}};
2187 
2188   for (auto &Suffix : Suffixes) {
2189     if (!Suffix.Active)
2190       continue;
2191 
2192     StringRef LibSuffix = Suffix.LibSuffix;
2193     std::error_code EC;
2194     for (vfs::directory_iterator
2195              LI = D.getVFS().dir_begin(LibDir + "/" + LibSuffix, EC),
2196              LE;
2197          !EC && LI != LE; LI = LI.increment(EC)) {
2198       StringRef VersionText = llvm::sys::path::filename(LI->getName());
2199       GCCVersion CandidateVersion = GCCVersion::Parse(VersionText);
2200       if (CandidateVersion.Major != -1) // Filter obviously bad entries.
2201         if (!CandidateGCCInstallPaths.insert(LI->getName()).second)
2202           continue; // Saw this path before; no need to look at it again.
2203       if (CandidateVersion.isOlderThan(4, 1, 1))
2204         continue;
2205       if (CandidateVersion <= Version)
2206         continue;
2207 
2208       if (!ScanGCCForMultilibs(TargetTriple, Args, LI->getName(),
2209                                NeedsBiarchSuffix))
2210         continue;
2211 
2212       Version = CandidateVersion;
2213       GCCTriple.setTriple(CandidateTriple);
2214       // FIXME: We hack together the directory name here instead of
2215       // using LI to ensure stable path separators across Windows and
2216       // Linux.
2217       GCCInstallPath = (LibDir + "/" + LibSuffix + "/" + VersionText).str();
2218       GCCParentLibPath = (GCCInstallPath + "/../" + Suffix.ReversePath).str();
2219       IsValid = true;
2220     }
2221   }
2222 }
2223 
2224 bool Generic_GCC::GCCInstallationDetector::ScanGentooGccConfig(
2225     const llvm::Triple &TargetTriple, const ArgList &Args,
2226     StringRef CandidateTriple, bool NeedsBiarchSuffix) {
2227   llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> File =
2228       D.getVFS().getBufferForFile(D.SysRoot + "/etc/env.d/gcc/config-" +
2229                                   CandidateTriple.str());
2230   if (File) {
2231     SmallVector<StringRef, 2> Lines;
2232     File.get()->getBuffer().split(Lines, "\n");
2233     for (StringRef Line : Lines) {
2234       Line = Line.trim();
2235       // CURRENT=triple-version
2236       if (Line.consume_front("CURRENT=")) {
2237         const std::pair<StringRef, StringRef> ActiveVersion =
2238           Line.rsplit('-');
2239         // Note: Strictly speaking, we should be reading
2240         // /etc/env.d/gcc/${CURRENT} now. However, the file doesn't
2241         // contain anything new or especially useful to us.
2242         const std::string GentooPath = D.SysRoot + "/usr/lib/gcc/" +
2243                                        ActiveVersion.first.str() + "/" +
2244                                        ActiveVersion.second.str();
2245         if (D.getVFS().exists(GentooPath + "/crtbegin.o")) {
2246           if (!ScanGCCForMultilibs(TargetTriple, Args, GentooPath,
2247                                    NeedsBiarchSuffix))
2248             return false;
2249 
2250           Version = GCCVersion::Parse(ActiveVersion.second);
2251           GCCInstallPath = GentooPath;
2252           GCCParentLibPath = GentooPath + "/../../..";
2253           GCCTriple.setTriple(ActiveVersion.first);
2254           IsValid = true;
2255           return true;
2256         }
2257       }
2258     }
2259   }
2260 
2261   return false;
2262 }
2263 
2264 Generic_GCC::Generic_GCC(const Driver &D, const llvm::Triple &Triple,
2265                          const ArgList &Args)
2266     : ToolChain(D, Triple, Args), GCCInstallation(D),
2267       CudaInstallation(D, Triple, Args) {
2268   getProgramPaths().push_back(getDriver().getInstalledDir());
2269   if (getDriver().getInstalledDir() != getDriver().Dir)
2270     getProgramPaths().push_back(getDriver().Dir);
2271 }
2272 
2273 Generic_GCC::~Generic_GCC() {}
2274 
2275 Tool *Generic_GCC::getTool(Action::ActionClass AC) const {
2276   switch (AC) {
2277   case Action::PreprocessJobClass:
2278     if (!Preprocess)
2279       Preprocess.reset(new clang::driver::tools::gcc::Preprocessor(*this));
2280     return Preprocess.get();
2281   case Action::CompileJobClass:
2282     if (!Compile)
2283       Compile.reset(new tools::gcc::Compiler(*this));
2284     return Compile.get();
2285   default:
2286     return ToolChain::getTool(AC);
2287   }
2288 }
2289 
2290 Tool *Generic_GCC::buildAssembler() const {
2291   return new tools::gnutools::Assembler(*this);
2292 }
2293 
2294 Tool *Generic_GCC::buildLinker() const { return new tools::gcc::Linker(*this); }
2295 
2296 void Generic_GCC::printVerboseInfo(raw_ostream &OS) const {
2297   // Print the information about how we detected the GCC installation.
2298   GCCInstallation.print(OS);
2299   CudaInstallation.print(OS);
2300 }
2301 
2302 bool Generic_GCC::IsUnwindTablesDefault(const ArgList &Args) const {
2303   return getArch() == llvm::Triple::x86_64;
2304 }
2305 
2306 bool Generic_GCC::isPICDefault() const {
2307   switch (getArch()) {
2308   case llvm::Triple::x86_64:
2309     return getTriple().isOSWindows();
2310   case llvm::Triple::ppc64:
2311   case llvm::Triple::ppc64le:
2312     return !getTriple().isOSBinFormatMachO() && !getTriple().isMacOSX();
2313   case llvm::Triple::mips64:
2314   case llvm::Triple::mips64el:
2315     return true;
2316   default:
2317     return false;
2318   }
2319 }
2320 
2321 bool Generic_GCC::isPIEDefault() const { return false; }
2322 
2323 bool Generic_GCC::isPICDefaultForced() const {
2324   return getArch() == llvm::Triple::x86_64 && getTriple().isOSWindows();
2325 }
2326 
2327 bool Generic_GCC::IsIntegratedAssemblerDefault() const {
2328   switch (getTriple().getArch()) {
2329   case llvm::Triple::x86:
2330   case llvm::Triple::x86_64:
2331   case llvm::Triple::aarch64:
2332   case llvm::Triple::aarch64_be:
2333   case llvm::Triple::arm:
2334   case llvm::Triple::armeb:
2335   case llvm::Triple::avr:
2336   case llvm::Triple::bpfel:
2337   case llvm::Triple::bpfeb:
2338   case llvm::Triple::thumb:
2339   case llvm::Triple::thumbeb:
2340   case llvm::Triple::ppc:
2341   case llvm::Triple::ppc64:
2342   case llvm::Triple::ppc64le:
2343   case llvm::Triple::riscv32:
2344   case llvm::Triple::riscv64:
2345   case llvm::Triple::systemz:
2346   case llvm::Triple::mips:
2347   case llvm::Triple::mipsel:
2348     return true;
2349   case llvm::Triple::mips64:
2350   case llvm::Triple::mips64el:
2351     // Enabled for Debian and Android mips64/mipsel, as they can precisely
2352     // identify the ABI in use (Debian) or only use N64 for MIPS64 (Android).
2353     // Other targets are unable to distinguish N32 from N64.
2354     if (getTriple().getEnvironment() == llvm::Triple::GNUABI64 ||
2355         getTriple().isAndroid())
2356       return true;
2357     return false;
2358   default:
2359     return false;
2360   }
2361 }
2362 
2363 void Generic_GCC::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
2364                                                ArgStringList &CC1Args) const {
2365   if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
2366       DriverArgs.hasArg(options::OPT_nostdincxx))
2367     return;
2368 
2369   switch (GetCXXStdlibType(DriverArgs)) {
2370   case ToolChain::CST_Libcxx: {
2371     std::string Path = findLibCxxIncludePath();
2372     if (!Path.empty())
2373       addSystemInclude(DriverArgs, CC1Args, Path);
2374     break;
2375   }
2376 
2377   case ToolChain::CST_Libstdcxx:
2378     addLibStdCxxIncludePaths(DriverArgs, CC1Args);
2379     break;
2380   }
2381 }
2382 
2383 std::string Generic_GCC::findLibCxxIncludePath() const {
2384   // FIXME: The Linux behavior would probaby be a better approach here.
2385   return getDriver().SysRoot + "/usr/include/c++/v1";
2386 }
2387 
2388 void
2389 Generic_GCC::addLibStdCxxIncludePaths(const llvm::opt::ArgList &DriverArgs,
2390                                       llvm::opt::ArgStringList &CC1Args) const {
2391   // By default, we don't assume we know where libstdc++ might be installed.
2392   // FIXME: If we have a valid GCCInstallation, use it.
2393 }
2394 
2395 /// \brief Helper to add the variant paths of a libstdc++ installation.
2396 bool Generic_GCC::addLibStdCXXIncludePaths(
2397     Twine Base, Twine Suffix, StringRef GCCTriple, StringRef GCCMultiarchTriple,
2398     StringRef TargetMultiarchTriple, Twine IncludeSuffix,
2399     const ArgList &DriverArgs, ArgStringList &CC1Args) const {
2400   if (!getVFS().exists(Base + Suffix))
2401     return false;
2402 
2403   addSystemInclude(DriverArgs, CC1Args, Base + Suffix);
2404 
2405   // The vanilla GCC layout of libstdc++ headers uses a triple subdirectory. If
2406   // that path exists or we have neither a GCC nor target multiarch triple, use
2407   // this vanilla search path.
2408   if ((GCCMultiarchTriple.empty() && TargetMultiarchTriple.empty()) ||
2409       getVFS().exists(Base + Suffix + "/" + GCCTriple + IncludeSuffix)) {
2410     addSystemInclude(DriverArgs, CC1Args,
2411                      Base + Suffix + "/" + GCCTriple + IncludeSuffix);
2412   } else {
2413     // Otherwise try to use multiarch naming schemes which have normalized the
2414     // triples and put the triple before the suffix.
2415     //
2416     // GCC surprisingly uses *both* the GCC triple with a multilib suffix and
2417     // the target triple, so we support that here.
2418     addSystemInclude(DriverArgs, CC1Args,
2419                      Base + "/" + GCCMultiarchTriple + Suffix + IncludeSuffix);
2420     addSystemInclude(DriverArgs, CC1Args,
2421                      Base + "/" + TargetMultiarchTriple + Suffix);
2422   }
2423 
2424   addSystemInclude(DriverArgs, CC1Args, Base + Suffix + "/backward");
2425   return true;
2426 }
2427 
2428 llvm::opt::DerivedArgList *
2429 Generic_GCC::TranslateArgs(const llvm::opt::DerivedArgList &Args, StringRef,
2430                            Action::OffloadKind DeviceOffloadKind) const {
2431 
2432   // If this tool chain is used for an OpenMP offloading device we have to make
2433   // sure we always generate a shared library regardless of the commands the
2434   // user passed to the host. This is required because the runtime library
2435   // is required to load the device image dynamically at run time.
2436   if (DeviceOffloadKind == Action::OFK_OpenMP) {
2437     DerivedArgList *DAL = new DerivedArgList(Args.getBaseArgs());
2438     const OptTable &Opts = getDriver().getOpts();
2439 
2440     // Request the shared library. Given that these options are decided
2441     // implicitly, they do not refer to any base argument.
2442     DAL->AddFlagArg(/*BaseArg=*/nullptr, Opts.getOption(options::OPT_shared));
2443     DAL->AddFlagArg(/*BaseArg=*/nullptr, Opts.getOption(options::OPT_fPIC));
2444 
2445     // Filter all the arguments we don't care passing to the offloading
2446     // toolchain as they can mess up with the creation of a shared library.
2447     for (auto *A : Args) {
2448       switch ((options::ID)A->getOption().getID()) {
2449       default:
2450         DAL->append(A);
2451         break;
2452       case options::OPT_shared:
2453       case options::OPT_dynamic:
2454       case options::OPT_static:
2455       case options::OPT_fPIC:
2456       case options::OPT_fno_PIC:
2457       case options::OPT_fpic:
2458       case options::OPT_fno_pic:
2459       case options::OPT_fPIE:
2460       case options::OPT_fno_PIE:
2461       case options::OPT_fpie:
2462       case options::OPT_fno_pie:
2463         break;
2464       }
2465     }
2466     return DAL;
2467   }
2468   return nullptr;
2469 }
2470 
2471 void Generic_ELF::anchor() {}
2472 
2473 void Generic_ELF::addClangTargetOptions(const ArgList &DriverArgs,
2474                                         ArgStringList &CC1Args,
2475                                         Action::OffloadKind) const {
2476   const Generic_GCC::GCCVersion &V = GCCInstallation.getVersion();
2477   bool UseInitArrayDefault =
2478       getTriple().getArch() == llvm::Triple::aarch64 ||
2479       getTriple().getArch() == llvm::Triple::aarch64_be ||
2480       (getTriple().getOS() == llvm::Triple::Linux &&
2481        ((!GCCInstallation.isValid() || !V.isOlderThan(4, 7, 0)) ||
2482         getTriple().isAndroid())) ||
2483       getTriple().getOS() == llvm::Triple::NaCl ||
2484       (getTriple().getVendor() == llvm::Triple::MipsTechnologies &&
2485        !getTriple().hasEnvironment()) ||
2486       getTriple().getOS() == llvm::Triple::Solaris;
2487 
2488   if (DriverArgs.hasFlag(options::OPT_fuse_init_array,
2489                          options::OPT_fno_use_init_array, UseInitArrayDefault))
2490     CC1Args.push_back("-fuse-init-array");
2491 }
2492