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