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