31#include "clang/Config/config.h"
43#include "llvm/ADT/STLExtras.h"
44#include "llvm/ADT/SmallSet.h"
45#include "llvm/ADT/SmallString.h"
46#include "llvm/ADT/StringExtras.h"
47#include "llvm/ADT/StringSwitch.h"
48#include "llvm/ADT/Twine.h"
49#include "llvm/BinaryFormat/Magic.h"
50#include "llvm/Config/llvm-config.h"
51#include "llvm/Option/Arg.h"
52#include "llvm/Option/ArgList.h"
53#include "llvm/Option/Option.h"
54#include "llvm/Support/CodeGen.h"
55#include "llvm/Support/Compression.h"
56#include "llvm/Support/Debug.h"
57#include "llvm/Support/ErrorHandling.h"
58#include "llvm/Support/FileSystem.h"
59#include "llvm/Support/Path.h"
60#include "llvm/Support/Process.h"
61#include "llvm/Support/Program.h"
62#include "llvm/Support/ScopedPrinter.h"
63#include "llvm/Support/Threading.h"
64#include "llvm/Support/VirtualFileSystem.h"
65#include "llvm/Support/YAMLParser.h"
66#include "llvm/TargetParser/Host.h"
67#include "llvm/TargetParser/PPCTargetParser.h"
68#include "llvm/TargetParser/TargetParser.h"
77 const llvm::Triple &Triple) {
78 if (Args.hasArg(clang::driver::options::OPT_pg) &&
79 !Args.hasArg(clang::driver::options::OPT_mfentry))
82 if (Triple.isAndroid())
85 switch (Triple.getArch()) {
86 case llvm::Triple::xcore:
87 case llvm::Triple::wasm32:
88 case llvm::Triple::wasm64:
89 case llvm::Triple::msp430:
93 case llvm::Triple::ppc:
94 case llvm::Triple::ppcle:
95 case llvm::Triple::ppc64:
96 case llvm::Triple::ppc64le:
97 case llvm::Triple::riscv32:
98 case llvm::Triple::riscv64:
99 case llvm::Triple::sparc:
100 case llvm::Triple::sparcel:
101 case llvm::Triple::sparcv9:
102 case llvm::Triple::amdgcn:
103 case llvm::Triple::r600:
104 case llvm::Triple::csky:
105 case llvm::Triple::loongarch32:
106 case llvm::Triple::loongarch64:
107 case llvm::Triple::m68k:
113 if (Triple.isOSFuchsia() || Triple.isOSNetBSD()) {
117 if (Triple.isOSLinux() || Triple.isOSHurd()) {
118 switch (Triple.getArch()) {
120 case llvm::Triple::arm:
121 case llvm::Triple::armeb:
122 case llvm::Triple::thumb:
123 case llvm::Triple::thumbeb:
124 case llvm::Triple::mips64:
125 case llvm::Triple::mips64el:
126 case llvm::Triple::mips:
127 case llvm::Triple::mipsel:
128 case llvm::Triple::systemz:
129 case llvm::Triple::x86:
130 case llvm::Triple::x86_64:
137 if (Triple.isOSWindows()) {
138 switch (Triple.getArch()) {
139 case llvm::Triple::x86:
141 case llvm::Triple::x86_64:
142 return Triple.isOSBinFormatMachO();
143 case llvm::Triple::arm:
144 case llvm::Triple::thumb:
158 if (Triple.isAArch64() || Triple.isPS() || Triple.isVE() ||
159 (Triple.isAndroid() && !Triple.isARM()))
166 switch (Triple.getArch()) {
169 case llvm::Triple::arm:
170 case llvm::Triple::thumb:
173 return Triple.isOSDarwin();
180 const llvm::Triple &Triple) {
181 if (Triple.isARM() || Triple.isThumb()) {
185 if (Arg *A = Args.getLastArg(options::OPT_mframe_chain)) {
186 StringRef
V = A->getValue();
197 const llvm::Triple &Triple) {
198 if (Triple.isARM() || Triple.isThumb()) {
202 if (Arg *A = Args.getLastArg(options::OPT_mframe_chain)) {
203 StringRef
V = A->getValue();
204 return V ==
"aapcs+leaf";
213 const llvm::Triple &Triple) {
243 Args.hasFlag(clang::driver::options::OPT_fno_omit_frame_pointer,
244 clang::driver::options::OPT_fomit_frame_pointer, DefaultFP);
249 bool EnableLeafFP = Args.hasFlag(
250 clang::driver::options::OPT_mno_omit_leaf_frame_pointer,
251 clang::driver::options::OPT_momit_leaf_frame_pointer, DefaultLeafFP);
266 const StringRef PluginOptPrefix) {
267 if (
const Arg *A = Args.getLastArg(options::OPT_Rpass_EQ))
268 CmdArgs.push_back(Args.MakeArgString(Twine(PluginOptPrefix) +
269 "-pass-remarks=" + A->getValue()));
271 if (
const Arg *A = Args.getLastArg(options::OPT_Rpass_missed_EQ))
272 CmdArgs.push_back(Args.MakeArgString(
273 Twine(PluginOptPrefix) +
"-pass-remarks-missed=" + A->getValue()));
275 if (
const Arg *A = Args.getLastArg(options::OPT_Rpass_analysis_EQ))
276 CmdArgs.push_back(Args.MakeArgString(
277 Twine(PluginOptPrefix) +
"-pass-remarks-analysis=" + A->getValue()));
281 const llvm::Triple &Triple,
284 const StringRef PluginOptPrefix) {
285 StringRef Format =
"yaml";
286 if (
const Arg *A = Args.getLastArg(options::OPT_fsave_optimization_record_EQ))
287 Format = A->getValue();
290 const Arg *A = Args.getLastArg(options::OPT_foptimization_record_file_EQ);
296 assert(!F.empty() &&
"Cannot determine remarks output name.");
298 CmdArgs.push_back(Args.MakeArgString(Twine(PluginOptPrefix) +
299 "opt-remarks-filename=" + F +
300 ".opt.ld." + Format));
303 Args.getLastArg(options::OPT_foptimization_record_passes_EQ))
304 CmdArgs.push_back(Args.MakeArgString(
305 Twine(PluginOptPrefix) +
"opt-remarks-passes=" + A->getValue()));
307 CmdArgs.push_back(Args.MakeArgString(Twine(PluginOptPrefix) +
308 "opt-remarks-format=" + Format.data()));
312 ArgStringList &CmdArgs,
313 const StringRef PluginOptPrefix) {
314 if (Args.hasFlag(options::OPT_fdiagnostics_show_hotness,
315 options::OPT_fno_diagnostics_show_hotness,
false))
316 CmdArgs.push_back(Args.MakeArgString(Twine(PluginOptPrefix) +
317 "opt-remarks-with-hotness"));
320 Args.getLastArg(options::OPT_fdiagnostics_hotness_threshold_EQ))
322 Args.MakeArgString(Twine(PluginOptPrefix) +
323 "opt-remarks-hotness-threshold=" + A->getValue()));
328 StringRef Processor) {
332 auto GPUKind =
T.isAMDGCN() ? llvm::AMDGPU::parseArchAMDGCN(Processor)
333 : llvm::AMDGPU::parseArchR600(Processor);
334 auto GPUFeatures =
T.isAMDGCN() ? llvm::AMDGPU::getArchAttrAMDGCN(GPUKind)
335 : llvm::AMDGPU::getArchAttrR600(GPUKind);
336 if (GPUFeatures & llvm::AMDGPU::FEATURE_WGP)
338 return TargetFeatureArg.getOption().matches(options::OPT_mno_cumode);
343 if (
D.getVFS().exists(
Path))
344 Paths.push_back(
Path.str());
348 const llvm::Triple &Triple,
350 std::vector<StringRef> &Features,
351 OptSpecifier Group) {
352 std::set<StringRef> Warned;
353 for (
const Arg *A : Args.filtered(Group)) {
354 StringRef Name = A->getOption().getName();
358 assert(Name.starts_with(
"m") &&
"Invalid feature name.");
359 Name = Name.substr(1);
363 if (Warned.count(Name) == 0) {
365 clang::diag::warn_drv_unsupported_option_for_processor)
366 << A->getAsString(Args) << Proc;
372 bool IsNegative = Name.consume_front(
"no-");
374 Features.push_back(Args.MakeArgString((IsNegative ?
"-" :
"+") + Name));
383 for (StringRef Feature : llvm::reverse(Features)) {
384 if (UsedFeatures.insert(Feature.drop_front()).second)
385 UnifiedFeatures.insert(UnifiedFeatures.begin(), Feature);
388 return UnifiedFeatures;
392 const char *ArgName,
const char *EnvVar) {
393 const char *DirList = ::getenv(EnvVar);
394 bool CombinedArg =
false;
399 StringRef Name(ArgName);
400 if (Name ==
"-I" || Name ==
"-L" || Name.empty())
403 StringRef Dirs(DirList);
407 StringRef::size_type Delim;
408 while ((Delim = Dirs.find(llvm::sys::EnvPathSeparator)) != StringRef::npos) {
411 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) +
"."));
413 CmdArgs.push_back(ArgName);
414 CmdArgs.push_back(
".");
419 Args.MakeArgString(std::string(ArgName) + Dirs.substr(0, Delim)));
421 CmdArgs.push_back(ArgName);
422 CmdArgs.push_back(Args.MakeArgString(Dirs.substr(0, Delim)));
425 Dirs = Dirs.substr(Delim + 1);
430 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) +
"."));
432 CmdArgs.push_back(ArgName);
433 CmdArgs.push_back(
".");
437 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + Dirs));
439 CmdArgs.push_back(ArgName);
440 CmdArgs.push_back(Args.MakeArgString(Dirs));
446 const ArgList &Args, ArgStringList &CmdArgs,
452 Args.AddAllArgValues(CmdArgs, options::OPT_Zlinker_input);
459 for (
const auto &II : Inputs) {
463 if (
auto *IA = II.getAction())
473 if (II.isFilename()) {
474 CmdArgs.push_back(II.getFilename());
483 const Arg &A = II.getInputArg();
486 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx))
488 else if (A.getOption().matches(options::OPT_Z_reserved_lib_cckext))
491 A.renderAsInput(Args, CmdArgs);
496 const ToolChain &TC,
const llvm::opt::ArgList &Args,
497 llvm::opt::ArgStringList &CmdArgs) {
503 if (
const Arg *A = Args.getLastArg(options::OPT_gz_EQ)) {
504 StringRef
V = A->getValue();
505 if (
V ==
"none" ||
V ==
"zlib" ||
V ==
"zstd")
506 CmdArgs.push_back(Args.MakeArgString(
"--compress-debug-sections=" +
V));
508 TC.
getDriver().
Diag(diag::err_drv_unsupported_option_argument)
509 << A->getSpelling() <<
V;
514 llvm::opt::ArgStringList &CmdArgs) {
515 if (Args.hasArg(options::OPT_nostdlib, options::OPT_r,
516 options::OPT_nodefaultlibs, options::OPT_nolibc,
517 options::OPT_nogpulibc))
524 CmdArgs.push_back(
"-lc");
525 CmdArgs.push_back(
"-lm");
530 std::vector<StringRef> &Features,
531 OptSpecifier OnOpt, OptSpecifier OffOpt,
532 StringRef FeatureName) {
533 if (Arg *A = Args.getLastArg(OnOpt, OffOpt)) {
534 if (A->getOption().matches(OnOpt))
535 Features.push_back(Args.MakeArgString(
"+" + FeatureName));
537 Features.push_back(Args.MakeArgString(
"-" + FeatureName));
543 const ArgList &Args) {
544 Arg *MArch = Args.getLastArg(options::OPT_march_EQ);
545 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
547 return llvm::StringSwitch<std::string>(GPUName)
548 .Cases(
"rv630",
"rv635",
"r600")
549 .Cases(
"rv610",
"rv620",
"rs780",
"rs880")
550 .Case(
"rv740",
"rv770")
551 .Case(
"palm",
"cedar")
552 .Cases(
"sumo",
"sumo2",
"sumo")
553 .Case(
"hemlock",
"cypress")
554 .Case(
"aruba",
"cayman")
555 .Default(GPUName.str());
563 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
564 return A->getValue();
572 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
573 StringRef CPU = A->getValue();
579 return llvm::sys::getHostCPUName();
589 const llvm::Triple &
T,
bool FromAs) {
592 switch (
T.getArch()) {
596 case llvm::Triple::aarch64:
597 case llvm::Triple::aarch64_32:
598 case llvm::Triple::aarch64_be:
601 case llvm::Triple::arm:
602 case llvm::Triple::armeb:
603 case llvm::Triple::thumb:
604 case llvm::Triple::thumbeb: {
605 StringRef MArch, MCPU;
610 case llvm::Triple::avr:
611 if (
const Arg *A = Args.getLastArg(options::OPT_mmcu_EQ))
612 return A->getValue();
615 case llvm::Triple::m68k:
618 case llvm::Triple::mips:
619 case llvm::Triple::mipsel:
620 case llvm::Triple::mips64:
621 case llvm::Triple::mips64el: {
625 return std::string(CPUName);
628 case llvm::Triple::nvptx:
629 case llvm::Triple::nvptx64:
630 if (
const Arg *A = Args.getLastArg(options::OPT_march_EQ))
631 return A->getValue();
634 case llvm::Triple::ppc:
635 case llvm::Triple::ppcle:
636 case llvm::Triple::ppc64:
637 case llvm::Triple::ppc64le:
638 if (Arg *A = Args.getLastArg(clang::driver::options::OPT_mcpu_EQ))
640 llvm::PPC::getNormalizedPPCTargetCPU(
T, A->getValue()));
641 return std::string(llvm::PPC::getNormalizedPPCTargetCPU(
T));
643 case llvm::Triple::csky:
644 if (
const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
645 return A->getValue();
646 else if (
const Arg *A = Args.getLastArg(options::OPT_march_EQ))
647 return A->getValue();
650 case llvm::Triple::riscv32:
651 case llvm::Triple::riscv64:
654 case llvm::Triple::bpfel:
655 case llvm::Triple::bpfeb:
656 if (
const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
657 return A->getValue();
660 case llvm::Triple::sparc:
661 case llvm::Triple::sparcel:
662 case llvm::Triple::sparcv9:
665 case llvm::Triple::x86:
666 case llvm::Triple::x86_64:
669 case llvm::Triple::hexagon:
673 case llvm::Triple::lanai:
676 case llvm::Triple::systemz:
679 case llvm::Triple::r600:
680 case llvm::Triple::amdgcn:
683 case llvm::Triple::wasm32:
684 case llvm::Triple::wasm64:
687 case llvm::Triple::loongarch32:
688 case llvm::Triple::loongarch64:
694 const llvm::Triple &Triple,
696 std::vector<StringRef> &Features) {
698 options::OPT_m_wasm_Features_Group);
702 const ArgList &Args, ArgStringList &CmdArgs,
703 bool ForAS,
bool IsAux) {
704 std::vector<StringRef> Features;
705 switch (Triple.getArch()) {
708 case llvm::Triple::mips:
709 case llvm::Triple::mipsel:
710 case llvm::Triple::mips64:
711 case llvm::Triple::mips64el:
714 case llvm::Triple::arm:
715 case llvm::Triple::armeb:
716 case llvm::Triple::thumb:
717 case llvm::Triple::thumbeb:
720 case llvm::Triple::ppc:
721 case llvm::Triple::ppcle:
722 case llvm::Triple::ppc64:
723 case llvm::Triple::ppc64le:
726 case llvm::Triple::riscv32:
727 case llvm::Triple::riscv64:
730 case llvm::Triple::systemz:
733 case llvm::Triple::aarch64:
734 case llvm::Triple::aarch64_32:
735 case llvm::Triple::aarch64_be:
738 case llvm::Triple::x86:
739 case llvm::Triple::x86_64:
742 case llvm::Triple::hexagon:
745 case llvm::Triple::wasm32:
746 case llvm::Triple::wasm64:
749 case llvm::Triple::sparc:
750 case llvm::Triple::sparcel:
751 case llvm::Triple::sparcv9:
754 case llvm::Triple::r600:
755 case llvm::Triple::amdgcn:
758 case llvm::Triple::nvptx:
759 case llvm::Triple::nvptx64:
762 case llvm::Triple::m68k:
765 case llvm::Triple::msp430:
768 case llvm::Triple::ve:
771 case llvm::Triple::csky:
774 case llvm::Triple::loongarch32:
775 case llvm::Triple::loongarch64:
781 CmdArgs.push_back(IsAux ?
"-aux-target-feature" :
"-target-feature");
782 CmdArgs.push_back(Feature.data());
787 Arg *LtoJobsArg = Args.getLastArg(options::OPT_flto_jobs_EQ);
790 if (!llvm::get_threadpool_strategy(LtoJobsArg->getValue()))
791 D.Diag(diag::err_drv_invalid_int_value)
792 << LtoJobsArg->getAsString(Args) << LtoJobsArg->getValue();
793 return LtoJobsArg->getValue();
798 return Triple.isPS();
802 const llvm::opt::ArgList &Args) {
804 Arg *A = Args.getLastArg(options::OPT_mtls_dialect_EQ);
806 return Triple.hasDefaultTLSDESC();
807 StringRef
V = A->getValue();
808 bool SupportedArgument =
false, EnableTLSDESC =
false;
809 bool Unsupported = !Triple.isOSBinFormatELF();
810 if (Triple.isLoongArch() || Triple.isRISCV()) {
811 SupportedArgument =
V ==
"desc" ||
V ==
"trad";
812 EnableTLSDESC =
V ==
"desc";
813 }
else if (Triple.isX86()) {
814 SupportedArgument =
V ==
"gnu" ||
V ==
"gnu2";
815 EnableTLSDESC =
V ==
"gnu2";
820 TC.
getDriver().
Diag(diag::err_drv_unsupported_opt_for_target)
821 << A->getSpelling() << Triple.getTriple();
822 }
else if (!SupportedArgument) {
823 TC.
getDriver().
Diag(diag::err_drv_unsupported_option_argument_for_target)
824 << A->getSpelling() <<
V << Triple.getTriple();
826 return EnableTLSDESC;
830 ArgStringList &CmdArgs,
const InputInfo &Output,
831 const InputInfo &Input,
bool IsThinLTO) {
833 const bool IsOSAIX = Triple.isOSAIX();
834 const bool IsAMDGCN = Triple.isAMDGCN();
837 const bool IsFatLTO = Args.hasArg(options::OPT_ffat_lto_objects);
838 const bool IsUnifiedLTO = Args.hasArg(options::OPT_funified_lto);
839 if (llvm::sys::path::filename(Linker) !=
"ld.lld" &&
840 llvm::sys::path::stem(Linker) !=
"ld.lld" && !Triple.isOSOpenBSD()) {
844 const char *PluginPrefix = IsOSAIX ?
"-bplugin:" :
"";
845 const char *PluginName = IsOSAIX ?
"/libLTO" :
"/LLVMgold";
848 CmdArgs.push_back(
"-plugin");
851 const char *Suffix =
".dll";
852#elif defined(__APPLE__)
853 const char *Suffix =
".dylib";
855 const char *Suffix =
".so";
859 llvm::sys::path::native(Twine(
D.Dir) +
860 "/../" CLANG_INSTALL_LIBDIR_BASENAME +
863 CmdArgs.push_back(Args.MakeArgString(Twine(PluginPrefix) + Plugin));
868 CmdArgs.push_back(
"--fat-lto-objects");
871 const char *PluginOptPrefix = IsOSAIX ?
"-bplugin_opt:" :
"-plugin-opt=";
872 const char *ExtraDash = IsOSAIX ?
"-" :
"";
873 const char *ParallelismOpt = IsOSAIX ?
"-threads=" :
"jobs=";
878 if (Args.hasArg(options::OPT_gdwarf_aranges)) {
879 CmdArgs.push_back(Args.MakeArgString(Twine(PluginOptPrefix) +
880 "-generate-arange-section"));
884 Arg *ArgVecLib = Args.getLastArg(options::OPT_fveclib);
885 if (ArgVecLib && ArgVecLib->getNumValues() == 1) {
888 std::optional<StringRef> OptVal =
889 llvm::StringSwitch<std::optional<StringRef>>(ArgVecLib->getValue())
890 .Case(
"Accelerate",
"Accelerate")
891 .Case(
"LIBMVEC",
"LIBMVEC-X86")
892 .Case(
"MASSV",
"MASSV")
893 .Case(
"SVML",
"SVML")
894 .Case(
"SLEEF",
"sleefgnuabi")
895 .Case(
"Darwin_libsystem_m",
"Darwin_libsystem_m")
896 .Case(
"ArmPL",
"ArmPL")
897 .Case(
"none",
"none")
898 .Default(std::nullopt);
901 CmdArgs.push_back(Args.MakeArgString(
902 Twine(PluginOptPrefix) +
"-vector-library=" + OptVal.value()));
912 Args.MakeArgString(Twine(PluginOptPrefix) + ExtraDash +
"mcpu=" + CPU));
914 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
918 if (A->getOption().matches(options::OPT_O4) ||
919 A->getOption().matches(options::OPT_Ofast))
921 else if (A->getOption().matches(options::OPT_O)) {
922 OOpt = A->getValue();
925 else if (OOpt ==
"s" || OOpt ==
"z")
927 }
else if (A->getOption().matches(options::OPT_O0))
931 Args.MakeArgString(Twine(PluginOptPrefix) + ExtraDash +
"O" + OOpt));
933 CmdArgs.push_back(Args.MakeArgString(Twine(
"--lto-CGO") + OOpt));
937 if (Args.hasArg(options::OPT_gsplit_dwarf))
938 CmdArgs.push_back(Args.MakeArgString(
939 Twine(PluginOptPrefix) +
"dwo_dir=" + Output.
getFilename() +
"_dwo"));
941 if (IsThinLTO && !IsOSAIX)
942 CmdArgs.push_back(Args.MakeArgString(Twine(PluginOptPrefix) +
"thinlto"));
943 else if (IsThinLTO && IsOSAIX)
944 CmdArgs.push_back(Args.MakeArgString(Twine(
"-bdbg:thinlto")));
949 if ((IsThinLTO || IsFatLTO || IsUnifiedLTO) &&
950 Args.hasArg(options::OPT_fenable_matrix))
952 Args.MakeArgString(Twine(PluginOptPrefix) +
"-enable-matrix"));
955 if (!Parallelism.empty())
956 CmdArgs.push_back(Args.MakeArgString(Twine(PluginOptPrefix) +
957 ParallelismOpt + Parallelism));
960 if (Arg *A = Args.getLastArg(options::OPT_fglobal_isel,
961 options::OPT_fno_global_isel)) {
964 CmdArgs.push_back(Args.MakeArgString(
965 Twine(PluginOptPrefix) +
"-global-isel=" +
966 (A->getOption().matches(options::OPT_fglobal_isel) ?
"1" :
"0")));
971 Args.getLastArg(options::OPT_gTune_Group, options::OPT_ggdbN_Group)) {
972 if (A->getOption().matches(options::OPT_glldb))
974 Args.MakeArgString(Twine(PluginOptPrefix) +
"-debugger-tune=lldb"));
975 else if (A->getOption().matches(options::OPT_gsce))
977 Args.MakeArgString(Twine(PluginOptPrefix) +
"-debugger-tune=sce"));
978 else if (A->getOption().matches(options::OPT_gdbx))
980 Args.MakeArgString(Twine(PluginOptPrefix) +
"-debugger-tune=dbx"));
983 Args.MakeArgString(Twine(PluginOptPrefix) +
"-debugger-tune=gdb"));
989 Args.MakeArgString(Twine(PluginOptPrefix) +
"-no-integrated-as=1"));
993 Arg *A = Args.getLastArg(options::OPT_g_Group);
994 bool EnableDebugInfo = A && !A->getOption().matches(options::OPT_g0) &&
995 !A->getOption().matches(options::OPT_ggdb0);
996 if (EnableDebugInfo && Args.hasFlag(options::OPT_gstrict_dwarf,
997 options::OPT_gno_strict_dwarf,
true))
999 Args.MakeArgString(Twine(PluginOptPrefix) +
"-strict-dwarf=true"));
1001 for (
const Arg *A : Args.filtered_reverse(options::OPT_mabi_EQ)) {
1002 StringRef
V = A->getValue();
1003 if (
V ==
"vec-default")
1005 if (
V ==
"vec-extabi") {
1007 Args.MakeArgString(Twine(PluginOptPrefix) +
"-vec-extabi"));
1013 bool UseSeparateSections =
1016 if (Args.hasFlag(options::OPT_ffunction_sections,
1017 options::OPT_fno_function_sections, UseSeparateSections))
1019 Args.MakeArgString(Twine(PluginOptPrefix) +
"-function-sections=1"));
1020 else if (Args.hasArg(options::OPT_fno_function_sections))
1022 Args.MakeArgString(Twine(PluginOptPrefix) +
"-function-sections=0"));
1024 bool DataSectionsTurnedOff =
false;
1025 if (Args.hasFlag(options::OPT_fdata_sections, options::OPT_fno_data_sections,
1026 UseSeparateSections)) {
1028 Args.MakeArgString(Twine(PluginOptPrefix) +
"-data-sections=1"));
1029 }
else if (Args.hasArg(options::OPT_fno_data_sections)) {
1030 DataSectionsTurnedOff =
true;
1032 Args.MakeArgString(Twine(PluginOptPrefix) +
"-data-sections=0"));
1035 if (Args.hasArg(options::OPT_mxcoff_roptr) ||
1036 Args.hasArg(options::OPT_mno_xcoff_roptr)) {
1037 bool HasRoptr = Args.hasFlag(options::OPT_mxcoff_roptr,
1038 options::OPT_mno_xcoff_roptr,
false);
1039 StringRef OptStr = HasRoptr ?
"-mxcoff-roptr" :
"-mno-xcoff-roptr";
1041 D.Diag(diag::err_drv_unsupported_opt_for_target)
1042 << OptStr << Triple.str();
1048 if (DataSectionsTurnedOff)
1049 D.Diag(diag::err_roptr_requires_data_sections);
1052 Args.MakeArgString(Twine(PluginOptPrefix) +
"-mxcoff-roptr"));
1057 if (
auto *A = Args.getLastArg(options::OPT_fsplit_machine_functions,
1058 options::OPT_fno_split_machine_functions)) {
1059 if (A->getOption().matches(options::OPT_fsplit_machine_functions))
1060 CmdArgs.push_back(Args.MakeArgString(Twine(PluginOptPrefix) +
1061 "-split-machine-functions"));
1065 StringRef FName = A->getValue();
1066 if (!llvm::sys::fs::exists(FName))
1067 D.Diag(diag::err_drv_no_such_file) << FName;
1069 CmdArgs.push_back(Args.MakeArgString(Twine(PluginOptPrefix) +
1070 "sample-profile=" + FName));
1074 CmdArgs.push_back(Args.MakeArgString(Twine(PluginOptPrefix) + ExtraDash +
1075 "cs-profile-generate"));
1076 if (CSPGOGenerateArg->getOption().matches(
1077 options::OPT_fcs_profile_generate_EQ)) {
1079 llvm::sys::path::append(
Path,
"default_%m.profraw");
1080 CmdArgs.push_back(Args.MakeArgString(Twine(PluginOptPrefix) + ExtraDash +
1081 "cs-profile-path=" +
Path));
1084 Args.MakeArgString(Twine(PluginOptPrefix) + ExtraDash +
1085 "cs-profile-path=default_%m.profraw"));
1088 ProfileUseArg->getNumValues() == 0 ?
"" : ProfileUseArg->getValue());
1089 if (
Path.empty() || llvm::sys::fs::is_directory(
Path))
1090 llvm::sys::path::append(
Path,
"default.profdata");
1091 CmdArgs.push_back(Args.MakeArgString(Twine(PluginOptPrefix) + ExtraDash +
1092 "cs-profile-path=" +
Path));
1096 if (Args.hasFlag(options::OPT_fjmc, options::OPT_fno_jmc,
false)) {
1098 CmdArgs.push_back(Args.MakeArgString(Twine(PluginOptPrefix) +
1099 "-enable-jmc-instrument"));
1101 D.Diag(clang::diag::warn_drv_fjmc_for_elf_only);
1104 if (Args.hasFlag(options::OPT_femulated_tls, options::OPT_fno_emulated_tls,
1105 Triple.hasDefaultEmulatedTLS())) {
1107 Args.MakeArgString(Twine(PluginOptPrefix) +
"-emulated-tls"));
1111 Args.MakeArgString(Twine(PluginOptPrefix) +
"-enable-tlsdesc"));
1113 if (Args.hasFlag(options::OPT_fstack_size_section,
1114 options::OPT_fno_stack_size_section,
false))
1116 Args.MakeArgString(Twine(PluginOptPrefix) +
"-stack-size-section"));
1120 if (!StatsFile.empty())
1122 Args.MakeArgString(Twine(PluginOptPrefix) +
"stats-file=" + StatsFile));
1125 if (Arg *A = Args.getLastArg(options::OPT_fcrash_diagnostics_dir))
1126 CmdArgs.push_back(Args.MakeArgString(
1127 Twine(PluginOptPrefix) +
"-crash-diagnostics-dir=" + A->getValue()));
1138 Output, PluginOptPrefix);
1144 true, PluginOptPrefix);
1146 for (
const Arg *A : Args.filtered(options::OPT_Wa_COMMA)) {
1148 for (StringRef
V : A->getValues()) {
1151 else if (
V ==
"--no-crel")
1158 if (Triple.isOSBinFormatELF() && !Triple.isMIPS()) {
1159 CmdArgs.push_back(Args.MakeArgString(Twine(PluginOptPrefix) +
"-crel"));
1161 D.Diag(diag::err_drv_unsupported_opt_for_target)
1162 <<
"-Wa,--crel" <<
D.getTargetTriple();
1169 const ArgList &Args,
1170 ArgStringList &CmdArgs) {
1175 llvm::sys::path::append(DefaultLibPath, CLANG_INSTALL_LIBDIR_BASENAME);
1176 CmdArgs.push_back(Args.MakeArgString(
"-L" + DefaultLibPath));
1180 ArgStringList &CmdArgs) {
1181 if (!Args.hasFlag(options::OPT_frtlib_add_rpath,
1182 options::OPT_fno_rtlib_add_rpath,
false))
1187 CandidateRPaths.emplace_back(*CandidateRPath);
1189 for (
const auto &CandidateRPath : CandidateRPaths) {
1190 if (TC.
getVFS().exists(CandidateRPath)) {
1191 CmdArgs.push_back(
"-rpath");
1192 CmdArgs.push_back(Args.MakeArgString(CandidateRPath));
1198 const ToolChain &TC,
const ArgList &Args,
1199 bool ForceStaticHostRuntime,
bool IsOffloadingHost,
1201 if (!Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
1202 options::OPT_fno_openmp,
false))
1211 if (ForceStaticHostRuntime)
1212 CmdArgs.push_back(
"-Bstatic");
1216 CmdArgs.push_back(
"-lomp");
1219 CmdArgs.push_back(
"-lgomp");
1222 CmdArgs.push_back(
"-liomp5");
1228 if (ForceStaticHostRuntime)
1229 CmdArgs.push_back(
"-Bdynamic");
1232 CmdArgs.push_back(
"-lrt");
1234 if (IsOffloadingHost)
1235 CmdArgs.push_back(
"-lomptarget");
1237 if (IsOffloadingHost && !Args.hasArg(options::OPT_nogpulib))
1238 CmdArgs.push_back(
"-lomptarget.devicertl");
1249 llvm::opt::ArgStringList &CmdArgs) {
1254 if (!TC.
getTriple().isKnownWindowsMSVCEnvironment()) {
1256 F128LibName.consume_front_insensitive(
"lib");
1257 if (!F128LibName.empty()) {
1258 bool AsNeeded = !TC.
getTriple().isOSAIX();
1259 CmdArgs.push_back(
"-lFortranFloat128Math");
1262 CmdArgs.push_back(Args.MakeArgString(
"-l" + F128LibName));
1266 CmdArgs.push_back(
"-lFortranRuntime");
1267 CmdArgs.push_back(
"-lFortranDecimal");
1272 const llvm::opt::ArgList &Args,
1273 ArgStringList &CmdArgs) {
1280 llvm::sys::path::append(DefaultLibPath,
"lib");
1281 if (TC.
getTriple().isKnownWindowsMSVCEnvironment())
1282 CmdArgs.push_back(Args.MakeArgString(
"-libpath:" + DefaultLibPath));
1284 CmdArgs.push_back(Args.MakeArgString(
"-L" + DefaultLibPath));
1288 ArgStringList &CmdArgs, StringRef Sanitizer,
1289 bool IsShared,
bool IsWhole) {
1292 if (IsWhole) CmdArgs.push_back(
"--whole-archive");
1295 if (IsWhole) CmdArgs.push_back(
"--no-whole-archive");
1305 ArgStringList &CmdArgs,
1306 StringRef Sanitizer) {
1311 if (TC.
getTriple().isOSSolaris() && !LinkerIsGnuLd)
1314 if (llvm::sys::fs::exists(SanRT +
".syms")) {
1315 CmdArgs.push_back(Args.MakeArgString(
"--dynamic-list=" + SanRT +
".syms"));
1322 const llvm::opt::ArgList &Args,
1323 llvm::opt::ArgStringList &CmdArgs,
1326 "AIX linker does not support any form of --as-needed option yet.");
1334 if (TC.
getTriple().isOSSolaris() && !LinkerIsGnuLd) {
1335 CmdArgs.push_back(
"-z");
1336 CmdArgs.push_back(as_needed ?
"ignore" :
"record");
1338 CmdArgs.push_back(as_needed ?
"--as-needed" :
"--no-as-needed");
1343 const llvm::opt::ArgList &Args,
1344 ArgStringList &CmdArgs) {
1349 if (TC.
getTriple().getOS() != llvm::Triple::RTEMS &&
1351 CmdArgs.push_back(
"-lpthread");
1353 CmdArgs.push_back(
"-lrt");
1355 CmdArgs.push_back(
"-lm");
1359 TC.
getTriple().getOS() != llvm::Triple::RTEMS)
1360 CmdArgs.push_back(
"-ldl");
1365 CmdArgs.push_back(
"-lexecinfo");
1371 CmdArgs.push_back(
"-lresolv");
1385 SharedRuntimes.push_back(
"asan");
1386 if (!Args.hasArg(options::OPT_shared) && !TC.
getTriple().isAndroid())
1387 HelperStaticRuntimes.push_back(
"asan-preinit");
1390 SharedRuntimes.push_back(
"memprof");
1391 if (!Args.hasArg(options::OPT_shared) && !TC.
getTriple().isAndroid())
1392 HelperStaticRuntimes.push_back(
"memprof-preinit");
1395 SharedRuntimes.push_back(
"nsan");
1398 SharedRuntimes.push_back(
"ubsan_minimal");
1400 SharedRuntimes.push_back(
"ubsan_standalone");
1403 SharedRuntimes.push_back(
"scudo_standalone");
1406 SharedRuntimes.push_back(
"tsan");
1409 SharedRuntimes.push_back(
"hwasan_aliases");
1411 SharedRuntimes.push_back(
"hwasan");
1412 if (!Args.hasArg(options::OPT_shared))
1413 HelperStaticRuntimes.push_back(
"hwasan-preinit");
1419 StaticRuntimes.push_back(
"stats_client");
1423 HelperStaticRuntimes.push_back(
"asan_static");
1426 if (Args.hasArg(options::OPT_shared)) {
1435 StaticRuntimes.push_back(
"asan");
1437 StaticRuntimes.push_back(
"asan_cxx");
1441 StaticRuntimes.push_back(
"memprof");
1443 StaticRuntimes.push_back(
"memprof_cxx");
1448 StaticRuntimes.push_back(
"hwasan_aliases");
1450 StaticRuntimes.push_back(
"hwasan_aliases_cxx");
1452 StaticRuntimes.push_back(
"hwasan");
1454 StaticRuntimes.push_back(
"hwasan_cxx");
1458 StaticRuntimes.push_back(
"dfsan");
1460 StaticRuntimes.push_back(
"lsan");
1462 StaticRuntimes.push_back(
"msan");
1464 StaticRuntimes.push_back(
"msan_cxx");
1467 StaticRuntimes.push_back(
"nsan");
1469 StaticRuntimes.push_back(
"tsan");
1471 StaticRuntimes.push_back(
"tsan_cxx");
1475 StaticRuntimes.push_back(
"ubsan_minimal");
1477 StaticRuntimes.push_back(
"ubsan_standalone");
1479 StaticRuntimes.push_back(
"ubsan_standalone_cxx");
1483 NonWholeStaticRuntimes.push_back(
"safestack");
1484 RequiredSymbols.push_back(
"__safestack_init");
1488 StaticRuntimes.push_back(
"cfi");
1490 StaticRuntimes.push_back(
"cfi_diag");
1492 StaticRuntimes.push_back(
"ubsan_standalone_cxx");
1496 NonWholeStaticRuntimes.push_back(
"stats");
1497 RequiredSymbols.push_back(
"__sanitizer_stats_register");
1500 StaticRuntimes.push_back(
"scudo_standalone");
1502 StaticRuntimes.push_back(
"scudo_standalone_cxx");
1509 ArgStringList &CmdArgs) {
1512 NonWholeStaticRuntimes, HelperStaticRuntimes, RequiredSymbols;
1515 NonWholeStaticRuntimes, HelperStaticRuntimes,
1520 for (
auto S : RequiredSymbols) {
1521 CmdArgs.push_back(
"-u");
1522 CmdArgs.push_back(Args.MakeArgString(S));
1527 !Args.hasArg(options::OPT_shared)) {
1533 if (!Args.hasArg(clang::driver::options::OPT_nostdlibxx)) {
1534 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
1535 !Args.hasArg(options::OPT_static);
1536 if (OnlyLibstdcxxStatic)
1537 CmdArgs.push_back(
"-Bstatic");
1539 if (OnlyLibstdcxxStatic)
1540 CmdArgs.push_back(
"-Bdynamic");
1544 for (
auto RT : SharedRuntimes)
1546 for (
auto RT : HelperStaticRuntimes)
1548 bool AddExportDynamic =
false;
1549 for (
auto RT : StaticRuntimes) {
1553 for (
auto RT : NonWholeStaticRuntimes) {
1559 if (AddExportDynamic)
1560 CmdArgs.push_back(
"--export-dynamic");
1563 CmdArgs.push_back(
"--export-dynamic-symbol=__cfi_check");
1567 TC.
getDriver().
Diag(diag::err_drv_unsupported_opt_for_target)
1568 <<
"-fsanitize=memtag*" << TC.
getTriple().str();
1571 Args.MakeArgString(
"--android-memtag-mode=" + SanArgs.
getMemtagMode()));
1573 CmdArgs.push_back(
"--android-memtag-heap");
1575 CmdArgs.push_back(
"--android-memtag-stack");
1578 return !StaticRuntimes.empty() || !NonWholeStaticRuntimes.empty();
1582 if (Args.hasArg(options::OPT_shared))
1586 CmdArgs.push_back(
"--whole-archive");
1590 CmdArgs.push_back(
"--no-whole-archive");
1598 const llvm::opt::ArgList &Args,
1599 ArgStringList &CmdArgs) {
1601 CmdArgs.push_back(
"-lpthread");
1603 CmdArgs.push_back(
"-lrt");
1604 CmdArgs.push_back(
"-lm");
1609 CmdArgs.push_back(
"-ldl");
1614 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
1615 return !A->getOption().matches(options::OPT_O0);
1623 auto AddPostfix = [JA](
auto &F) {
1628 if (Arg *A = Args.getLastArg(options::OPT_gsplit_dwarf_EQ))
1629 if (StringRef(A->getValue()) ==
"single" && Output.
isFilename())
1633 if (
const Arg *A = Args.getLastArg(options::OPT_dumpdir)) {
1636 Arg *FinalOutput = Args.getLastArg(options::OPT_o, options::OPT__SLASH_o);
1637 if (FinalOutput && Args.hasArg(options::OPT_c)) {
1638 T = FinalOutput->getValue();
1639 llvm::sys::path::remove_filename(
T);
1640 llvm::sys::path::append(
T,
1641 llvm::sys::path::stem(FinalOutput->getValue()));
1643 return Args.MakeArgString(
T);
1649 return Args.MakeArgString(
T);
1653 const JobAction &JA,
const ArgList &Args,
1654 const InputInfo &Output,
const char *OutFile) {
1655 ArgStringList ExtractArgs;
1656 ExtractArgs.push_back(
"--extract-dwo");
1658 ArgStringList StripArgs;
1659 StripArgs.push_back(
"--strip-dwo");
1664 ExtractArgs.push_back(OutFile);
1671 C.addCommand(std::make_unique<Command>(JA,
T,
1673 Exec, ExtractArgs, II, Output));
1676 C.addCommand(std::make_unique<Command>(
1686 Args.ClaimAllArgs(options::OPT_flto_EQ);
1687 Args.ClaimAllArgs(options::OPT_flto);
1688 Args.ClaimAllArgs(options::OPT_fno_lto);
1692 auto *CSPGOGenerateArg = Args.getLastArg(options::OPT_fcs_profile_generate,
1693 options::OPT_fcs_profile_generate_EQ,
1694 options::OPT_fno_profile_generate);
1695 if (CSPGOGenerateArg &&
1696 CSPGOGenerateArg->getOption().matches(options::OPT_fno_profile_generate))
1697 CSPGOGenerateArg =
nullptr;
1699 return CSPGOGenerateArg;
1703 auto *ProfileUseArg = Args.getLastArg(
1704 options::OPT_fprofile_instr_use, options::OPT_fprofile_instr_use_EQ,
1705 options::OPT_fprofile_use, options::OPT_fprofile_use_EQ,
1706 options::OPT_fno_profile_instr_use);
1708 if (ProfileUseArg &&
1709 ProfileUseArg->getOption().matches(options::OPT_fno_profile_instr_use))
1710 ProfileUseArg =
nullptr;
1712 return ProfileUseArg;
1716 auto *ProfileSampleUseArg = Args.getLastArg(
1717 options::OPT_fprofile_sample_use, options::OPT_fprofile_sample_use_EQ,
1718 options::OPT_fauto_profile, options::OPT_fauto_profile_EQ,
1719 options::OPT_fno_profile_sample_use, options::OPT_fno_auto_profile);
1721 if (ProfileSampleUseArg &&
1722 (ProfileSampleUseArg->getOption().matches(
1723 options::OPT_fno_profile_sample_use) ||
1724 ProfileSampleUseArg->getOption().matches(options::OPT_fno_auto_profile)))
1727 return Args.getLastArg(options::OPT_fprofile_sample_use_EQ,
1728 options::OPT_fauto_profile_EQ);
1733 case llvm::Reloc::Static:
1735 case llvm::Reloc::PIC_:
1737 case llvm::Reloc::DynamicNoPIC:
1738 return "dynamic-no-pic";
1739 case llvm::Reloc::ROPI:
1741 case llvm::Reloc::RWPI:
1743 case llvm::Reloc::ROPI_RWPI:
1746 llvm_unreachable(
"Unknown Reloc::Model kind");
1753std::tuple<llvm::Reloc::Model, unsigned, bool>
1761 if (Triple.isOSBinFormatMachO() && Args.hasArg(options::OPT_static))
1763 bool IsPICLevelTwo = PIC;
1766 Args.hasArg(options::OPT_mkernel, options::OPT_fapple_kext);
1769 if (Triple.isAndroid()) {
1770 switch (Triple.getArch()) {
1771 case llvm::Triple::arm:
1772 case llvm::Triple::armeb:
1773 case llvm::Triple::thumb:
1774 case llvm::Triple::thumbeb:
1775 case llvm::Triple::aarch64:
1776 case llvm::Triple::mips:
1777 case llvm::Triple::mipsel:
1778 case llvm::Triple::mips64:
1779 case llvm::Triple::mips64el:
1783 case llvm::Triple::x86:
1784 case llvm::Triple::x86_64:
1786 IsPICLevelTwo =
true;
1795 if (Triple.isOHOSFamily() && Triple.getArch() == llvm::Triple::aarch64)
1799 if (Triple.isOSOpenBSD()) {
1801 case llvm::Triple::arm:
1802 case llvm::Triple::aarch64:
1803 case llvm::Triple::mips64:
1804 case llvm::Triple::mips64el:
1805 case llvm::Triple::x86:
1806 case llvm::Triple::x86_64:
1807 IsPICLevelTwo =
false;
1810 case llvm::Triple::ppc:
1811 case llvm::Triple::sparcv9:
1812 IsPICLevelTwo =
true;
1824 Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
1825 options::OPT_fpic, options::OPT_fno_pic,
1826 options::OPT_fPIE, options::OPT_fno_PIE,
1827 options::OPT_fpie, options::OPT_fno_pie);
1828 if (Triple.isOSWindows() && !Triple.isOSCygMing() && LastPICArg &&
1829 LastPICArg == Args.getLastArg(options::OPT_fPIC, options::OPT_fpic,
1830 options::OPT_fPIE, options::OPT_fpie)) {
1832 << LastPICArg->getSpelling() << Triple.str();
1833 if (Triple.getArch() == llvm::Triple::x86_64)
1834 return std::make_tuple(llvm::Reloc::PIC_, 2U,
false);
1835 return std::make_tuple(llvm::Reloc::Static, 0
U,
false);
1842 Option O = LastPICArg->getOption();
1843 if (O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic) ||
1844 O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie)) {
1845 PIE = O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie);
1847 PIE || O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic);
1849 O.matches(options::OPT_fPIE) || O.matches(options::OPT_fPIC);
1852 if (EffectiveTriple.isPS()) {
1853 Arg *ModelArg = Args.getLastArg(options::OPT_mcmodel_EQ);
1854 StringRef Model = ModelArg ? ModelArg->getValue() :
"";
1855 if (Model !=
"kernel") {
1858 << LastPICArg->getSpelling()
1859 << (EffectiveTriple.isPS4() ?
"PS4" :
"PS5");
1869 if (PIC && (Triple.isOSDarwin() || EffectiveTriple.isPS()))
1875 ((!EffectiveTriple.isiOS() || EffectiveTriple.isOSVersionLT(6)) &&
1876 !EffectiveTriple.isWatchOS() && !EffectiveTriple.isDriverKit()))
1879 if (Arg *A = Args.getLastArg(options::OPT_mdynamic_no_pic)) {
1882 if (!Triple.isOSDarwin())
1884 << A->getSpelling() << Triple.str();
1893 return std::make_tuple(llvm::Reloc::DynamicNoPIC, PIC ? 2U : 0
U,
false);
1896 bool EmbeddedPISupported;
1897 switch (Triple.getArch()) {
1898 case llvm::Triple::arm:
1899 case llvm::Triple::armeb:
1900 case llvm::Triple::thumb:
1901 case llvm::Triple::thumbeb:
1902 EmbeddedPISupported =
true;
1905 EmbeddedPISupported =
false;
1909 bool ROPI =
false, RWPI =
false;
1910 Arg* LastROPIArg = Args.getLastArg(options::OPT_fropi, options::OPT_fno_ropi);
1911 if (LastROPIArg && LastROPIArg->getOption().matches(options::OPT_fropi)) {
1912 if (!EmbeddedPISupported)
1914 << LastROPIArg->getSpelling() << Triple.str();
1917 Arg *LastRWPIArg = Args.getLastArg(options::OPT_frwpi, options::OPT_fno_rwpi);
1918 if (LastRWPIArg && LastRWPIArg->getOption().matches(options::OPT_frwpi)) {
1919 if (!EmbeddedPISupported)
1921 << LastRWPIArg->getSpelling() << Triple.str();
1926 if ((ROPI || RWPI) && (PIC || PIE))
1929 if (Triple.isMIPS()) {
1936 if (ABIName ==
"n64")
1939 if(Args.hasArg(options::OPT_mno_abicalls))
1940 return std::make_tuple(llvm::Reloc::Static, 0
U,
false);
1943 IsPICLevelTwo =
false;
1947 return std::make_tuple(llvm::Reloc::PIC_, IsPICLevelTwo ? 2U : 1U, PIE);
1949 llvm::Reloc::Model RelocM = llvm::Reloc::Static;
1951 RelocM = llvm::Reloc::ROPI_RWPI;
1953 RelocM = llvm::Reloc::ROPI;
1955 RelocM = llvm::Reloc::RWPI;
1957 return std::make_tuple(RelocM, 0
U,
false);
1977 const ArgList &Args) {
1978 const Arg *A = Args.getLastArg(options::OPT_falign_functions,
1979 options::OPT_falign_functions_EQ,
1980 options::OPT_fno_align_functions);
1981 if (!A || A->getOption().matches(options::OPT_fno_align_functions))
1984 if (A->getOption().matches(options::OPT_falign_functions))
1988 if (StringRef(A->getValue()).getAsInteger(10,
Value) ||
Value > 65536)
1990 << A->getAsString(Args) << A->getValue();
1995 ArgStringList &CmdArgs, llvm::codegenoptions::DebugInfoKind DebugInfoKind) {
1996 switch (DebugInfoKind) {
1997 case llvm::codegenoptions::DebugDirectivesOnly:
1998 CmdArgs.push_back(
"-debug-info-kind=line-directives-only");
2000 case llvm::codegenoptions::DebugLineTablesOnly:
2001 CmdArgs.push_back(
"-debug-info-kind=line-tables-only");
2003 case llvm::codegenoptions::DebugInfoConstructor:
2004 CmdArgs.push_back(
"-debug-info-kind=constructor");
2006 case llvm::codegenoptions::LimitedDebugInfo:
2007 CmdArgs.push_back(
"-debug-info-kind=limited");
2009 case llvm::codegenoptions::FullDebugInfo:
2010 CmdArgs.push_back(
"-debug-info-kind=standalone");
2012 case llvm::codegenoptions::UnusedTypeInfo:
2013 CmdArgs.push_back(
"-debug-info-kind=unused-types");
2023 assert(A.getOption().matches(options::OPT_gN_Group) &&
2024 "Not a -g option that specifies a debug-info level");
2025 if (A.getOption().matches(options::OPT_g0) ||
2026 A.getOption().matches(options::OPT_ggdb0))
2027 return llvm::codegenoptions::NoDebugInfo;
2028 if (A.getOption().matches(options::OPT_gline_tables_only) ||
2029 A.getOption().matches(options::OPT_ggdb1))
2030 return llvm::codegenoptions::DebugLineTablesOnly;
2031 if (A.getOption().matches(options::OPT_gline_directives_only))
2032 return llvm::codegenoptions::DebugDirectivesOnly;
2033 return llvm::codegenoptions::DebugInfoConstructor;
2037 const ArgList &Args) {
2038 const Arg *A = Args.getLastArg(options::OPT_fdebug_default_version);
2044 if (StringRef(A->getValue()).getAsInteger(10,
Value) ||
Value > 5 ||
2047 << A->getAsString(Args) << A->getValue();
2052 return llvm::StringSwitch<unsigned>(ArgValue)
2053 .Case(
"-gdwarf-2", 2)
2054 .Case(
"-gdwarf-3", 3)
2055 .Case(
"-gdwarf-4", 4)
2056 .Case(
"-gdwarf-5", 5)
2061 return Args.getLastArg(options::OPT_gdwarf_2, options::OPT_gdwarf_3,
2062 options::OPT_gdwarf_4, options::OPT_gdwarf_5,
2063 options::OPT_gdwarf);
2067 const llvm::opt::ArgList &Args) {
2072 if (DwarfVersion == 5 && TC.
getTriple().isOSAIX())
2073 TC.
getDriver().
Diag(diag::err_drv_unsupported_opt_for_target)
2074 << GDwarfN->getSpelling() << TC.
getTriple().str();
2076 if (DwarfVersion == 0) {
2078 assert(DwarfVersion &&
"toolchain default DWARF version must be nonzero");
2080 return DwarfVersion;
2084 ArgStringList &CmdArgs) {
2085 llvm::Reloc::Model RelocationModel;
2090 if (RelocationModel != llvm::Reloc::Static)
2091 CmdArgs.push_back(
"-KPIC");
2097 return Args.hasFlag(options::OPT_fobjc_arc, options::OPT_fno_objc_arc,
false);
2103 const ArgList &Args) {
2104 if (Args.hasArg(options::OPT_static_libgcc) ||
2105 Args.hasArg(options::OPT_static) || Args.hasArg(options::OPT_static_pie) ||
2109 if (Args.hasArg(options::OPT_shared_libgcc))
2128 ArgStringList &CmdArgs,
const ArgList &Args) {
2132 CmdArgs.push_back(
"-l:libunwind.a");
2155 CmdArgs.push_back(
"-lgcc_eh");
2157 CmdArgs.push_back(
"-lgcc_s");
2165 CmdArgs.push_back(
"-lunwind");
2167 CmdArgs.push_back(
"-l:libunwind.a");
2170 CmdArgs.push_back(
"-l:libunwind.dll.a");
2172 CmdArgs.push_back(
"-l:libunwind.so");
2176 CmdArgs.push_back(
"-lunwind");
2186 ArgStringList &CmdArgs,
const ArgList &Args) {
2190 CmdArgs.push_back(
"-lgcc");
2194 CmdArgs.push_back(
"-lgcc");
2198 ArgStringList &CmdArgs,
const ArgList &Args) {
2209 if (TC.
getTriple().isKnownWindowsMSVCEnvironment()) {
2212 Arg *A = Args.getLastArg(options::OPT_rtlib_EQ);
2213 if (A && A->getValue() != StringRef(
"platform")) {
2214 TC.
getDriver().
Diag(diag::err_drv_unsupported_rtlib_for_platform)
2215 << A->getValue() <<
"MSVC";
2225 if (TC.
getTriple().isAndroid() && !Args.hasArg(options::OPT_static) &&
2226 !Args.hasArg(options::OPT_static_pie))
2227 CmdArgs.push_back(
"-ldl");
2234 const Arg *A = Args.getLastArg(options::OPT_save_stats_EQ);
2235 if (!A && !
D.CCPrintInternalStats)
2240 StringRef SaveStats = A->getValue();
2241 if (SaveStats ==
"obj" && Output.
isFilename()) {
2243 llvm::sys::path::remove_filename(StatsFile);
2244 }
else if (SaveStats !=
"cwd") {
2245 D.Diag(diag::err_drv_invalid_value) << A->getAsString(Args) << SaveStats;
2249 StringRef BaseName = llvm::sys::path::filename(Input.
getBaseInput());
2250 llvm::sys::path::append(StatsFile, BaseName);
2251 llvm::sys::path::replace_extension(StatsFile,
"stats");
2253 assert(
D.CCPrintInternalStats);
2254 StatsFile.assign(
D.CCPrintInternalStatReportFilename.empty()
2256 :
D.CCPrintInternalStatReportFilename);
2263 assert(Flag.front() ==
'-');
2265 Flags.push_back(Flag.str());
2267 Flags.push_back((
"!" + Flag.substr(1)).str());
2272 ArgStringList &CmdArgs,
bool IsLTO,
2273 const StringRef PluginOptPrefix) {
2274 auto addArg = [&, IsLTO](
const Twine &Arg) {
2276 assert(!PluginOptPrefix.empty() &&
"Cannot have empty PluginOptPrefix!");
2277 CmdArgs.push_back(Args.MakeArgString(Twine(PluginOptPrefix) + Arg));
2279 CmdArgs.push_back(
"-mllvm");
2280 CmdArgs.push_back(Args.MakeArgString(Arg));
2284 if (Args.hasArg(options::OPT_mbranches_within_32B_boundaries)) {
2285 addArg(Twine(
"-x86-branches-within-32B-boundaries"));
2287 if (
const Arg *A = Args.getLastArg(options::OPT_malign_branch_boundary_EQ)) {
2288 StringRef
Value = A->getValue();
2290 if (
Value.getAsInteger(10, Boundary) || Boundary < 16 ||
2291 !llvm::isPowerOf2_64(Boundary)) {
2292 D.Diag(diag::err_drv_invalid_argument_to_option)
2293 <<
Value << A->getOption().getName();
2295 addArg(
"-x86-align-branch-boundary=" + Twine(Boundary));
2298 if (
const Arg *A = Args.getLastArg(options::OPT_malign_branch_EQ)) {
2299 std::string AlignBranch;
2300 for (StringRef
T : A->getValues()) {
2301 if (
T !=
"fused" &&
T !=
"jcc" &&
T !=
"jmp" &&
T !=
"call" &&
2302 T !=
"ret" &&
T !=
"indirect")
2303 D.Diag(diag::err_drv_invalid_malign_branch_EQ)
2304 <<
T <<
"fused, jcc, jmp, call, ret, indirect";
2305 if (!AlignBranch.empty())
2309 addArg(
"-x86-align-branch=" + Twine(AlignBranch));
2311 if (
const Arg *A = Args.getLastArg(options::OPT_mpad_max_prefix_size_EQ)) {
2312 StringRef
Value = A->getValue();
2313 unsigned PrefixSize;
2314 if (
Value.getAsInteger(10, PrefixSize)) {
2315 D.Diag(diag::err_drv_invalid_argument_to_option)
2316 <<
Value << A->getOption().getName();
2318 addArg(
"-x86-pad-max-prefix-size=" + Twine(PrefixSize));
2344 llvm::opt::ArgStringList &CC1Args,
2346 StringRef Lib, StringRef Arch, StringRef
Target,
2347 bool isBitCodeSDL) {
2350 std::string LibDeviceLoc =
"/libdevice";
2351 std::string LibBcPrefix =
"/libbc-";
2352 std::string LibPrefix =
"/lib";
2369 for (StringRef
Base : {LibBcPrefix, LibPrefix}) {
2370 const auto *Ext =
Base.contains(LibBcPrefix) ?
".a" :
".bc";
2372 for (
auto Suffix : {Twine(Lib +
"-" + Arch +
"-" +
Target).str(),
2373 Twine(Lib +
"-" + Arch).str(), Twine(Lib).str()}) {
2374 SDLs.push_back(Twine(LibDeviceLoc +
Base + Suffix + Ext).str());
2375 SDLs.push_back(Twine(
Base + Suffix + Ext).str());
2385 const auto *Ext =
".a";
2387 for (
auto Suffix : {Twine(Lib +
"-" + Arch +
"-" +
Target).str(),
2388 Twine(Lib +
"-" + Arch).str()}) {
2389 SDLs.push_back(Twine(LibDeviceLoc + LibPrefix + Suffix + Ext).str());
2390 SDLs.push_back(Twine(LibPrefix + Suffix + Ext).str());
2401 bool FoundSDL =
false;
2402 for (
auto LPath : LibraryPaths) {
2403 for (
auto SDL : SDLs) {
2404 auto FullName = Twine(LPath + SDL).str();
2405 if (llvm::sys::fs::exists(
FullName)) {
2406 CC1Args.push_back(DriverArgs.MakeArgString(
FullName));
2423 const InputInfoList &Inputs,
const llvm::opt::ArgList &DriverArgs,
2424 llvm::opt::ArgStringList &CC1Args,
2426 StringRef Arch, StringRef
Target,
bool isBitCodeSDL) {
2429 if (isBitCodeSDL && Arch.contains(
"nvptx"))
2432 bool FoundAOB =
false;
2433 std::string ArchiveOfBundles;
2435 llvm::Triple Triple(
D.getTargetTriple());
2436 bool IsMSVC = Triple.isWindowsMSVCEnvironment();
2437 auto Ext = IsMSVC ?
".lib" :
".a";
2438 if (!Lib.starts_with(
":") && !Lib.starts_with(
"-l")) {
2439 if (llvm::sys::fs::exists(Lib)) {
2440 ArchiveOfBundles = Lib;
2444 Lib.consume_front(
"-l");
2445 for (
auto LPath : LibraryPaths) {
2446 ArchiveOfBundles.clear();
2447 auto LibFile = (Lib.starts_with(
":") ? Lib.drop_front()
2448 : IsMSVC ? Lib + Ext
2449 :
"lib" + Lib + Ext)
2451 for (
auto Prefix : {
"/libdevice/",
"/"}) {
2452 auto AOB = Twine(LPath + Prefix + LibFile).str();
2453 if (llvm::sys::fs::exists(AOB)) {
2454 ArchiveOfBundles = AOB;
2467 llvm::file_magic Magic;
2468 auto EC = llvm::identify_magic(ArchiveOfBundles, Magic);
2469 if (EC || Magic != llvm::file_magic::archive)
2472 StringRef Prefix = isBitCodeSDL ?
"libbc-" :
"lib";
2473 std::string OutputLib =
2474 D.GetTemporaryPath(Twine(Prefix + llvm::sys::path::filename(Lib) +
"-" +
2479 C.addTempFile(
C.getArgs().MakeArgString(OutputLib));
2481 ArgStringList CmdArgs;
2484 DeviceTriple +=
'-';
2485 std::string NormalizedTriple =
T.getToolChain().getTriple().normalize();
2486 DeviceTriple += NormalizedTriple;
2488 DeviceTriple +=
'-';
2492 std::string UnbundleArg(
"-unbundle");
2493 std::string TypeArg(
"-type=a");
2494 std::string InputArg(
"-input=" + ArchiveOfBundles);
2495 std::string OffloadArg(
"-targets=" + std::string(DeviceTriple));
2496 std::string OutputArg(
"-output=" + OutputLib);
2498 const char *UBProgram = DriverArgs.MakeArgString(
2499 T.getToolChain().GetProgramPath(
"clang-offload-bundler"));
2501 ArgStringList UBArgs;
2502 UBArgs.push_back(
C.getArgs().MakeArgString(UnbundleArg));
2503 UBArgs.push_back(
C.getArgs().MakeArgString(TypeArg));
2504 UBArgs.push_back(
C.getArgs().MakeArgString(InputArg));
2505 UBArgs.push_back(
C.getArgs().MakeArgString(OffloadArg));
2506 UBArgs.push_back(
C.getArgs().MakeArgString(OutputArg));
2510 std::string AdditionalArgs(
"-allow-missing-bundles");
2511 UBArgs.push_back(
C.getArgs().MakeArgString(AdditionalArgs));
2516 std::string HipCompatibleArgs(
"-hip-openmp-compatible");
2517 UBArgs.push_back(
C.getArgs().MakeArgString(HipCompatibleArgs));
2519 C.addCommand(std::make_unique<Command>(
2521 InputInfo(&JA,
C.getArgs().MakeArgString(OutputLib))));
2523 CC1Args.push_back(DriverArgs.MakeArgString(OutputLib));
2532 const llvm::opt::ArgList &DriverArgs,
2533 llvm::opt::ArgStringList &CC1Args,
2534 StringRef Arch, StringRef
Target,
2535 bool isBitCodeSDL) {
2537 Arch,
Target, isBitCodeSDL);
2566 const llvm::opt::ArgList &DriverArgs,
2567 llvm::opt::ArgStringList &CC1Args,
2568 StringRef Arch, StringRef
Target,
2569 bool isBitCodeSDL) {
2573 std::optional<std::string> LibPath =
2574 llvm::sys::Process::GetEnv(
"LIBRARY_PATH");
2577 const char EnvPathSeparatorStr[] = {llvm::sys::EnvPathSeparator,
'\0'};
2578 llvm::SplitString(*LibPath, Frags, EnvPathSeparatorStr);
2579 for (StringRef
Path : Frags)
2580 LibraryPaths.emplace_back(
Path.trim());
2584 for (std::string Search_Dir : DriverArgs.getAllArgValues(options::OPT_L))
2585 LibraryPaths.emplace_back(Search_Dir);
2589 llvm::sys::path::append(DefaultLibPath, CLANG_INSTALL_LIBDIR_BASENAME);
2590 LibraryPaths.emplace_back(DefaultLibPath.c_str());
2593 llvm::SmallSet<std::string, 16> SDLNames;
2594 static const StringRef HostOnlyArchives[] = {
2595 "omp",
"cudart",
"m",
"gcc",
"gcc_s",
"pthread",
"hip_hcc"};
2596 for (
auto SDLName : DriverArgs.getAllArgValues(options::OPT_l)) {
2597 if (!llvm::is_contained(HostOnlyArchives, SDLName)) {
2598 SDLNames.insert(std::string(
"-l") + SDLName);
2602 for (
auto Input : DriverArgs.getAllArgValues(options::OPT_INPUT)) {
2609 const StringRef LibFileExt =
".lib";
2610 if (!llvm::sys::path::has_extension(
FileName) ||
2612 llvm::sys::path::extension(
FileName).drop_front()) ==
2614 llvm::sys::path::extension(
FileName) == LibFileExt)
2615 SDLNames.insert(Input);
2622 for (
auto SDLName : SDLNames) {
2624 if (!
SDLSearch(
D, DriverArgs, CC1Args, LibraryPaths, SDLName, Arch,
Target,
2627 LibraryPaths, SDLName, Arch,
Target,
2633static llvm::opt::Arg *
2635 return Args.getLastArg(options::OPT_mcode_object_version_EQ);
2639 const llvm::opt::ArgList &Args) {
2640 const unsigned MinCodeObjVer = 4;
2641 const unsigned MaxCodeObjVer = 6;
2644 if (CodeObjArg->getOption().getID() ==
2645 options::OPT_mcode_object_version_EQ) {
2646 unsigned CodeObjVer = MaxCodeObjVer;
2648 StringRef(CodeObjArg->getValue()).getAsInteger(0, CodeObjVer);
2649 if (Remnant || CodeObjVer < MinCodeObjVer || CodeObjVer > MaxCodeObjVer)
2650 D.Diag(diag::err_drv_invalid_int_value)
2651 << CodeObjArg->getAsString(Args) << CodeObjArg->getValue();
2656 if (CodeObjVer == 6)
2657 D.Diag(diag::warn_drv_amdgpu_cov6);
2663 const llvm::opt::ArgList &Args) {
2664 unsigned CodeObjVer = 4;
2666 StringRef(CodeObjArg->getValue()).getAsInteger(0, CodeObjVer);
2671 const Driver &
D,
const llvm::opt::ArgList &Args) {
2676 const llvm::opt::ArgList &Args,
2677 llvm::opt::ArgStringList &CmdArgs,
2678 const llvm::Triple &Triple,
bool IsLTO,
2679 const StringRef PluginOptPrefix) {
2680 auto addArg = [&, IsLTO](
const Twine &Arg) {
2682 assert(!PluginOptPrefix.empty() &&
"Cannot have empty PluginOptPrefix!");
2683 CmdArgs.push_back(Args.MakeArgString(Twine(PluginOptPrefix) + Arg));
2685 CmdArgs.push_back(
"-mllvm");
2686 CmdArgs.push_back(Args.MakeArgString(Arg));
2690 if (Arg *A = Args.getLastArg(options::OPT_moutline,
2691 options::OPT_mno_outline)) {
2692 if (A->getOption().matches(options::OPT_moutline)) {
2696 if (!(Triple.isARM() || Triple.isThumb() || Triple.isAArch64())) {
2697 D.Diag(diag::warn_drv_moutline_unsupported_opt) << Triple.getArchName();
2699 addArg(Twine(
"-enable-machine-outliner"));
2703 addArg(Twine(
"-enable-machine-outliner=never"));
2709 const llvm::opt::ArgList &DriverArgs,
2710 llvm::opt::ArgStringList &CC1Args,
2711 StringRef BitcodeSuffix,
2712 const llvm::Triple &Triple,
2717 std::optional<std::string> LibPath =
2718 llvm::sys::Process::GetEnv(
"LIBRARY_PATH");
2721 const char EnvPathSeparatorStr[] = {llvm::sys::EnvPathSeparator,
'\0'};
2722 llvm::SplitString(*LibPath, Frags, EnvPathSeparatorStr);
2723 for (StringRef
Path : Frags)
2724 LibraryPaths.emplace_back(
Path.trim());
2729 LibraryPaths.emplace_back(LibPath);
2731 OptSpecifier LibomptargetBCPathOpt =
2732 Triple.isAMDGCN() ? options::OPT_libomptarget_amdgpu_bc_path_EQ
2733 : options::OPT_libomptarget_nvptx_bc_path_EQ;
2735 StringRef ArchPrefix = Triple.isAMDGCN() ?
"amdgpu" :
"nvptx";
2736 std::string LibOmpTargetName =
2737 (
"libomptarget-" + ArchPrefix +
"-" + BitcodeSuffix +
".bc").str();
2740 if (
const Arg *A = DriverArgs.getLastArg(LibomptargetBCPathOpt)) {
2742 if (llvm::sys::fs::exists(LibOmpTargetFile) &&
2743 llvm::sys::fs::is_directory(LibOmpTargetFile)) {
2744 llvm::sys::path::append(LibOmpTargetFile, LibOmpTargetName);
2747 if (llvm::sys::fs::exists(LibOmpTargetFile)) {
2748 CC1Args.push_back(
"-mlink-builtin-bitcode");
2749 CC1Args.push_back(DriverArgs.MakeArgString(LibOmpTargetFile));
2751 D.Diag(diag::err_drv_omp_offload_target_bcruntime_not_found)
2752 << LibOmpTargetFile;
2755 bool FoundBCLibrary =
false;
2757 for (StringRef LibraryPath : LibraryPaths) {
2759 llvm::sys::path::append(LibOmpTargetFile, LibOmpTargetName);
2760 if (llvm::sys::fs::exists(LibOmpTargetFile)) {
2761 CC1Args.push_back(
"-mlink-builtin-bitcode");
2762 CC1Args.push_back(DriverArgs.MakeArgString(LibOmpTargetFile));
2763 FoundBCLibrary =
true;
2768 if (!FoundBCLibrary)
2769 D.Diag(diag::err_drv_omp_offload_target_missingbcruntime)
2770 << LibOmpTargetName << ArchPrefix;
2774 const llvm::opt::ArgList &Args,
2775 llvm::opt::ArgStringList &CmdArgs) {
2777 !Args.hasArg(options::OPT_nostdlib) &&
2778 !Args.hasArg(options::OPT_no_hip_rt) && !Args.hasArg(options::OPT_r)) {
2782 for (
auto *Arg : Args.filtered(options::OPT_no_hip_rt)) {
2789 const llvm::opt::ArgList &Args,
2790 llvm::opt::ArgStringList &CmdArgs,
2791 const llvm::Triple &Triple) {
2792 if (Arg *A = Args.getLastArg(options::OPT_moutline_atomics,
2793 options::OPT_mno_outline_atomics)) {
2795 if (!Triple.isAArch64()) {
2796 D.Diag(diag::warn_drv_moutline_atomics_unsupported_opt)
2797 << Triple.getArchName() << A->getOption().getName();
2799 if (A->getOption().matches(options::OPT_moutline_atomics)) {
2800 CmdArgs.push_back(
"-target-feature");
2801 CmdArgs.push_back(
"+outline-atomics");
2803 CmdArgs.push_back(
"-target-feature");
2804 CmdArgs.push_back(
"-outline-atomics");
2808 CmdArgs.push_back(
"-target-feature");
2809 CmdArgs.push_back(
"+outline-atomics");
2814 llvm::opt::ArgStringList &CmdArgs) {
2815 if (TCArgs.hasFlag(options::OPT_offload_compress,
2816 options::OPT_no_offload_compress,
false))
2817 CmdArgs.push_back(
"-compress");
2818 if (TCArgs.hasArg(options::OPT_v))
2819 CmdArgs.push_back(
"-verbose");
2820 if (
auto *Arg = TCArgs.getLastArg(options::OPT_offload_compression_level_EQ))
2822 TCArgs.MakeArgString(Twine(
"-compression-level=") + Arg->getValue()));
2826 const llvm::Triple &Triple,
2827 const llvm::Reloc::Model &RelocationModel,
2828 llvm::opt::ArgStringList &CmdArgs) {
2829 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
2830 StringRef CM = A->getValue();
2832 if (Triple.isOSAIX() && CM ==
"medium")
2834 if (Triple.isAArch64(64)) {
2835 Ok = CM ==
"tiny" || CM ==
"small" || CM ==
"large";
2836 if (CM ==
"large" && !Triple.isOSBinFormatMachO() &&
2837 RelocationModel != llvm::Reloc::Static)
2838 D.Diag(diag::err_drv_argument_only_allowed_with)
2839 << A->getAsString(Args) <<
"-fno-pic";
2840 }
else if (Triple.isLoongArch()) {
2841 if (CM ==
"extreme" &&
2842 Args.hasFlagNoClaim(options::OPT_fplt, options::OPT_fno_plt,
false))
2843 D.Diag(diag::err_drv_argument_not_allowed_with)
2844 << A->getAsString(Args) <<
"-fplt";
2845 Ok = CM ==
"normal" || CM ==
"medium" || CM ==
"extreme";
2848 CM = llvm::StringSwitch<StringRef>(CM)
2849 .Case(
"normal",
"small")
2850 .Case(
"extreme",
"large")
2852 }
else if (Triple.isPPC64() || Triple.isOSAIX()) {
2853 Ok = CM ==
"small" || CM ==
"medium" || CM ==
"large";
2854 }
else if (Triple.isRISCV()) {
2857 else if (CM ==
"medany")
2859 Ok = CM ==
"small" || CM ==
"medium";
2860 }
else if (Triple.getArch() == llvm::Triple::x86_64) {
2861 Ok = llvm::is_contained({
"small",
"kernel",
"medium",
"large",
"tiny"},
2863 }
else if (Triple.isNVPTX() || Triple.isAMDGPU() || Triple.isSPIRV()) {
2867 }
else if (Triple.isSPARC64()) {
2870 else if (CM ==
"medmid")
2872 else if (CM ==
"medany")
2874 Ok = CM ==
"small" || CM ==
"medium" || CM ==
"large";
2877 CmdArgs.push_back(Args.MakeArgString(
"-mcmodel=" + CM));
2879 D.Diag(diag::err_drv_unsupported_option_argument_for_target)
2880 << A->getSpelling() << CM << Triple.getTriple();
2884 if (Triple.getArch() == llvm::Triple::x86_64) {
2885 bool IsMediumCM =
false;
2886 bool IsLargeCM =
false;
2887 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
2888 IsMediumCM = StringRef(A->getValue()) ==
"medium";
2889 IsLargeCM = StringRef(A->getValue()) ==
"large";
2891 if (Arg *A = Args.getLastArg(options::OPT_mlarge_data_threshold_EQ)) {
2892 if (!IsMediumCM && !IsLargeCM) {
2893 D.Diag(diag::warn_drv_large_data_threshold_invalid_code_model)
2894 << A->getOption().getRenderName();
2896 A->render(Args, CmdArgs);
2898 }
else if (IsMediumCM) {
2899 CmdArgs.push_back(
"-mlarge-data-threshold=65536");
2900 }
else if (IsLargeCM) {
2901 CmdArgs.push_back(
"-mlarge-data-threshold=0");
static bool useLeafFramePointerForTargetByDefault(const llvm::Triple &Triple)
static unsigned ParseDebugDefaultVersion(const ToolChain &TC, const ArgList &Args)
static void getWebAssemblyTargetFeatures(const Driver &D, const llvm::Triple &Triple, const ArgList &Args, std::vector< StringRef > &Features)
static bool addSanitizerDynamicList(const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs, StringRef Sanitizer)
static bool mustMaintainValidFrameChain(const llvm::opt::ArgList &Args, const llvm::Triple &Triple)
static llvm::opt::Arg * getAMDGPUCodeObjectArgument(const Driver &D, const llvm::opt::ArgList &Args)
static void collectSanitizerRuntimes(const ToolChain &TC, const ArgList &Args, SmallVectorImpl< StringRef > &SharedRuntimes, SmallVectorImpl< StringRef > &StaticRuntimes, SmallVectorImpl< StringRef > &NonWholeStaticRuntimes, SmallVectorImpl< StringRef > &HelperStaticRuntimes, SmallVectorImpl< StringRef > &RequiredSymbols)
static void addSanitizerRuntime(const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs, StringRef Sanitizer, bool IsShared, bool IsWhole)
static void AddUnwindLibrary(const ToolChain &TC, const Driver &D, ArgStringList &CmdArgs, const ArgList &Args)
static bool SDLSearch(const Driver &D, const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args, const SmallVectorImpl< std::string > &LibraryPaths, StringRef Lib, StringRef Arch, StringRef Target, bool isBitCodeSDL)
SDLSearch: Search for Static Device Library The search for SDL bitcode files is consistent with how s...
static void renderRpassOptions(const ArgList &Args, ArgStringList &CmdArgs, const StringRef PluginOptPrefix)
static StringRef getWebAssemblyTargetCPU(const ArgList &Args)
Get the (LLVM) name of the WebAssembly cpu we are targeting.
static bool framePointerImpliesLeafFramePointer(const llvm::opt::ArgList &Args, const llvm::Triple &Triple)
static void renderRemarksHotnessOptions(const ArgList &Args, ArgStringList &CmdArgs, const StringRef PluginOptPrefix)
static void GetSDLFromOffloadArchive(Compilation &C, const Driver &D, const Tool &T, const JobAction &JA, const InputInfoList &Inputs, const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args, const SmallVectorImpl< std::string > &LibraryPaths, StringRef Lib, StringRef Arch, StringRef Target, bool isBitCodeSDL)
Search if a user provided archive file lib<libname>.a exists in any of the library paths.
static std::string getLanaiTargetCPU(const ArgList &Args)
static void renderRemarksOptions(const ArgList &Args, ArgStringList &CmdArgs, const llvm::Triple &Triple, const InputInfo &Input, const InputInfo &Output, const StringRef PluginOptPrefix)
static bool useFramePointerForTargetByDefault(const llvm::opt::ArgList &Args, const llvm::Triple &Triple)
static void AddLibgcc(const ToolChain &TC, const Driver &D, ArgStringList &CmdArgs, const ArgList &Args)
static LibGccType getLibGccType(const ToolChain &TC, const Driver &D, const ArgList &Args)
clang::CodeGenOptions::FramePointerKind getFramePointerKind(const llvm::opt::ArgList &Args, const llvm::Triple &Triple)
static std::string getAMDGPUTargetGPU(const llvm::Triple &T, const ArgList &Args)
Get the (LLVM) name of the AMDGPU gpu we are targeting.
static bool mustUseNonLeafFramePointerForTarget(const llvm::Triple &Triple)
static bool shouldIgnoreUnsupportedTargetFeature(const Arg &TargetFeatureArg, llvm::Triple T, StringRef Processor)
Defines the clang::LangOptions interface.
llvm::MachO::Target Target
Defines types useful for describing an Objective-C runtime.
Defines version macros and version-related utility functions for Clang.
const char * getOffloadingArch() const
static StringRef GetOffloadKindName(OffloadKind Kind)
Return a string containing a offload kind name.
OffloadKind getOffloadingDeviceKind() const
bool isHostOffloading(unsigned int OKind) const
Check if this action have any offload kinds.
Compilation - A set of tasks to perform for a single driver invocation.
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
OpenMPRuntimeKind getOpenMPRuntime(const llvm::opt::ArgList &Args) const
Compute the desired OpenMP runtime from the flags provided.
DiagnosticBuilder Diag(unsigned DiagID) const
StringRef getFlangF128MathLibrary() const
std::string Dir
The path the driver executable was in, as invoked from the command line.
@ OMPRT_IOMP5
The legacy name for the LLVM OpenMP runtime from when it was the Intel OpenMP runtime.
@ OMPRT_OMP
The LLVM OpenMP runtime.
@ OMPRT_Unknown
An unknown OpenMP runtime.
@ OMPRT_GOMP
The GNU OpenMP runtime.
std::vector< std::string > flags_list
bool needsFuzzerInterceptors() const
bool needsHwasanAliasesRt() const
bool needsStatsRt() const
bool needsMemProfRt() const
bool needsCfiDiagRt() const
bool linkRuntimes() const
bool needsUbsanRt() const
bool needsHwasanRt() const
bool hasCrossDsoCfi() const
bool hasMemtagHeap() const
bool needsSafeStackRt() const
bool requiresMinimalRuntime() const
bool hasMemtagStack() const
bool needsDfsanRt() const
bool needsScudoRt() const
const std::string & getMemtagMode() const
bool needsSharedRt() const
bool linkCXXRuntimes() const
llvm::ArrayRef< std::string > modeList() const
bool isLLVMIR(ID Id)
Is this LLVM IR.
ID lookupTypeForExtension(llvm::StringRef Ext)
lookupTypeForExtension - Lookup the type to use for the file extension Ext.
bool willEmitRemarks(const llvm::opt::ArgList &Args)
The JSON file list parser is used to communicate input to InstallAPI.
llvm::StringRef getProcessorFromTargetID(const llvm::Triple &T, llvm::StringRef OffloadArch)
Get processor name from target ID.
const FunctionProtoType * T
static constexpr ResponseFileSupport AtFileCurCP()