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