1 //===--- CommonArgs.cpp - Args handling for multiple toolchains -*- C++ -*-===//
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
7 //===----------------------------------------------------------------------===//
9 #include "CommonArgs.h"
10 #include "Arch/AArch64.h"
12 #include "Arch/Mips.h"
14 #include "Arch/SystemZ.h"
19 #include "InputInfo.h"
20 #include "clang/Basic/CharInfo.h"
21 #include "clang/Basic/LangOptions.h"
22 #include "clang/Basic/ObjCRuntime.h"
23 #include "clang/Basic/Version.h"
24 #include "clang/Config/config.h"
25 #include "clang/Driver/Action.h"
26 #include "clang/Driver/Compilation.h"
27 #include "clang/Driver/Driver.h"
28 #include "clang/Driver/DriverDiagnostic.h"
29 #include "clang/Driver/Job.h"
30 #include "clang/Driver/Options.h"
31 #include "clang/Driver/SanitizerArgs.h"
32 #include "clang/Driver/ToolChain.h"
33 #include "clang/Driver/Util.h"
34 #include "clang/Driver/XRayArgs.h"
35 #include "llvm/ADT/STLExtras.h"
36 #include "llvm/ADT/SmallString.h"
37 #include "llvm/ADT/StringExtras.h"
38 #include "llvm/ADT/StringSwitch.h"
39 #include "llvm/ADT/Twine.h"
40 #include "llvm/Option/Arg.h"
41 #include "llvm/Option/ArgList.h"
42 #include "llvm/Option/Option.h"
43 #include "llvm/Support/CodeGen.h"
44 #include "llvm/Support/Compression.h"
45 #include "llvm/Support/Debug.h"
46 #include "llvm/Support/ErrorHandling.h"
47 #include "llvm/Support/FileSystem.h"
48 #include "llvm/Support/Host.h"
49 #include "llvm/Support/Path.h"
50 #include "llvm/Support/Process.h"
51 #include "llvm/Support/Program.h"
52 #include "llvm/Support/ScopedPrinter.h"
53 #include "llvm/Support/TargetParser.h"
54 #include "llvm/Support/Threading.h"
55 #include "llvm/Support/VirtualFileSystem.h"
56 #include "llvm/Support/YAMLParser.h"
58 using namespace clang::driver;
59 using namespace clang::driver::tools;
60 using namespace clang;
61 using namespace llvm::opt;
63 void tools::addPathIfExists(const Driver &D, const Twine &Path,
64 ToolChain::path_list &Paths) {
65 if (D.getVFS().exists(Path))
66 Paths.push_back(Path.str());
69 void tools::handleTargetFeaturesGroup(const ArgList &Args,
70 std::vector<StringRef> &Features,
72 for (const Arg *A : Args.filtered(Group)) {
73 StringRef Name = A->getOption().getName();
77 assert(Name.startswith("m") && "Invalid feature name.");
78 Name = Name.substr(1);
80 bool IsNegative = Name.startswith("no-");
82 Name = Name.substr(3);
83 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
87 std::vector<StringRef>
88 tools::unifyTargetFeatures(const std::vector<StringRef> &Features) {
89 std::vector<StringRef> UnifiedFeatures;
90 // Find the last of each feature.
91 llvm::StringMap<unsigned> LastOpt;
92 for (unsigned I = 0, N = Features.size(); I < N; ++I) {
93 StringRef Name = Features[I];
94 assert(Name[0] == '-' || Name[0] == '+');
95 LastOpt[Name.drop_front(1)] = I;
98 for (unsigned I = 0, N = Features.size(); I < N; ++I) {
99 // If this feature was overridden, ignore it.
100 StringRef Name = Features[I];
101 llvm::StringMap<unsigned>::iterator LastI = LastOpt.find(Name.drop_front(1));
102 assert(LastI != LastOpt.end());
103 unsigned Last = LastI->second;
107 UnifiedFeatures.push_back(Name);
109 return UnifiedFeatures;
112 void tools::addDirectoryList(const ArgList &Args, ArgStringList &CmdArgs,
113 const char *ArgName, const char *EnvVar) {
114 const char *DirList = ::getenv(EnvVar);
115 bool CombinedArg = false;
118 return; // Nothing to do.
120 StringRef Name(ArgName);
121 if (Name.equals("-I") || Name.equals("-L") || Name.empty())
124 StringRef Dirs(DirList);
125 if (Dirs.empty()) // Empty string should not add '.'.
128 StringRef::size_type Delim;
129 while ((Delim = Dirs.find(llvm::sys::EnvPathSeparator)) != StringRef::npos) {
130 if (Delim == 0) { // Leading colon.
132 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + "."));
134 CmdArgs.push_back(ArgName);
135 CmdArgs.push_back(".");
140 Args.MakeArgString(std::string(ArgName) + Dirs.substr(0, Delim)));
142 CmdArgs.push_back(ArgName);
143 CmdArgs.push_back(Args.MakeArgString(Dirs.substr(0, Delim)));
146 Dirs = Dirs.substr(Delim + 1);
149 if (Dirs.empty()) { // Trailing colon.
151 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + "."));
153 CmdArgs.push_back(ArgName);
154 CmdArgs.push_back(".");
156 } else { // Add the last path.
158 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + Dirs));
160 CmdArgs.push_back(ArgName);
161 CmdArgs.push_back(Args.MakeArgString(Dirs));
166 void tools::AddLinkerInputs(const ToolChain &TC, const InputInfoList &Inputs,
167 const ArgList &Args, ArgStringList &CmdArgs,
168 const JobAction &JA) {
169 const Driver &D = TC.getDriver();
171 // Add extra linker input arguments which are not treated as inputs
172 // (constructed via -Xarch_).
173 Args.AddAllArgValues(CmdArgs, options::OPT_Zlinker_input);
175 // LIBRARY_PATH are included before user inputs and only supported on native
177 if (!TC.isCrossCompiling())
178 addDirectoryList(Args, CmdArgs, "-L", "LIBRARY_PATH");
180 for (const auto &II : Inputs) {
181 // If the current tool chain refers to an OpenMP offloading host, we
182 // should ignore inputs that refer to OpenMP offloading devices -
183 // they will be embedded according to a proper linker script.
184 if (auto *IA = II.getAction())
185 if ((JA.isHostOffloading(Action::OFK_OpenMP) &&
186 IA->isDeviceOffloading(Action::OFK_OpenMP)))
189 if (!TC.HasNativeLLVMSupport() && types::isLLVMIR(II.getType()))
190 // Don't try to pass LLVM inputs unless we have native support.
191 D.Diag(diag::err_drv_no_linker_llvm_support) << TC.getTripleString();
193 // Add filenames immediately.
194 if (II.isFilename()) {
195 CmdArgs.push_back(II.getFilename());
199 // Otherwise, this is a linker input argument.
200 const Arg &A = II.getInputArg();
202 // Handle reserved library options.
203 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx))
204 TC.AddCXXStdlibLibArgs(Args, CmdArgs);
205 else if (A.getOption().matches(options::OPT_Z_reserved_lib_cckext))
206 TC.AddCCKextLibArgs(Args, CmdArgs);
207 else if (A.getOption().matches(options::OPT_z)) {
208 // Pass -z prefix for gcc linker compatibility.
210 A.render(Args, CmdArgs);
212 A.renderAsInput(Args, CmdArgs);
217 void tools::AddTargetFeature(const ArgList &Args,
218 std::vector<StringRef> &Features,
219 OptSpecifier OnOpt, OptSpecifier OffOpt,
220 StringRef FeatureName) {
221 if (Arg *A = Args.getLastArg(OnOpt, OffOpt)) {
222 if (A->getOption().matches(OnOpt))
223 Features.push_back(Args.MakeArgString("+" + FeatureName));
225 Features.push_back(Args.MakeArgString("-" + FeatureName));
229 /// Get the (LLVM) name of the R600 gpu we are targeting.
230 static std::string getR600TargetGPU(const ArgList &Args) {
231 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
232 const char *GPUName = A->getValue();
233 return llvm::StringSwitch<const char *>(GPUName)
234 .Cases("rv630", "rv635", "r600")
235 .Cases("rv610", "rv620", "rs780", "rs880")
236 .Case("rv740", "rv770")
237 .Case("palm", "cedar")
238 .Cases("sumo", "sumo2", "sumo")
239 .Case("hemlock", "cypress")
240 .Case("aruba", "cayman")
246 static std::string getLanaiTargetCPU(const ArgList &Args) {
247 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
248 return A->getValue();
253 /// Get the (LLVM) name of the WebAssembly cpu we are targeting.
254 static StringRef getWebAssemblyTargetCPU(const ArgList &Args) {
255 // If we have -mcpu=, use that.
256 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
257 StringRef CPU = A->getValue();
260 // Handle "native" by examining the host. "native" isn't meaningful when
261 // cross compiling, so only support this when the host is also WebAssembly.
263 return llvm::sys::getHostCPUName();
272 std::string tools::getCPUName(const ArgList &Args, const llvm::Triple &T,
276 switch (T.getArch()) {
280 case llvm::Triple::aarch64:
281 case llvm::Triple::aarch64_32:
282 case llvm::Triple::aarch64_be:
283 return aarch64::getAArch64TargetCPU(Args, T, A);
285 case llvm::Triple::arm:
286 case llvm::Triple::armeb:
287 case llvm::Triple::thumb:
288 case llvm::Triple::thumbeb: {
289 StringRef MArch, MCPU;
290 arm::getARMArchCPUFromArgs(Args, MArch, MCPU, FromAs);
291 return arm::getARMTargetCPU(MCPU, MArch, T);
294 case llvm::Triple::avr:
295 if (const Arg *A = Args.getLastArg(options::OPT_mmcu_EQ))
296 return A->getValue();
299 case llvm::Triple::mips:
300 case llvm::Triple::mipsel:
301 case llvm::Triple::mips64:
302 case llvm::Triple::mips64el: {
305 mips::getMipsCPUAndABI(Args, T, CPUName, ABIName);
306 return std::string(CPUName);
309 case llvm::Triple::nvptx:
310 case llvm::Triple::nvptx64:
311 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
312 return A->getValue();
315 case llvm::Triple::ppc:
316 case llvm::Triple::ppc64:
317 case llvm::Triple::ppc64le: {
318 std::string TargetCPUName = ppc::getPPCTargetCPU(Args);
319 // LLVM may default to generating code for the native CPU,
320 // but, like gcc, we default to a more generic option for
321 // each architecture. (except on AIX)
322 if (!TargetCPUName.empty())
323 return TargetCPUName;
326 TargetCPUName = "pwr4";
327 else if (T.getArch() == llvm::Triple::ppc64le)
328 TargetCPUName = "ppc64le";
329 else if (T.getArch() == llvm::Triple::ppc64)
330 TargetCPUName = "ppc64";
332 TargetCPUName = "ppc";
334 return TargetCPUName;
336 case llvm::Triple::riscv32:
337 case llvm::Triple::riscv64:
338 if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
339 return A->getValue();
342 case llvm::Triple::bpfel:
343 case llvm::Triple::bpfeb:
344 case llvm::Triple::sparc:
345 case llvm::Triple::sparcel:
346 case llvm::Triple::sparcv9:
347 if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
348 return A->getValue();
351 case llvm::Triple::x86:
352 case llvm::Triple::x86_64:
353 return x86::getX86TargetCPU(Args, T);
355 case llvm::Triple::hexagon:
357 toolchains::HexagonToolChain::GetTargetCPUVersion(Args).str();
359 case llvm::Triple::lanai:
360 return getLanaiTargetCPU(Args);
362 case llvm::Triple::systemz:
363 return systemz::getSystemZTargetCPU(Args);
365 case llvm::Triple::r600:
366 case llvm::Triple::amdgcn:
367 return getR600TargetGPU(Args);
369 case llvm::Triple::wasm32:
370 case llvm::Triple::wasm64:
371 return std::string(getWebAssemblyTargetCPU(Args));
375 llvm::StringRef tools::getLTOParallelism(const ArgList &Args, const Driver &D) {
376 Arg *LtoJobsArg = Args.getLastArg(options::OPT_flto_jobs_EQ);
379 if (!llvm::get_threadpool_strategy(LtoJobsArg->getValue()))
380 D.Diag(diag::err_drv_invalid_int_value)
381 << LtoJobsArg->getAsString(Args) << LtoJobsArg->getValue();
382 return LtoJobsArg->getValue();
385 // CloudABI uses -ffunction-sections and -fdata-sections by default.
386 bool tools::isUseSeparateSections(const llvm::Triple &Triple) {
387 return Triple.getOS() == llvm::Triple::CloudABI;
390 void tools::addLTOOptions(const ToolChain &ToolChain, const ArgList &Args,
391 ArgStringList &CmdArgs, const InputInfo &Output,
392 const InputInfo &Input, bool IsThinLTO) {
393 const char *Linker = Args.MakeArgString(ToolChain.GetLinkerPath());
394 const Driver &D = ToolChain.getDriver();
395 if (llvm::sys::path::filename(Linker) != "ld.lld" &&
396 llvm::sys::path::stem(Linker) != "ld.lld") {
397 // Tell the linker to load the plugin. This has to come before
398 // AddLinkerInputs as gold requires -plugin to come before any -plugin-opt
399 // that -Wl might forward.
400 CmdArgs.push_back("-plugin");
403 const char *Suffix = ".dll";
404 #elif defined(__APPLE__)
405 const char *Suffix = ".dylib";
407 const char *Suffix = ".so";
410 SmallString<1024> Plugin;
411 llvm::sys::path::native(
412 Twine(D.Dir) + "/../lib" CLANG_LIBDIR_SUFFIX "/LLVMgold" + Suffix,
414 CmdArgs.push_back(Args.MakeArgString(Plugin));
417 // Try to pass driver level flags relevant to LTO code generation down to
420 // Handle flags for selecting CPU variants.
421 std::string CPU = getCPUName(Args, ToolChain.getTriple());
423 CmdArgs.push_back(Args.MakeArgString(Twine("-plugin-opt=mcpu=") + CPU));
425 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
426 // The optimization level matches
427 // CompilerInvocation.cpp:getOptimizationLevel().
429 if (A->getOption().matches(options::OPT_O4) ||
430 A->getOption().matches(options::OPT_Ofast))
432 else if (A->getOption().matches(options::OPT_O)) {
433 OOpt = A->getValue();
436 else if (OOpt == "s" || OOpt == "z")
438 } else if (A->getOption().matches(options::OPT_O0))
441 CmdArgs.push_back(Args.MakeArgString(Twine("-plugin-opt=O") + OOpt));
444 if (Args.hasArg(options::OPT_gsplit_dwarf)) {
446 Args.MakeArgString(Twine("-plugin-opt=dwo_dir=") +
447 Output.getFilename() + "_dwo"));
451 CmdArgs.push_back("-plugin-opt=thinlto");
453 StringRef Parallelism = getLTOParallelism(Args, D);
454 if (!Parallelism.empty())
456 Args.MakeArgString("-plugin-opt=jobs=" + Twine(Parallelism)));
458 // If an explicit debugger tuning argument appeared, pass it along.
459 if (Arg *A = Args.getLastArg(options::OPT_gTune_Group,
460 options::OPT_ggdbN_Group)) {
461 if (A->getOption().matches(options::OPT_glldb))
462 CmdArgs.push_back("-plugin-opt=-debugger-tune=lldb");
463 else if (A->getOption().matches(options::OPT_gsce))
464 CmdArgs.push_back("-plugin-opt=-debugger-tune=sce");
466 CmdArgs.push_back("-plugin-opt=-debugger-tune=gdb");
469 bool UseSeparateSections =
470 isUseSeparateSections(ToolChain.getEffectiveTriple());
472 if (Args.hasFlag(options::OPT_ffunction_sections,
473 options::OPT_fno_function_sections, UseSeparateSections)) {
474 CmdArgs.push_back("-plugin-opt=-function-sections");
477 if (Args.hasFlag(options::OPT_fdata_sections, options::OPT_fno_data_sections,
478 UseSeparateSections)) {
479 CmdArgs.push_back("-plugin-opt=-data-sections");
482 if (Arg *A = getLastProfileSampleUseArg(Args)) {
483 StringRef FName = A->getValue();
484 if (!llvm::sys::fs::exists(FName))
485 D.Diag(diag::err_drv_no_such_file) << FName;
488 Args.MakeArgString(Twine("-plugin-opt=sample-profile=") + FName));
491 auto *CSPGOGenerateArg = Args.getLastArg(options::OPT_fcs_profile_generate,
492 options::OPT_fcs_profile_generate_EQ,
493 options::OPT_fno_profile_generate);
494 if (CSPGOGenerateArg &&
495 CSPGOGenerateArg->getOption().matches(options::OPT_fno_profile_generate))
496 CSPGOGenerateArg = nullptr;
498 auto *ProfileUseArg = getLastProfileUseArg(Args);
500 if (CSPGOGenerateArg) {
501 CmdArgs.push_back(Args.MakeArgString("-plugin-opt=cs-profile-generate"));
502 if (CSPGOGenerateArg->getOption().matches(
503 options::OPT_fcs_profile_generate_EQ)) {
504 SmallString<128> Path(CSPGOGenerateArg->getValue());
505 llvm::sys::path::append(Path, "default_%m.profraw");
507 Args.MakeArgString(Twine("-plugin-opt=cs-profile-path=") + Path));
510 Args.MakeArgString("-plugin-opt=cs-profile-path=default_%m.profraw"));
511 } else if (ProfileUseArg) {
512 SmallString<128> Path(
513 ProfileUseArg->getNumValues() == 0 ? "" : ProfileUseArg->getValue());
514 if (Path.empty() || llvm::sys::fs::is_directory(Path))
515 llvm::sys::path::append(Path, "default.profdata");
516 CmdArgs.push_back(Args.MakeArgString(Twine("-plugin-opt=cs-profile-path=") +
520 // Need this flag to turn on new pass manager via Gold plugin.
521 if (Args.hasFlag(options::OPT_fexperimental_new_pass_manager,
522 options::OPT_fno_experimental_new_pass_manager,
523 /* Default */ ENABLE_EXPERIMENTAL_NEW_PASS_MANAGER)) {
524 CmdArgs.push_back("-plugin-opt=new-pass-manager");
527 // Setup statistics file output.
528 SmallString<128> StatsFile = getStatsFileName(Args, Output, Input, D);
529 if (!StatsFile.empty())
531 Args.MakeArgString(Twine("-plugin-opt=stats-file=") + StatsFile));
533 addX86AlignBranchArgs(D, Args, CmdArgs, /*IsLTO=*/true);
536 void tools::addArchSpecificRPath(const ToolChain &TC, const ArgList &Args,
537 ArgStringList &CmdArgs) {
538 // Enable -frtlib-add-rpath by default for the case of VE.
539 const bool IsVE = TC.getTriple().isVE();
540 bool DefaultValue = IsVE;
541 if (!Args.hasFlag(options::OPT_frtlib_add_rpath,
542 options::OPT_fno_rtlib_add_rpath, DefaultValue))
545 std::string CandidateRPath = TC.getArchSpecificLibPath();
546 if (TC.getVFS().exists(CandidateRPath)) {
547 CmdArgs.push_back("-rpath");
548 CmdArgs.push_back(Args.MakeArgString(CandidateRPath.c_str()));
552 bool tools::addOpenMPRuntime(ArgStringList &CmdArgs, const ToolChain &TC,
553 const ArgList &Args, bool ForceStaticHostRuntime,
554 bool IsOffloadingHost, bool GompNeedsRT) {
555 if (!Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
556 options::OPT_fno_openmp, false))
559 Driver::OpenMPRuntimeKind RTKind = TC.getDriver().getOpenMPRuntime(Args);
561 if (RTKind == Driver::OMPRT_Unknown)
562 // Already diagnosed.
565 if (ForceStaticHostRuntime)
566 CmdArgs.push_back("-Bstatic");
569 case Driver::OMPRT_OMP:
570 CmdArgs.push_back("-lomp");
572 case Driver::OMPRT_GOMP:
573 CmdArgs.push_back("-lgomp");
575 case Driver::OMPRT_IOMP5:
576 CmdArgs.push_back("-liomp5");
578 case Driver::OMPRT_Unknown:
582 if (ForceStaticHostRuntime)
583 CmdArgs.push_back("-Bdynamic");
585 if (RTKind == Driver::OMPRT_GOMP && GompNeedsRT)
586 CmdArgs.push_back("-lrt");
588 if (IsOffloadingHost)
589 CmdArgs.push_back("-lomptarget");
591 addArchSpecificRPath(TC, Args, CmdArgs);
596 static void addSanitizerRuntime(const ToolChain &TC, const ArgList &Args,
597 ArgStringList &CmdArgs, StringRef Sanitizer,
598 bool IsShared, bool IsWhole) {
599 // Wrap any static runtimes that must be forced into executable in
601 if (IsWhole) CmdArgs.push_back("--whole-archive");
602 CmdArgs.push_back(TC.getCompilerRTArgString(
603 Args, Sanitizer, IsShared ? ToolChain::FT_Shared : ToolChain::FT_Static));
604 if (IsWhole) CmdArgs.push_back("--no-whole-archive");
607 addArchSpecificRPath(TC, Args, CmdArgs);
611 // Tries to use a file with the list of dynamic symbols that need to be exported
612 // from the runtime library. Returns true if the file was found.
613 static bool addSanitizerDynamicList(const ToolChain &TC, const ArgList &Args,
614 ArgStringList &CmdArgs,
615 StringRef Sanitizer) {
616 // Solaris ld defaults to --export-dynamic behaviour but doesn't support
617 // the option, so don't try to pass it.
618 if (TC.getTriple().getOS() == llvm::Triple::Solaris)
620 // Myriad is static linking only. Furthermore, some versions of its
621 // linker have the bug where --export-dynamic overrides -static, so
622 // don't use --export-dynamic on that platform.
623 if (TC.getTriple().getVendor() == llvm::Triple::Myriad)
625 SmallString<128> SanRT(TC.getCompilerRT(Args, Sanitizer));
626 if (llvm::sys::fs::exists(SanRT + ".syms")) {
627 CmdArgs.push_back(Args.MakeArgString("--dynamic-list=" + SanRT + ".syms"));
633 void tools::linkSanitizerRuntimeDeps(const ToolChain &TC,
634 ArgStringList &CmdArgs) {
635 // Fuchsia never needs these. Any sanitizer runtimes with system
636 // dependencies use the `.deplibs` feature instead.
637 if (TC.getTriple().isOSFuchsia())
640 // Force linking against the system libraries sanitizers depends on
641 // (see PR15823 why this is necessary).
642 CmdArgs.push_back("--no-as-needed");
643 // There's no libpthread or librt on RTEMS & Android.
644 if (TC.getTriple().getOS() != llvm::Triple::RTEMS &&
645 !TC.getTriple().isAndroid()) {
646 CmdArgs.push_back("-lpthread");
647 if (!TC.getTriple().isOSOpenBSD())
648 CmdArgs.push_back("-lrt");
650 CmdArgs.push_back("-lm");
651 // There's no libdl on all OSes.
652 if (!TC.getTriple().isOSFreeBSD() &&
653 !TC.getTriple().isOSNetBSD() &&
654 !TC.getTriple().isOSOpenBSD() &&
655 TC.getTriple().getOS() != llvm::Triple::RTEMS)
656 CmdArgs.push_back("-ldl");
657 // Required for backtrace on some OSes
658 if (TC.getTriple().isOSFreeBSD() ||
659 TC.getTriple().isOSNetBSD())
660 CmdArgs.push_back("-lexecinfo");
664 collectSanitizerRuntimes(const ToolChain &TC, const ArgList &Args,
665 SmallVectorImpl<StringRef> &SharedRuntimes,
666 SmallVectorImpl<StringRef> &StaticRuntimes,
667 SmallVectorImpl<StringRef> &NonWholeStaticRuntimes,
668 SmallVectorImpl<StringRef> &HelperStaticRuntimes,
669 SmallVectorImpl<StringRef> &RequiredSymbols) {
670 const SanitizerArgs &SanArgs = TC.getSanitizerArgs();
671 // Collect shared runtimes.
672 if (SanArgs.needsSharedRt()) {
673 if (SanArgs.needsAsanRt() && SanArgs.linkRuntimes()) {
674 SharedRuntimes.push_back("asan");
675 if (!Args.hasArg(options::OPT_shared) && !TC.getTriple().isAndroid())
676 HelperStaticRuntimes.push_back("asan-preinit");
678 if (SanArgs.needsUbsanRt() && SanArgs.linkRuntimes()) {
679 if (SanArgs.requiresMinimalRuntime())
680 SharedRuntimes.push_back("ubsan_minimal");
682 SharedRuntimes.push_back("ubsan_standalone");
684 if (SanArgs.needsScudoRt() && SanArgs.linkRuntimes()) {
685 if (SanArgs.requiresMinimalRuntime())
686 SharedRuntimes.push_back("scudo_minimal");
688 SharedRuntimes.push_back("scudo");
690 if (SanArgs.needsHwasanRt() && SanArgs.linkRuntimes())
691 SharedRuntimes.push_back("hwasan");
694 // The stats_client library is also statically linked into DSOs.
695 if (SanArgs.needsStatsRt() && SanArgs.linkRuntimes())
696 StaticRuntimes.push_back("stats_client");
698 // Collect static runtimes.
699 if (Args.hasArg(options::OPT_shared)) {
700 // Don't link static runtimes into DSOs.
704 // Each static runtime that has a DSO counterpart above is excluded below,
705 // but runtimes that exist only as static are not affected by needsSharedRt.
707 if (!SanArgs.needsSharedRt() && SanArgs.needsAsanRt() && SanArgs.linkRuntimes()) {
708 StaticRuntimes.push_back("asan");
709 if (SanArgs.linkCXXRuntimes())
710 StaticRuntimes.push_back("asan_cxx");
713 if (!SanArgs.needsSharedRt() && SanArgs.needsHwasanRt() && SanArgs.linkRuntimes()) {
714 StaticRuntimes.push_back("hwasan");
715 if (SanArgs.linkCXXRuntimes())
716 StaticRuntimes.push_back("hwasan_cxx");
718 if (SanArgs.needsDfsanRt() && SanArgs.linkRuntimes())
719 StaticRuntimes.push_back("dfsan");
720 if (SanArgs.needsLsanRt() && SanArgs.linkRuntimes())
721 StaticRuntimes.push_back("lsan");
722 if (SanArgs.needsMsanRt() && SanArgs.linkRuntimes()) {
723 StaticRuntimes.push_back("msan");
724 if (SanArgs.linkCXXRuntimes())
725 StaticRuntimes.push_back("msan_cxx");
727 if (SanArgs.needsTsanRt() && SanArgs.linkRuntimes()) {
728 StaticRuntimes.push_back("tsan");
729 if (SanArgs.linkCXXRuntimes())
730 StaticRuntimes.push_back("tsan_cxx");
732 if (!SanArgs.needsSharedRt() && SanArgs.needsUbsanRt() && SanArgs.linkRuntimes()) {
733 if (SanArgs.requiresMinimalRuntime()) {
734 StaticRuntimes.push_back("ubsan_minimal");
736 StaticRuntimes.push_back("ubsan_standalone");
737 if (SanArgs.linkCXXRuntimes())
738 StaticRuntimes.push_back("ubsan_standalone_cxx");
741 if (SanArgs.needsSafeStackRt() && SanArgs.linkRuntimes()) {
742 NonWholeStaticRuntimes.push_back("safestack");
743 RequiredSymbols.push_back("__safestack_init");
745 if (!(SanArgs.needsSharedRt() && SanArgs.needsUbsanRt() && SanArgs.linkRuntimes())) {
746 if (SanArgs.needsCfiRt() && SanArgs.linkRuntimes())
747 StaticRuntimes.push_back("cfi");
748 if (SanArgs.needsCfiDiagRt() && SanArgs.linkRuntimes()) {
749 StaticRuntimes.push_back("cfi_diag");
750 if (SanArgs.linkCXXRuntimes())
751 StaticRuntimes.push_back("ubsan_standalone_cxx");
754 if (SanArgs.needsStatsRt() && SanArgs.linkRuntimes()) {
755 NonWholeStaticRuntimes.push_back("stats");
756 RequiredSymbols.push_back("__sanitizer_stats_register");
758 if (!SanArgs.needsSharedRt() && SanArgs.needsScudoRt() && SanArgs.linkRuntimes()) {
759 if (SanArgs.requiresMinimalRuntime()) {
760 StaticRuntimes.push_back("scudo_minimal");
761 if (SanArgs.linkCXXRuntimes())
762 StaticRuntimes.push_back("scudo_cxx_minimal");
764 StaticRuntimes.push_back("scudo");
765 if (SanArgs.linkCXXRuntimes())
766 StaticRuntimes.push_back("scudo_cxx");
771 // Should be called before we add system libraries (C++ ABI, libstdc++/libc++,
772 // C runtime, etc). Returns true if sanitizer system deps need to be linked in.
773 bool tools::addSanitizerRuntimes(const ToolChain &TC, const ArgList &Args,
774 ArgStringList &CmdArgs) {
775 SmallVector<StringRef, 4> SharedRuntimes, StaticRuntimes,
776 NonWholeStaticRuntimes, HelperStaticRuntimes, RequiredSymbols;
777 collectSanitizerRuntimes(TC, Args, SharedRuntimes, StaticRuntimes,
778 NonWholeStaticRuntimes, HelperStaticRuntimes,
781 const SanitizerArgs &SanArgs = TC.getSanitizerArgs();
782 // Inject libfuzzer dependencies.
783 if (SanArgs.needsFuzzer() && SanArgs.linkRuntimes() &&
784 !Args.hasArg(options::OPT_shared)) {
786 addSanitizerRuntime(TC, Args, CmdArgs, "fuzzer", false, true);
787 if (!Args.hasArg(clang::driver::options::OPT_nostdlibxx))
788 TC.AddCXXStdlibLibArgs(Args, CmdArgs);
791 for (auto RT : SharedRuntimes)
792 addSanitizerRuntime(TC, Args, CmdArgs, RT, true, false);
793 for (auto RT : HelperStaticRuntimes)
794 addSanitizerRuntime(TC, Args, CmdArgs, RT, false, true);
795 bool AddExportDynamic = false;
796 for (auto RT : StaticRuntimes) {
797 addSanitizerRuntime(TC, Args, CmdArgs, RT, false, true);
798 AddExportDynamic |= !addSanitizerDynamicList(TC, Args, CmdArgs, RT);
800 for (auto RT : NonWholeStaticRuntimes) {
801 addSanitizerRuntime(TC, Args, CmdArgs, RT, false, false);
802 AddExportDynamic |= !addSanitizerDynamicList(TC, Args, CmdArgs, RT);
804 for (auto S : RequiredSymbols) {
805 CmdArgs.push_back("-u");
806 CmdArgs.push_back(Args.MakeArgString(S));
808 // If there is a static runtime with no dynamic list, force all the symbols
809 // to be dynamic to be sure we export sanitizer interface functions.
810 if (AddExportDynamic)
811 CmdArgs.push_back("--export-dynamic");
813 if (SanArgs.hasCrossDsoCfi() && !AddExportDynamic)
814 CmdArgs.push_back("--export-dynamic-symbol=__cfi_check");
816 return !StaticRuntimes.empty() || !NonWholeStaticRuntimes.empty();
819 bool tools::addXRayRuntime(const ToolChain&TC, const ArgList &Args, ArgStringList &CmdArgs) {
820 if (Args.hasArg(options::OPT_shared))
823 if (TC.getXRayArgs().needsXRayRt()) {
824 CmdArgs.push_back("-whole-archive");
825 CmdArgs.push_back(TC.getCompilerRTArgString(Args, "xray"));
826 for (const auto &Mode : TC.getXRayArgs().modeList())
827 CmdArgs.push_back(TC.getCompilerRTArgString(Args, Mode));
828 CmdArgs.push_back("-no-whole-archive");
835 void tools::linkXRayRuntimeDeps(const ToolChain &TC, ArgStringList &CmdArgs) {
836 CmdArgs.push_back("--no-as-needed");
837 CmdArgs.push_back("-lpthread");
838 if (!TC.getTriple().isOSOpenBSD())
839 CmdArgs.push_back("-lrt");
840 CmdArgs.push_back("-lm");
842 if (!TC.getTriple().isOSFreeBSD() &&
843 !TC.getTriple().isOSNetBSD() &&
844 !TC.getTriple().isOSOpenBSD())
845 CmdArgs.push_back("-ldl");
848 bool tools::areOptimizationsEnabled(const ArgList &Args) {
849 // Find the last -O arg and see if it is non-zero.
850 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
851 return !A->getOption().matches(options::OPT_O0);
856 const char *tools::SplitDebugName(const ArgList &Args, const InputInfo &Input,
857 const InputInfo &Output) {
858 if (Arg *A = Args.getLastArg(options::OPT_gsplit_dwarf_EQ))
859 if (StringRef(A->getValue()) == "single")
860 return Args.MakeArgString(Output.getFilename());
862 Arg *FinalOutput = Args.getLastArg(options::OPT_o);
863 if (FinalOutput && Args.hasArg(options::OPT_c)) {
864 SmallString<128> T(FinalOutput->getValue());
865 llvm::sys::path::replace_extension(T, "dwo");
866 return Args.MakeArgString(T);
868 // Use the compilation dir.
870 Args.getLastArgValue(options::OPT_fdebug_compilation_dir));
871 SmallString<128> F(llvm::sys::path::stem(Input.getBaseInput()));
872 llvm::sys::path::replace_extension(F, "dwo");
874 return Args.MakeArgString(F);
878 void tools::SplitDebugInfo(const ToolChain &TC, Compilation &C, const Tool &T,
879 const JobAction &JA, const ArgList &Args,
880 const InputInfo &Output, const char *OutFile) {
881 ArgStringList ExtractArgs;
882 ExtractArgs.push_back("--extract-dwo");
884 ArgStringList StripArgs;
885 StripArgs.push_back("--strip-dwo");
887 // Grabbing the output of the earlier compile step.
888 StripArgs.push_back(Output.getFilename());
889 ExtractArgs.push_back(Output.getFilename());
890 ExtractArgs.push_back(OutFile);
893 Args.MakeArgString(TC.GetProgramPath(CLANG_DEFAULT_OBJCOPY));
894 InputInfo II(types::TY_Object, Output.getFilename(), Output.getFilename());
896 // First extract the dwo sections.
897 C.addCommand(std::make_unique<Command>(
898 JA, T, ResponseFileSupport::AtFileCurCP(), Exec, ExtractArgs, II));
900 // Then remove them from the original .o file.
901 C.addCommand(std::make_unique<Command>(
902 JA, T, ResponseFileSupport::AtFileCurCP(), Exec, StripArgs, II));
905 // Claim options we don't want to warn if they are unused. We do this for
906 // options that build systems might add but are unused when assembling or only
907 // running the preprocessor for example.
908 void tools::claimNoWarnArgs(const ArgList &Args) {
909 // Don't warn about unused -f(no-)?lto. This can happen when we're
910 // preprocessing, precompiling or assembling.
911 Args.ClaimAllArgs(options::OPT_flto_EQ);
912 Args.ClaimAllArgs(options::OPT_flto);
913 Args.ClaimAllArgs(options::OPT_fno_lto);
916 Arg *tools::getLastProfileUseArg(const ArgList &Args) {
917 auto *ProfileUseArg = Args.getLastArg(
918 options::OPT_fprofile_instr_use, options::OPT_fprofile_instr_use_EQ,
919 options::OPT_fprofile_use, options::OPT_fprofile_use_EQ,
920 options::OPT_fno_profile_instr_use);
923 ProfileUseArg->getOption().matches(options::OPT_fno_profile_instr_use))
924 ProfileUseArg = nullptr;
926 return ProfileUseArg;
929 Arg *tools::getLastProfileSampleUseArg(const ArgList &Args) {
930 auto *ProfileSampleUseArg = Args.getLastArg(
931 options::OPT_fprofile_sample_use, options::OPT_fprofile_sample_use_EQ,
932 options::OPT_fauto_profile, options::OPT_fauto_profile_EQ,
933 options::OPT_fno_profile_sample_use, options::OPT_fno_auto_profile);
935 if (ProfileSampleUseArg &&
936 (ProfileSampleUseArg->getOption().matches(
937 options::OPT_fno_profile_sample_use) ||
938 ProfileSampleUseArg->getOption().matches(options::OPT_fno_auto_profile)))
941 return Args.getLastArg(options::OPT_fprofile_sample_use_EQ,
942 options::OPT_fauto_profile_EQ);
945 /// Parses the various -fpic/-fPIC/-fpie/-fPIE arguments. Then,
946 /// smooshes them together with platform defaults, to decide whether
947 /// this compile should be using PIC mode or not. Returns a tuple of
948 /// (RelocationModel, PICLevel, IsPIE).
949 std::tuple<llvm::Reloc::Model, unsigned, bool>
950 tools::ParsePICArgs(const ToolChain &ToolChain, const ArgList &Args) {
951 const llvm::Triple &EffectiveTriple = ToolChain.getEffectiveTriple();
952 const llvm::Triple &Triple = ToolChain.getTriple();
954 bool PIE = ToolChain.isPIEDefault();
955 bool PIC = PIE || ToolChain.isPICDefault();
956 // The Darwin/MachO default to use PIC does not apply when using -static.
957 if (Triple.isOSBinFormatMachO() && Args.hasArg(options::OPT_static))
959 bool IsPICLevelTwo = PIC;
962 Args.hasArg(options::OPT_mkernel, options::OPT_fapple_kext);
964 // Android-specific defaults for PIC/PIE
965 if (Triple.isAndroid()) {
966 switch (Triple.getArch()) {
967 case llvm::Triple::arm:
968 case llvm::Triple::armeb:
969 case llvm::Triple::thumb:
970 case llvm::Triple::thumbeb:
971 case llvm::Triple::aarch64:
972 case llvm::Triple::mips:
973 case llvm::Triple::mipsel:
974 case llvm::Triple::mips64:
975 case llvm::Triple::mips64el:
976 PIC = true; // "-fpic"
979 case llvm::Triple::x86:
980 case llvm::Triple::x86_64:
981 PIC = true; // "-fPIC"
982 IsPICLevelTwo = true;
990 // OpenBSD-specific defaults for PIE
991 if (Triple.isOSOpenBSD()) {
992 switch (ToolChain.getArch()) {
993 case llvm::Triple::arm:
994 case llvm::Triple::aarch64:
995 case llvm::Triple::mips64:
996 case llvm::Triple::mips64el:
997 case llvm::Triple::x86:
998 case llvm::Triple::x86_64:
999 IsPICLevelTwo = false; // "-fpie"
1002 case llvm::Triple::ppc:
1003 case llvm::Triple::sparc:
1004 case llvm::Triple::sparcel:
1005 case llvm::Triple::sparcv9:
1006 IsPICLevelTwo = true; // "-fPIE"
1014 // AMDGPU-specific defaults for PIC.
1015 if (Triple.getArch() == llvm::Triple::amdgcn)
1018 // The last argument relating to either PIC or PIE wins, and no
1019 // other argument is used. If the last argument is any flavor of the
1020 // '-fno-...' arguments, both PIC and PIE are disabled. Any PIE
1021 // option implicitly enables PIC at the same level.
1022 Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
1023 options::OPT_fpic, options::OPT_fno_pic,
1024 options::OPT_fPIE, options::OPT_fno_PIE,
1025 options::OPT_fpie, options::OPT_fno_pie);
1026 if (Triple.isOSWindows() && LastPICArg &&
1028 Args.getLastArg(options::OPT_fPIC, options::OPT_fpic,
1029 options::OPT_fPIE, options::OPT_fpie)) {
1030 ToolChain.getDriver().Diag(diag::err_drv_unsupported_opt_for_target)
1031 << LastPICArg->getSpelling() << Triple.str();
1032 if (Triple.getArch() == llvm::Triple::x86_64)
1033 return std::make_tuple(llvm::Reloc::PIC_, 2U, false);
1034 return std::make_tuple(llvm::Reloc::Static, 0U, false);
1037 // Check whether the tool chain trumps the PIC-ness decision. If the PIC-ness
1038 // is forced, then neither PIC nor PIE flags will have no effect.
1039 if (!ToolChain.isPICDefaultForced()) {
1041 Option O = LastPICArg->getOption();
1042 if (O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic) ||
1043 O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie)) {
1044 PIE = O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie);
1046 PIE || O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic);
1048 O.matches(options::OPT_fPIE) || O.matches(options::OPT_fPIC);
1051 if (EffectiveTriple.isPS4CPU()) {
1052 Arg *ModelArg = Args.getLastArg(options::OPT_mcmodel_EQ);
1053 StringRef Model = ModelArg ? ModelArg->getValue() : "";
1054 if (Model != "kernel") {
1056 ToolChain.getDriver().Diag(diag::warn_drv_ps4_force_pic)
1057 << LastPICArg->getSpelling();
1064 // Introduce a Darwin and PS4-specific hack. If the default is PIC, but the
1065 // PIC level would've been set to level 1, force it back to level 2 PIC
1067 if (PIC && (Triple.isOSDarwin() || EffectiveTriple.isPS4CPU()))
1068 IsPICLevelTwo |= ToolChain.isPICDefault();
1070 // This kernel flags are a trump-card: they will disable PIC/PIE
1071 // generation, independent of the argument order.
1073 ((!EffectiveTriple.isiOS() || EffectiveTriple.isOSVersionLT(6)) &&
1074 !EffectiveTriple.isWatchOS()))
1077 if (Arg *A = Args.getLastArg(options::OPT_mdynamic_no_pic)) {
1078 // This is a very special mode. It trumps the other modes, almost no one
1079 // uses it, and it isn't even valid on any OS but Darwin.
1080 if (!Triple.isOSDarwin())
1081 ToolChain.getDriver().Diag(diag::err_drv_unsupported_opt_for_target)
1082 << A->getSpelling() << Triple.str();
1084 // FIXME: Warn when this flag trumps some other PIC or PIE flag.
1086 // Only a forced PIC mode can cause the actual compile to have PIC defines
1087 // etc., no flags are sufficient. This behavior was selected to closely
1088 // match that of llvm-gcc and Apple GCC before that.
1089 PIC = ToolChain.isPICDefault() && ToolChain.isPICDefaultForced();
1091 return std::make_tuple(llvm::Reloc::DynamicNoPIC, PIC ? 2U : 0U, false);
1094 bool EmbeddedPISupported;
1095 switch (Triple.getArch()) {
1096 case llvm::Triple::arm:
1097 case llvm::Triple::armeb:
1098 case llvm::Triple::thumb:
1099 case llvm::Triple::thumbeb:
1100 EmbeddedPISupported = true;
1103 EmbeddedPISupported = false;
1107 bool ROPI = false, RWPI = false;
1108 Arg* LastROPIArg = Args.getLastArg(options::OPT_fropi, options::OPT_fno_ropi);
1109 if (LastROPIArg && LastROPIArg->getOption().matches(options::OPT_fropi)) {
1110 if (!EmbeddedPISupported)
1111 ToolChain.getDriver().Diag(diag::err_drv_unsupported_opt_for_target)
1112 << LastROPIArg->getSpelling() << Triple.str();
1115 Arg *LastRWPIArg = Args.getLastArg(options::OPT_frwpi, options::OPT_fno_rwpi);
1116 if (LastRWPIArg && LastRWPIArg->getOption().matches(options::OPT_frwpi)) {
1117 if (!EmbeddedPISupported)
1118 ToolChain.getDriver().Diag(diag::err_drv_unsupported_opt_for_target)
1119 << LastRWPIArg->getSpelling() << Triple.str();
1123 // ROPI and RWPI are not compatible with PIC or PIE.
1124 if ((ROPI || RWPI) && (PIC || PIE))
1125 ToolChain.getDriver().Diag(diag::err_drv_ropi_rwpi_incompatible_with_pic);
1127 if (Triple.isMIPS()) {
1130 mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
1131 // When targeting the N64 ABI, PIC is the default, except in the case
1132 // when the -mno-abicalls option is used. In that case we exit
1133 // at next check regardless of PIC being set below.
1134 if (ABIName == "n64")
1136 // When targettng MIPS with -mno-abicalls, it's always static.
1137 if(Args.hasArg(options::OPT_mno_abicalls))
1138 return std::make_tuple(llvm::Reloc::Static, 0U, false);
1139 // Unlike other architectures, MIPS, even with -fPIC/-mxgot/multigot,
1140 // does not use PIC level 2 for historical reasons.
1141 IsPICLevelTwo = false;
1145 return std::make_tuple(llvm::Reloc::PIC_, IsPICLevelTwo ? 2U : 1U, PIE);
1147 llvm::Reloc::Model RelocM = llvm::Reloc::Static;
1149 RelocM = llvm::Reloc::ROPI_RWPI;
1151 RelocM = llvm::Reloc::ROPI;
1153 RelocM = llvm::Reloc::RWPI;
1155 return std::make_tuple(RelocM, 0U, false);
1158 // `-falign-functions` indicates that the functions should be aligned to a
1159 // 16-byte boundary.
1161 // `-falign-functions=1` is the same as `-fno-align-functions`.
1163 // The scalar `n` in `-falign-functions=n` must be an integral value between
1164 // [0, 65536]. If the value is not a power-of-two, it will be rounded up to
1165 // the nearest power-of-two.
1167 // If we return `0`, the frontend will default to the backend's preferred
1170 // NOTE: icc only allows values between [0, 4096]. icc uses `-falign-functions`
1171 // to mean `-falign-functions=16`. GCC defaults to the backend's preferred
1172 // alignment. For unaligned functions, we default to the backend's preferred
1174 unsigned tools::ParseFunctionAlignment(const ToolChain &TC,
1175 const ArgList &Args) {
1176 const Arg *A = Args.getLastArg(options::OPT_falign_functions,
1177 options::OPT_falign_functions_EQ,
1178 options::OPT_fno_align_functions);
1179 if (!A || A->getOption().matches(options::OPT_fno_align_functions))
1182 if (A->getOption().matches(options::OPT_falign_functions))
1186 if (StringRef(A->getValue()).getAsInteger(10, Value) || Value > 65536)
1187 TC.getDriver().Diag(diag::err_drv_invalid_int_value)
1188 << A->getAsString(Args) << A->getValue();
1189 return Value ? llvm::Log2_32_Ceil(std::min(Value, 65536u)) : Value;
1192 unsigned tools::ParseDebugDefaultVersion(const ToolChain &TC,
1193 const ArgList &Args) {
1194 const Arg *A = Args.getLastArg(options::OPT_fdebug_default_version);
1200 if (StringRef(A->getValue()).getAsInteger(10, Value) || Value > 5 ||
1202 TC.getDriver().Diag(diag::err_drv_invalid_int_value)
1203 << A->getAsString(Args) << A->getValue();
1207 void tools::AddAssemblerKPIC(const ToolChain &ToolChain, const ArgList &Args,
1208 ArgStringList &CmdArgs) {
1209 llvm::Reloc::Model RelocationModel;
1212 std::tie(RelocationModel, PICLevel, IsPIE) = ParsePICArgs(ToolChain, Args);
1214 if (RelocationModel != llvm::Reloc::Static)
1215 CmdArgs.push_back("-KPIC");
1218 /// Determine whether Objective-C automated reference counting is
1220 bool tools::isObjCAutoRefCount(const ArgList &Args) {
1221 return Args.hasFlag(options::OPT_fobjc_arc, options::OPT_fno_objc_arc, false);
1224 enum class LibGccType { UnspecifiedLibGcc, StaticLibGcc, SharedLibGcc };
1226 static LibGccType getLibGccType(const Driver &D, const ArgList &Args) {
1227 if (Args.hasArg(options::OPT_static_libgcc) ||
1228 Args.hasArg(options::OPT_static) || Args.hasArg(options::OPT_static_pie))
1229 return LibGccType::StaticLibGcc;
1230 if (Args.hasArg(options::OPT_shared_libgcc) || D.CCCIsCXX())
1231 return LibGccType::SharedLibGcc;
1232 return LibGccType::UnspecifiedLibGcc;
1235 // Gcc adds libgcc arguments in various ways:
1237 // gcc <none>: -lgcc --as-needed -lgcc_s --no-as-needed
1238 // g++ <none>: -lgcc_s -lgcc
1239 // gcc shared: -lgcc_s -lgcc
1240 // g++ shared: -lgcc_s -lgcc
1241 // gcc static: -lgcc -lgcc_eh
1242 // g++ static: -lgcc -lgcc_eh
1243 // gcc static-pie: -lgcc -lgcc_eh
1244 // g++ static-pie: -lgcc -lgcc_eh
1246 // Also, certain targets need additional adjustments.
1248 static void AddUnwindLibrary(const ToolChain &TC, const Driver &D,
1249 ArgStringList &CmdArgs, const ArgList &Args) {
1250 ToolChain::UnwindLibType UNW = TC.GetUnwindLibType(Args);
1251 // Targets that don't use unwind libraries.
1252 if (TC.getTriple().isAndroid() || TC.getTriple().isOSIAMCU() ||
1253 TC.getTriple().isOSBinFormatWasm() ||
1254 UNW == ToolChain::UNW_None)
1257 LibGccType LGT = getLibGccType(D, Args);
1258 bool AsNeeded = LGT == LibGccType::UnspecifiedLibGcc &&
1259 !TC.getTriple().isAndroid() && !TC.getTriple().isOSCygMing();
1261 CmdArgs.push_back("--as-needed");
1264 case ToolChain::UNW_None:
1266 case ToolChain::UNW_Libgcc: {
1267 if (LGT == LibGccType::StaticLibGcc)
1268 CmdArgs.push_back("-lgcc_eh");
1270 CmdArgs.push_back("-lgcc_s");
1273 case ToolChain::UNW_CompilerRT:
1274 if (LGT == LibGccType::StaticLibGcc)
1275 CmdArgs.push_back("-l:libunwind.a");
1276 else if (TC.getTriple().isOSCygMing()) {
1277 if (LGT == LibGccType::SharedLibGcc)
1278 CmdArgs.push_back("-l:libunwind.dll.a");
1280 // Let the linker choose between libunwind.dll.a and libunwind.a
1281 // depending on what's available, and depending on the -static flag
1282 CmdArgs.push_back("-lunwind");
1284 CmdArgs.push_back("-l:libunwind.so");
1289 CmdArgs.push_back("--no-as-needed");
1292 static void AddLibgcc(const ToolChain &TC, const Driver &D,
1293 ArgStringList &CmdArgs, const ArgList &Args) {
1294 LibGccType LGT = getLibGccType(D, Args);
1295 if (LGT != LibGccType::SharedLibGcc)
1296 CmdArgs.push_back("-lgcc");
1297 AddUnwindLibrary(TC, D, CmdArgs, Args);
1298 if (LGT == LibGccType::SharedLibGcc)
1299 CmdArgs.push_back("-lgcc");
1301 // According to Android ABI, we have to link with libdl if we are
1302 // linking with non-static libgcc.
1304 // NOTE: This fixes a link error on Android MIPS as well. The non-static
1305 // libgcc for MIPS relies on _Unwind_Find_FDE and dl_iterate_phdr from libdl.
1306 if (TC.getTriple().isAndroid() && LGT != LibGccType::StaticLibGcc)
1307 CmdArgs.push_back("-ldl");
1310 void tools::AddRunTimeLibs(const ToolChain &TC, const Driver &D,
1311 ArgStringList &CmdArgs, const ArgList &Args) {
1312 // Make use of compiler-rt if --rtlib option is used
1313 ToolChain::RuntimeLibType RLT = TC.GetRuntimeLibType(Args);
1316 case ToolChain::RLT_CompilerRT:
1317 CmdArgs.push_back(TC.getCompilerRTArgString(Args, "builtins"));
1318 AddUnwindLibrary(TC, D, CmdArgs, Args);
1320 case ToolChain::RLT_Libgcc:
1321 // Make sure libgcc is not used under MSVC environment by default
1322 if (TC.getTriple().isKnownWindowsMSVCEnvironment()) {
1323 // Issue error diagnostic if libgcc is explicitly specified
1324 // through command line as --rtlib option argument.
1325 if (Args.hasArg(options::OPT_rtlib_EQ)) {
1326 TC.getDriver().Diag(diag::err_drv_unsupported_rtlib_for_platform)
1327 << Args.getLastArg(options::OPT_rtlib_EQ)->getValue() << "MSVC";
1330 AddLibgcc(TC, D, CmdArgs, Args);
1335 SmallString<128> tools::getStatsFileName(const llvm::opt::ArgList &Args,
1336 const InputInfo &Output,
1337 const InputInfo &Input,
1339 const Arg *A = Args.getLastArg(options::OPT_save_stats_EQ);
1343 StringRef SaveStats = A->getValue();
1344 SmallString<128> StatsFile;
1345 if (SaveStats == "obj" && Output.isFilename()) {
1346 StatsFile.assign(Output.getFilename());
1347 llvm::sys::path::remove_filename(StatsFile);
1348 } else if (SaveStats != "cwd") {
1349 D.Diag(diag::err_drv_invalid_value) << A->getAsString(Args) << SaveStats;
1353 StringRef BaseName = llvm::sys::path::filename(Input.getBaseInput());
1354 llvm::sys::path::append(StatsFile, BaseName);
1355 llvm::sys::path::replace_extension(StatsFile, "stats");
1359 void tools::addMultilibFlag(bool Enabled, const char *const Flag,
1360 Multilib::flags_list &Flags) {
1361 Flags.push_back(std::string(Enabled ? "+" : "-") + Flag);
1364 void tools::addX86AlignBranchArgs(const Driver &D, const ArgList &Args,
1365 ArgStringList &CmdArgs, bool IsLTO) {
1366 auto addArg = [&, IsLTO](const Twine &Arg) {
1368 CmdArgs.push_back(Args.MakeArgString("-plugin-opt=" + Arg));
1370 CmdArgs.push_back("-mllvm");
1371 CmdArgs.push_back(Args.MakeArgString(Arg));
1375 if (Args.hasArg(options::OPT_mbranches_within_32B_boundaries)) {
1376 addArg(Twine("-x86-branches-within-32B-boundaries"));
1378 if (const Arg *A = Args.getLastArg(options::OPT_malign_branch_boundary_EQ)) {
1379 StringRef Value = A->getValue();
1381 if (Value.getAsInteger(10, Boundary) || Boundary < 16 ||
1382 !llvm::isPowerOf2_64(Boundary)) {
1383 D.Diag(diag::err_drv_invalid_argument_to_option)
1384 << Value << A->getOption().getName();
1386 addArg("-x86-align-branch-boundary=" + Twine(Boundary));
1389 if (const Arg *A = Args.getLastArg(options::OPT_malign_branch_EQ)) {
1390 std::string AlignBranch;
1391 for (StringRef T : A->getValues()) {
1392 if (T != "fused" && T != "jcc" && T != "jmp" && T != "call" &&
1393 T != "ret" && T != "indirect")
1394 D.Diag(diag::err_drv_invalid_malign_branch_EQ)
1395 << T << "fused, jcc, jmp, call, ret, indirect";
1396 if (!AlignBranch.empty())
1400 addArg("-x86-align-branch=" + Twine(AlignBranch));
1402 if (const Arg *A = Args.getLastArg(options::OPT_mpad_max_prefix_size_EQ)) {
1403 StringRef Value = A->getValue();
1404 unsigned PrefixSize;
1405 if (Value.getAsInteger(10, PrefixSize)) {
1406 D.Diag(diag::err_drv_invalid_argument_to_option)
1407 << Value << A->getOption().getName();
1409 addArg("-x86-pad-max-prefix-size=" + Twine(PrefixSize));