1	//===--- CommonArgs.cpp - Args handling for multiple toolchains -*- 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 "clang/Driver/CommonArgs.h"
10	#include "Arch/AArch64.h"
11	#include "Arch/ARM.h"
12	#include "Arch/CSKY.h"
13	#include "Arch/LoongArch.h"
14	#include "Arch/M68k.h"
15	#include "Arch/Mips.h"
16	#include "Arch/PPC.h"
17	#include "Arch/RISCV.h"
18	#include "Arch/Sparc.h"
19	#include "Arch/SystemZ.h"
20	#include "Arch/VE.h"
21	#include "Arch/X86.h"
22	#include "HIPAMD.h"
23	#include "Hexagon.h"
24	#include "MSP430.h"
25	#include "Solaris.h"
26	#include "clang/Basic/CodeGenOptions.h"
27	#include "clang/Config/config.h"
28	#include "clang/Driver/Action.h"
29	#include "clang/Driver/Compilation.h"
30	#include "clang/Driver/Driver.h"
31	#include "clang/Driver/InputInfo.h"
32	#include "clang/Driver/Job.h"
33	#include "clang/Driver/Options.h"
34	#include "clang/Driver/SanitizerArgs.h"
35	#include "clang/Driver/ToolChain.h"
36	#include "clang/Driver/Util.h"
37	#include "clang/Driver/XRayArgs.h"
38	#include "llvm/ADT/STLExtras.h"
39	#include "llvm/ADT/SmallSet.h"
40	#include "llvm/ADT/SmallString.h"
41	#include "llvm/ADT/StringExtras.h"
42	#include "llvm/ADT/StringSwitch.h"
43	#include "llvm/ADT/Twine.h"
44	#include "llvm/BinaryFormat/Magic.h"
45	#include "llvm/Config/llvm-config.h"
46	#include "llvm/Option/Arg.h"
47	#include "llvm/Option/ArgList.h"
48	#include "llvm/Option/Option.h"
49	#include "llvm/Support/CodeGen.h"
50	#include "llvm/Support/Compression.h"
51	#include "llvm/Support/ErrorHandling.h"
52	#include "llvm/Support/FileSystem.h"
53	#include "llvm/Support/Path.h"
54	#include "llvm/Support/Process.h"
55	#include "llvm/Support/Program.h"
56	#include "llvm/Support/Threading.h"
57	#include "llvm/Support/VirtualFileSystem.h"
58	#include "llvm/Support/YAMLParser.h"
59	#include "llvm/TargetParser/Host.h"
60	#include "llvm/TargetParser/PPCTargetParser.h"
61	#include "llvm/TargetParser/TargetParser.h"
62	#include <optional>
63
64	using namespace clang::driver;
65	using namespace clang::driver::tools;
66	using namespace clang;
67	using namespace llvm::opt;
68
69	static bool useFramePointerForTargetByDefault(const llvm::opt::ArgList &Args,
70	const llvm::Triple &Triple) {
71	if (Args.hasArg(Ids: clang::driver::options::OPT_pg) &&
72	!Args.hasArg(Ids: clang::driver::options::OPT_mfentry))
73	return true;
74
75	if (Triple.isAndroid())
76	return true;
77
78	switch (Triple.getArch()) {
79	case llvm::Triple::xcore:
80	case llvm::Triple::wasm32:
81	case llvm::Triple::wasm64:
82	case llvm::Triple::msp430:
83	// XCore never wants frame pointers, regardless of OS.
84	// WebAssembly never wants frame pointers.
85	return false;
86	case llvm::Triple::ppc:
87	case llvm::Triple::ppcle:
88	case llvm::Triple::ppc64:
89	case llvm::Triple::ppc64le:
90	case llvm::Triple::riscv32:
91	case llvm::Triple::riscv64:
92	case llvm::Triple::sparc:
93	case llvm::Triple::sparcel:
94	case llvm::Triple::sparcv9:
95	case llvm::Triple::amdgcn:
96	case llvm::Triple::r600:
97	case llvm::Triple::csky:
98	case llvm::Triple::loongarch32:
99	case llvm::Triple::loongarch64:
100	case llvm::Triple::m68k:
101	return !clang::driver::tools::areOptimizationsEnabled(Args);
102	default:
103	break;
104	}
105
106	if (Triple.isOSFuchsia() || Triple.isOSNetBSD()) {
107	return !clang::driver::tools::areOptimizationsEnabled(Args);
108	}
109
110	if (Triple.isOSLinux() || Triple.isOSHurd()) {
111	switch (Triple.getArch()) {
112	// Don't use a frame pointer on linux if optimizing for certain targets.
113	case llvm::Triple::arm:
114	case llvm::Triple::armeb:
115	case llvm::Triple::thumb:
116	case llvm::Triple::thumbeb:
117	case llvm::Triple::mips64:
118	case llvm::Triple::mips64el:
119	case llvm::Triple::mips:
120	case llvm::Triple::mipsel:
121	case llvm::Triple::systemz:
122	case llvm::Triple::x86:
123	case llvm::Triple::x86_64:
124	return !clang::driver::tools::areOptimizationsEnabled(Args);
125	default:
126	return true;
127	}
128	}
129
130	if (Triple.isOSWindows()) {
131	switch (Triple.getArch()) {
132	case llvm::Triple::x86:
133	return !clang::driver::tools::areOptimizationsEnabled(Args);
134	case llvm::Triple::x86_64:
135	return Triple.isOSBinFormatMachO();
136	case llvm::Triple::arm:
137	case llvm::Triple::thumb:
138	// Windows on ARM builds with FPO disabled to aid fast stack walking
139	return true;
140	default:
141	// All other supported Windows ISAs use xdata unwind information, so frame
142	// pointers are not generally useful.
143	return false;
144	}
145	}
146
147	if (arm::isARMEABIBareMetal(Triple))
148	return false;
149
150	return true;
151	}
152
153	static bool useLeafFramePointerForTargetByDefault(const llvm::Triple &Triple) {
154	if (Triple.isAArch64() || Triple.isPS() || Triple.isVE() ||
155	(Triple.isAndroid() && !Triple.isARM()))
156	return false;
157
158	return true;
159	}
160
161	static bool mustUseNonLeafFramePointerForTarget(const llvm::Triple &Triple) {
162	switch (Triple.getArch()) {
163	default:
164	return false;
165	case llvm::Triple::arm:
166	case llvm::Triple::thumb:
167	// ARM Darwin targets require a frame pointer to be always present to aid
168	// offline debugging via backtraces.
169	return Triple.isOSDarwin();
170	}
171	}
172
173	// True if a target-specific option requires the frame chain to be preserved,
174	// even if new frame records are not created.
175	static bool mustMaintainValidFrameChain(const llvm::opt::ArgList &Args,
176	const llvm::Triple &Triple) {
177	switch (Triple.getArch()) {
178	default:
179	return false;
180	case llvm::Triple::arm:
181	case llvm::Triple::armeb:
182	case llvm::Triple::thumb:
183	case llvm::Triple::thumbeb:
184	// For 32-bit Arm, the -mframe-chain=aapcs and -mframe-chain=aapcs+leaf
185	// options require the frame pointer register to be reserved (or point to a
186	// new AAPCS-compilant frame record), even with -fno-omit-frame-pointer.
187	if (Arg *A = Args.getLastArg(Ids: options::OPT_mframe_chain)) {
188	StringRef V = A->getValue();
189	return V != "none";
190	}
191	return false;
192
193	case llvm::Triple::aarch64:
194	// Arm64 Windows requires that the frame chain is valid, as there is no
195	// way to indicate during a stack walk that a frame has used the frame
196	// pointer as a general purpose register.
197	return Triple.isOSWindows();
198	}
199	}
200
201	// True if a target-specific option causes -fno-omit-frame-pointer to also
202	// cause frame records to be created in leaf functions.
203	static bool framePointerImpliesLeafFramePointer(const llvm::opt::ArgList &Args,
204	const llvm::Triple &Triple) {
205	if (Triple.isARM() || Triple.isThumb()) {
206	// For 32-bit Arm, the -mframe-chain=aapcs+leaf option causes the
207	// -fno-omit-frame-pointer optiion to imply -mno-omit-leaf-frame-pointer,
208	// but does not by itself imply either option.
209	if (Arg *A = Args.getLastArg(Ids: options::OPT_mframe_chain)) {
210	StringRef V = A->getValue();
211	return V == "aapcs+leaf";
212	}
213	return false;
214	}
215	return false;
216	}
217
218	clang::CodeGenOptions::FramePointerKind
219	getFramePointerKind(const llvm::opt::ArgList &Args,
220	const llvm::Triple &Triple) {
221	// There are three things to consider here:
222	// * Should a frame record be created for non-leaf functions?
223	// * Should a frame record be created for leaf functions?
224	// * Is the frame pointer register reserved, i.e. must it always point to
225	// either a new, valid frame record or be un-modified?
226	//
227	// Not all combinations of these are valid:
228	// * It's not useful to have leaf frame records without non-leaf ones.
229	// * It's not useful to have frame records without reserving the frame
230	// pointer.
231	//
232	// | Non-leaf | Leaf | Reserved |
233	// | N | N | N | FramePointerKind::None
234	// | N | N | Y | FramePointerKind::Reserved
235	// | N | Y | N | Invalid
236	// | N | Y | Y | Invalid
237	// | Y | N | N | Invalid
238	// | Y | N | Y | FramePointerKind::NonLeaf
239	// | Y | Y | N | Invalid
240	// | Y | Y | Y | FramePointerKind::All
241	//
242	// The FramePointerKind::Reserved case is currently only reachable for Arm,
243	// which has the -mframe-chain= option which can (in combination with
244	// -fno-omit-frame-pointer) specify that the frame chain must be valid,
245	// without requiring new frame records to be created.
246
247	bool DefaultFP = useFramePointerForTargetByDefault(Args, Triple);
248	bool EnableFP =
249	mustUseNonLeafFramePointerForTarget(Triple) ||
250	Args.hasFlag(Pos: clang::driver::options::OPT_fno_omit_frame_pointer,
251	Neg: clang::driver::options::OPT_fomit_frame_pointer, Default: DefaultFP);
252
253	bool DefaultLeafFP =
254	useLeafFramePointerForTargetByDefault(Triple) ||
255	(EnableFP && framePointerImpliesLeafFramePointer(Args, Triple));
256	bool EnableLeafFP = Args.hasFlag(
257	Pos: clang::driver::options::OPT_mno_omit_leaf_frame_pointer,
258	Neg: clang::driver::options::OPT_momit_leaf_frame_pointer, Default: DefaultLeafFP);
259
260	bool FPRegReserved = EnableFP || mustMaintainValidFrameChain(Args, Triple);
261
262	if (EnableFP) {
263	if (EnableLeafFP)
264	return clang::CodeGenOptions::FramePointerKind::All;
265	return clang::CodeGenOptions::FramePointerKind::NonLeaf;
266	}
267	if (FPRegReserved)
268	return clang::CodeGenOptions::FramePointerKind::Reserved;
269	return clang::CodeGenOptions::FramePointerKind::None;
270	}
271
272	static void renderRpassOptions(const ArgList &Args, ArgStringList &CmdArgs,
273	const StringRef PluginOptPrefix) {
274	if (const Arg *A = Args.getLastArg(Ids: options::OPT_Rpass_EQ))
275	CmdArgs.push_back(Elt: Args.MakeArgString(Str: Twine(PluginOptPrefix) +
276	"-pass-remarks=" + A->getValue()));
277
278	if (const Arg *A = Args.getLastArg(Ids: options::OPT_Rpass_missed_EQ))
279	CmdArgs.push_back(Elt: Args.MakeArgString(
280	Str: Twine(PluginOptPrefix) + "-pass-remarks-missed=" + A->getValue()));
281
282	if (const Arg *A = Args.getLastArg(Ids: options::OPT_Rpass_analysis_EQ))
283	CmdArgs.push_back(Elt: Args.MakeArgString(
284	Str: Twine(PluginOptPrefix) + "-pass-remarks-analysis=" + A->getValue()));
285	}
286
287	static void renderRemarksOptions(const ArgList &Args, ArgStringList &CmdArgs,
288	const llvm::Triple &Triple,
289	const InputInfo &Input,
290	const InputInfo &Output,
291	const StringRef PluginOptPrefix) {
292	StringRef Format = "yaml";
293	if (const Arg *A = Args.getLastArg(Ids: options::OPT_fsave_optimization_record_EQ))
294	Format = A->getValue();
295
296	SmallString<128> F;
297	const Arg *A = Args.getLastArg(Ids: options::OPT_foptimization_record_file_EQ);
298	if (A)
299	F = A->getValue();
300	else if (Output.isFilename())
301	F = Output.getFilename();
302
303	assert(!F.empty() && "Cannot determine remarks output name.");
304	// Append "opt.ld.<format>" to the end of the file name.
305	CmdArgs.push_back(Elt: Args.MakeArgString(Str: Twine(PluginOptPrefix) +
306	"opt-remarks-filename=" + F +
307	".opt.ld." + Format));
308
309	if (const Arg *A =
310	Args.getLastArg(Ids: options::OPT_foptimization_record_passes_EQ))
311	CmdArgs.push_back(Elt: Args.MakeArgString(
312	Str: Twine(PluginOptPrefix) + "opt-remarks-passes=" + A->getValue()));
313
314	CmdArgs.push_back(Elt: Args.MakeArgString(Str: Twine(PluginOptPrefix) +
315	"opt-remarks-format=" + Format.data()));
316	}
317
318	static void renderRemarksHotnessOptions(const ArgList &Args,
319	ArgStringList &CmdArgs,
320	const StringRef PluginOptPrefix) {
321	if (Args.hasFlag(Pos: options::OPT_fdiagnostics_show_hotness,
322	Neg: options::OPT_fno_diagnostics_show_hotness, Default: false))
323	CmdArgs.push_back(Elt: Args.MakeArgString(Str: Twine(PluginOptPrefix) +
324	"opt-remarks-with-hotness"));
325
326	if (const Arg *A =
327	Args.getLastArg(Ids: options::OPT_fdiagnostics_hotness_threshold_EQ))
328	CmdArgs.push_back(
329	Elt: Args.MakeArgString(Str: Twine(PluginOptPrefix) +
330	"opt-remarks-hotness-threshold=" + A->getValue()));
331	}
332
333	static bool shouldIgnoreUnsupportedTargetFeature(const Arg &TargetFeatureArg,
334	llvm::Triple T,
335	StringRef Processor) {
336	// Warn no-cumode for AMDGCN processors not supporing WGP mode.
337	if (!T.isAMDGPU())
338	return false;
339	auto GPUKind = T.isAMDGCN() ? llvm::AMDGPU::parseArchAMDGCN(CPU: Processor)
340	: llvm::AMDGPU::parseArchR600(CPU: Processor);
341	auto GPUFeatures = T.isAMDGCN() ? llvm::AMDGPU::getArchAttrAMDGCN(AK: GPUKind)
342	: llvm::AMDGPU::getArchAttrR600(AK: GPUKind);
343	if (GPUFeatures & llvm::AMDGPU::FEATURE_WGP)
344	return false;
345	return TargetFeatureArg.getOption().matches(ID: options::OPT_mno_cumode);
346	}
347
348	void tools::addPathIfExists(const Driver &D, const Twine &Path,
349	ToolChain::path_list &Paths) {
350	if (D.getVFS().exists(Path))
351	Paths.push_back(Elt: Path.str());
352	}
353
354	void tools::handleTargetFeaturesGroup(const Driver &D,
355	const llvm::Triple &Triple,
356	const ArgList &Args,
357	std::vector<StringRef> &Features,
358	OptSpecifier Group) {
359	std::set<StringRef> Warned;
360	for (const Arg *A : Args.filtered(Ids: Group)) {
361	StringRef Name = A->getOption().getName();
362	A->claim();
363
364	// Skip over "-m".
365	assert(Name.starts_with("m") && "Invalid feature name.");
366	Name = Name.substr(Start: 1);
367
368	auto Proc = getCPUName(D, Args, T: Triple);
369	if (shouldIgnoreUnsupportedTargetFeature(TargetFeatureArg: *A, T: Triple, Processor: Proc)) {
370	if (Warned.count(x: Name) == 0) {
371	D.getDiags().Report(
372	DiagID: clang::diag::warn_drv_unsupported_option_for_processor)
373	<< A->getAsString(Args) << Proc;
374	Warned.insert(x: Name);
375	}
376	continue;
377	}
378
379	bool IsNegative = Name.consume_front(Prefix: "no-");
380
381	Features.push_back(x: Args.MakeArgString(Str: (IsNegative ? "-" : "+") + Name));
382	}
383	}
384
385	SmallVector<StringRef>
386	tools::unifyTargetFeatures(ArrayRef<StringRef> Features) {
387	// Only add a feature if it hasn't been seen before starting from the end.
388	SmallVector<StringRef> UnifiedFeatures;
389	llvm::DenseSet<StringRef> UsedFeatures;
390	for (StringRef Feature : llvm::reverse(C&: Features)) {
391	if (UsedFeatures.insert(V: Feature.drop_front()).second)
392	UnifiedFeatures.insert(I: UnifiedFeatures.begin(), Elt: Feature);
393	}
394
395	return UnifiedFeatures;
396	}
397
398	void tools::addDirectoryList(const ArgList &Args, ArgStringList &CmdArgs,
399	const char *ArgName, const char *EnvVar) {
400	const char *DirList = ::getenv(name: EnvVar);
401	bool CombinedArg = false;
402
403	if (!DirList)
404	return; // Nothing to do.
405
406	StringRef Name(ArgName);
407	if (Name == "-I" || Name == "-L" || Name.empty())
408	CombinedArg = true;
409
410	StringRef Dirs(DirList);
411	if (Dirs.empty()) // Empty string should not add '.'.
412	return;
413
414	StringRef::size_type Delim;
415	while ((Delim = Dirs.find(C: llvm::sys::EnvPathSeparator)) != StringRef::npos) {
416	if (Delim == 0) { // Leading colon.
417	if (CombinedArg) {
418	CmdArgs.push_back(Elt: Args.MakeArgString(Str: std::string(ArgName) + "."));
419	} else {
420	CmdArgs.push_back(Elt: ArgName);
421	CmdArgs.push_back(Elt: ".");
422	}
423	} else {
424	if (CombinedArg) {
425	CmdArgs.push_back(
426	Elt: Args.MakeArgString(Str: std::string(ArgName) + Dirs.substr(Start: 0, N: Delim)));
427	} else {
428	CmdArgs.push_back(Elt: ArgName);
429	CmdArgs.push_back(Elt: Args.MakeArgString(Str: Dirs.substr(Start: 0, N: Delim)));
430	}
431	}
432	Dirs = Dirs.substr(Start: Delim + 1);
433	}
434
435	if (Dirs.empty()) { // Trailing colon.
436	if (CombinedArg) {
437	CmdArgs.push_back(Elt: Args.MakeArgString(Str: std::string(ArgName) + "."));
438	} else {
439	CmdArgs.push_back(Elt: ArgName);
440	CmdArgs.push_back(Elt: ".");
441	}
442	} else { // Add the last path.
443	if (CombinedArg) {
444	CmdArgs.push_back(Elt: Args.MakeArgString(Str: std::string(ArgName) + Dirs));
445	} else {
446	CmdArgs.push_back(Elt: ArgName);
447	CmdArgs.push_back(Elt: Args.MakeArgString(Str: Dirs));
448	}
449	}
450	}
451
452	void tools::AddLinkerInputs(const ToolChain &TC, const InputInfoList &Inputs,
453	const ArgList &Args, ArgStringList &CmdArgs,
454	const JobAction &JA) {
455	const Driver &D = TC.getDriver();
456
457	// Add extra linker input arguments which are not treated as inputs
458	// (constructed via -Xarch_).
459	Args.AddAllArgValues(Output&: CmdArgs, Id0: options::OPT_Zlinker_input);
460
461	// LIBRARY_PATH are included before user inputs and only supported on native
462	// toolchains.
463	if (!TC.isCrossCompiling())
464	addDirectoryList(Args, CmdArgs, ArgName: "-L", EnvVar: "LIBRARY_PATH");
465
466	for (const auto &II : Inputs) {
467	// If the current tool chain refers to an OpenMP offloading host, we
468	// should ignore inputs that refer to OpenMP offloading devices -
469	// they will be embedded according to a proper linker script.
470	if (auto *IA = II.getAction())
471	if ((JA.isHostOffloading(OKind: Action::OFK_OpenMP) &&
472	IA->isDeviceOffloading(OKind: Action::OFK_OpenMP)))
473	continue;
474
475	if (!TC.HasNativeLLVMSupport() && types::isLLVMIR(Id: II.getType()))
476	// Don't try to pass LLVM inputs unless we have native support.
477	D.Diag(DiagID: diag::err_drv_no_linker_llvm_support) << TC.getTripleString();
478
479	// Add filenames immediately.
480	if (II.isFilename()) {
481	CmdArgs.push_back(Elt: II.getFilename());
482	continue;
483	}
484
485	// In some error cases, the input could be Nothing; skip those.
486	if (II.isNothing())
487	continue;
488
489	// Otherwise, this is a linker input argument.
490	const Arg &A = II.getInputArg();
491
492	// Handle reserved library options.
493	if (A.getOption().matches(ID: options::OPT_Z_reserved_lib_stdcxx))
494	TC.AddCXXStdlibLibArgs(Args, CmdArgs);
495	else if (A.getOption().matches(ID: options::OPT_Z_reserved_lib_cckext))
496	TC.AddCCKextLibArgs(Args, CmdArgs);
497	// Do not pass OPT_rpath to linker in AIX
498	else if (A.getOption().matches(ID: options::OPT_rpath) &&
499	TC.getTriple().isOSAIX())
500	continue;
501	else
502	A.renderAsInput(Args, Output&: CmdArgs);
503	}
504	if (const Arg *A = Args.getLastArg(Ids: options::OPT_fveclib)) {
505	const llvm::Triple &Triple = TC.getTriple();
506	StringRef V = A->getValue();
507	if (V == "ArmPL" && (Triple.isOSLinux() || Triple.isOSDarwin())) {
508	// To support -fveclib=ArmPL we need to link against libamath. Some of the
509	// libamath functions depend on libm, at the same time, libamath exports
510	// its own implementation of some of the libm functions. These are faster
511	// and potentially less accurate implementations, hence we need to be
512	// careful what is being linked in. Since here we are interested only in
513	// the subset of libamath functions that is covered by the veclib
514	// mappings, we need to prioritize libm functions by putting -lm before
515	// -lamath (and then -lm again, to fulfill libamath requirements).
516	//
517	// Therefore we need to do the following:
518	//
519	// 1. On Linux, link only when actually needed.
520	//
521	// 2. Prefer libm functions over libamath (when no -nostdlib in use).
522	//
523	// 3. Link against libm to resolve libamath dependencies.
524	//
525	if (Triple.isOSLinux()) {
526	CmdArgs.push_back(Elt: Args.MakeArgString(Str: "--push-state"));
527	CmdArgs.push_back(Elt: Args.MakeArgString(Str: "--as-needed"));
528	}
529	if (!Args.hasArg(Ids: options::OPT_nostdlib))
530	CmdArgs.push_back(Elt: Args.MakeArgString(Str: "-lm"));
531	CmdArgs.push_back(Elt: Args.MakeArgString(Str: "-lamath"));
532	if (!Args.hasArg(Ids: options::OPT_nostdlib))
533	CmdArgs.push_back(Elt: Args.MakeArgString(Str: "-lm"));
534	if (Triple.isOSLinux())
535	CmdArgs.push_back(Elt: Args.MakeArgString(Str: "--pop-state"));
536	addArchSpecificRPath(TC, Args, CmdArgs);
537	}
538	}
539	}
540
541	const char *tools::getLDMOption(const llvm::Triple &T, const ArgList &Args) {
542	switch (T.getArch()) {
543	case llvm::Triple::x86:
544	if (T.isOSIAMCU())
545	return "elf_iamcu";
546	return "elf_i386";
547	case llvm::Triple::aarch64:
548	if (T.isOSManagarm())
549	return "aarch64managarm";
550	else if (aarch64::isAArch64BareMetal(Triple: T))
551	return "aarch64elf";
552	return "aarch64linux";
553	case llvm::Triple::aarch64_be:
554	if (aarch64::isAArch64BareMetal(Triple: T))
555	return "aarch64elfb";
556	return "aarch64linuxb";
557	case llvm::Triple::arm:
558	case llvm::Triple::thumb:
559	case llvm::Triple::armeb:
560	case llvm::Triple::thumbeb: {
561	bool IsBigEndian = tools::arm::isARMBigEndian(Triple: T, Args);
562	if (arm::isARMEABIBareMetal(Triple: T))
563	return IsBigEndian ? "armelfb" : "armelf";
564	return IsBigEndian ? "armelfb_linux_eabi" : "armelf_linux_eabi";
565	}
566	case llvm::Triple::m68k:
567	return "m68kelf";
568	case llvm::Triple::ppc:
569	if (T.isOSLinux())
570	return "elf32ppclinux";
571	return "elf32ppc";
572	case llvm::Triple::ppcle:
573	if (T.isOSLinux())
574	return "elf32lppclinux";
575	return "elf32lppc";
576	case llvm::Triple::ppc64:
577	return "elf64ppc";
578	case llvm::Triple::ppc64le:
579	return "elf64lppc";
580	case llvm::Triple::riscv32:
581	return "elf32lriscv";
582	case llvm::Triple::riscv64:
583	return "elf64lriscv";
584	case llvm::Triple::sparc:
585	case llvm::Triple::sparcel:
586	return "elf32_sparc";
587	case llvm::Triple::sparcv9:
588	return "elf64_sparc";
589	case llvm::Triple::loongarch32:
590	return "elf32loongarch";
591	case llvm::Triple::loongarch64:
592	return "elf64loongarch";
593	case llvm::Triple::mips:
594	return "elf32btsmip";
595	case llvm::Triple::mipsel:
596	return "elf32ltsmip";
597	case llvm::Triple::mips64:
598	if (tools::mips::hasMipsAbiArg(Args, Value: "n32") || T.isABIN32())
599	return "elf32btsmipn32";
600	return "elf64btsmip";
601	case llvm::Triple::mips64el:
602	if (tools::mips::hasMipsAbiArg(Args, Value: "n32") || T.isABIN32())
603	return "elf32ltsmipn32";
604	return "elf64ltsmip";
605	case llvm::Triple::systemz:
606	return "elf64_s390";
607	case llvm::Triple::x86_64:
608	if (T.isX32())
609	return "elf32_x86_64";
610	return "elf_x86_64";
611	case llvm::Triple::ve:
612	return "elf64ve";
613	case llvm::Triple::csky:
614	return "cskyelf_linux";
615	default:
616	return nullptr;
617	}
618	}
619
620	void tools::addLinkerCompressDebugSectionsOption(
621	const ToolChain &TC, const llvm::opt::ArgList &Args,
622	llvm::opt::ArgStringList &CmdArgs) {
623	// GNU ld supports --compress-debug-sections=none|zlib|zlib-gnu|zlib-gabi
624	// whereas zlib is an alias to zlib-gabi and zlib-gnu is obsoleted. Therefore
625	// -gz=none|zlib are translated to --compress-debug-sections=none|zlib. -gz
626	// is not translated since ld --compress-debug-sections option requires an
627	// argument.
628	if (const Arg *A = Args.getLastArg(Ids: options::OPT_gz_EQ)) {
629	StringRef V = A->getValue();
630	if (V == "none" || V == "zlib" || V == "zstd")
631	CmdArgs.push_back(Elt: Args.MakeArgString(Str: "--compress-debug-sections=" + V));
632	else
633	TC.getDriver().Diag(DiagID: diag::err_drv_unsupported_option_argument)
634	<< A->getSpelling() << V;
635	}
636	}
637
638	void tools::AddTargetFeature(const ArgList &Args,
639	std::vector<StringRef> &Features,
640	OptSpecifier OnOpt, OptSpecifier OffOpt,
641	StringRef FeatureName) {
642	if (Arg *A = Args.getLastArg(Ids: OnOpt, Ids: OffOpt)) {
643	if (A->getOption().matches(ID: OnOpt))
644	Features.push_back(x: Args.MakeArgString(Str: "+" + FeatureName));
645	else
646	Features.push_back(x: Args.MakeArgString(Str: "-" + FeatureName));
647	}
648	}
649
650	/// Get the (LLVM) name of the AMDGPU gpu we are targeting.
651	static std::string getAMDGPUTargetGPU(const llvm::Triple &T,
652	const ArgList &Args) {
653	Arg *MArch = Args.getLastArg(Ids: options::OPT_march_EQ);
654	if (Arg *A = Args.getLastArg(Ids: options::OPT_mcpu_EQ)) {
655	auto GPUName = getProcessorFromTargetID(T, OffloadArch: A->getValue());
656	return llvm::StringSwitch<std::string>(GPUName)
657	.Cases(S0: "rv630", S1: "rv635", Value: "r600")
658	.Cases(S0: "rv610", S1: "rv620", S2: "rs780", Value: "rs880")
659	.Case(S: "rv740", Value: "rv770")
660	.Case(S: "palm", Value: "cedar")
661	.Cases(S0: "sumo", S1: "sumo2", Value: "sumo")
662	.Case(S: "hemlock", Value: "cypress")
663	.Case(S: "aruba", Value: "cayman")
664	.Default(Value: GPUName.str());
665	}
666	if (MArch)
667	return getProcessorFromTargetID(T, OffloadArch: MArch->getValue()).str();
668	return "";
669	}
670
671	static std::string getLanaiTargetCPU(const ArgList &Args) {
672	if (Arg *A = Args.getLastArg(Ids: options::OPT_mcpu_EQ)) {
673	return A->getValue();
674	}
675	return "";
676	}
677
678	/// Get the (LLVM) name of the WebAssembly cpu we are targeting.
679	static StringRef getWebAssemblyTargetCPU(const ArgList &Args) {
680	// If we have -mcpu=, use that.
681	if (Arg *A = Args.getLastArg(Ids: options::OPT_mcpu_EQ)) {
682	StringRef CPU = A->getValue();
683
684	#ifdef __wasm__
685	// Handle "native" by examining the host. "native" isn't meaningful when
686	// cross compiling, so only support this when the host is also WebAssembly.
687	if (CPU == "native")
688	return llvm::sys::getHostCPUName();
689	#endif
690
691	return CPU;
692	}
693
694	return "generic";
695	}
696
697	std::string tools::getCPUName(const Driver &D, const ArgList &Args,
698	const llvm::Triple &T, bool FromAs) {
699	Arg *A;
700
701	switch (T.getArch()) {
702	default:
703	return "";
704
705	case llvm::Triple::aarch64:
706	case llvm::Triple::aarch64_32:
707	case llvm::Triple::aarch64_be:
708	return aarch64::getAArch64TargetCPU(Args, Triple: T, A);
709
710	case llvm::Triple::arm:
711	case llvm::Triple::armeb:
712	case llvm::Triple::thumb:
713	case llvm::Triple::thumbeb: {
714	StringRef MArch, MCPU;
715	arm::getARMArchCPUFromArgs(Args, Arch&: MArch, CPU&: MCPU, FromAs);
716	return arm::getARMTargetCPU(CPU: MCPU, Arch: MArch, Triple: T);
717	}
718
719	case llvm::Triple::avr:
720	if (const Arg *A = Args.getLastArg(Ids: options::OPT_mmcu_EQ))
721	return A->getValue();
722	return "";
723
724	case llvm::Triple::m68k:
725	return m68k::getM68kTargetCPU(Args);
726
727	case llvm::Triple::mips:
728	case llvm::Triple::mipsel:
729	case llvm::Triple::mips64:
730	case llvm::Triple::mips64el: {
731	StringRef CPUName;
732	StringRef ABIName;
733	mips::getMipsCPUAndABI(Args, Triple: T, CPUName, ABIName);
734	return std::string(CPUName);
735	}
736
737	case llvm::Triple::nvptx:
738	case llvm::Triple::nvptx64:
739	if (const Arg *A = Args.getLastArg(Ids: options::OPT_march_EQ))
740	return A->getValue();
741	return "";
742
743	case llvm::Triple::ppc:
744	case llvm::Triple::ppcle:
745	case llvm::Triple::ppc64:
746	case llvm::Triple::ppc64le:
747	if (Arg *A = Args.getLastArg(Ids: clang::driver::options::OPT_mcpu_EQ))
748	return std::string(
749	llvm::PPC::getNormalizedPPCTargetCPU(T, CPUName: A->getValue()));
750	return std::string(llvm::PPC::getNormalizedPPCTargetCPU(T));
751
752	case llvm::Triple::csky:
753	if (const Arg *A = Args.getLastArg(Ids: options::OPT_mcpu_EQ))
754	return A->getValue();
755	else if (const Arg *A = Args.getLastArg(Ids: options::OPT_march_EQ))
756	return A->getValue();
757	else
758	return "ck810";
759	case llvm::Triple::riscv32:
760	case llvm::Triple::riscv64:
761	return riscv::getRISCVTargetCPU(Args, Triple: T);
762
763	case llvm::Triple::bpfel:
764	case llvm::Triple::bpfeb:
765	if (const Arg *A = Args.getLastArg(Ids: options::OPT_mcpu_EQ))
766	return A->getValue();
767	return "";
768
769	case llvm::Triple::sparc:
770	case llvm::Triple::sparcel:
771	case llvm::Triple::sparcv9:
772	return sparc::getSparcTargetCPU(D, Args, Triple: T);
773
774	case llvm::Triple::x86:
775	case llvm::Triple::x86_64:
776	return x86::getX86TargetCPU(D, Args, Triple: T);
777
778	case llvm::Triple::hexagon:
779	return "hexagon" +
780	toolchains::HexagonToolChain::GetTargetCPUVersion(Args).str();
781
782	case llvm::Triple::lanai:
783	return getLanaiTargetCPU(Args);
784
785	case llvm::Triple::systemz:
786	return systemz::getSystemZTargetCPU(Args, T);
787
788	case llvm::Triple::r600:
789	case llvm::Triple::amdgcn:
790	return getAMDGPUTargetGPU(T, Args);
791
792	case llvm::Triple::wasm32:
793	case llvm::Triple::wasm64:
794	return std::string(getWebAssemblyTargetCPU(Args));
795
796	case llvm::Triple::loongarch32:
797	case llvm::Triple::loongarch64:
798	return loongarch::getLoongArchTargetCPU(Args, Triple: T);
799
800	case llvm::Triple::xtensa:
801	if (const Arg *A = Args.getLastArg(Ids: options::OPT_mcpu_EQ))
802	return A->getValue();
803	return "";
804	}
805	}
806
807	static void getWebAssemblyTargetFeatures(const Driver &D,
808	const llvm::Triple &Triple,
809	const ArgList &Args,
810	std::vector<StringRef> &Features) {
811	handleTargetFeaturesGroup(D, Triple, Args, Features,
812	Group: options::OPT_m_wasm_Features_Group);
813	}
814
815	void tools::getTargetFeatures(const Driver &D, const llvm::Triple &Triple,
816	const ArgList &Args, ArgStringList &CmdArgs,
817	bool ForAS, bool IsAux) {
818	std::vector<StringRef> Features;
819	switch (Triple.getArch()) {
820	default:
821	break;
822	case llvm::Triple::mips:
823	case llvm::Triple::mipsel:
824	case llvm::Triple::mips64:
825	case llvm::Triple::mips64el:
826	mips::getMIPSTargetFeatures(D, Triple, Args, Features);
827	break;
828	case llvm::Triple::arm:
829	case llvm::Triple::armeb:
830	case llvm::Triple::thumb:
831	case llvm::Triple::thumbeb:
832	arm::getARMTargetFeatures(D, Triple, Args, Features, ForAS);
833	break;
834	case llvm::Triple::ppc:
835	case llvm::Triple::ppcle:
836	case llvm::Triple::ppc64:
837	case llvm::Triple::ppc64le:
838	ppc::getPPCTargetFeatures(D, Triple, Args, Features);
839	break;
840	case llvm::Triple::riscv32:
841	case llvm::Triple::riscv64:
842	riscv::getRISCVTargetFeatures(D, Triple, Args, Features);
843	break;
844	case llvm::Triple::systemz:
845	systemz::getSystemZTargetFeatures(D, Args, Features);
846	break;
847	case llvm::Triple::aarch64:
848	case llvm::Triple::aarch64_32:
849	case llvm::Triple::aarch64_be:
850	aarch64::getAArch64TargetFeatures(D, Triple, Args, Features, ForAS);
851	break;
852	case llvm::Triple::x86:
853	case llvm::Triple::x86_64:
854	x86::getX86TargetFeatures(D, Triple, Args, Features);
855	break;
856	case llvm::Triple::hexagon:
857	hexagon::getHexagonTargetFeatures(D, Triple, Args, Features);
858	break;
859	case llvm::Triple::wasm32:
860	case llvm::Triple::wasm64:
861	getWebAssemblyTargetFeatures(D, Triple, Args, Features);
862	break;
863	case llvm::Triple::sparc:
864	case llvm::Triple::sparcel:
865	case llvm::Triple::sparcv9:
866	sparc::getSparcTargetFeatures(D, Triple, Args, Features);
867	break;
868	case llvm::Triple::r600:
869	case llvm::Triple::amdgcn:
870	amdgpu::getAMDGPUTargetFeatures(D, Triple, Args, Features);
871	break;
872	case llvm::Triple::nvptx:
873	case llvm::Triple::nvptx64:
874	NVPTX::getNVPTXTargetFeatures(D, Triple, Args, Features);
875	break;
876	case llvm::Triple::m68k:
877	m68k::getM68kTargetFeatures(D, Triple, Args, Features);
878	break;
879	case llvm::Triple::msp430:
880	msp430::getMSP430TargetFeatures(D, Args, Features);
881	break;
882	case llvm::Triple::ve:
883	ve::getVETargetFeatures(D, Args, Features);
884	break;
885	case llvm::Triple::csky:
886	csky::getCSKYTargetFeatures(D, Triple, Args, CmdArgs, Features);
887	break;
888	case llvm::Triple::loongarch32:
889	case llvm::Triple::loongarch64:
890	loongarch::getLoongArchTargetFeatures(D, Triple, Args, Features);
891	break;
892	}
893
894	for (auto Feature : unifyTargetFeatures(Features)) {
895	CmdArgs.push_back(Elt: IsAux ? "-aux-target-feature" : "-target-feature");
896	CmdArgs.push_back(Elt: Feature.data());
897	}
898	}
899
900	llvm::StringRef tools::getLTOParallelism(const ArgList &Args, const Driver &D) {
901	Arg *LtoJobsArg = Args.getLastArg(Ids: options::OPT_flto_jobs_EQ);
902	if (!LtoJobsArg)
903	return {};
904	if (!llvm::get_threadpool_strategy(Num: LtoJobsArg->getValue()))
905	D.Diag(DiagID: diag::err_drv_invalid_int_value)
906	<< LtoJobsArg->getAsString(Args) << LtoJobsArg->getValue();
907	return LtoJobsArg->getValue();
908	}
909
910	// PS4/PS5 uses -ffunction-sections and -fdata-sections by default.
911	bool tools::isUseSeparateSections(const llvm::Triple &Triple) {
912	return Triple.isPS();
913	}
914
915	bool tools::isTLSDESCEnabled(const ToolChain &TC,
916	const llvm::opt::ArgList &Args) {
917	const llvm::Triple &Triple = TC.getEffectiveTriple();
918	Arg *A = Args.getLastArg(Ids: options::OPT_mtls_dialect_EQ);
919	if (!A)
920	return Triple.hasDefaultTLSDESC();
921	StringRef V = A->getValue();
922	bool SupportedArgument = false, EnableTLSDESC = false;
923	bool Unsupported = !Triple.isOSBinFormatELF();
924	if (Triple.isLoongArch() || Triple.isRISCV()) {
925	SupportedArgument = V == "desc" || V == "trad";
926	EnableTLSDESC = V == "desc";
927	} else if (Triple.isX86()) {
928	SupportedArgument = V == "gnu" || V == "gnu2";
929	EnableTLSDESC = V == "gnu2";
930	} else {
931	Unsupported = true;
932	}
933	if (Unsupported) {
934	TC.getDriver().Diag(DiagID: diag::err_drv_unsupported_opt_for_target)
935	<< A->getSpelling() << Triple.getTriple();
936	} else if (!SupportedArgument) {
937	TC.getDriver().Diag(DiagID: diag::err_drv_unsupported_option_argument_for_target)
938	<< A->getSpelling() << V << Triple.getTriple();
939	}
940	return EnableTLSDESC;
941	}
942
943	void tools::addLTOOptions(const ToolChain &ToolChain, const ArgList &Args,
944	ArgStringList &CmdArgs, const InputInfo &Output,
945	const InputInfoList &Inputs, bool IsThinLTO) {
946	const llvm::Triple &Triple = ToolChain.getTriple();
947	const bool IsOSAIX = Triple.isOSAIX();
948	const bool IsAMDGCN = Triple.isAMDGCN();
949	StringRef Linker = Args.getLastArgValue(Id: options::OPT_fuse_ld_EQ);
950	const char *LinkerPath = Args.MakeArgString(Str: ToolChain.GetLinkerPath());
951	const Driver &D = ToolChain.getDriver();
952	const bool IsFatLTO = Args.hasFlag(Pos: options::OPT_ffat_lto_objects,
953	Neg: options::OPT_fno_fat_lto_objects, Default: false);
954	const bool IsUnifiedLTO = Args.hasArg(Ids: options::OPT_funified_lto);
955
956	assert(!Inputs.empty() && "Must have at least one input.");
957
958	auto Input = llvm::find_if(
959	Range: Inputs, P: [](const InputInfo &II) -> bool { return II.isFilename(); });
960	if (Input == Inputs.end()) {
961	// For a very rare case, all of the inputs to the linker are
962	// InputArg. If that happens, just use the first InputInfo.
963	Input = Inputs.begin();
964	}
965
966	if (Linker != "lld" && Linker != "lld-link" &&
967	llvm::sys::path::filename(path: LinkerPath) != "ld.lld" &&
968	llvm::sys::path::stem(path: LinkerPath) != "ld.lld" && !Triple.isOSOpenBSD()) {
969	// Tell the linker to load the plugin. This has to come before
970	// AddLinkerInputs as gold requires -plugin and AIX ld requires -bplugin to
971	// come before any -plugin-opt/-bplugin_opt that -Wl might forward.
972	const char *PluginPrefix = IsOSAIX ? "-bplugin:" : "";
973	const char *PluginName = IsOSAIX ? "/libLTO" : "/LLVMgold";
974
975	if (!IsOSAIX)
976	CmdArgs.push_back(Elt: "-plugin");
977
978	#if defined(_WIN32)
979	const char *Suffix = ".dll";
980	#elif defined(__APPLE__)
981	const char *Suffix = ".dylib";
982	#else
983	const char *Suffix = ".so";
984	#endif
985
986	SmallString<1024> Plugin;
987	llvm::sys::path::native(path: Twine(D.Dir) +
988	"/../" CLANG_INSTALL_LIBDIR_BASENAME +
989	PluginName + Suffix,
990	result&: Plugin);
991	CmdArgs.push_back(Elt: Args.MakeArgString(Str: Twine(PluginPrefix) + Plugin));
992	} else {
993	// Tell LLD to find and use .llvm.lto section in regular relocatable object
994	// files
995	if (IsFatLTO)
996	CmdArgs.push_back(Elt: "--fat-lto-objects");
997
998	if (Args.hasArg(Ids: options::OPT_flto_partitions_EQ)) {
999	int Value = 0;
1000	StringRef A = Args.getLastArgValue(Id: options::OPT_flto_partitions_EQ, Default: "8");
1001	if (A.getAsInteger(Radix: 10, Result&: Value) || (Value < 1)) {
1002	Arg *Arg = Args.getLastArg(Ids: options::OPT_flto_partitions_EQ);
1003	D.Diag(DiagID: diag::err_drv_invalid_int_value)
1004	<< Arg->getAsString(Args) << Arg->getValue();
1005	}
1006	CmdArgs.push_back(Elt: Args.MakeArgString(Str: "--lto-partitions=" + A));
1007	}
1008	}
1009
1010	const char *PluginOptPrefix = IsOSAIX ? "-bplugin_opt:" : "-plugin-opt=";
1011	const char *ExtraDash = IsOSAIX ? "-" : "";
1012	const char *ParallelismOpt = IsOSAIX ? "-threads=" : "jobs=";
1013
1014	// Note, this solution is far from perfect, better to encode it into IR
1015	// metadata, but this may not be worth it, since it looks like aranges is on
1016	// the way out.
1017	if (Args.hasArg(Ids: options::OPT_gdwarf_aranges)) {
1018	CmdArgs.push_back(Elt: Args.MakeArgString(Str: Twine(PluginOptPrefix) +
1019	"-generate-arange-section"));
1020	}
1021
1022	// Pass vector library arguments to LTO.
1023	Arg *ArgVecLib = Args.getLastArg(Ids: options::OPT_fveclib);
1024	if (ArgVecLib && ArgVecLib->getNumValues() == 1) {
1025	// Map the vector library names from clang front-end to opt front-end. The
1026	// values are taken from the TargetLibraryInfo class command line options.
1027	std::optional<StringRef> OptVal =
1028	llvm::StringSwitch<std::optional<StringRef>>(ArgVecLib->getValue())
1029	.Case(S: "Accelerate", Value: "Accelerate")
1030	.Case(S: "libmvec", Value: "LIBMVEC")
1031	.Case(S: "AMDLIBM", Value: "AMDLIBM")
1032	.Case(S: "MASSV", Value: "MASSV")
1033	.Case(S: "SVML", Value: "SVML")
1034	.Case(S: "SLEEF", Value: "sleefgnuabi")
1035	.Case(S: "Darwin_libsystem_m", Value: "Darwin_libsystem_m")
1036	.Case(S: "ArmPL", Value: "ArmPL")
1037	.Case(S: "none", Value: "none")
1038	.Default(Value: std::nullopt);
1039
1040	if (OptVal)
1041	CmdArgs.push_back(Elt: Args.MakeArgString(
1042	Str: Twine(PluginOptPrefix) + "-vector-library=" + OptVal.value()));
1043	}
1044
1045	// Try to pass driver level flags relevant to LTO code generation down to
1046	// the plugin.
1047
1048	// Handle flags for selecting CPU variants.
1049	std::string CPU = getCPUName(D, Args, T: Triple);
1050	if (!CPU.empty())
1051	CmdArgs.push_back(
1052	Elt: Args.MakeArgString(Str: Twine(PluginOptPrefix) + ExtraDash + "mcpu=" + CPU));
1053
1054	if (Arg *A = Args.getLastArg(Ids: options::OPT_O_Group)) {
1055	// The optimization level matches
1056	// CompilerInvocation.cpp:getOptimizationLevel().
1057	StringRef OOpt;
1058	if (A->getOption().matches(ID: options::OPT_O4) ||
1059	A->getOption().matches(ID: options::OPT_Ofast))
1060	OOpt = "3";
1061	else if (A->getOption().matches(ID: options::OPT_O)) {
1062	OOpt = A->getValue();
1063	if (OOpt == "g")
1064	OOpt = "1";
1065	else if (OOpt == "s" || OOpt == "z")
1066	OOpt = "2";
1067	} else if (A->getOption().matches(ID: options::OPT_O0))
1068	OOpt = "0";
1069	if (!OOpt.empty()) {
1070	CmdArgs.push_back(
1071	Elt: Args.MakeArgString(Str: Twine(PluginOptPrefix) + ExtraDash + "O" + OOpt));
1072	if (IsAMDGCN)
1073	CmdArgs.push_back(Elt: Args.MakeArgString(Str: Twine("--lto-CGO") + OOpt));
1074	}
1075	}
1076
1077	if (Args.hasArg(Ids: options::OPT_gsplit_dwarf))
1078	CmdArgs.push_back(Elt: Args.MakeArgString(
1079	Str: Twine(PluginOptPrefix) + "dwo_dir=" + Output.getFilename() + "_dwo"));
1080
1081	if (IsThinLTO && !IsOSAIX)
1082	CmdArgs.push_back(Elt: Args.MakeArgString(Str: Twine(PluginOptPrefix) + "thinlto"));
1083	else if (IsThinLTO && IsOSAIX)
1084	CmdArgs.push_back(Elt: Args.MakeArgString(Str: Twine("-bdbg:thinlto")));
1085
1086	// Matrix intrinsic lowering happens at link time with ThinLTO. Enable
1087	// LowerMatrixIntrinsicsPass, which is transitively called by
1088	// buildThinLTODefaultPipeline under EnableMatrix.
1089	if ((IsThinLTO || IsFatLTO || IsUnifiedLTO) &&
1090	Args.hasArg(Ids: options::OPT_fenable_matrix))
1091	CmdArgs.push_back(
1092	Elt: Args.MakeArgString(Str: Twine(PluginOptPrefix) + "-enable-matrix"));
1093
1094	StringRef Parallelism = getLTOParallelism(Args, D);
1095	if (!Parallelism.empty())
1096	CmdArgs.push_back(Elt: Args.MakeArgString(Str: Twine(PluginOptPrefix) +
1097	ParallelismOpt + Parallelism));
1098
1099	// Pass down GlobalISel options.
1100	if (Arg *A = Args.getLastArg(Ids: options::OPT_fglobal_isel,
1101	Ids: options::OPT_fno_global_isel)) {
1102	// Parsing -fno-global-isel explicitly gives architectures that enable GISel
1103	// by default a chance to disable it.
1104	CmdArgs.push_back(Elt: Args.MakeArgString(
1105	Str: Twine(PluginOptPrefix) + "-global-isel=" +
1106	(A->getOption().matches(ID: options::OPT_fglobal_isel) ? "1" : "0")));
1107	}
1108
1109	// If an explicit debugger tuning argument appeared, pass it along.
1110	if (Arg *A =
1111	Args.getLastArg(Ids: options::OPT_gTune_Group, Ids: options::OPT_ggdbN_Group)) {
1112	if (A->getOption().matches(ID: options::OPT_glldb))
1113	CmdArgs.push_back(
1114	Elt: Args.MakeArgString(Str: Twine(PluginOptPrefix) + "-debugger-tune=lldb"));
1115	else if (A->getOption().matches(ID: options::OPT_gsce))
1116	CmdArgs.push_back(
1117	Elt: Args.MakeArgString(Str: Twine(PluginOptPrefix) + "-debugger-tune=sce"));
1118	else if (A->getOption().matches(ID: options::OPT_gdbx))
1119	CmdArgs.push_back(
1120	Elt: Args.MakeArgString(Str: Twine(PluginOptPrefix) + "-debugger-tune=dbx"));
1121	else
1122	CmdArgs.push_back(
1123	Elt: Args.MakeArgString(Str: Twine(PluginOptPrefix) + "-debugger-tune=gdb"));
1124	}
1125
1126	if (IsOSAIX) {
1127	if (!ToolChain.useIntegratedAs())
1128	CmdArgs.push_back(
1129	Elt: Args.MakeArgString(Str: Twine(PluginOptPrefix) + "-no-integrated-as=1"));
1130
1131	// On AIX, clang assumes strict-dwarf is true if any debug option is
1132	// specified, unless it is told explicitly not to assume so.
1133	Arg *A = Args.getLastArg(Ids: options::OPT_g_Group);
1134	bool EnableDebugInfo = A && !A->getOption().matches(ID: options::OPT_g0) &&
1135	!A->getOption().matches(ID: options::OPT_ggdb0);
1136	if (EnableDebugInfo && Args.hasFlag(Pos: options::OPT_gstrict_dwarf,
1137	Neg: options::OPT_gno_strict_dwarf, Default: true))
1138	CmdArgs.push_back(
1139	Elt: Args.MakeArgString(Str: Twine(PluginOptPrefix) + "-strict-dwarf=true"));
1140
1141	for (const Arg *A : Args.filtered_reverse(Ids: options::OPT_mabi_EQ)) {
1142	StringRef V = A->getValue();
1143	if (V == "vec-default")
1144	break;
1145	if (V == "vec-extabi") {
1146	CmdArgs.push_back(
1147	Elt: Args.MakeArgString(Str: Twine(PluginOptPrefix) + "-vec-extabi"));
1148	break;
1149	}
1150	}
1151	}
1152
1153	bool UseSeparateSections =
1154	isUseSeparateSections(Triple: ToolChain.getEffectiveTriple());
1155
1156	if (Args.hasFlag(Pos: options::OPT_ffunction_sections,
1157	Neg: options::OPT_fno_function_sections, Default: UseSeparateSections))
1158	CmdArgs.push_back(
1159	Elt: Args.MakeArgString(Str: Twine(PluginOptPrefix) + "-function-sections=1"));
1160	else if (Args.hasArg(Ids: options::OPT_fno_function_sections))
1161	CmdArgs.push_back(
1162	Elt: Args.MakeArgString(Str: Twine(PluginOptPrefix) + "-function-sections=0"));
1163
1164	bool DataSectionsTurnedOff = false;
1165	if (Args.hasFlag(Pos: options::OPT_fdata_sections, Neg: options::OPT_fno_data_sections,
1166	Default: UseSeparateSections)) {
1167	CmdArgs.push_back(
1168	Elt: Args.MakeArgString(Str: Twine(PluginOptPrefix) + "-data-sections=1"));
1169	} else if (Args.hasArg(Ids: options::OPT_fno_data_sections)) {
1170	DataSectionsTurnedOff = true;
1171	CmdArgs.push_back(
1172	Elt: Args.MakeArgString(Str: Twine(PluginOptPrefix) + "-data-sections=0"));
1173	}
1174
1175	if (Args.hasArg(Ids: options::OPT_mxcoff_roptr) ||
1176	Args.hasArg(Ids: options::OPT_mno_xcoff_roptr)) {
1177	bool HasRoptr = Args.hasFlag(Pos: options::OPT_mxcoff_roptr,
1178	Neg: options::OPT_mno_xcoff_roptr, Default: false);
1179	StringRef OptStr = HasRoptr ? "-mxcoff-roptr" : "-mno-xcoff-roptr";
1180	if (!IsOSAIX)
1181	D.Diag(DiagID: diag::err_drv_unsupported_opt_for_target)
1182	<< OptStr << Triple.str();
1183
1184	if (HasRoptr) {
1185	// The data sections option is on by default on AIX. We only need to error
1186	// out when -fno-data-sections is specified explicitly to turn off data
1187	// sections.
1188	if (DataSectionsTurnedOff)
1189	D.Diag(DiagID: diag::err_roptr_requires_data_sections);
1190
1191	CmdArgs.push_back(
1192	Elt: Args.MakeArgString(Str: Twine(PluginOptPrefix) + "-mxcoff-roptr"));
1193	}
1194	}
1195
1196	// Pass an option to enable split machine functions.
1197	if (auto *A = Args.getLastArg(Ids: options::OPT_fsplit_machine_functions,
1198	Ids: options::OPT_fno_split_machine_functions)) {
1199	if (A->getOption().matches(ID: options::OPT_fsplit_machine_functions))
1200	CmdArgs.push_back(Elt: Args.MakeArgString(Str: Twine(PluginOptPrefix) +
1201	"-split-machine-functions"));
1202	}
1203
1204	if (Arg *A = getLastProfileSampleUseArg(Args)) {
1205	StringRef FName = A->getValue();
1206	if (!llvm::sys::fs::exists(Path: FName))
1207	D.Diag(DiagID: diag::err_drv_no_such_file) << FName;
1208	else
1209	CmdArgs.push_back(Elt: Args.MakeArgString(Str: Twine(PluginOptPrefix) +
1210	"sample-profile=" + FName));
1211	}
1212
1213	if (auto *CSPGOGenerateArg = getLastCSProfileGenerateArg(Args)) {
1214	CmdArgs.push_back(Elt: Args.MakeArgString(Str: Twine(PluginOptPrefix) + ExtraDash +
1215	"cs-profile-generate"));
1216	if (CSPGOGenerateArg->getOption().matches(
1217	ID: options::OPT_fcs_profile_generate_EQ)) {
1218	SmallString<128> Path(CSPGOGenerateArg->getValue());
1219	llvm::sys::path::append(path&: Path, a: "default_%m.profraw");
1220	CmdArgs.push_back(Elt: Args.MakeArgString(Str: Twine(PluginOptPrefix) + ExtraDash +
1221	"cs-profile-path=" + Path));
1222	} else
1223	CmdArgs.push_back(
1224	Elt: Args.MakeArgString(Str: Twine(PluginOptPrefix) + ExtraDash +
1225	"cs-profile-path=default_%m.profraw"));
1226	} else if (auto *ProfileUseArg = getLastProfileUseArg(Args)) {
1227	SmallString<128> Path(
1228	ProfileUseArg->getNumValues() == 0 ? "" : ProfileUseArg->getValue());
1229	if (Path.empty() || llvm::sys::fs::is_directory(Path))
1230	llvm::sys::path::append(path&: Path, a: "default.profdata");
1231	CmdArgs.push_back(Elt: Args.MakeArgString(Str: Twine(PluginOptPrefix) + ExtraDash +
1232	"cs-profile-path=" + Path));
1233	}
1234
1235	// This controls whether or not we perform JustMyCode instrumentation.
1236	if (Args.hasFlag(Pos: options::OPT_fjmc, Neg: options::OPT_fno_jmc, Default: false)) {
1237	if (ToolChain.getEffectiveTriple().isOSBinFormatELF())
1238	CmdArgs.push_back(Elt: Args.MakeArgString(Str: Twine(PluginOptPrefix) +
1239	"-enable-jmc-instrument"));
1240	else
1241	D.Diag(DiagID: clang::diag::warn_drv_fjmc_for_elf_only);
1242	}
1243
1244	if (Args.hasFlag(Pos: options::OPT_femulated_tls, Neg: options::OPT_fno_emulated_tls,
1245	Default: Triple.hasDefaultEmulatedTLS())) {
1246	CmdArgs.push_back(
1247	Elt: Args.MakeArgString(Str: Twine(PluginOptPrefix) + "-emulated-tls"));
1248	}
1249	if (isTLSDESCEnabled(TC: ToolChain, Args))
1250	CmdArgs.push_back(
1251	Elt: Args.MakeArgString(Str: Twine(PluginOptPrefix) + "-enable-tlsdesc"));
1252
1253	if (Args.hasFlag(Pos: options::OPT_fstack_size_section,
1254	Neg: options::OPT_fno_stack_size_section, Default: false))
1255	CmdArgs.push_back(
1256	Elt: Args.MakeArgString(Str: Twine(PluginOptPrefix) + "-stack-size-section"));
1257
1258	// Setup statistics file output.
1259	SmallString<128> StatsFile = getStatsFileName(Args, Output, Input: *Input, D);
1260	if (!StatsFile.empty())
1261	CmdArgs.push_back(
1262	Elt: Args.MakeArgString(Str: Twine(PluginOptPrefix) + "stats-file=" + StatsFile));
1263
1264	// Setup crash diagnostics dir.
1265	if (Arg *A = Args.getLastArg(Ids: options::OPT_fcrash_diagnostics_dir))
1266	CmdArgs.push_back(Elt: Args.MakeArgString(
1267	Str: Twine(PluginOptPrefix) + "-crash-diagnostics-dir=" + A->getValue()));
1268
1269	addX86AlignBranchArgs(D, Args, CmdArgs, /*IsLTO=*/true, PluginOptPrefix);
1270
1271	// Handle remark diagnostics on screen options: '-Rpass-*'.
1272	renderRpassOptions(Args, CmdArgs, PluginOptPrefix);
1273
1274	// Handle serialized remarks options: '-fsave-optimization-record'
1275	// and '-foptimization-record-*'.
1276	if (willEmitRemarks(Args))
1277	renderRemarksOptions(Args, CmdArgs, Triple: ToolChain.getEffectiveTriple(), Input: *Input,
1278	Output, PluginOptPrefix);
1279
1280	// Handle remarks hotness/threshold related options.
1281	renderRemarksHotnessOptions(Args, CmdArgs, PluginOptPrefix);
1282
1283	addMachineOutlinerArgs(D, Args, CmdArgs, Triple: ToolChain.getEffectiveTriple(),
1284	/*IsLTO=*/true, PluginOptPrefix);
1285
1286	bool IsELF = Triple.isOSBinFormatELF();
1287	bool Crel = false;
1288	bool ImplicitMapSyms = false;
1289	for (const Arg *A : Args.filtered(Ids: options::OPT_Wa_COMMA)) {
1290	for (StringRef V : A->getValues()) {
1291	auto Equal = V.split(Separator: '=');
1292	auto checkArg = [&](bool ValidTarget,
1293	std::initializer_list<const char *> Set) {
1294	if (!ValidTarget) {
1295	D.Diag(DiagID: diag::err_drv_unsupported_opt_for_target)
1296	<< (Twine("-Wa,") + Equal.first + "=").str()
1297	<< Triple.getTriple();
1298	} else if (!llvm::is_contained(Set, Element: Equal.second)) {
1299	D.Diag(DiagID: diag::err_drv_unsupported_option_argument)
1300	<< (Twine("-Wa,") + Equal.first + "=").str() << Equal.second;
1301	}
1302	};
1303	if (Equal.first == "-mmapsyms") {
1304	ImplicitMapSyms = Equal.second == "implicit";
1305	checkArg(IsELF && Triple.isAArch64(), {"default", "implicit"});
1306	} else if (V == "--crel")
1307	Crel = true;
1308	else if (V == "--no-crel")
1309	Crel = false;
1310	else
1311	continue;
1312	A->claim();
1313	}
1314	}
1315	if (Crel) {
1316	if (IsELF && !Triple.isMIPS()) {
1317	CmdArgs.push_back(Elt: Args.MakeArgString(Str: Twine(PluginOptPrefix) + "-crel"));
1318	} else {
1319	D.Diag(DiagID: diag::err_drv_unsupported_opt_for_target)
1320	<< "-Wa,--crel" << D.getTargetTriple();
1321	}
1322	}
1323	if (ImplicitMapSyms)
1324	CmdArgs.push_back(
1325	Elt: Args.MakeArgString(Str: Twine(PluginOptPrefix) + "-implicit-mapsyms"));
1326
1327	if (Args.hasArg(Ids: options::OPT_ftime_report))
1328	CmdArgs.push_back(
1329	Elt: Args.MakeArgString(Str: Twine(PluginOptPrefix) + "-time-passes"));
1330
1331	if (Arg *A = Args.getLastArg(Ids: options::OPT_fthinlto_distributor_EQ)) {
1332	CmdArgs.push_back(
1333	Elt: Args.MakeArgString(Str: "--thinlto-distributor=" + Twine(A->getValue())));
1334	CmdArgs.push_back(
1335	Elt: Args.MakeArgString(Str: "--thinlto-remote-compiler=" +
1336	Twine(ToolChain.getDriver().getClangProgramPath())));
1337
1338	for (auto A : Args.getAllArgValues(Id: options::OPT_Xthinlto_distributor_EQ))
1339	CmdArgs.push_back(Elt: Args.MakeArgString(Str: "--thinlto-distributor-arg=" + A));
1340	}
1341	}
1342
1343	void tools::addOpenMPRuntimeLibraryPath(const ToolChain &TC,
1344	const ArgList &Args,
1345	ArgStringList &CmdArgs) {
1346	// Default to clang lib / lib64 folder, i.e. the same location as device
1347	// runtime.
1348	SmallString<256> DefaultLibPath =
1349	llvm::sys::path::parent_path(path: TC.getDriver().Dir);
1350	llvm::sys::path::append(path&: DefaultLibPath, CLANG_INSTALL_LIBDIR_BASENAME);
1351	CmdArgs.push_back(Elt: Args.MakeArgString(Str: "-L" + DefaultLibPath));
1352	}
1353
1354	void tools::addArchSpecificRPath(const ToolChain &TC, const ArgList &Args,
1355	ArgStringList &CmdArgs) {
1356	if (!Args.hasFlag(Pos: options::OPT_frtlib_add_rpath,
1357	Neg: options::OPT_fno_rtlib_add_rpath, Default: false))
1358	return;
1359
1360	if (TC.getTriple().isOSAIX()) // TODO: AIX doesn't support -rpath option.
1361	return;
1362
1363	SmallVector<std::string> CandidateRPaths(TC.getArchSpecificLibPaths());
1364	if (const auto CandidateRPath = TC.getStdlibPath())
1365	CandidateRPaths.emplace_back(Args: *CandidateRPath);
1366
1367	for (const auto &CandidateRPath : CandidateRPaths) {
1368	if (TC.getVFS().exists(Path: CandidateRPath)) {
1369	CmdArgs.push_back(Elt: "-rpath");
1370	CmdArgs.push_back(Elt: Args.MakeArgString(Str: CandidateRPath));
1371	}
1372	}
1373	}
1374
1375	bool tools::addOpenMPRuntime(const Compilation &C, ArgStringList &CmdArgs,
1376	const ToolChain &TC, const ArgList &Args,
1377	bool ForceStaticHostRuntime, bool IsOffloadingHost,
1378	bool GompNeedsRT) {
1379	if (!Args.hasFlag(Pos: options::OPT_fopenmp, PosAlias: options::OPT_fopenmp_EQ,
1380	Neg: options::OPT_fno_openmp, Default: false)) {
1381	// We need libomptarget (liboffload) if it's the choosen offloading runtime.
1382	if (Args.hasFlag(Pos: options::OPT_foffload_via_llvm,
1383	Neg: options::OPT_fno_offload_via_llvm, Default: false))
1384	CmdArgs.push_back(Elt: "-lomptarget");
1385	return false;
1386	}
1387
1388	Driver::OpenMPRuntimeKind RTKind = TC.getDriver().getOpenMPRuntime(Args);
1389
1390	if (RTKind == Driver::OMPRT_Unknown)
1391	// Already diagnosed.
1392	return false;
1393
1394	if (ForceStaticHostRuntime)
1395	CmdArgs.push_back(Elt: "-Bstatic");
1396
1397	switch (RTKind) {
1398	case Driver::OMPRT_OMP:
1399	CmdArgs.push_back(Elt: "-lomp");
1400	break;
1401	case Driver::OMPRT_GOMP:
1402	CmdArgs.push_back(Elt: "-lgomp");
1403	break;
1404	case Driver::OMPRT_IOMP5:
1405	CmdArgs.push_back(Elt: "-liomp5");
1406	break;
1407	case Driver::OMPRT_Unknown:
1408	break;
1409	}
1410
1411	if (ForceStaticHostRuntime)
1412	CmdArgs.push_back(Elt: "-Bdynamic");
1413
1414	if (RTKind == Driver::OMPRT_GOMP && GompNeedsRT)
1415	CmdArgs.push_back(Elt: "-lrt");
1416
1417	if (IsOffloadingHost)
1418	CmdArgs.push_back(Elt: "-lomptarget");
1419
1420	addArchSpecificRPath(TC, Args, CmdArgs);
1421
1422	addOpenMPRuntimeLibraryPath(TC, Args, CmdArgs);
1423
1424	return true;
1425	}
1426
1427	void tools::addOpenMPHostOffloadingArgs(const Compilation &C,
1428	const JobAction &JA,
1429	const llvm::opt::ArgList &Args,
1430	llvm::opt::ArgStringList &CmdArgs) {
1431	if (!JA.isHostOffloading(OKind: Action::OFK_OpenMP))
1432	return;
1433
1434	// For all the host OpenMP offloading compile jobs we need to pass the targets
1435	// information using -fopenmp-targets= option.
1436	constexpr llvm::StringLiteral Targets("--offload-targets=");
1437
1438	SmallVector<std::string> Triples;
1439	auto TCRange = C.getOffloadToolChains<Action::OFK_OpenMP>();
1440	std::transform(first: TCRange.first, last: TCRange.second, result: std::back_inserter(x&: Triples),
1441	unary_op: [](auto TC) { return TC.second->getTripleString(); });
1442	CmdArgs.push_back(
1443	Elt: Args.MakeArgString(Str: Twine(Targets) + llvm::join(R&: Triples, Separator: ",")));
1444	}
1445
1446	static void addSanitizerRuntime(const ToolChain &TC, const ArgList &Args,
1447	ArgStringList &CmdArgs, StringRef Sanitizer,
1448	bool IsShared, bool IsWhole) {
1449	// Wrap any static runtimes that must be forced into executable in
1450	// whole-archive.
1451	if (IsWhole) CmdArgs.push_back(Elt: "--whole-archive");
1452	CmdArgs.push_back(Elt: TC.getCompilerRTArgString(
1453	Args, Component: Sanitizer, Type: IsShared ? ToolChain::FT_Shared : ToolChain::FT_Static));
1454	if (IsWhole) CmdArgs.push_back(Elt: "--no-whole-archive");
1455
1456	if (IsShared) {
1457	addArchSpecificRPath(TC, Args, CmdArgs);
1458	}
1459	}
1460
1461	// Tries to use a file with the list of dynamic symbols that need to be exported
1462	// from the runtime library. Returns true if the file was found.
1463	static bool addSanitizerDynamicList(const ToolChain &TC, const ArgList &Args,
1464	ArgStringList &CmdArgs,
1465	StringRef Sanitizer) {
1466	bool LinkerIsGnuLd = solaris::isLinkerGnuLd(TC, Args);
1467
1468	// Solaris ld defaults to --export-dynamic behaviour but doesn't support
1469	// the option, so don't try to pass it.
1470	if (TC.getTriple().isOSSolaris() && !LinkerIsGnuLd)
1471	return true;
1472	SmallString<128> SanRT(TC.getCompilerRT(Args, Component: Sanitizer));
1473	if (llvm::sys::fs::exists(Path: SanRT + ".syms")) {
1474	CmdArgs.push_back(Elt: Args.MakeArgString(Str: "--dynamic-list=" + SanRT + ".syms"));
1475	return true;
1476	}
1477	return false;
1478	}
1479
1480	void tools::addAsNeededOption(const ToolChain &TC,
1481	const llvm::opt::ArgList &Args,
1482	llvm::opt::ArgStringList &CmdArgs,
1483	bool as_needed) {
1484	assert(!TC.getTriple().isOSAIX() &&
1485	"AIX linker does not support any form of --as-needed option yet.");
1486	bool LinkerIsGnuLd = solaris::isLinkerGnuLd(TC, Args);
1487
1488	// While the Solaris 11.2 ld added --as-needed/--no-as-needed as aliases
1489	// for the native forms -z ignore/-z record, they are missing in Illumos,
1490	// so always use the native form.
1491	// GNU ld doesn't support -z ignore/-z record, so don't use them even on
1492	// Solaris.
1493	if (TC.getTriple().isOSSolaris() && !LinkerIsGnuLd) {
1494	CmdArgs.push_back(Elt: "-z");
1495	CmdArgs.push_back(Elt: as_needed ? "ignore" : "record");
1496	} else {
1497	CmdArgs.push_back(Elt: as_needed ? "--as-needed" : "--no-as-needed");
1498	}
1499	}
1500
1501	void tools::linkSanitizerRuntimeDeps(const ToolChain &TC,
1502	const llvm::opt::ArgList &Args,
1503	ArgStringList &CmdArgs) {
1504	// Force linking against the system libraries sanitizers depends on
1505	// (see PR15823 why this is necessary).
1506	addAsNeededOption(TC, Args, CmdArgs, as_needed: false);
1507	// There's no libpthread or librt on RTEMS & Android.
1508	if (TC.getTriple().getOS() != llvm::Triple::RTEMS &&
1509	!TC.getTriple().isAndroid() && !TC.getTriple().isOHOSFamily()) {
1510	CmdArgs.push_back(Elt: "-lpthread");
1511	if (!TC.getTriple().isOSOpenBSD() && !TC.getTriple().isOSHaiku())
1512	CmdArgs.push_back(Elt: "-lrt");
1513	}
1514	CmdArgs.push_back(Elt: "-lm");
1515	// There's no libdl on all OSes.
1516	if (!TC.getTriple().isOSFreeBSD() && !TC.getTriple().isOSNetBSD() &&
1517	!TC.getTriple().isOSOpenBSD() && !TC.getTriple().isOSDragonFly() &&
1518	!TC.getTriple().isOSHaiku() &&
1519	TC.getTriple().getOS() != llvm::Triple::RTEMS)
1520	CmdArgs.push_back(Elt: "-ldl");
1521	// Required for backtrace on some OSes
1522	if (TC.getTriple().isOSFreeBSD() || TC.getTriple().isOSNetBSD() ||
1523	TC.getTriple().isOSOpenBSD() || TC.getTriple().isOSDragonFly())
1524	CmdArgs.push_back(Elt: "-lexecinfo");
1525	if (TC.getTriple().isOSHaiku())
1526	CmdArgs.push_back(Elt: "-lbsd");
1527	// There is no libresolv on Android, FreeBSD, OpenBSD, etc. On musl
1528	// libresolv.a, even if exists, is an empty archive to satisfy POSIX -lresolv
1529	// requirement.
1530	if (TC.getTriple().isOSLinux() && !TC.getTriple().isAndroid() &&
1531	!TC.getTriple().isMusl())
1532	CmdArgs.push_back(Elt: "-lresolv");
1533	}
1534
1535	static void
1536	collectSanitizerRuntimes(const ToolChain &TC, const ArgList &Args,
1537	SmallVectorImpl<StringRef> &SharedRuntimes,
1538	SmallVectorImpl<StringRef> &StaticRuntimes,
1539	SmallVectorImpl<StringRef> &NonWholeStaticRuntimes,
1540	SmallVectorImpl<StringRef> &HelperStaticRuntimes,
1541	SmallVectorImpl<StringRef> &RequiredSymbols) {
1542	assert(!TC.getTriple().isOSDarwin() && "it's not used by Darwin");
1543	const SanitizerArgs &SanArgs = TC.getSanitizerArgs(JobArgs: Args);
1544	// Collect shared runtimes.
1545	if (SanArgs.needsSharedRt()) {
1546	if (SanArgs.needsAsanRt()) {
1547	SharedRuntimes.push_back(Elt: "asan");
1548	if (!Args.hasArg(Ids: options::OPT_shared) && !TC.getTriple().isAndroid())
1549	HelperStaticRuntimes.push_back(Elt: "asan-preinit");
1550	}
1551	if (SanArgs.needsMemProfRt()) {
1552	SharedRuntimes.push_back(Elt: "memprof");
1553	if (!Args.hasArg(Ids: options::OPT_shared) && !TC.getTriple().isAndroid())
1554	HelperStaticRuntimes.push_back(Elt: "memprof-preinit");
1555	}
1556	if (SanArgs.needsNsanRt())
1557	SharedRuntimes.push_back(Elt: "nsan");
1558	if (SanArgs.needsUbsanRt()) {
1559	if (SanArgs.requiresMinimalRuntime())
1560	SharedRuntimes.push_back(Elt: "ubsan_minimal");
1561	else
1562	SharedRuntimes.push_back(Elt: "ubsan_standalone");
1563	}
1564	if (SanArgs.needsScudoRt()) {
1565	SharedRuntimes.push_back(Elt: "scudo_standalone");
1566	}
1567	if (SanArgs.needsTsanRt())
1568	SharedRuntimes.push_back(Elt: "tsan");
1569	if (SanArgs.needsTysanRt())
1570	SharedRuntimes.push_back(Elt: "tysan");
1571	if (SanArgs.needsHwasanRt()) {
1572	if (SanArgs.needsHwasanAliasesRt())
1573	SharedRuntimes.push_back(Elt: "hwasan_aliases");
1574	else
1575	SharedRuntimes.push_back(Elt: "hwasan");
1576	if (!Args.hasArg(Ids: options::OPT_shared))
1577	HelperStaticRuntimes.push_back(Elt: "hwasan-preinit");
1578	}
1579	if (SanArgs.needsRtsanRt() && SanArgs.linkRuntimes())
1580	SharedRuntimes.push_back(Elt: "rtsan");
1581	}
1582
1583	// The stats_client library is also statically linked into DSOs.
1584	if (SanArgs.needsStatsRt())
1585	StaticRuntimes.push_back(Elt: "stats_client");
1586
1587	// Always link the static runtime regardless of DSO or executable.
1588	if (SanArgs.needsAsanRt())
1589	HelperStaticRuntimes.push_back(Elt: "asan_static");
1590
1591	// Collect static runtimes.
1592	if (Args.hasArg(Ids: options::OPT_shared)) {
1593	// Don't link static runtimes into DSOs.
1594	return;
1595	}
1596
1597	// Each static runtime that has a DSO counterpart above is excluded below,
1598	// but runtimes that exist only as static are not affected by needsSharedRt.
1599
1600	if (!SanArgs.needsSharedRt() && SanArgs.needsAsanRt()) {
1601	StaticRuntimes.push_back(Elt: "asan");
1602	if (SanArgs.linkCXXRuntimes())
1603	StaticRuntimes.push_back(Elt: "asan_cxx");
1604	}
1605
1606	if (!SanArgs.needsSharedRt() && SanArgs.needsRtsanRt() &&
1607	SanArgs.linkRuntimes())
1608	StaticRuntimes.push_back(Elt: "rtsan");
1609
1610	if (!SanArgs.needsSharedRt() && SanArgs.needsMemProfRt()) {
1611	StaticRuntimes.push_back(Elt: "memprof");
1612	if (SanArgs.linkCXXRuntimes())
1613	StaticRuntimes.push_back(Elt: "memprof_cxx");
1614	}
1615
1616	if (!SanArgs.needsSharedRt() && SanArgs.needsHwasanRt()) {
1617	if (SanArgs.needsHwasanAliasesRt()) {
1618	StaticRuntimes.push_back(Elt: "hwasan_aliases");
1619	if (SanArgs.linkCXXRuntimes())
1620	StaticRuntimes.push_back(Elt: "hwasan_aliases_cxx");
1621	} else {
1622	StaticRuntimes.push_back(Elt: "hwasan");
1623	if (SanArgs.linkCXXRuntimes())
1624	StaticRuntimes.push_back(Elt: "hwasan_cxx");
1625	}
1626	}
1627	if (SanArgs.needsDfsanRt())
1628	StaticRuntimes.push_back(Elt: "dfsan");
1629	if (SanArgs.needsLsanRt())
1630	StaticRuntimes.push_back(Elt: "lsan");
1631	if (SanArgs.needsMsanRt()) {
1632	StaticRuntimes.push_back(Elt: "msan");
1633	if (SanArgs.linkCXXRuntimes())
1634	StaticRuntimes.push_back(Elt: "msan_cxx");
1635	}
1636	if (!SanArgs.needsSharedRt() && SanArgs.needsNsanRt())
1637	StaticRuntimes.push_back(Elt: "nsan");
1638	if (!SanArgs.needsSharedRt() && SanArgs.needsTsanRt()) {
1639	StaticRuntimes.push_back(Elt: "tsan");
1640	if (SanArgs.linkCXXRuntimes())
1641	StaticRuntimes.push_back(Elt: "tsan_cxx");
1642	}
1643	if (!SanArgs.needsSharedRt() && SanArgs.needsTysanRt())
1644	StaticRuntimes.push_back(Elt: "tysan");
1645	if (!SanArgs.needsSharedRt() && SanArgs.needsUbsanRt()) {
1646	if (SanArgs.requiresMinimalRuntime()) {
1647	StaticRuntimes.push_back(Elt: "ubsan_minimal");
1648	} else {
1649	StaticRuntimes.push_back(Elt: "ubsan_standalone");
1650	}
1651	}
1652	if (SanArgs.needsSafeStackRt()) {
1653	NonWholeStaticRuntimes.push_back(Elt: "safestack");
1654	RequiredSymbols.push_back(Elt: "__safestack_init");
1655	}
1656	if (!(SanArgs.needsSharedRt() && SanArgs.needsUbsanRt())) {
1657	if (SanArgs.needsCfiCrossDsoRt())
1658	StaticRuntimes.push_back(Elt: "cfi");
1659	if (SanArgs.needsCfiCrossDsoDiagRt())
1660	StaticRuntimes.push_back(Elt: "cfi_diag");
1661	}
1662	if (SanArgs.linkCXXRuntimes() && !SanArgs.requiresMinimalRuntime() &&
1663	((!SanArgs.needsSharedRt() && SanArgs.needsUbsanCXXRt()) ||
1664	SanArgs.needsCfiCrossDsoDiagRt())) {
1665	StaticRuntimes.push_back(Elt: "ubsan_standalone_cxx");
1666	}
1667	if (SanArgs.needsStatsRt()) {
1668	NonWholeStaticRuntimes.push_back(Elt: "stats");
1669	RequiredSymbols.push_back(Elt: "__sanitizer_stats_register");
1670	}
1671	if (!SanArgs.needsSharedRt() && SanArgs.needsScudoRt()) {
1672	StaticRuntimes.push_back(Elt: "scudo_standalone");
1673	if (SanArgs.linkCXXRuntimes())
1674	StaticRuntimes.push_back(Elt: "scudo_standalone_cxx");
1675	}
1676	}
1677
1678	// Should be called before we add system libraries (C++ ABI, libstdc++/libc++,
1679	// C runtime, etc). Returns true if sanitizer system deps need to be linked in.
1680	bool tools::addSanitizerRuntimes(const ToolChain &TC, const ArgList &Args,
1681	ArgStringList &CmdArgs) {
1682	const SanitizerArgs &SanArgs = TC.getSanitizerArgs(JobArgs: Args);
1683	SmallVector<StringRef, 4> SharedRuntimes, StaticRuntimes,
1684	NonWholeStaticRuntimes, HelperStaticRuntimes, RequiredSymbols;
1685	if (SanArgs.linkRuntimes()) {
1686	collectSanitizerRuntimes(TC, Args, SharedRuntimes, StaticRuntimes,
1687	NonWholeStaticRuntimes, HelperStaticRuntimes,
1688	RequiredSymbols);
1689	}
1690
1691	// -u options must be added before the runtime libs that resolve them.
1692	for (auto S : RequiredSymbols) {
1693	CmdArgs.push_back(Elt: "-u");
1694	CmdArgs.push_back(Elt: Args.MakeArgString(Str: S));
1695	}
1696
1697	// Inject libfuzzer dependencies.
1698	if (SanArgs.needsFuzzer() && SanArgs.linkRuntimes() &&
1699	!Args.hasArg(Ids: options::OPT_shared)) {
1700
1701	addSanitizerRuntime(TC, Args, CmdArgs, Sanitizer: "fuzzer", IsShared: false, IsWhole: true);
1702	if (SanArgs.needsFuzzerInterceptors())
1703	addSanitizerRuntime(TC, Args, CmdArgs, Sanitizer: "fuzzer_interceptors", IsShared: false,
1704	IsWhole: true);
1705	if (!Args.hasArg(Ids: clang::driver::options::OPT_nostdlibxx)) {
1706	bool OnlyLibstdcxxStatic = Args.hasArg(Ids: options::OPT_static_libstdcxx) &&
1707	!Args.hasArg(Ids: options::OPT_static);
1708	if (OnlyLibstdcxxStatic)
1709	CmdArgs.push_back(Elt: "-Bstatic");
1710	TC.AddCXXStdlibLibArgs(Args, CmdArgs);
1711	if (OnlyLibstdcxxStatic)
1712	CmdArgs.push_back(Elt: "-Bdynamic");
1713	}
1714	}
1715
1716	for (auto RT : SharedRuntimes)
1717	addSanitizerRuntime(TC, Args, CmdArgs, Sanitizer: RT, IsShared: true, IsWhole: false);
1718	for (auto RT : HelperStaticRuntimes)
1719	addSanitizerRuntime(TC, Args, CmdArgs, Sanitizer: RT, IsShared: false, IsWhole: true);
1720	bool AddExportDynamic = false;
1721	for (auto RT : StaticRuntimes) {
1722	addSanitizerRuntime(TC, Args, CmdArgs, Sanitizer: RT, IsShared: false, IsWhole: true);
1723	AddExportDynamic |= !addSanitizerDynamicList(TC, Args, CmdArgs, Sanitizer: RT);
1724	}
1725	for (auto RT : NonWholeStaticRuntimes) {
1726	addSanitizerRuntime(TC, Args, CmdArgs, Sanitizer: RT, IsShared: false, IsWhole: false);
1727	AddExportDynamic |= !addSanitizerDynamicList(TC, Args, CmdArgs, Sanitizer: RT);
1728	}
1729	// If there is a static runtime with no dynamic list, force all the symbols
1730	// to be dynamic to be sure we export sanitizer interface functions.
1731	if (AddExportDynamic)
1732	CmdArgs.push_back(Elt: "--export-dynamic");
1733
1734	if (SanArgs.hasCrossDsoCfi() && !AddExportDynamic)
1735	CmdArgs.push_back(Elt: "--export-dynamic-symbol=__cfi_check");
1736
1737	if (SanArgs.hasMemTag()) {
1738	if (!TC.getTriple().isAndroid()) {
1739	TC.getDriver().Diag(DiagID: diag::err_drv_unsupported_opt_for_target)
1740	<< "-fsanitize=memtag*" << TC.getTriple().str();
1741	}
1742	CmdArgs.push_back(
1743	Elt: Args.MakeArgString(Str: "--android-memtag-mode=" + SanArgs.getMemtagMode()));
1744	if (SanArgs.hasMemtagHeap())
1745	CmdArgs.push_back(Elt: "--android-memtag-heap");
1746	if (SanArgs.hasMemtagStack())
1747	CmdArgs.push_back(Elt: "--android-memtag-stack");
1748	}
1749
1750	return !StaticRuntimes.empty() || !NonWholeStaticRuntimes.empty();
1751	}
1752
1753	bool tools::addXRayRuntime(const ToolChain&TC, const ArgList &Args, ArgStringList &CmdArgs) {
1754	const XRayArgs &XRay = TC.getXRayArgs(Args);
1755	if (Args.hasArg(Ids: options::OPT_shared)) {
1756	if (XRay.needsXRayDSORt()) {
1757	CmdArgs.push_back(Elt: "--whole-archive");
1758	CmdArgs.push_back(Elt: TC.getCompilerRTArgString(Args, Component: "xray-dso"));
1759	CmdArgs.push_back(Elt: "--no-whole-archive");
1760	return true;
1761	}
1762	} else if (XRay.needsXRayRt()) {
1763	CmdArgs.push_back(Elt: "--whole-archive");
1764	CmdArgs.push_back(Elt: TC.getCompilerRTArgString(Args, Component: "xray"));
1765	for (const auto &Mode : XRay.modeList())
1766	CmdArgs.push_back(Elt: TC.getCompilerRTArgString(Args, Component: Mode));
1767	CmdArgs.push_back(Elt: "--no-whole-archive");
1768	return true;
1769	}
1770
1771	return false;
1772	}
1773
1774	void tools::linkXRayRuntimeDeps(const ToolChain &TC,
1775	const llvm::opt::ArgList &Args,
1776	ArgStringList &CmdArgs) {
1777	addAsNeededOption(TC, Args, CmdArgs, as_needed: false);
1778	CmdArgs.push_back(Elt: "-lpthread");
1779	if (!TC.getTriple().isOSOpenBSD())
1780	CmdArgs.push_back(Elt: "-lrt");
1781	CmdArgs.push_back(Elt: "-lm");
1782
1783	if (!TC.getTriple().isOSFreeBSD() &&
1784	!TC.getTriple().isOSNetBSD() &&
1785	!TC.getTriple().isOSOpenBSD())
1786	CmdArgs.push_back(Elt: "-ldl");
1787	}
1788
1789	bool tools::areOptimizationsEnabled(const ArgList &Args) {
1790	// Find the last -O arg and see if it is non-zero.
1791	if (Arg *A = Args.getLastArg(Ids: options::OPT_O_Group))
1792	return !A->getOption().matches(ID: options::OPT_O0);
1793	// Defaults to -O0.
1794	return false;
1795	}
1796
1797	const char *tools::SplitDebugName(const JobAction &JA, const ArgList &Args,
1798	const InputInfo &Input,
1799	const InputInfo &Output) {
1800	auto AddPostfix = [JA](auto &F) {
1801	if (JA.getOffloadingDeviceKind() == Action::OFK_HIP)
1802	F += (Twine("_") + JA.getOffloadingArch()).str();
1803	F += ".dwo";
1804	};
1805	if (Arg *A = Args.getLastArg(Ids: options::OPT_gsplit_dwarf_EQ))
1806	if (StringRef(A->getValue()) == "single" && Output.isFilename())
1807	return Args.MakeArgString(Str: Output.getFilename());
1808
1809	SmallString<128> T;
1810	if (const Arg *A = Args.getLastArg(Ids: options::OPT_dumpdir)) {
1811	T = A->getValue();
1812	} else {
1813	Arg *FinalOutput = Args.getLastArg(Ids: options::OPT_o, Ids: options::OPT__SLASH_o);
1814	if (FinalOutput && Args.hasArg(Ids: options::OPT_c)) {
1815	T = FinalOutput->getValue();
1816	llvm::sys::path::remove_filename(path&: T);
1817	llvm::sys::path::append(path&: T,
1818	a: llvm::sys::path::stem(path: FinalOutput->getValue()));
1819	AddPostfix(T);
1820	return Args.MakeArgString(Str: T);
1821	}
1822	}
1823
1824	T += llvm::sys::path::stem(path: Input.getBaseInput());
1825	AddPostfix(T);
1826	return Args.MakeArgString(Str: T);
1827	}
1828
1829	void tools::SplitDebugInfo(const ToolChain &TC, Compilation &C, const Tool &T,
1830	const JobAction &JA, const ArgList &Args,
1831	const InputInfo &Output, const char *OutFile) {
1832	ArgStringList ExtractArgs;
1833	ExtractArgs.push_back(Elt: "--extract-dwo");
1834
1835	ArgStringList StripArgs;
1836	StripArgs.push_back(Elt: "--strip-dwo");
1837
1838	// Grabbing the output of the earlier compile step.
1839	StripArgs.push_back(Elt: Output.getFilename());
1840	ExtractArgs.push_back(Elt: Output.getFilename());
1841	ExtractArgs.push_back(Elt: OutFile);
1842
1843	const char *Exec =
1844	Args.MakeArgString(Str: TC.GetProgramPath(CLANG_DEFAULT_OBJCOPY));
1845	InputInfo II(types::TY_Object, Output.getFilename(), Output.getFilename());
1846
1847	// First extract the dwo sections.
1848	C.addCommand(C: std::make_unique<Command>(args: JA, args: T,
1849	args: ResponseFileSupport::AtFileCurCP(),
1850	args&: Exec, args&: ExtractArgs, args&: II, args: Output));
1851
1852	// Then remove them from the original .o file.
1853	C.addCommand(C: std::make_unique<Command>(
1854	args: JA, args: T, args: ResponseFileSupport::AtFileCurCP(), args&: Exec, args&: StripArgs, args&: II, args: Output));
1855	}
1856
1857	// Claim options we don't want to warn if they are unused. We do this for
1858	// options that build systems might add but are unused when assembling or only
1859	// running the preprocessor for example.
1860	void tools::claimNoWarnArgs(const ArgList &Args) {
1861	// Don't warn about unused -f(no-)?lto. This can happen when we're
1862	// preprocessing, precompiling or assembling.
1863	Args.ClaimAllArgs(Id0: options::OPT_flto_EQ);
1864	Args.ClaimAllArgs(Id0: options::OPT_flto);
1865	Args.ClaimAllArgs(Id0: options::OPT_fno_lto);
1866	}
1867
1868	Arg *tools::getLastCSProfileGenerateArg(const ArgList &Args) {
1869	auto *CSPGOGenerateArg = Args.getLastArg(Ids: options::OPT_fcs_profile_generate,
1870	Ids: options::OPT_fcs_profile_generate_EQ,
1871	Ids: options::OPT_fno_profile_generate);
1872	if (CSPGOGenerateArg &&
1873	CSPGOGenerateArg->getOption().matches(ID: options::OPT_fno_profile_generate))
1874	CSPGOGenerateArg = nullptr;
1875
1876	return CSPGOGenerateArg;
1877	}
1878
1879	Arg *tools::getLastProfileUseArg(const ArgList &Args) {
1880	auto *ProfileUseArg = Args.getLastArg(
1881	Ids: options::OPT_fprofile_instr_use, Ids: options::OPT_fprofile_instr_use_EQ,
1882	Ids: options::OPT_fprofile_use, Ids: options::OPT_fprofile_use_EQ,
1883	Ids: options::OPT_fno_profile_instr_use);
1884
1885	if (ProfileUseArg &&
1886	ProfileUseArg->getOption().matches(ID: options::OPT_fno_profile_instr_use))
1887	ProfileUseArg = nullptr;
1888
1889	return ProfileUseArg;
1890	}
1891
1892	Arg *tools::getLastProfileSampleUseArg(const ArgList &Args) {
1893	auto *ProfileSampleUseArg = Args.getLastArg(
1894	Ids: options::OPT_fprofile_sample_use_EQ, Ids: options::OPT_fno_profile_sample_use);
1895
1896	if (ProfileSampleUseArg && (ProfileSampleUseArg->getOption().matches(
1897	ID: options::OPT_fno_profile_sample_use)))
1898	return nullptr;
1899
1900	return Args.getLastArg(Ids: options::OPT_fprofile_sample_use_EQ);
1901	}
1902
1903	const char *tools::RelocationModelName(llvm::Reloc::Model Model) {
1904	switch (Model) {
1905	case llvm::Reloc::Static:
1906	return "static";
1907	case llvm::Reloc::PIC_:
1908	return "pic";
1909	case llvm::Reloc::DynamicNoPIC:
1910	return "dynamic-no-pic";
1911	case llvm::Reloc::ROPI:
1912	return "ropi";
1913	case llvm::Reloc::RWPI:
1914	return "rwpi";
1915	case llvm::Reloc::ROPI_RWPI:
1916	return "ropi-rwpi";
1917	}
1918	llvm_unreachable("Unknown Reloc::Model kind");
1919	}
1920
1921	/// Parses the various -fpic/-fPIC/-fpie/-fPIE arguments. Then,
1922	/// smooshes them together with platform defaults, to decide whether
1923	/// this compile should be using PIC mode or not. Returns a tuple of
1924	/// (RelocationModel, PICLevel, IsPIE).
1925	std::tuple<llvm::Reloc::Model, unsigned, bool>
1926	tools::ParsePICArgs(const ToolChain &ToolChain, const ArgList &Args) {
1927	const llvm::Triple &EffectiveTriple = ToolChain.getEffectiveTriple();
1928	const llvm::Triple &Triple = ToolChain.getTriple();
1929
1930	bool PIE = ToolChain.isPIEDefault(Args);
1931	bool PIC = PIE || ToolChain.isPICDefault();
1932	// The Darwin/MachO default to use PIC does not apply when using -static.
1933	if (Triple.isOSBinFormatMachO() && Args.hasArg(Ids: options::OPT_static))
1934	PIE = PIC = false;
1935	bool IsPICLevelTwo = PIC;
1936
1937	bool KernelOrKext =
1938	Args.hasArg(Ids: options::OPT_mkernel, Ids: options::OPT_fapple_kext);
1939
1940	// Android-specific defaults for PIC/PIE
1941	if (Triple.isAndroid()) {
1942	switch (Triple.getArch()) {
1943	case llvm::Triple::x86:
1944	case llvm::Triple::x86_64:
1945	PIC = true; // "-fPIC"
1946	IsPICLevelTwo = true;
1947	break;
1948
1949	default:
1950	PIC = true; // "-fpic"
1951	break;
1952	}
1953	}
1954
1955	// OHOS-specific defaults for PIC/PIE
1956	if (Triple.isOHOSFamily() && Triple.getArch() == llvm::Triple::aarch64)
1957	PIC = true;
1958
1959	// OpenBSD-specific defaults for PIE
1960	if (Triple.isOSOpenBSD()) {
1961	switch (ToolChain.getArch()) {
1962	case llvm::Triple::arm:
1963	case llvm::Triple::aarch64:
1964	case llvm::Triple::mips64:
1965	case llvm::Triple::mips64el:
1966	case llvm::Triple::x86:
1967	case llvm::Triple::x86_64:
1968	IsPICLevelTwo = false; // "-fpie"
1969	break;
1970
1971	case llvm::Triple::ppc:
1972	case llvm::Triple::sparcv9:
1973	IsPICLevelTwo = true; // "-fPIE"
1974	break;
1975
1976	default:
1977	break;
1978	}
1979	}
1980
1981	// The last argument relating to either PIC or PIE wins, and no
1982	// other argument is used. If the last argument is any flavor of the
1983	// '-fno-...' arguments, both PIC and PIE are disabled. Any PIE
1984	// option implicitly enables PIC at the same level.
1985	Arg *LastPICArg = Args.getLastArg(Ids: options::OPT_fPIC, Ids: options::OPT_fno_PIC,
1986	Ids: options::OPT_fpic, Ids: options::OPT_fno_pic,
1987	Ids: options::OPT_fPIE, Ids: options::OPT_fno_PIE,
1988	Ids: options::OPT_fpie, Ids: options::OPT_fno_pie);
1989	if (Triple.isOSWindows() && !Triple.isOSCygMing() && LastPICArg &&
1990	LastPICArg == Args.getLastArg(Ids: options::OPT_fPIC, Ids: options::OPT_fpic,
1991	Ids: options::OPT_fPIE, Ids: options::OPT_fpie)) {
1992	ToolChain.getDriver().Diag(DiagID: diag::err_drv_unsupported_opt_for_target)
1993	<< LastPICArg->getSpelling() << Triple.str();
1994	if (Triple.getArch() == llvm::Triple::x86_64)
1995	return std::make_tuple(args: llvm::Reloc::PIC_, args: 2U, args: false);
1996	return std::make_tuple(args: llvm::Reloc::Static, args: 0U, args: false);
1997	}
1998
1999	// Check whether the tool chain trumps the PIC-ness decision. If the PIC-ness
2000	// is forced, then neither PIC nor PIE flags will have no effect.
2001	if (!ToolChain.isPICDefaultForced()) {
2002	if (LastPICArg) {
2003	Option O = LastPICArg->getOption();
2004	if (O.matches(ID: options::OPT_fPIC) || O.matches(ID: options::OPT_fpic) ||
2005	O.matches(ID: options::OPT_fPIE) || O.matches(ID: options::OPT_fpie)) {
2006	PIE = O.matches(ID: options::OPT_fPIE) || O.matches(ID: options::OPT_fpie);
2007	PIC =
2008	PIE || O.matches(ID: options::OPT_fPIC) || O.matches(ID: options::OPT_fpic);
2009	IsPICLevelTwo =
2010	O.matches(ID: options::OPT_fPIE) || O.matches(ID: options::OPT_fPIC);
2011	} else {
2012	PIE = PIC = false;
2013	if (EffectiveTriple.isPS()) {
2014	Arg *ModelArg = Args.getLastArg(Ids: options::OPT_mcmodel_EQ);
2015	StringRef Model = ModelArg ? ModelArg->getValue() : "";
2016	if (Model != "kernel") {
2017	PIC = true;
2018	ToolChain.getDriver().Diag(DiagID: diag::warn_drv_ps_force_pic)
2019	<< LastPICArg->getSpelling()
2020	<< (EffectiveTriple.isPS4() ? "PS4" : "PS5");
2021	}
2022	}
2023	}
2024	}
2025	}
2026
2027	// Introduce a Darwin and PS4/PS5-specific hack. If the default is PIC, but
2028	// the PIC level would've been set to level 1, force it back to level 2 PIC
2029	// instead.
2030	if (PIC && (Triple.isOSDarwin() || EffectiveTriple.isPS()))
2031	IsPICLevelTwo |= ToolChain.isPICDefault();
2032
2033	// This kernel flags are a trump-card: they will disable PIC/PIE
2034	// generation, independent of the argument order.
2035	if (KernelOrKext &&
2036	((!EffectiveTriple.isiOS() || EffectiveTriple.isOSVersionLT(Major: 6)) &&
2037	!EffectiveTriple.isWatchOS() && !EffectiveTriple.isDriverKit()))
2038	PIC = PIE = false;
2039
2040	if (Arg *A = Args.getLastArg(Ids: options::OPT_mdynamic_no_pic)) {
2041	// This is a very special mode. It trumps the other modes, almost no one
2042	// uses it, and it isn't even valid on any OS but Darwin.
2043	if (!Triple.isOSDarwin())
2044	ToolChain.getDriver().Diag(DiagID: diag::err_drv_unsupported_opt_for_target)
2045	<< A->getSpelling() << Triple.str();
2046
2047	// FIXME: Warn when this flag trumps some other PIC or PIE flag.
2048
2049	// Only a forced PIC mode can cause the actual compile to have PIC defines
2050	// etc., no flags are sufficient. This behavior was selected to closely
2051	// match that of llvm-gcc and Apple GCC before that.
2052	PIC = ToolChain.isPICDefault() && ToolChain.isPICDefaultForced();
2053
2054	return std::make_tuple(args: llvm::Reloc::DynamicNoPIC, args: PIC ? 2U : 0U, args: false);
2055	}
2056
2057	bool EmbeddedPISupported;
2058	switch (Triple.getArch()) {
2059	case llvm::Triple::arm:
2060	case llvm::Triple::armeb:
2061	case llvm::Triple::thumb:
2062	case llvm::Triple::thumbeb:
2063	EmbeddedPISupported = true;
2064	break;
2065	default:
2066	EmbeddedPISupported = false;
2067	break;
2068	}
2069
2070	bool ROPI = false, RWPI = false;
2071	Arg* LastROPIArg = Args.getLastArg(Ids: options::OPT_fropi, Ids: options::OPT_fno_ropi);
2072	if (LastROPIArg && LastROPIArg->getOption().matches(ID: options::OPT_fropi)) {
2073	if (!EmbeddedPISupported)
2074	ToolChain.getDriver().Diag(DiagID: diag::err_drv_unsupported_opt_for_target)
2075	<< LastROPIArg->getSpelling() << Triple.str();
2076	ROPI = true;
2077	}
2078	Arg *LastRWPIArg = Args.getLastArg(Ids: options::OPT_frwpi, Ids: options::OPT_fno_rwpi);
2079	if (LastRWPIArg && LastRWPIArg->getOption().matches(ID: options::OPT_frwpi)) {
2080	if (!EmbeddedPISupported)
2081	ToolChain.getDriver().Diag(DiagID: diag::err_drv_unsupported_opt_for_target)
2082	<< LastRWPIArg->getSpelling() << Triple.str();
2083	RWPI = true;
2084	}
2085
2086	// ROPI and RWPI are not compatible with PIC or PIE.
2087	if ((ROPI || RWPI) && (PIC || PIE))
2088	ToolChain.getDriver().Diag(DiagID: diag::err_drv_ropi_rwpi_incompatible_with_pic);
2089
2090	if (Triple.isMIPS()) {
2091	StringRef CPUName;
2092	StringRef ABIName;
2093	mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
2094	// When targeting the N64 ABI, PIC is the default, except in the case
2095	// when the -mno-abicalls option is used. In that case we exit
2096	// at next check regardless of PIC being set below.
2097	if (ABIName == "n64")
2098	PIC = true;
2099	// When targettng MIPS with -mno-abicalls, it's always static.
2100	if(Args.hasArg(Ids: options::OPT_mno_abicalls))
2101	return std::make_tuple(args: llvm::Reloc::Static, args: 0U, args: false);
2102	// Unlike other architectures, MIPS, even with -fPIC/-mxgot/multigot,
2103	// does not use PIC level 2 for historical reasons.
2104	IsPICLevelTwo = false;
2105	}
2106
2107	if (PIC)
2108	return std::make_tuple(args: llvm::Reloc::PIC_, args: IsPICLevelTwo ? 2U : 1U, args&: PIE);
2109
2110	llvm::Reloc::Model RelocM = llvm::Reloc::Static;
2111	if (ROPI && RWPI)
2112	RelocM = llvm::Reloc::ROPI_RWPI;
2113	else if (ROPI)
2114	RelocM = llvm::Reloc::ROPI;
2115	else if (RWPI)
2116	RelocM = llvm::Reloc::RWPI;
2117
2118	return std::make_tuple(args&: RelocM, args: 0U, args: false);
2119	}
2120
2121	// `-falign-functions` indicates that the functions should be aligned to the
2122	// backend's preferred alignment.
2123	//
2124	// `-falign-functions=1` is the same as `-fno-align-functions`.
2125	//
2126	// The scalar `n` in `-falign-functions=n` must be an integral value between
2127	// [0, 65536]. If the value is not a power-of-two, it will be rounded up to
2128	// the nearest power-of-two.
2129	//
2130	// If we return `0`, the frontend will default to the backend's preferred
2131	// alignment.
2132	//
2133	// NOTE: icc only allows values between [0, 4096]. icc uses `-falign-functions`
2134	// to mean `-falign-functions=16`. GCC defaults to the backend's preferred
2135	// alignment. For unaligned functions, we default to the backend's preferred
2136	// alignment.
2137	unsigned tools::ParseFunctionAlignment(const ToolChain &TC,
2138	const ArgList &Args) {
2139	const Arg *A = Args.getLastArg(Ids: options::OPT_falign_functions,
2140	Ids: options::OPT_falign_functions_EQ,
2141	Ids: options::OPT_fno_align_functions);
2142	if (!A || A->getOption().matches(ID: options::OPT_fno_align_functions))
2143	return 0;
2144
2145	if (A->getOption().matches(ID: options::OPT_falign_functions))
2146	return 0;
2147
2148	unsigned Value = 0;
2149	if (StringRef(A->getValue()).getAsInteger(Radix: 10, Result&: Value) || Value > 65536)
2150	TC.getDriver().Diag(DiagID: diag::err_drv_invalid_int_value)
2151	<< A->getAsString(Args) << A->getValue();
2152	return Value ? llvm::Log2_32_Ceil(Value: std::min(a: Value, b: 65536u)) : Value;
2153	}
2154
2155	void tools::addDebugInfoKind(
2156	ArgStringList &CmdArgs, llvm::codegenoptions::DebugInfoKind DebugInfoKind) {
2157	switch (DebugInfoKind) {
2158	case llvm::codegenoptions::DebugDirectivesOnly:
2159	CmdArgs.push_back(Elt: "-debug-info-kind=line-directives-only");
2160	break;
2161	case llvm::codegenoptions::DebugLineTablesOnly:
2162	CmdArgs.push_back(Elt: "-debug-info-kind=line-tables-only");
2163	break;
2164	case llvm::codegenoptions::DebugInfoConstructor:
2165	CmdArgs.push_back(Elt: "-debug-info-kind=constructor");
2166	break;
2167	case llvm::codegenoptions::LimitedDebugInfo:
2168	CmdArgs.push_back(Elt: "-debug-info-kind=limited");
2169	break;
2170	case llvm::codegenoptions::FullDebugInfo:
2171	CmdArgs.push_back(Elt: "-debug-info-kind=standalone");
2172	break;
2173	case llvm::codegenoptions::UnusedTypeInfo:
2174	CmdArgs.push_back(Elt: "-debug-info-kind=unused-types");
2175	break;
2176	default:
2177	break;
2178	}
2179	}
2180
2181	// Convert an arg of the form "-gN" or "-ggdbN" or one of their aliases
2182	// to the corresponding DebugInfoKind.
2183	llvm::codegenoptions::DebugInfoKind tools::debugLevelToInfoKind(const Arg &A) {
2184	assert(A.getOption().matches(options::OPT_gN_Group) &&
2185	"Not a -g option that specifies a debug-info level");
2186	if (A.getOption().matches(ID: options::OPT_g0) ||
2187	A.getOption().matches(ID: options::OPT_ggdb0))
2188	return llvm::codegenoptions::NoDebugInfo;
2189	if (A.getOption().matches(ID: options::OPT_gline_tables_only) ||
2190	A.getOption().matches(ID: options::OPT_ggdb1))
2191	return llvm::codegenoptions::DebugLineTablesOnly;
2192	if (A.getOption().matches(ID: options::OPT_gline_directives_only))
2193	return llvm::codegenoptions::DebugDirectivesOnly;
2194	return llvm::codegenoptions::DebugInfoConstructor;
2195	}
2196
2197	static unsigned ParseDebugDefaultVersion(const ToolChain &TC,
2198	const ArgList &Args) {
2199	const Arg *A = Args.getLastArg(Ids: options::OPT_fdebug_default_version);
2200
2201	if (!A)
2202	return 0;
2203
2204	unsigned Value = 0;
2205	if (StringRef(A->getValue()).getAsInteger(Radix: 10, Result&: Value) || Value > 5 ||
2206	Value < 2)
2207	TC.getDriver().Diag(DiagID: diag::err_drv_invalid_int_value)
2208	<< A->getAsString(Args) << A->getValue();
2209	return Value;
2210	}
2211
2212	unsigned tools::DwarfVersionNum(StringRef ArgValue) {
2213	return llvm::StringSwitch<unsigned>(ArgValue)
2214	.Case(S: "-gdwarf-2", Value: 2)
2215	.Case(S: "-gdwarf-3", Value: 3)
2216	.Case(S: "-gdwarf-4", Value: 4)
2217	.Case(S: "-gdwarf-5", Value: 5)
2218	.Default(Value: 0);
2219	}
2220
2221	const Arg *tools::getDwarfNArg(const ArgList &Args) {
2222	return Args.getLastArg(Ids: options::OPT_gdwarf_2, Ids: options::OPT_gdwarf_3,
2223	Ids: options::OPT_gdwarf_4, Ids: options::OPT_gdwarf_5,
2224	Ids: options::OPT_gdwarf);
2225	}
2226
2227	unsigned tools::getDwarfVersion(const ToolChain &TC,
2228	const llvm::opt::ArgList &Args) {
2229	unsigned DwarfVersion = ParseDebugDefaultVersion(TC, Args);
2230	if (const Arg *GDwarfN = getDwarfNArg(Args))
2231	if (int N = DwarfVersionNum(ArgValue: GDwarfN->getSpelling())) {
2232	DwarfVersion = N;
2233	if (DwarfVersion == 5 && TC.getTriple().isOSAIX())
2234	TC.getDriver().Diag(DiagID: diag::err_drv_unsupported_opt_for_target)
2235	<< GDwarfN->getSpelling() << TC.getTriple().str();
2236	}
2237	if (DwarfVersion == 0) {
2238	DwarfVersion = TC.GetDefaultDwarfVersion();
2239	assert(DwarfVersion && "toolchain default DWARF version must be nonzero");
2240	}
2241	return DwarfVersion;
2242	}
2243
2244	void tools::AddAssemblerKPIC(const ToolChain &ToolChain, const ArgList &Args,
2245	ArgStringList &CmdArgs) {
2246	llvm::Reloc::Model RelocationModel;
2247	unsigned PICLevel;
2248	bool IsPIE;
2249	std::tie(args&: RelocationModel, args&: PICLevel, args&: IsPIE) = ParsePICArgs(ToolChain, Args);
2250
2251	if (RelocationModel != llvm::Reloc::Static)
2252	CmdArgs.push_back(Elt: "-KPIC");
2253	}
2254
2255	/// Determine whether Objective-C automated reference counting is
2256	/// enabled.
2257	bool tools::isObjCAutoRefCount(const ArgList &Args) {
2258	return Args.hasFlag(Pos: options::OPT_fobjc_arc, Neg: options::OPT_fno_objc_arc, Default: false);
2259	}
2260
2261	enum class LibGccType { UnspecifiedLibGcc, StaticLibGcc, SharedLibGcc };
2262
2263	static LibGccType getLibGccType(const ToolChain &TC, const Driver &D,
2264	const ArgList &Args) {
2265	if (Args.hasArg(Ids: options::OPT_static_libgcc) ||
2266	Args.hasArg(Ids: options::OPT_static) || Args.hasArg(Ids: options::OPT_static_pie) ||
2267	// The Android NDK only provides libunwind.a, not libunwind.so.
2268	TC.getTriple().isAndroid())
2269	return LibGccType::StaticLibGcc;
2270	if (Args.hasArg(Ids: options::OPT_shared_libgcc))
2271	return LibGccType::SharedLibGcc;
2272	return LibGccType::UnspecifiedLibGcc;
2273	}
2274
2275	// Gcc adds libgcc arguments in various ways:
2276	//
2277	// gcc <none>: -lgcc --as-needed -lgcc_s --no-as-needed
2278	// g++ <none>: -lgcc_s -lgcc
2279	// gcc shared: -lgcc_s -lgcc
2280	// g++ shared: -lgcc_s -lgcc
2281	// gcc static: -lgcc -lgcc_eh
2282	// g++ static: -lgcc -lgcc_eh
2283	// gcc static-pie: -lgcc -lgcc_eh
2284	// g++ static-pie: -lgcc -lgcc_eh
2285	//
2286	// Also, certain targets need additional adjustments.
2287
2288	static void AddUnwindLibrary(const ToolChain &TC, const Driver &D,
2289	ArgStringList &CmdArgs, const ArgList &Args) {
2290	ToolChain::UnwindLibType UNW = TC.GetUnwindLibType(Args);
2291	// By default OHOS binaries are linked statically to libunwind.
2292	if (TC.getTriple().isOHOSFamily() && UNW == ToolChain::UNW_CompilerRT) {
2293	CmdArgs.push_back(Elt: "-l:libunwind.a");
2294	return;
2295	}
2296
2297	// Targets that don't use unwind libraries.
2298	if ((TC.getTriple().isAndroid() && UNW == ToolChain::UNW_Libgcc) ||
2299	TC.getTriple().isOSIAMCU() || TC.getTriple().isOSBinFormatWasm() ||
2300	TC.getTriple().isWindowsMSVCEnvironment() || UNW == ToolChain::UNW_None)
2301	return;
2302
2303	LibGccType LGT = getLibGccType(TC, D, Args);
2304	bool AsNeeded = LGT == LibGccType::UnspecifiedLibGcc &&
2305	(UNW == ToolChain::UNW_CompilerRT || !D.CCCIsCXX()) &&
2306	!TC.getTriple().isAndroid() &&
2307	!TC.getTriple().isOSCygMing() && !TC.getTriple().isOSAIX();
2308	if (AsNeeded)
2309	addAsNeededOption(TC, Args, CmdArgs, as_needed: true);
2310
2311	switch (UNW) {
2312	case ToolChain::UNW_None:
2313	return;
2314	case ToolChain::UNW_Libgcc: {
2315	if (LGT == LibGccType::StaticLibGcc)
2316	CmdArgs.push_back(Elt: "-lgcc_eh");
2317	else
2318	CmdArgs.push_back(Elt: "-lgcc_s");
2319	break;
2320	}
2321	case ToolChain::UNW_CompilerRT:
2322	if (TC.getTriple().isOSAIX()) {
2323	// AIX only has libunwind as a shared library. So do not pass
2324	// anything in if -static is specified.
2325	if (LGT != LibGccType::StaticLibGcc)
2326	CmdArgs.push_back(Elt: "-lunwind");
2327	} else if (LGT == LibGccType::StaticLibGcc) {
2328	CmdArgs.push_back(Elt: "-l:libunwind.a");
2329	} else if (LGT == LibGccType::SharedLibGcc) {
2330	if (TC.getTriple().isOSCygMing())
2331	CmdArgs.push_back(Elt: "-l:libunwind.dll.a");
2332	else
2333	CmdArgs.push_back(Elt: "-l:libunwind.so");
2334	} else {
2335	// Let the linker choose between libunwind.so and libunwind.a
2336	// depending on what's available, and depending on the -static flag
2337	CmdArgs.push_back(Elt: "-lunwind");
2338	}
2339	break;
2340	}
2341
2342	if (AsNeeded)
2343	addAsNeededOption(TC, Args, CmdArgs, as_needed: false);
2344	}
2345
2346	static void AddLibgcc(const ToolChain &TC, const Driver &D,
2347	ArgStringList &CmdArgs, const ArgList &Args) {
2348	LibGccType LGT = getLibGccType(TC, D, Args);
2349	if (LGT == LibGccType::StaticLibGcc ||
2350	(LGT == LibGccType::UnspecifiedLibGcc && !D.CCCIsCXX()))
2351	CmdArgs.push_back(Elt: "-lgcc");
2352	AddUnwindLibrary(TC, D, CmdArgs, Args);
2353	if (LGT == LibGccType::SharedLibGcc ||
2354	(LGT == LibGccType::UnspecifiedLibGcc && D.CCCIsCXX()))
2355	CmdArgs.push_back(Elt: "-lgcc");
2356	// compiler-rt is needed after libgcc for flang on AArch64 for the
2357	// __trampoline_setup symbol
2358	if (D.IsFlangMode() && TC.getArch() == llvm::Triple::aarch64) {
2359	CmdArgs.push_back(Elt: "--as-needed");
2360	CmdArgs.push_back(Elt: TC.getCompilerRTArgString(Args, Component: "builtins"));
2361	CmdArgs.push_back(Elt: "--no-as-needed");
2362	}
2363	}
2364
2365	void tools::AddRunTimeLibs(const ToolChain &TC, const Driver &D,
2366	ArgStringList &CmdArgs, const ArgList &Args) {
2367	// Make use of compiler-rt if --rtlib option is used
2368	ToolChain::RuntimeLibType RLT = TC.GetRuntimeLibType(Args);
2369
2370	switch (RLT) {
2371	case ToolChain::RLT_CompilerRT:
2372	CmdArgs.push_back(Elt: TC.getCompilerRTArgString(Args, Component: "builtins"));
2373	AddUnwindLibrary(TC, D, CmdArgs, Args);
2374	break;
2375	case ToolChain::RLT_Libgcc:
2376	// Make sure libgcc is not used under MSVC environment by default
2377	if (TC.getTriple().isKnownWindowsMSVCEnvironment()) {
2378	// Issue error diagnostic if libgcc is explicitly specified
2379	// through command line as --rtlib option argument.
2380	Arg *A = Args.getLastArg(Ids: options::OPT_rtlib_EQ);
2381	if (A && A->getValue() != StringRef("platform")) {
2382	TC.getDriver().Diag(DiagID: diag::err_drv_unsupported_rtlib_for_platform)
2383	<< A->getValue() << "MSVC";
2384	}
2385	} else
2386	AddLibgcc(TC, D, CmdArgs, Args);
2387	break;
2388	}
2389
2390	// On Android, the unwinder uses dl_iterate_phdr (or one of
2391	// dl_unwind_find_exidx/__gnu_Unwind_Find_exidx on arm32) from libdl.so. For
2392	// statically-linked executables, these functions come from libc.a instead.
2393	if (TC.getTriple().isAndroid() && !Args.hasArg(Ids: options::OPT_static) &&
2394	!Args.hasArg(Ids: options::OPT_static_pie))
2395	CmdArgs.push_back(Elt: "-ldl");
2396	}
2397
2398	SmallString<128> tools::getStatsFileName(const llvm::opt::ArgList &Args,
2399	const InputInfo &Output,
2400	const InputInfo &Input,
2401	const Driver &D) {
2402	const Arg *A = Args.getLastArg(Ids: options::OPT_save_stats_EQ);
2403	if (!A && !D.CCPrintInternalStats)
2404	return {};
2405
2406	SmallString<128> StatsFile;
2407	if (A) {
2408	StringRef SaveStats = A->getValue();
2409	if (SaveStats == "obj" && Output.isFilename()) {
2410	StatsFile.assign(RHS: Output.getFilename());
2411	llvm::sys::path::remove_filename(path&: StatsFile);
2412	} else if (SaveStats != "cwd") {
2413	D.Diag(DiagID: diag::err_drv_invalid_value) << A->getAsString(Args) << SaveStats;
2414	return {};
2415	}
2416
2417	StringRef BaseName = llvm::sys::path::filename(path: Input.getBaseInput());
2418	llvm::sys::path::append(path&: StatsFile, a: BaseName);
2419	llvm::sys::path::replace_extension(path&: StatsFile, extension: "stats");
2420	} else {
2421	assert(D.CCPrintInternalStats);
2422	StatsFile.assign(RHS: D.CCPrintInternalStatReportFilename.empty()
2423	? "-"
2424	: D.CCPrintInternalStatReportFilename);
2425	}
2426	return StatsFile;
2427	}
2428
2429	void tools::addMultilibFlag(bool Enabled, const StringRef Flag,
2430	Multilib::flags_list &Flags) {
2431	assert(Flag.front() == '-');
2432	if (Enabled) {
2433	Flags.push_back(x: Flag.str());
2434	} else {
2435	Flags.push_back(x: ("!" + Flag.substr(Start: 1)).str());
2436	}
2437	}
2438
2439	void tools::addX86AlignBranchArgs(const Driver &D, const ArgList &Args,
2440	ArgStringList &CmdArgs, bool IsLTO,
2441	const StringRef PluginOptPrefix) {
2442	auto addArg = [&, IsLTO](const Twine &Arg) {
2443	if (IsLTO) {
2444	assert(!PluginOptPrefix.empty() && "Cannot have empty PluginOptPrefix!");
2445	CmdArgs.push_back(Elt: Args.MakeArgString(Str: Twine(PluginOptPrefix) + Arg));
2446	} else {
2447	CmdArgs.push_back(Elt: "-mllvm");
2448	CmdArgs.push_back(Elt: Args.MakeArgString(Str: Arg));
2449	}
2450	};
2451
2452	if (Args.hasArg(Ids: options::OPT_mbranches_within_32B_boundaries)) {
2453	addArg(Twine("-x86-branches-within-32B-boundaries"));
2454	}
2455	if (const Arg *A = Args.getLastArg(Ids: options::OPT_malign_branch_boundary_EQ)) {
2456	StringRef Value = A->getValue();
2457	unsigned Boundary;
2458	if (Value.getAsInteger(Radix: 10, Result&: Boundary) || Boundary < 16 ||
2459	!llvm::isPowerOf2_64(Value: Boundary)) {
2460	D.Diag(DiagID: diag::err_drv_invalid_argument_to_option)
2461	<< Value << A->getOption().getName();
2462	} else {
2463	addArg("-x86-align-branch-boundary=" + Twine(Boundary));
2464	}
2465	}
2466	if (const Arg *A = Args.getLastArg(Ids: options::OPT_malign_branch_EQ)) {
2467	std::string AlignBranch;
2468	for (StringRef T : A->getValues()) {
2469	if (T != "fused" && T != "jcc" && T != "jmp" && T != "call" &&
2470	T != "ret" && T != "indirect")
2471	D.Diag(DiagID: diag::err_drv_invalid_malign_branch_EQ)
2472	<< T << "fused, jcc, jmp, call, ret, indirect";
2473	if (!AlignBranch.empty())
2474	AlignBranch += '+';
2475	AlignBranch += T;
2476	}
2477	addArg("-x86-align-branch=" + Twine(AlignBranch));
2478	}
2479	if (const Arg *A = Args.getLastArg(Ids: options::OPT_mpad_max_prefix_size_EQ)) {
2480	StringRef Value = A->getValue();
2481	unsigned PrefixSize;
2482	if (Value.getAsInteger(Radix: 10, Result&: PrefixSize)) {
2483	D.Diag(DiagID: diag::err_drv_invalid_argument_to_option)
2484	<< Value << A->getOption().getName();
2485	} else {
2486	addArg("-x86-pad-max-prefix-size=" + Twine(PrefixSize));
2487	}
2488	}
2489	}
2490
2491	/// SDLSearch: Search for Static Device Library
2492	/// The search for SDL bitcode files is consistent with how static host
2493	/// libraries are discovered. That is, the -l option triggers a search for
2494	/// files in a set of directories called the LINKPATH. The host library search
2495	/// procedure looks for a specific filename in the LINKPATH. The filename for
2496	/// a host library is lib<libname>.a or lib<libname>.so. For SDLs, there is an
2497	/// ordered-set of filenames that are searched. We call this ordered-set of
2498	/// filenames as SEARCH-ORDER. Since an SDL can either be device-type specific,
2499	/// architecture specific, or generic across all architectures, a naming
2500	/// convention and search order is used where the file name embeds the
2501	/// architecture name <arch-name> (nvptx or amdgcn) and the GPU device type
2502	/// <device-name> such as sm_30 and gfx906. <device-name> is absent in case of
2503	/// device-independent SDLs. To reduce congestion in host library directories,
2504	/// the search first looks for files in the “libdevice” subdirectory. SDLs that
2505	/// are bc files begin with the prefix “lib”.
2506	///
2507	/// Machine-code SDLs can also be managed as an archive (*.a file). The
2508	/// convention has been to use the prefix “lib”. To avoid confusion with host
2509	/// archive libraries, we use prefix "libbc-" for the bitcode SDL archives.
2510	///
2511	static bool SDLSearch(const Driver &D, const llvm::opt::ArgList &DriverArgs,
2512	llvm::opt::ArgStringList &CC1Args,
2513	const SmallVectorImpl<std::string> &LibraryPaths,
2514	StringRef Lib, StringRef Arch, StringRef Target,
2515	bool isBitCodeSDL) {
2516	SmallVector<std::string, 12> SDLs;
2517
2518	std::string LibDeviceLoc = "/libdevice";
2519	std::string LibBcPrefix = "/libbc-";
2520	std::string LibPrefix = "/lib";
2521
2522	if (isBitCodeSDL) {
2523	// SEARCH-ORDER for Bitcode SDLs:
2524	// libdevice/libbc-<libname>-<arch-name>-<device-type>.a
2525	// libbc-<libname>-<arch-name>-<device-type>.a
2526	// libdevice/libbc-<libname>-<arch-name>.a
2527	// libbc-<libname>-<arch-name>.a
2528	// libdevice/libbc-<libname>.a
2529	// libbc-<libname>.a
2530	// libdevice/lib<libname>-<arch-name>-<device-type>.bc
2531	// lib<libname>-<arch-name>-<device-type>.bc
2532	// libdevice/lib<libname>-<arch-name>.bc
2533	// lib<libname>-<arch-name>.bc
2534	// libdevice/lib<libname>.bc
2535	// lib<libname>.bc
2536
2537	for (StringRef Base : {LibBcPrefix, LibPrefix}) {
2538	const auto *Ext = Base.contains(Other: LibBcPrefix) ? ".a" : ".bc";
2539
2540	for (auto Suffix : {Twine(Lib + "-" + Arch + "-" + Target).str(),
2541	Twine(Lib + "-" + Arch).str(), Twine(Lib).str()}) {
2542	SDLs.push_back(Elt: Twine(LibDeviceLoc + Base + Suffix + Ext).str());
2543	SDLs.push_back(Elt: Twine(Base + Suffix + Ext).str());
2544	}
2545	}
2546	} else {
2547	// SEARCH-ORDER for Machine-code SDLs:
2548	// libdevice/lib<libname>-<arch-name>-<device-type>.a
2549	// lib<libname>-<arch-name>-<device-type>.a
2550	// libdevice/lib<libname>-<arch-name>.a
2551	// lib<libname>-<arch-name>.a
2552
2553	const auto *Ext = ".a";
2554
2555	for (auto Suffix : {Twine(Lib + "-" + Arch + "-" + Target).str(),
2556	Twine(Lib + "-" + Arch).str()}) {
2557	SDLs.push_back(Elt: Twine(LibDeviceLoc + LibPrefix + Suffix + Ext).str());
2558	SDLs.push_back(Elt: Twine(LibPrefix + Suffix + Ext).str());
2559	}
2560	}
2561
2562	// The CUDA toolchain does not use a global device llvm-link before the LLVM
2563	// backend generates ptx. So currently, the use of bitcode SDL for nvptx is
2564	// only possible with post-clang-cc1 linking. Clang cc1 has a feature that
2565	// will link libraries after clang compilation while the LLVM IR is still in
2566	// memory. This utilizes a clang cc1 option called “-mlink-builtin-bitcode”.
2567	// This is a clang -cc1 option that is generated by the clang driver. The
2568	// option value must a full path to an existing file.
2569	bool FoundSDL = false;
2570	for (auto LPath : LibraryPaths) {
2571	for (auto SDL : SDLs) {
2572	auto FullName = Twine(LPath + SDL).str();
2573	if (llvm::sys::fs::exists(Path: FullName)) {
2574	CC1Args.push_back(Elt: DriverArgs.MakeArgString(Str: FullName));
2575	FoundSDL = true;
2576	break;
2577	}
2578	}
2579	if (FoundSDL)
2580	break;
2581	}
2582	return FoundSDL;
2583	}
2584
2585	/// Search if a user provided archive file lib<libname>.a exists in any of
2586	/// the library paths. If so, add a new command to clang-offload-bundler to
2587	/// unbundle this archive and create a temporary device specific archive. Name
2588	/// of this SDL is passed to the llvm-link tool.
2589	static void GetSDLFromOffloadArchive(
2590	Compilation &C, const Driver &D, const Tool &T, const JobAction &JA,
2591	const InputInfoList &Inputs, const llvm::opt::ArgList &DriverArgs,
2592	llvm::opt::ArgStringList &CC1Args,
2593	const SmallVectorImpl<std::string> &LibraryPaths, StringRef Lib,
2594	StringRef Arch, StringRef Target, bool isBitCodeSDL) {
2595
2596	// We don't support bitcode archive bundles for nvptx
2597	if (isBitCodeSDL && Arch.contains(Other: "nvptx"))
2598	return;
2599
2600	bool FoundAOB = false;
2601	std::string ArchiveOfBundles;
2602
2603	llvm::Triple Triple(D.getTargetTriple());
2604	bool IsMSVC = Triple.isWindowsMSVCEnvironment();
2605	auto Ext = IsMSVC ? ".lib" : ".a";
2606	if (!Lib.starts_with(Prefix: ":") && !Lib.starts_with(Prefix: "-l")) {
2607	if (llvm::sys::fs::exists(Path: Lib)) {
2608	ArchiveOfBundles = Lib;
2609	FoundAOB = true;
2610	}
2611	} else {
2612	Lib.consume_front(Prefix: "-l");
2613	for (auto LPath : LibraryPaths) {
2614	ArchiveOfBundles.clear();
2615	auto LibFile = (Lib.starts_with(Prefix: ":") ? Lib.drop_front()
2616	: IsMSVC ? Lib + Ext
2617	: "lib" + Lib + Ext)
2618	.str();
2619	for (auto Prefix : {"/libdevice/", "/"}) {
2620	auto AOB = Twine(LPath + Prefix + LibFile).str();
2621	if (llvm::sys::fs::exists(Path: AOB)) {
2622	ArchiveOfBundles = AOB;
2623	FoundAOB = true;
2624	break;
2625	}
2626	}
2627	if (FoundAOB)
2628	break;
2629	}
2630	}
2631
2632	if (!FoundAOB)
2633	return;
2634
2635	llvm::file_magic Magic;
2636	auto EC = llvm::identify_magic(path: ArchiveOfBundles, result&: Magic);
2637	if (EC || Magic != llvm::file_magic::archive)
2638	return;
2639
2640	StringRef Prefix = isBitCodeSDL ? "libbc-" : "lib";
2641	std::string OutputLib =
2642	D.GetTemporaryPath(Prefix: Twine(Prefix + llvm::sys::path::filename(path: Lib) + "-" +
2643	Arch + "-" + Target)
2644	.str(),
2645	Suffix: "a");
2646
2647	C.addTempFile(Name: C.getArgs().MakeArgString(Str: OutputLib));
2648
2649	SmallString<128> DeviceTriple;
2650	DeviceTriple += Action::GetOffloadKindName(Kind: JA.getOffloadingDeviceKind());
2651	DeviceTriple += '-';
2652	std::string NormalizedTriple = T.getToolChain().getTriple().normalize(
2653	Form: llvm::Triple::CanonicalForm::FOUR_IDENT);
2654	DeviceTriple += NormalizedTriple;
2655	if (!Target.empty()) {
2656	DeviceTriple += '-';
2657	DeviceTriple += Target;
2658	}
2659
2660	std::string UnbundleArg("-unbundle");
2661	std::string TypeArg("-type=a");
2662	std::string InputArg("-input=" + ArchiveOfBundles);
2663	std::string OffloadArg("-targets=" + std::string(DeviceTriple));
2664	std::string OutputArg("-output=" + OutputLib);
2665
2666	const char *UBProgram = DriverArgs.MakeArgString(
2667	Str: T.getToolChain().GetProgramPath(Name: "clang-offload-bundler"));
2668
2669	ArgStringList UBArgs;
2670	UBArgs.push_back(Elt: C.getArgs().MakeArgString(Str: UnbundleArg));
2671	UBArgs.push_back(Elt: C.getArgs().MakeArgString(Str: TypeArg));
2672	UBArgs.push_back(Elt: C.getArgs().MakeArgString(Str: InputArg));
2673	UBArgs.push_back(Elt: C.getArgs().MakeArgString(Str: OffloadArg));
2674	UBArgs.push_back(Elt: C.getArgs().MakeArgString(Str: OutputArg));
2675
2676	// Add this flag to not exit from clang-offload-bundler if no compatible
2677	// code object is found in heterogenous archive library.
2678	std::string AdditionalArgs("-allow-missing-bundles");
2679	UBArgs.push_back(Elt: C.getArgs().MakeArgString(Str: AdditionalArgs));
2680
2681	// Add this flag to treat hip and hipv4 offload kinds as compatible with
2682	// openmp offload kind while extracting code objects from a heterogenous
2683	// archive library. Vice versa is also considered compatible.
2684	std::string HipCompatibleArgs("-hip-openmp-compatible");
2685	UBArgs.push_back(Elt: C.getArgs().MakeArgString(Str: HipCompatibleArgs));
2686
2687	C.addCommand(C: std::make_unique<Command>(
2688	args: JA, args: T, args: ResponseFileSupport::AtFileCurCP(), args&: UBProgram, args&: UBArgs, args: Inputs,
2689	args: InputInfo(&JA, C.getArgs().MakeArgString(Str: OutputLib))));
2690
2691	CC1Args.push_back(Elt: DriverArgs.MakeArgString(Str: OutputLib));
2692	}
2693
2694	// Wrapper function used by driver for adding SDLs during link phase.
2695	void tools::AddStaticDeviceLibsLinking(Compilation &C, const Tool &T,
2696	const JobAction &JA,
2697	const InputInfoList &Inputs,
2698	const llvm::opt::ArgList &DriverArgs,
2699	llvm::opt::ArgStringList &CC1Args,
2700	StringRef Arch, StringRef Target,
2701	bool isBitCodeSDL) {
2702	AddStaticDeviceLibs(C: &C, T: &T, JA: &JA, Inputs: &Inputs, D: C.getDriver(), DriverArgs, CmdArgs&: CC1Args,
2703	Arch, Target, isBitCodeSDL);
2704	}
2705
2706	// User defined Static Device Libraries(SDLs) can be passed to clang for
2707	// offloading GPU compilers. Like static host libraries, the use of a SDL is
2708	// specified with the -l command line option. The primary difference between
2709	// host and SDLs is the filenames for SDLs (refer SEARCH-ORDER for Bitcode SDLs
2710	// and SEARCH-ORDER for Machine-code SDLs for the naming convention).
2711	// SDLs are of following types:
2712	//
2713	// * Bitcode SDLs: They can either be a *.bc file or an archive of *.bc files.
2714	// For NVPTX, these libraries are post-clang linked following each
2715	// compilation. For AMDGPU, these libraries are linked one time
2716	// during the application link phase.
2717	//
2718	// * Machine-code SDLs: They are archive files. For AMDGPU, the process for
2719	// machine code SDLs is still in development. But they will be linked
2720	// by the LLVM tool lld.
2721	//
2722	// * Bundled objects that contain both host and device codes: Bundled objects
2723	// may also contain library code compiled from source. For NVPTX, the
2724	// bundle contains cubin. For AMDGPU, the bundle contains bitcode.
2725	//
2726	// For Bitcode and Machine-code SDLs, current compiler toolchains hardcode the
2727	// inclusion of specific SDLs such as math libraries and the OpenMP device
2728	// library libomptarget.
2729	void tools::AddStaticDeviceLibs(Compilation *C, const Tool *T,
2730	const JobAction *JA,
2731	const InputInfoList *Inputs, const Driver &D,
2732	const llvm::opt::ArgList &DriverArgs,
2733	llvm::opt::ArgStringList &CC1Args,
2734	StringRef Arch, StringRef Target,
2735	bool isBitCodeSDL) {
2736
2737	SmallVector<std::string, 8> LibraryPaths;
2738	// Add search directories from LIBRARY_PATH env variable
2739	std::optional<std::string> LibPath =
2740	llvm::sys::Process::GetEnv(name: "LIBRARY_PATH");
2741	if (LibPath) {
2742	SmallVector<StringRef, 8> Frags;
2743	const char EnvPathSeparatorStr[] = {llvm::sys::EnvPathSeparator, '\0'};
2744	llvm::SplitString(Source: *LibPath, OutFragments&: Frags, Delimiters: EnvPathSeparatorStr);
2745	for (StringRef Path : Frags)
2746	LibraryPaths.emplace_back(Args: Path.trim());
2747	}
2748
2749	// Add directories from user-specified -L options
2750	for (std::string Search_Dir : DriverArgs.getAllArgValues(Id: options::OPT_L))
2751	LibraryPaths.emplace_back(Args&: Search_Dir);
2752
2753	// Add path to lib-debug folders
2754	SmallString<256> DefaultLibPath = llvm::sys::path::parent_path(path: D.Dir);
2755	llvm::sys::path::append(path&: DefaultLibPath, CLANG_INSTALL_LIBDIR_BASENAME);
2756	LibraryPaths.emplace_back(Args: DefaultLibPath.c_str());
2757
2758	// Build list of Static Device Libraries SDLs specified by -l option
2759	llvm::SmallSet<std::string, 16> SDLNames;
2760	static const StringRef HostOnlyArchives[] = {
2761	"omp", "cudart", "m", "gcc", "gcc_s", "pthread", "hip_hcc"};
2762	for (auto SDLName : DriverArgs.getAllArgValues(Id: options::OPT_l)) {
2763	if (!llvm::is_contained(Range: HostOnlyArchives, Element: SDLName)) {
2764	SDLNames.insert(V: std::string("-l") + SDLName);
2765	}
2766	}
2767
2768	for (auto Input : DriverArgs.getAllArgValues(Id: options::OPT_INPUT)) {
2769	auto FileName = StringRef(Input);
2770	// Clang treats any unknown file types as archives and passes them to the
2771	// linker. Files with extension 'lib' are classified as TY_Object by clang
2772	// but they are usually archives. It is OK if the file is not really an
2773	// archive since GetSDLFromOffloadArchive will check the magic of the file
2774	// and only unbundle it if it is really an archive.
2775	const StringRef LibFileExt = ".lib";
2776	if (!llvm::sys::path::has_extension(path: FileName) ||
2777	types::lookupTypeForExtension(
2778	Ext: llvm::sys::path::extension(path: FileName).drop_front()) ==
2779	types::TY_INVALID ||
2780	llvm::sys::path::extension(path: FileName) == LibFileExt)
2781	SDLNames.insert(V: Input);
2782	}
2783
2784	// The search stops as soon as an SDL file is found. The driver then provides
2785	// the full filename of the SDL to the llvm-link command. If no SDL is found
2786	// after searching each LINKPATH with SEARCH-ORDER, it is possible that an
2787	// archive file lib<libname>.a exists and may contain bundled object files.
2788	for (auto SDLName : SDLNames) {
2789	// This is the only call to SDLSearch
2790	if (!SDLSearch(D, DriverArgs, CC1Args, LibraryPaths, Lib: SDLName, Arch, Target,
2791	isBitCodeSDL)) {
2792	GetSDLFromOffloadArchive(C&: *C, D, T: *T, JA: *JA, Inputs: *Inputs, DriverArgs, CC1Args,
2793	LibraryPaths, Lib: SDLName, Arch, Target,
2794	isBitCodeSDL);
2795	}
2796	}
2797	}
2798
2799	static llvm::opt::Arg *
2800	getAMDGPUCodeObjectArgument(const Driver &D, const llvm::opt::ArgList &Args) {
2801	return Args.getLastArg(Ids: options::OPT_mcode_object_version_EQ);
2802	}
2803
2804	void tools::checkAMDGPUCodeObjectVersion(const Driver &D,
2805	const llvm::opt::ArgList &Args) {
2806	const unsigned MinCodeObjVer = 4;
2807	const unsigned MaxCodeObjVer = 6;
2808
2809	if (auto *CodeObjArg = getAMDGPUCodeObjectArgument(D, Args)) {
2810	if (CodeObjArg->getOption().getID() ==
2811	options::OPT_mcode_object_version_EQ) {
2812	unsigned CodeObjVer = MaxCodeObjVer;
2813	auto Remnant =
2814	StringRef(CodeObjArg->getValue()).getAsInteger(Radix: 0, Result&: CodeObjVer);
2815	if (Remnant || CodeObjVer < MinCodeObjVer || CodeObjVer > MaxCodeObjVer)
2816	D.Diag(DiagID: diag::err_drv_invalid_int_value)
2817	<< CodeObjArg->getAsString(Args) << CodeObjArg->getValue();
2818	}
2819	}
2820	}
2821
2822	unsigned tools::getAMDGPUCodeObjectVersion(const Driver &D,
2823	const llvm::opt::ArgList &Args) {
2824	unsigned CodeObjVer = 6; // default
2825	if (auto *CodeObjArg = getAMDGPUCodeObjectArgument(D, Args))
2826	StringRef(CodeObjArg->getValue()).getAsInteger(Radix: 0, Result&: CodeObjVer);
2827	return CodeObjVer;
2828	}
2829
2830	bool tools::haveAMDGPUCodeObjectVersionArgument(
2831	const Driver &D, const llvm::opt::ArgList &Args) {
2832	return getAMDGPUCodeObjectArgument(D, Args) != nullptr;
2833	}
2834
2835	void tools::addMachineOutlinerArgs(const Driver &D,
2836	const llvm::opt::ArgList &Args,
2837	llvm::opt::ArgStringList &CmdArgs,
2838	const llvm::Triple &Triple, bool IsLTO,
2839	const StringRef PluginOptPrefix) {
2840	auto addArg = [&, IsLTO](const Twine &Arg) {
2841	if (IsLTO) {
2842	assert(!PluginOptPrefix.empty() && "Cannot have empty PluginOptPrefix!");
2843	CmdArgs.push_back(Elt: Args.MakeArgString(Str: Twine(PluginOptPrefix) + Arg));
2844	} else {
2845	CmdArgs.push_back(Elt: "-mllvm");
2846	CmdArgs.push_back(Elt: Args.MakeArgString(Str: Arg));
2847	}
2848	};
2849
2850	if (Arg *A = Args.getLastArg(Ids: options::OPT_moutline,
2851	Ids: options::OPT_mno_outline)) {
2852	if (A->getOption().matches(ID: options::OPT_moutline)) {
2853	// We only support -moutline in AArch64 and ARM targets right now. If
2854	// we're not compiling for these, emit a warning and ignore the flag.
2855	// Otherwise, add the proper mllvm flags.
2856	if (!(Triple.isARM() || Triple.isThumb() || Triple.isAArch64())) {
2857	D.Diag(DiagID: diag::warn_drv_moutline_unsupported_opt) << Triple.getArchName();
2858	} else {
2859	addArg(Twine("-enable-machine-outliner"));
2860	}
2861	} else {
2862	// Disable all outlining behaviour.
2863	addArg(Twine("-enable-machine-outliner=never"));
2864	}
2865	}
2866
2867	auto *CodeGenDataGenArg =
2868	Args.getLastArg(Ids: options::OPT_fcodegen_data_generate_EQ);
2869	auto *CodeGenDataUseArg = Args.getLastArg(Ids: options::OPT_fcodegen_data_use_EQ);
2870
2871	// We only allow one of them to be specified.
2872	if (CodeGenDataGenArg && CodeGenDataUseArg)
2873	D.Diag(DiagID: diag::err_drv_argument_not_allowed_with)
2874	<< CodeGenDataGenArg->getAsString(Args)
2875	<< CodeGenDataUseArg->getAsString(Args);
2876
2877	// For codegen data gen, the output file is passed to the linker
2878	// while a boolean flag is passed to the LLVM backend.
2879	if (CodeGenDataGenArg)
2880	addArg(Twine("-codegen-data-generate"));
2881
2882	// For codegen data use, the input file is passed to the LLVM backend.
2883	if (CodeGenDataUseArg)
2884	addArg(Twine("-codegen-data-use-path=") + CodeGenDataUseArg->getValue());
2885	}
2886
2887	void tools::addOpenMPDeviceRTL(const Driver &D,
2888	const llvm::opt::ArgList &DriverArgs,
2889	llvm::opt::ArgStringList &CC1Args,
2890	StringRef BitcodeSuffix,
2891	const llvm::Triple &Triple,
2892	const ToolChain &HostTC) {
2893	SmallVector<StringRef, 8> LibraryPaths;
2894
2895	// Add user defined library paths from LIBRARY_PATH.
2896	std::optional<std::string> LibPath =
2897	llvm::sys::Process::GetEnv(name: "LIBRARY_PATH");
2898	if (LibPath) {
2899	SmallVector<StringRef, 8> Frags;
2900	const char EnvPathSeparatorStr[] = {llvm::sys::EnvPathSeparator, '\0'};
2901	llvm::SplitString(Source: *LibPath, OutFragments&: Frags, Delimiters: EnvPathSeparatorStr);
2902	for (StringRef Path : Frags)
2903	LibraryPaths.emplace_back(Args: Path.trim());
2904	}
2905
2906	// Check all of the standard library search paths used by the compiler.
2907	for (const auto &LibPath : HostTC.getFilePaths())
2908	LibraryPaths.emplace_back(Args: LibPath);
2909
2910	// Check the target specific library path for the triple as well.
2911	SmallString<128> P(D.Dir);
2912	llvm::sys::path::append(path&: P, a: "..", b: "lib", c: Triple.getTriple());
2913	LibraryPaths.emplace_back(Args&: P);
2914
2915	OptSpecifier LibomptargetBCPathOpt =
2916	Triple.isAMDGCN() ? options::OPT_libomptarget_amdgpu_bc_path_EQ
2917	: Triple.isNVPTX() ? options::OPT_libomptarget_nvptx_bc_path_EQ
2918	: options::OPT_libomptarget_spirv_bc_path_EQ;
2919
2920	StringRef ArchPrefix = Triple.isAMDGCN() ? "amdgpu"
2921	: Triple.isNVPTX() ? "nvptx"
2922	: "spirv";
2923	std::string LibOmpTargetName = ("libomptarget-" + ArchPrefix + ".bc").str();
2924
2925	// First check whether user specifies bc library
2926	if (const Arg *A = DriverArgs.getLastArg(Ids: LibomptargetBCPathOpt)) {
2927	SmallString<128> LibOmpTargetFile(A->getValue());
2928	if (llvm::sys::fs::exists(Path: LibOmpTargetFile) &&
2929	llvm::sys::fs::is_directory(Path: LibOmpTargetFile)) {
2930	llvm::sys::path::append(path&: LibOmpTargetFile, a: LibOmpTargetName);
2931	}
2932
2933	if (llvm::sys::fs::exists(Path: LibOmpTargetFile)) {
2934	CC1Args.push_back(Elt: "-mlink-builtin-bitcode");
2935	CC1Args.push_back(Elt: DriverArgs.MakeArgString(Str: LibOmpTargetFile));
2936	} else {
2937	D.Diag(DiagID: diag::err_drv_omp_offload_target_bcruntime_not_found)
2938	<< LibOmpTargetFile;
2939	}
2940	} else {
2941	bool FoundBCLibrary = false;
2942
2943	for (StringRef LibraryPath : LibraryPaths) {
2944	SmallString<128> LibOmpTargetFile(LibraryPath);
2945	llvm::sys::path::append(path&: LibOmpTargetFile, a: LibOmpTargetName);
2946	if (llvm::sys::fs::exists(Path: LibOmpTargetFile)) {
2947	CC1Args.push_back(Elt: "-mlink-builtin-bitcode");
2948	CC1Args.push_back(Elt: DriverArgs.MakeArgString(Str: LibOmpTargetFile));
2949	FoundBCLibrary = true;
2950	break;
2951	}
2952	}
2953
2954	if (!FoundBCLibrary)
2955	D.Diag(DiagID: diag::err_drv_omp_offload_target_missingbcruntime)
2956	<< LibOmpTargetName << ArchPrefix;
2957	}
2958	}
2959	void tools::addHIPRuntimeLibArgs(const ToolChain &TC, Compilation &C,
2960	const llvm::opt::ArgList &Args,
2961	llvm::opt::ArgStringList &CmdArgs) {
2962	if ((C.getActiveOffloadKinds() & Action::OFK_HIP) &&
2963	!Args.hasArg(Ids: options::OPT_nostdlib) &&
2964	!Args.hasArg(Ids: options::OPT_no_hip_rt) && !Args.hasArg(Ids: options::OPT_r)) {
2965	TC.AddHIPRuntimeLibArgs(Args, CmdArgs);
2966	} else {
2967	// Claim "no HIP libraries" arguments if any
2968	for (auto *Arg : Args.filtered(Ids: options::OPT_no_hip_rt)) {
2969	Arg->claim();
2970	}
2971	}
2972	}
2973
2974	void tools::addOutlineAtomicsArgs(const Driver &D, const ToolChain &TC,
2975	const llvm::opt::ArgList &Args,
2976	llvm::opt::ArgStringList &CmdArgs,
2977	const llvm::Triple &Triple) {
2978	if (Arg *A = Args.getLastArg(Ids: options::OPT_moutline_atomics,
2979	Ids: options::OPT_mno_outline_atomics)) {
2980	// Option -moutline-atomics supported for AArch64 target only.
2981	if (!Triple.isAArch64()) {
2982	D.Diag(DiagID: diag::warn_drv_moutline_atomics_unsupported_opt)
2983	<< Triple.getArchName() << A->getOption().getName();
2984	} else {
2985	if (A->getOption().matches(ID: options::OPT_moutline_atomics)) {
2986	CmdArgs.push_back(Elt: "-target-feature");
2987	CmdArgs.push_back(Elt: "+outline-atomics");
2988	} else {
2989	CmdArgs.push_back(Elt: "-target-feature");
2990	CmdArgs.push_back(Elt: "-outline-atomics");
2991	}
2992	}
2993	} else if (Triple.isAArch64() && TC.IsAArch64OutlineAtomicsDefault(Args)) {
2994	CmdArgs.push_back(Elt: "-target-feature");
2995	CmdArgs.push_back(Elt: "+outline-atomics");
2996	}
2997	}
2998
2999	void tools::addOffloadCompressArgs(const llvm::opt::ArgList &TCArgs,
3000	llvm::opt::ArgStringList &CmdArgs) {
3001	if (TCArgs.hasFlag(Pos: options::OPT_offload_compress,
3002	Neg: options::OPT_no_offload_compress, Default: false))
3003	CmdArgs.push_back(Elt: "-compress");
3004	if (TCArgs.hasArg(Ids: options::OPT_v))
3005	CmdArgs.push_back(Elt: "-verbose");
3006	if (auto *Arg = TCArgs.getLastArg(Ids: options::OPT_offload_compression_level_EQ))
3007	CmdArgs.push_back(
3008	Elt: TCArgs.MakeArgString(Str: Twine("-compression-level=") + Arg->getValue()));
3009	}
3010
3011	void tools::addMCModel(const Driver &D, const llvm::opt::ArgList &Args,
3012	const llvm::Triple &Triple,
3013	const llvm::Reloc::Model &RelocationModel,
3014	llvm::opt::ArgStringList &CmdArgs) {
3015	if (Arg *A = Args.getLastArg(Ids: options::OPT_mcmodel_EQ)) {
3016	StringRef CM = A->getValue();
3017	bool Ok = false;
3018	if (Triple.isOSAIX() && CM == "medium")
3019	CM = "large";
3020	if (Triple.isAArch64(PointerWidth: 64)) {
3021	Ok = CM == "tiny" || CM == "small" || CM == "large";
3022	if (CM == "large" && !Triple.isOSBinFormatMachO() &&
3023	RelocationModel != llvm::Reloc::Static)
3024	D.Diag(DiagID: diag::err_drv_argument_only_allowed_with)
3025	<< A->getAsString(Args) << "-fno-pic";
3026	} else if (Triple.isLoongArch()) {
3027	if (CM == "extreme" &&
3028	Args.hasFlagNoClaim(Pos: options::OPT_fplt, Neg: options::OPT_fno_plt, Default: false))
3029	D.Diag(DiagID: diag::err_drv_argument_not_allowed_with)
3030	<< A->getAsString(Args) << "-fplt";
3031	Ok = CM == "normal" || CM == "medium" || CM == "extreme";
3032	// Convert to LLVM recognizable names.
3033	if (Ok)
3034	CM = llvm::StringSwitch<StringRef>(CM)
3035	.Case(S: "normal", Value: "small")
3036	.Case(S: "extreme", Value: "large")
3037	.Default(Value: CM);
3038	} else if (Triple.isPPC64() || Triple.isOSAIX()) {
3039	Ok = CM == "small" || CM == "medium" || CM == "large";
3040	} else if (Triple.isRISCV()) {
3041	// Large code model is disallowed to be used with PIC code model.
3042	if (CM == "large" && RelocationModel != llvm::Reloc::Static)
3043	D.Diag(DiagID: diag::err_drv_argument_not_allowed_with)
3044	<< A->getAsString(Args) << "-fpic";
3045	if (CM == "medlow")
3046	CM = "small";
3047	else if (CM == "medany")
3048	CM = "medium";
3049	Ok = CM == "small" || CM == "medium" ||
3050	(CM == "large" && Triple.isRISCV64());
3051	} else if (Triple.getArch() == llvm::Triple::x86_64) {
3052	Ok = llvm::is_contained(Set: {"small", "kernel", "medium", "large"}, Element: CM);
3053	} else if (Triple.isNVPTX() || Triple.isAMDGPU() || Triple.isSPIRV()) {
3054	// NVPTX/AMDGPU/SPIRV does not care about the code model and will accept
3055	// whatever works for the host.
3056	Ok = true;
3057	} else if (Triple.isSPARC64()) {
3058	if (CM == "medlow")
3059	CM = "small";
3060	else if (CM == "medmid")
3061	CM = "medium";
3062	else if (CM == "medany")
3063	CM = "large";
3064	Ok = CM == "small" || CM == "medium" || CM == "large";
3065	}
3066	if (Ok) {
3067	CmdArgs.push_back(Elt: Args.MakeArgString(Str: "-mcmodel=" + CM));
3068	} else {
3069	D.Diag(DiagID: diag::err_drv_unsupported_option_argument_for_target)
3070	<< A->getSpelling() << CM << Triple.getTriple();
3071	}
3072	}
3073
3074	if (Triple.getArch() == llvm::Triple::x86_64) {
3075	bool IsMediumCM = false;
3076	bool IsLargeCM = false;
3077	if (Arg *A = Args.getLastArg(Ids: options::OPT_mcmodel_EQ)) {
3078	IsMediumCM = StringRef(A->getValue()) == "medium";
3079	IsLargeCM = StringRef(A->getValue()) == "large";
3080	}
3081	if (Arg *A = Args.getLastArg(Ids: options::OPT_mlarge_data_threshold_EQ)) {
3082	if (!IsMediumCM && !IsLargeCM) {
3083	D.Diag(DiagID: diag::warn_drv_large_data_threshold_invalid_code_model)
3084	<< A->getOption().getRenderName();
3085	} else {
3086	A->render(Args, Output&: CmdArgs);
3087	}
3088	} else if (IsMediumCM) {
3089	CmdArgs.push_back(Elt: "-mlarge-data-threshold=65536");
3090	} else if (IsLargeCM) {
3091	CmdArgs.push_back(Elt: "-mlarge-data-threshold=0");
3092	}
3093	}
3094	}
3095
3096	void tools::handleColorDiagnosticsArgs(const Driver &D, const ArgList &Args,
3097	ArgStringList &CmdArgs) {
3098	// Color diagnostics are parsed by the driver directly from argv and later
3099	// re-parsed to construct this job; claim any possible color diagnostic here
3100	// to avoid warn_drv_unused_argument and diagnose bad
3101	// OPT_fdiagnostics_color_EQ values.
3102	Args.getLastArg(Ids: options::OPT_fcolor_diagnostics,
3103	Ids: options::OPT_fno_color_diagnostics);
3104	if (const Arg *A = Args.getLastArg(Ids: options::OPT_fdiagnostics_color_EQ)) {
3105	StringRef Value(A->getValue());
3106	if (Value != "always" && Value != "never" && Value != "auto")
3107	D.Diag(DiagID: diag::err_drv_invalid_argument_to_option)
3108	<< Value << A->getOption().getName();
3109	}
3110
3111	if (D.getDiags().getDiagnosticOptions().ShowColors)
3112	CmdArgs.push_back(Elt: "-fcolor-diagnostics");
3113	}
3114
3115	void tools::escapeSpacesAndBackslashes(const char *Arg,
3116	llvm::SmallVectorImpl<char> &Res) {
3117	for (; *Arg; ++Arg) {
3118	switch (*Arg) {
3119	default:
3120	break;
3121	case ' ':
3122	case '\\':
3123	Res.push_back(Elt: '\\');
3124	break;
3125	}
3126	Res.push_back(Elt: *Arg);
3127	}
3128	}
3129
3130	const char *tools::renderEscapedCommandLine(const ToolChain &TC,
3131	const llvm::opt::ArgList &Args) {
3132	const Driver &D = TC.getDriver();
3133	const char *Exec = D.getClangProgramPath();
3134
3135	llvm::opt::ArgStringList OriginalArgs;
3136	for (const auto &Arg : Args)
3137	Arg->render(Args, Output&: OriginalArgs);
3138
3139	llvm::SmallString<256> Flags;
3140	escapeSpacesAndBackslashes(Arg: Exec, Res&: Flags);
3141	for (const char *OriginalArg : OriginalArgs) {
3142	llvm::SmallString<128> EscapedArg;
3143	escapeSpacesAndBackslashes(Arg: OriginalArg, Res&: EscapedArg);
3144	Flags += " ";
3145	Flags += EscapedArg;
3146	}
3147
3148	return Args.MakeArgString(Str: Flags);
3149	}
3150
3151	bool tools::shouldRecordCommandLine(const ToolChain &TC,
3152	const llvm::opt::ArgList &Args,
3153	bool &FRecordCommandLine,
3154	bool &GRecordCommandLine) {
3155	const Driver &D = TC.getDriver();
3156	const llvm::Triple &Triple = TC.getEffectiveTriple();
3157	const std::string &TripleStr = Triple.getTriple();
3158
3159	FRecordCommandLine =
3160	Args.hasFlag(Pos: options::OPT_frecord_command_line,
3161	Neg: options::OPT_fno_record_command_line, Default: false);
3162	GRecordCommandLine =
3163	Args.hasFlag(Pos: options::OPT_grecord_command_line,
3164	Neg: options::OPT_gno_record_command_line, Default: false);
3165	if (FRecordCommandLine && !Triple.isOSBinFormatELF() &&
3166	!Triple.isOSBinFormatXCOFF() && !Triple.isOSBinFormatMachO())
3167	D.Diag(DiagID: diag::err_drv_unsupported_opt_for_target)
3168	<< Args.getLastArg(Ids: options::OPT_frecord_command_line)->getAsString(Args)
3169	<< TripleStr;
3170
3171	return FRecordCommandLine || TC.UseDwarfDebugFlags() || GRecordCommandLine;
3172	}
3173
3174	void tools::renderCommonIntegerOverflowOptions(const ArgList &Args,
3175	ArgStringList &CmdArgs) {
3176	bool use_fwrapv = false;
3177	bool use_fwrapv_pointer = false;
3178	for (const Arg *A : Args.filtered(
3179	Ids: options::OPT_fstrict_overflow, Ids: options::OPT_fno_strict_overflow,
3180	Ids: options::OPT_fwrapv, Ids: options::OPT_fno_wrapv,
3181	Ids: options::OPT_fwrapv_pointer, Ids: options::OPT_fno_wrapv_pointer)) {
3182	A->claim();
3183	switch (A->getOption().getID()) {
3184	case options::OPT_fstrict_overflow:
3185	use_fwrapv = false;
3186	use_fwrapv_pointer = false;
3187	break;
3188	case options::OPT_fno_strict_overflow:
3189	use_fwrapv = true;
3190	use_fwrapv_pointer = true;
3191	break;
3192	case options::OPT_fwrapv:
3193	use_fwrapv = true;
3194	break;
3195	case options::OPT_fno_wrapv:
3196	use_fwrapv = false;
3197	break;
3198	case options::OPT_fwrapv_pointer:
3199	use_fwrapv_pointer = true;
3200	break;
3201	case options::OPT_fno_wrapv_pointer:
3202	use_fwrapv_pointer = false;
3203	break;
3204	}
3205	}
3206
3207	if (use_fwrapv)
3208	CmdArgs.push_back(Elt: "-fwrapv");
3209	if (use_fwrapv_pointer)
3210	CmdArgs.push_back(Elt: "-fwrapv-pointer");
3211	}
3212
3213	/// Vectorize at all optimization levels greater than 1 except for -Oz.
3214	/// For -Oz the loop vectorizer is disabled, while the slp vectorizer is
3215	/// enabled.
3216	bool tools::shouldEnableVectorizerAtOLevel(const ArgList &Args, bool isSlpVec) {
3217	if (Arg *A = Args.getLastArg(Ids: options::OPT_O_Group)) {
3218	if (A->getOption().matches(ID: options::OPT_O4) ||
3219	A->getOption().matches(ID: options::OPT_Ofast))
3220	return true;
3221
3222	if (A->getOption().matches(ID: options::OPT_O0))
3223	return false;
3224
3225	assert(A->getOption().matches(options::OPT_O) && "Must have a -O flag");
3226
3227	// Vectorize -Os.
3228	StringRef S(A->getValue());
3229	if (S == "s")
3230	return true;
3231
3232	// Don't vectorize -Oz, unless it's the slp vectorizer.
3233	if (S == "z")
3234	return isSlpVec;
3235
3236	unsigned OptLevel = 0;
3237	if (S.getAsInteger(Radix: 10, Result&: OptLevel))
3238	return false;
3239
3240	return OptLevel > 1;
3241	}
3242
3243	return false;
3244	}
3245
3246	void tools::handleVectorizeLoopsArgs(const ArgList &Args,
3247	ArgStringList &CmdArgs) {
3248	bool EnableVec = shouldEnableVectorizerAtOLevel(Args, isSlpVec: false);
3249	OptSpecifier vectorizeAliasOption =
3250	EnableVec ? options::OPT_O_Group : options::OPT_fvectorize;
3251	if (Args.hasFlag(Pos: options::OPT_fvectorize, PosAlias: vectorizeAliasOption,
3252	Neg: options::OPT_fno_vectorize, Default: EnableVec))
3253	CmdArgs.push_back(Elt: "-vectorize-loops");
3254	}
3255
3256	void tools::handleVectorizeSLPArgs(const ArgList &Args,
3257	ArgStringList &CmdArgs) {
3258	bool EnableSLPVec = shouldEnableVectorizerAtOLevel(Args, isSlpVec: true);
3259	OptSpecifier SLPVectAliasOption =
3260	EnableSLPVec ? options::OPT_O_Group : options::OPT_fslp_vectorize;
3261	if (Args.hasFlag(Pos: options::OPT_fslp_vectorize, PosAlias: SLPVectAliasOption,
3262	Neg: options::OPT_fno_slp_vectorize, Default: EnableSLPVec))
3263	CmdArgs.push_back(Elt: "-vectorize-slp");
3264	}
3265
3266	void tools::handleInterchangeLoopsArgs(const ArgList &Args,
3267	ArgStringList &CmdArgs) {
3268	if (Args.hasFlag(Pos: options::OPT_floop_interchange,
3269	Neg: options::OPT_fno_loop_interchange, Default: false))
3270	CmdArgs.push_back(Elt: "-floop-interchange");
3271	}
3272
3273	// Parse -mprefer-vector-width=. Return the Value string if well-formed.
3274	// Otherwise, return an empty string and issue a diagnosic message if needed.
3275	StringRef tools::parseMPreferVectorWidthOption(clang::DiagnosticsEngine &Diags,
3276	const llvm::opt::ArgList &Args) {
3277	Arg *A = Args.getLastArg(Ids: clang::driver::options::OPT_mprefer_vector_width_EQ);
3278	if (!A)
3279	return "";
3280
3281	StringRef Value = A->getValue();
3282	unsigned Width LLVM_ATTRIBUTE_UNINITIALIZED;
3283
3284	// Only "none" and Integer values are accepted by
3285	// -mprefer-vector-width=<value>.
3286	if (Value != "none" && Value.getAsInteger(Radix: 10, Result&: Width)) {
3287	Diags.Report(DiagID: clang::diag::err_drv_invalid_value)
3288	<< A->getOption().getName() << Value;
3289	return "";
3290	}
3291
3292	return Value;
3293	}
3294
3295	// This is a helper function for validating the optional refinement step
3296	// parameter in reciprocal argument strings. Return false if there is an error
3297	// parsing the refinement step. Otherwise, return true and set the Position
3298	// of the refinement step in the input string.
3299	static bool getRefinementStep(StringRef In, clang::DiagnosticsEngine &Diags,
3300	const Arg &A, size_t &Position) {
3301	const char RefinementStepToken = ':';
3302	Position = In.find(C: RefinementStepToken);
3303	if (Position != StringRef::npos) {
3304	StringRef Option = A.getOption().getName();
3305	StringRef RefStep = In.substr(Start: Position + 1);
3306	// Allow exactly one numeric character for the additional refinement
3307	// step parameter. This is reasonable for all currently-supported
3308	// operations and architectures because we would expect that a larger value
3309	// of refinement steps would cause the estimate "optimization" to
3310	// under-perform the native operation. Also, if the estimate does not
3311	// converge quickly, it probably will not ever converge, so further
3312	// refinement steps will not produce a better answer.
3313	if (RefStep.size() != 1) {
3314	Diags.Report(DiagID: diag::err_drv_invalid_value) << Option << RefStep;
3315	return false;
3316	}
3317	char RefStepChar = RefStep[0];
3318	if (RefStepChar < '0' || RefStepChar > '9') {
3319	Diags.Report(DiagID: diag::err_drv_invalid_value) << Option << RefStep;
3320	return false;
3321	}
3322	}
3323	return true;
3324	}
3325
3326	// Parse -mrecip. Return the Value string if well-formed.
3327	// Otherwise, return an empty string and issue a diagnosic message if needed.
3328	StringRef tools::parseMRecipOption(clang::DiagnosticsEngine &Diags,
3329	const ArgList &Args) {
3330	StringRef DisabledPrefixIn = "!";
3331	StringRef DisabledPrefixOut = "!";
3332	StringRef EnabledPrefixOut = "";
3333	StringRef Out = "";
3334
3335	Arg *A = Args.getLastArg(Ids: options::OPT_mrecip, Ids: options::OPT_mrecip_EQ);
3336	if (!A)
3337	return "";
3338
3339	unsigned NumOptions = A->getNumValues();
3340	if (NumOptions == 0) {
3341	// No option is the same as "all".
3342	return "all";
3343	}
3344
3345	// Pass through "all", "none", or "default" with an optional refinement step.
3346	if (NumOptions == 1) {
3347	StringRef Val = A->getValue(N: 0);
3348	size_t RefStepLoc;
3349	if (!getRefinementStep(In: Val, Diags, A: *A, Position&: RefStepLoc))
3350	return "";
3351	StringRef ValBase = Val.slice(Start: 0, End: RefStepLoc);
3352	if (ValBase == "all" || ValBase == "none" || ValBase == "default") {
3353	return Val;
3354	}
3355	}
3356
3357	// Each reciprocal type may be enabled or disabled individually.
3358	// Check each input value for validity, concatenate them all back together,
3359	// and pass through.
3360
3361	llvm::StringMap<bool> OptionStrings;
3362	OptionStrings.insert(KV: std::make_pair(x: "divd", y: false));
3363	OptionStrings.insert(KV: std::make_pair(x: "divf", y: false));
3364	OptionStrings.insert(KV: std::make_pair(x: "divh", y: false));
3365	OptionStrings.insert(KV: std::make_pair(x: "vec-divd", y: false));
3366	OptionStrings.insert(KV: std::make_pair(x: "vec-divf", y: false));
3367	OptionStrings.insert(KV: std::make_pair(x: "vec-divh", y: false));
3368	OptionStrings.insert(KV: std::make_pair(x: "sqrtd", y: false));
3369	OptionStrings.insert(KV: std::make_pair(x: "sqrtf", y: false));
3370	OptionStrings.insert(KV: std::make_pair(x: "sqrth", y: false));
3371	OptionStrings.insert(KV: std::make_pair(x: "vec-sqrtd", y: false));
3372	OptionStrings.insert(KV: std::make_pair(x: "vec-sqrtf", y: false));
3373	OptionStrings.insert(KV: std::make_pair(x: "vec-sqrth", y: false));
3374
3375	for (unsigned i = 0; i != NumOptions; ++i) {
3376	StringRef Val = A->getValue(N: i);
3377
3378	bool IsDisabled = Val.starts_with(Prefix: DisabledPrefixIn);
3379	// Ignore the disablement token for string matching.
3380	if (IsDisabled)
3381	Val = Val.substr(Start: 1);
3382
3383	size_t RefStep;
3384	if (!getRefinementStep(In: Val, Diags, A: *A, Position&: RefStep))
3385	return "";
3386
3387	StringRef ValBase = Val.slice(Start: 0, End: RefStep);
3388	llvm::StringMap<bool>::iterator OptionIter = OptionStrings.find(Key: ValBase);
3389	if (OptionIter == OptionStrings.end()) {
3390	// Try again specifying float suffix.
3391	OptionIter = OptionStrings.find(Key: ValBase.str() + 'f');
3392	if (OptionIter == OptionStrings.end()) {
3393	// The input name did not match any known option string.
3394	Diags.Report(DiagID: diag::err_drv_unknown_argument) << Val;
3395	return "";
3396	}
3397	// The option was specified without a half or float or double suffix.
3398	// Make sure that the double or half entry was not already specified.
3399	// The float entry will be checked below.
3400	if (OptionStrings[ValBase.str() + 'd'] ||
3401	OptionStrings[ValBase.str() + 'h']) {
3402	Diags.Report(DiagID: diag::err_drv_invalid_value)
3403	<< A->getOption().getName() << Val;
3404	return "";
3405	}
3406	}
3407
3408	if (OptionIter->second == true) {
3409	// Duplicate option specified.
3410	Diags.Report(DiagID: diag::err_drv_invalid_value)
3411	<< A->getOption().getName() << Val;
3412	return "";
3413	}
3414
3415	// Mark the matched option as found. Do not allow duplicate specifiers.
3416	OptionIter->second = true;
3417
3418	// If the precision was not specified, also mark the double and half entry
3419	// as found.
3420	if (ValBase.back() != 'f' && ValBase.back() != 'd' &&
3421	ValBase.back() != 'h') {
3422	OptionStrings[ValBase.str() + 'd'] = true;
3423	OptionStrings[ValBase.str() + 'h'] = true;
3424	}
3425
3426	// Build the output string.
3427	StringRef Prefix = IsDisabled ? DisabledPrefixOut : EnabledPrefixOut;
3428	Out = Args.MakeArgString(Str: Out + Prefix + Val);
3429	if (i != NumOptions - 1)
3430	Out = Args.MakeArgString(Str: Out + ",");
3431	}
3432
3433	return Out;
3434	}
3435
3436	std::string tools::complexRangeKindToStr(LangOptions::ComplexRangeKind Range) {
3437	switch (Range) {
3438	case LangOptions::ComplexRangeKind::CX_Full:
3439	return "full";
3440	break;
3441	case LangOptions::ComplexRangeKind::CX_Basic:
3442	return "basic";
3443	break;
3444	case LangOptions::ComplexRangeKind::CX_Improved:
3445	return "improved";
3446	break;
3447	case LangOptions::ComplexRangeKind::CX_Promoted:
3448	return "promoted";
3449	break;
3450	default:
3451	return "";
3452	}
3453	}
3454
3455	std::string
3456	tools::renderComplexRangeOption(LangOptionsBase::ComplexRangeKind Range) {
3457	std::string ComplexRangeStr = complexRangeKindToStr(Range);
3458	if (!ComplexRangeStr.empty())
3459	return "-complex-range=" + ComplexRangeStr;
3460	return ComplexRangeStr;
3461	}
3462