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