Gnu.cpp source code [clang_source_code/lib/Driver/ToolChains/Gnu.cpp]

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

Clang Project