clang: lib/Driver/ToolChains/CommonArgs.cpp Source File (original) (raw)
1
2
3
4
5
6
7
8
32#include "clang/Config/config.h"
44#include "llvm/ADT/STLExtras.h"
45#include "llvm/ADT/SmallSet.h"
46#include "llvm/ADT/SmallString.h"
47#include "llvm/ADT/StringExtras.h"
48#include "llvm/ADT/StringSwitch.h"
49#include "llvm/ADT/Twine.h"
50#include "llvm/BinaryFormat/Magic.h"
51#include "llvm/Config/llvm-config.h"
52#include "llvm/Option/Arg.h"
53#include "llvm/Option/ArgList.h"
54#include "llvm/Option/Option.h"
55#include "llvm/Support/CodeGen.h"
56#include "llvm/Support/Compression.h"
57#include "llvm/Support/Debug.h"
58#include "llvm/Support/ErrorHandling.h"
59#include "llvm/Support/FileSystem.h"
60#include "llvm/Support/Path.h"
61#include "llvm/Support/Process.h"
62#include "llvm/Support/Program.h"
63#include "llvm/Support/ScopedPrinter.h"
64#include "llvm/Support/Threading.h"
65#include "llvm/Support/VirtualFileSystem.h"
66#include "llvm/Support/YAMLParser.h"
67#include "llvm/TargetParser/Host.h"
68#include "llvm/TargetParser/PPCTargetParser.h"
69#include "llvm/TargetParser/TargetParser.h"
70#include
71
74using namespace clang;
76
78 const llvm::Triple &Triple) {
79 if (Args.hasArg(clang::driver::options::OPT_pg) &&
80 !Args.hasArg(clang::driver::options::OPT_mfentry))
81 return true;
82
83 if (Triple.isAndroid())
84 return true;
85
86 switch (Triple.getArch()) {
87 case llvm::Triple::xcore:
88 case llvm::Triple::wasm32:
89 case llvm::Triple::wasm64:
90 case llvm::Triple::msp430:
91
92
93 return false;
94 case llvm::Triple::ppc:
95 case llvm::Triple::ppcle:
96 case llvm::Triple::ppc64:
97 case llvm::Triple::ppc64le:
98 case llvm::Triple::riscv32:
99 case llvm::Triple::riscv64:
100 case llvm::Triple::sparc:
101 case llvm::Triple::sparcel:
102 case llvm::Triple::sparcv9:
103 case llvm::Triple::amdgcn:
104 case llvm::Triple::r600:
105 case llvm::Triple::csky:
106 case llvm::Triple::loongarch32:
107 case llvm::Triple::loongarch64:
108 case llvm::Triple::m68k:
110 default:
111 break;
112 }
113
114 if (Triple.isOSFuchsia() || Triple.isOSNetBSD()) {
116 }
117
118 if (Triple.isOSLinux() || Triple.isOSHurd()) {
119 switch (Triple.getArch()) {
120
121 case llvm::Triple::arm:
122 case llvm::Triple::armeb:
123 case llvm::Triple::thumb:
124 case llvm::Triple::thumbeb:
125 case llvm::Triple::mips64:
126 case llvm::Triple::mips64el:
127 case llvm::Triple::mips:
128 case llvm::Triple::mipsel:
129 case llvm::Triple::systemz:
130 case llvm::Triple::x86:
131 case llvm::Triple::x86_64:
133 default:
134 return true;
135 }
136 }
137
138 if (Triple.isOSWindows()) {
139 switch (Triple.getArch()) {
140 case llvm::Triple::x86:
142 case llvm::Triple::x86_64:
143 return Triple.isOSBinFormatMachO();
144 case llvm::Triple::arm:
145 case llvm::Triple::thumb:
146
147 return true;
148 default:
149
150
151 return false;
152 }
153 }
154
156 return false;
157
158 return true;
159}
160
162 if (Triple.isAArch64() || Triple.isPS() || Triple.isVE() ||
163 (Triple.isAndroid() && !Triple.isARM()))
164 return false;
165
166 return true;
167}
168
170 switch (Triple.getArch()) {
171 default:
172 return false;
173 case llvm::Triple::arm:
174 case llvm::Triple::thumb:
175
176
177 return Triple.isOSDarwin();
178 }
179}
180
181
182
184 const llvm::Triple &Triple) {
185 if (Triple.isARM() || Triple.isThumb()) {
186
187
188
189 if (Arg *A = Args.getLastArg(options::OPT_mframe_chain)) {
190 StringRef V = A->getValue();
191 return V != "none";
192 }
193 return false;
194 }
195 return false;
196}
197
198
199
201 const llvm::Triple &Triple) {
202 if (Triple.isARM() || Triple.isThumb()) {
203
204
205
206 if (Arg *A = Args.getLastArg(options::OPT_mframe_chain)) {
207 StringRef V = A->getValue();
208 return V == "aapcs+leaf";
209 }
210 return false;
211 }
212 return false;
213}
214
217 const llvm::Triple &Triple) {
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
245 bool EnableFP =
247 Args.hasFlag(clang::driver::options::OPT_fno_omit_frame_pointer,
248 clang::driver::options::OPT_fomit_frame_pointer, DefaultFP);
249
250 bool DefaultLeafFP =
253 bool EnableLeafFP = Args.hasFlag(
254 clang::driver::options::OPT_mno_omit_leaf_frame_pointer,
255 clang::driver::options::OPT_momit_leaf_frame_pointer, DefaultLeafFP);
256
258
259 if (EnableFP) {
260 if (EnableLeafFP)
263 }
264 if (FPRegReserved)
267}
268
270 const StringRef PluginOptPrefix) {
271 if (const Arg *A = Args.getLastArg(options::OPT_Rpass_EQ))
272 CmdArgs.push_back(Args.MakeArgString(Twine(PluginOptPrefix) +
273 "-pass-remarks=" + A->getValue()));
274
275 if (const Arg *A = Args.getLastArg(options::OPT_Rpass_missed_EQ))
276 CmdArgs.push_back(Args.MakeArgString(
277 Twine(PluginOptPrefix) + "-pass-remarks-missed=" + A->getValue()));
278
279 if (const Arg *A = Args.getLastArg(options::OPT_Rpass_analysis_EQ))
280 CmdArgs.push_back(Args.MakeArgString(
281 Twine(PluginOptPrefix) + "-pass-remarks-analysis=" + A->getValue()));
282}
283
285 const llvm::Triple &Triple,
288 const StringRef PluginOptPrefix) {
289 StringRef Format = "yaml";
290 if (const Arg *A = Args.getLastArg(options::OPT_fsave_optimization_record_EQ))
291 Format = A->getValue();
292
294 const Arg *A = Args.getLastArg(options::OPT_foptimization_record_file_EQ);
295 if (A)
296 F = A->getValue();
299
300 assert(!F.empty() && "Cannot determine remarks output name.");
301
302 CmdArgs.push_back(Args.MakeArgString(Twine(PluginOptPrefix) +
303 "opt-remarks-filename=" + F +
304 ".opt.ld." + Format));
305
306 if (const Arg *A =
307 Args.getLastArg(options::OPT_foptimization_record_passes_EQ))
308 CmdArgs.push_back(Args.MakeArgString(
309 Twine(PluginOptPrefix) + "opt-remarks-passes=" + A->getValue()));
310
311 CmdArgs.push_back(Args.MakeArgString(Twine(PluginOptPrefix) +
312 "opt-remarks-format=" + Format.data()));
313}
314
316 ArgStringList &CmdArgs,
317 const StringRef PluginOptPrefix) {
318 if (Args.hasFlag(options::OPT_fdiagnostics_show_hotness,
319 options::OPT_fno_diagnostics_show_hotness, false))
320 CmdArgs.push_back(Args.MakeArgString(Twine(PluginOptPrefix) +
321 "opt-remarks-with-hotness"));
322
323 if (const Arg *A =
324 Args.getLastArg(options::OPT_fdiagnostics_hotness_threshold_EQ))
325 CmdArgs.push_back(
326 Args.MakeArgString(Twine(PluginOptPrefix) +
327 "opt-remarks-hotness-threshold=" + A->getValue()));
328}
329
331 llvm::Triple T,
332 StringRef Processor) {
333
334 if (.isAMDGPU())
335 return false;
336 auto GPUKind = T.isAMDGCN() ? llvm::AMDGPU::parseArchAMDGCN(Processor)
337 : llvm::AMDGPU::parseArchR600(Processor);
338 auto GPUFeatures = T.isAMDGCN() ? llvm::AMDGPU::getArchAttrAMDGCN(GPUKind)
339 : llvm::AMDGPU::getArchAttrR600(GPUKind);
340 if (GPUFeatures & llvm::AMDGPU::FEATURE_WGP)
341 return false;
342 return TargetFeatureArg.getOption().matches(options::OPT_mno_cumode);
343}
344
347 if (D.getVFS().exists(Path))
348 Paths.push_back(Path.str());
349}
350
352 const llvm::Triple &Triple,
353 const ArgList &Args,
354 std::vector &Features,
355 OptSpecifier Group) {
356 std::set Warned;
357 for (const Arg *A : Args.filtered(Group)) {
358 StringRef Name = A->getOption().getName();
359 A->claim();
360
361
362 assert(Name.starts_with("m") && "Invalid feature name.");
363 Name = Name.substr(1);
364
367 if (Warned.count(Name) == 0) {
368 D.getDiags().Report(
369 clang::diag::warn_drv_unsupported_option_for_processor)
370 << A->getAsString(Args) << Proc;
371 Warned.insert(Name);
372 }
373 continue;
374 }
375
376 bool IsNegative = Name.consume_front("no-");
377
378 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));
379 }
380}
381
384
386 llvm::DenseSet UsedFeatures;
387 for (StringRef Feature : llvm::reverse(Features)) {
388 if (UsedFeatures.insert(Feature.drop_front()).second)
389 UnifiedFeatures.insert(UnifiedFeatures.begin(), Feature);
390 }
391
392 return UnifiedFeatures;
393}
394
396 const char *ArgName, const char *EnvVar) {
397 const char *DirList = ::getenv(EnvVar);
398 bool CombinedArg = false;
399
400 if (!DirList)
401 return;
402
403 StringRef Name(ArgName);
404 if (Name == "-I" || Name == "-L" || Name.empty())
405 CombinedArg = true;
406
407 StringRef Dirs(DirList);
408 if (Dirs.empty())
409 return;
410
411 StringRef::size_type Delim;
412 while ((Delim = Dirs.find(llvm::sys::EnvPathSeparator)) != StringRef::npos) {
413 if (Delim == 0) {
414 if (CombinedArg) {
415 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + "."));
416 } else {
417 CmdArgs.push_back(ArgName);
418 CmdArgs.push_back(".");
419 }
420 } else {
421 if (CombinedArg) {
422 CmdArgs.push_back(
423 Args.MakeArgString(std::string(ArgName) + Dirs.substr(0, Delim)));
424 } else {
425 CmdArgs.push_back(ArgName);
426 CmdArgs.push_back(Args.MakeArgString(Dirs.substr(0, Delim)));
427 }
428 }
429 Dirs = Dirs.substr(Delim + 1);
430 }
431
432 if (Dirs.empty()) {
433 if (CombinedArg) {
434 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + "."));
435 } else {
436 CmdArgs.push_back(ArgName);
437 CmdArgs.push_back(".");
438 }
439 } else {
440 if (CombinedArg) {
441 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + Dirs));
442 } else {
443 CmdArgs.push_back(ArgName);
444 CmdArgs.push_back(Args.MakeArgString(Dirs));
445 }
446 }
447}
448
450 const ArgList &Args, ArgStringList &CmdArgs,
453
454
455
456 Args.AddAllArgValues(CmdArgs, options::OPT_Zlinker_input);
457
458
459
462
463 for (const auto &II : Inputs) {
464
465
466
467 if (auto *IA = II.getAction())
470 continue;
471
473
474 D.Diag(diag::err_drv_no_linker_llvm_support) << TC.getTripleString();
475
476
477 if (II.isFilename()) {
478 CmdArgs.push_back(II.getFilename());
479 continue;
480 }
481
482
483 if (II.isNothing())
484 continue;
485
486
487 const Arg &A = II.getInputArg();
488
489
490 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx))
492 else if (A.getOption().matches(options::OPT_Z_reserved_lib_cckext))
494 else
495 A.renderAsInput(Args, CmdArgs);
496 }
497 if (const Arg *A = Args.getLastArg(options::OPT_fveclib)) {
498 const llvm::Triple &Triple = TC.getTriple();
499 StringRef V = A->getValue();
500 if (V == "ArmPL" && (Triple.isOSLinux() || Triple.isOSDarwin())) {
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518 if (Triple.isOSLinux()) {
519 CmdArgs.push_back(Args.MakeArgString("--push-state"));
520 CmdArgs.push_back(Args.MakeArgString("--as-needed"));
521 }
522 CmdArgs.push_back(Args.MakeArgString("-lm"));
523 CmdArgs.push_back(Args.MakeArgString("-lamath"));
524 CmdArgs.push_back(Args.MakeArgString("-lm"));
525 if (Triple.isOSLinux())
526 CmdArgs.push_back(Args.MakeArgString("--pop-state"));
528 }
529 }
530}
531
533 const ToolChain &TC, const llvm::opt::ArgList &Args,
534 llvm::opt::ArgStringList &CmdArgs) {
535
536
537
538
539
540 if (const Arg *A = Args.getLastArg(options::OPT_gz_EQ)) {
541 StringRef V = A->getValue();
542 if (V == "none" || V == "zlib" || V == "zstd")
543 CmdArgs.push_back(Args.MakeArgString("--compress-debug-sections=" + V));
544 else
545 TC.getDriver().Diag(diag::err_drv_unsupported_option_argument)
546 << A->getSpelling() << V;
547 }
548}
549
551 std::vector &Features,
552 OptSpecifier OnOpt, OptSpecifier OffOpt,
553 StringRef FeatureName) {
554 if (Arg *A = Args.getLastArg(OnOpt, OffOpt)) {
555 if (A->getOption().matches(OnOpt))
556 Features.push_back(Args.MakeArgString("+" + FeatureName));
557 else
558 Features.push_back(Args.MakeArgString("-" + FeatureName));
559 }
560}
561
562
564 const ArgList &Args) {
565 Arg *MArch = Args.getLastArg(options::OPT_march_EQ);
566 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
568 return llvm::StringSwitchstd::string(GPUName)
569 .Cases("rv630", "rv635", "r600")
570 .Cases("rv610", "rv620", "rs780", "rs880")
571 .Case("rv740", "rv770")
572 .Case("palm", "cedar")
573 .Cases("sumo", "sumo2", "sumo")
574 .Case("hemlock", "cypress")
575 .Case("aruba", "cayman")
576 .Default(GPUName.str());
577 }
578 if (MArch)
580 return "";
581}
582
584 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
585 return A->getValue();
586 }
587 return "";
588}
589
590
592
593 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
594 StringRef CPU = A->getValue();
595
596#ifdef __wasm__
597
598
599 if (CPU == "native")
600 return llvm::sys::getHostCPUName();
601#endif
602
603 return CPU;
604 }
605
606 return "generic";
607}
608
610 const llvm::Triple &T, bool FromAs) {
611 Arg *A;
612
613 switch (T.getArch()) {
614 default:
615 return "";
616
617 case llvm::Triple::aarch64:
618 case llvm::Triple::aarch64_32:
619 case llvm::Triple::aarch64_be:
621
622 case llvm::Triple::arm:
623 case llvm::Triple::armeb:
624 case llvm::Triple::thumb:
625 case llvm::Triple::thumbeb: {
626 StringRef MArch, MCPU;
629 }
630
631 case llvm::Triple::avr:
632 if (const Arg *A = Args.getLastArg(options::OPT_mmcu_EQ))
633 return A->getValue();
634 return "";
635
636 case llvm::Triple::m68k:
638
639 case llvm::Triple::mips:
640 case llvm::Triple::mipsel:
641 case llvm::Triple::mips64:
642 case llvm::Triple::mips64el: {
643 StringRef CPUName;
644 StringRef ABIName;
646 return std::string(CPUName);
647 }
648
649 case llvm::Triple::nvptx:
650 case llvm::Triple::nvptx64:
651 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
652 return A->getValue();
653 return "";
654
655 case llvm::Triple::ppc:
656 case llvm::Triple::ppcle:
657 case llvm::Triple::ppc64:
658 case llvm::Triple::ppc64le:
659 if (Arg *A = Args.getLastArg(clang::driver::options::OPT_mcpu_EQ))
660 return std::string(
661 llvm::PPC::getNormalizedPPCTargetCPU(T, A->getValue()));
662 return std::string(llvm::PPC::getNormalizedPPCTargetCPU(T));
663
664 case llvm::Triple::csky:
665 if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
666 return A->getValue();
667 else if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
668 return A->getValue();
669 else
670 return "ck810";
671 case llvm::Triple::riscv32:
672 case llvm::Triple::riscv64:
674
675 case llvm::Triple::bpfel:
676 case llvm::Triple::bpfeb:
677 if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
678 return A->getValue();
679 return "";
680
681 case llvm::Triple::sparc:
682 case llvm::Triple::sparcel:
683 case llvm::Triple::sparcv9:
685
686 case llvm::Triple::x86:
687 case llvm::Triple::x86_64:
689
690 case llvm::Triple::hexagon:
691 return "hexagon" +
693
694 case llvm::Triple::lanai:
696
697 case llvm::Triple::systemz:
699
700 case llvm::Triple::r600:
701 case llvm::Triple::amdgcn:
703
704 case llvm::Triple::wasm32:
705 case llvm::Triple::wasm64:
707
708 case llvm::Triple::loongarch32:
709 case llvm::Triple::loongarch64:
711
712 case llvm::Triple::xtensa:
713 if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
714 return A->getValue();
715 return "";
716 }
717}
718
720 const llvm::Triple &Triple,
721 const ArgList &Args,
722 std::vector &Features) {
724 options::OPT_m_wasm_Features_Group);
725}
726
728 const ArgList &Args, ArgStringList &CmdArgs,
729 bool ForAS, bool IsAux) {
730 std::vector Features;
731 switch (Triple.getArch()) {
732 default:
733 break;
734 case llvm::Triple::mips:
735 case llvm::Triple::mipsel:
736 case llvm::Triple::mips64:
737 case llvm::Triple::mips64el:
739 break;
740 case llvm::Triple::arm:
741 case llvm::Triple::armeb:
742 case llvm::Triple::thumb:
743 case llvm::Triple::thumbeb:
745 break;
746 case llvm::Triple::ppc:
747 case llvm::Triple::ppcle:
748 case llvm::Triple::ppc64:
749 case llvm::Triple::ppc64le:
751 break;
752 case llvm::Triple::riscv32:
753 case llvm::Triple::riscv64:
755 break;
756 case llvm::Triple::systemz:
758 break;
759 case llvm::Triple::aarch64:
760 case llvm::Triple::aarch64_32:
761 case llvm::Triple::aarch64_be:
763 break;
764 case llvm::Triple::x86:
765 case llvm::Triple::x86_64:
767 break;
768 case llvm::Triple::hexagon:
770 break;
771 case llvm::Triple::wasm32:
772 case llvm::Triple::wasm64:
774 break;
775 case llvm::Triple::sparc:
776 case llvm::Triple::sparcel:
777 case llvm::Triple::sparcv9:
779 break;
780 case llvm::Triple::r600:
781 case llvm::Triple::amdgcn:
783 break;
784 case llvm::Triple::nvptx:
785 case llvm::Triple::nvptx64:
787 break;
788 case llvm::Triple::m68k:
790 break;
791 case llvm::Triple::msp430:
793 break;
794 case llvm::Triple::ve:
796 break;
797 case llvm::Triple::csky:
799 break;
800 case llvm::Triple::loongarch32:
801 case llvm::Triple::loongarch64:
803 break;
804 }
805
807 CmdArgs.push_back(IsAux ? "-aux-target-feature" : "-target-feature");
808 CmdArgs.push_back(Feature.data());
809 }
810}
811
813 Arg *LtoJobsArg = Args.getLastArg(options::OPT_flto_jobs_EQ);
814 if (!LtoJobsArg)
815 return {};
816 if (!llvm::get_threadpool_strategy(LtoJobsArg->getValue()))
817 D.Diag(diag::err_drv_invalid_int_value)
818 << LtoJobsArg->getAsString(Args) << LtoJobsArg->getValue();
819 return LtoJobsArg->getValue();
820}
821
822
824 return Triple.isPS();
825}
826
828 const llvm::opt::ArgList &Args) {
830 Arg *A = Args.getLastArg(options::OPT_mtls_dialect_EQ);
831 if (!A)
832 return Triple.hasDefaultTLSDESC();
833 StringRef V = A->getValue();
834 bool SupportedArgument = false, EnableTLSDESC = false;
835 bool Unsupported = !Triple.isOSBinFormatELF();
836 if (Triple.isLoongArch() || Triple.isRISCV()) {
837 SupportedArgument = V == "desc" || V == "trad";
838 EnableTLSDESC = V == "desc";
839 } else if (Triple.isX86()) {
840 SupportedArgument = V == "gnu" || V == "gnu2";
841 EnableTLSDESC = V == "gnu2";
842 } else {
843 Unsupported = true;
844 }
845 if (Unsupported) {
846 TC.getDriver().Diag(diag::err_drv_unsupported_opt_for_target)
847 << A->getSpelling() << Triple.getTriple();
848 } else if (!SupportedArgument) {
849 TC.getDriver().Diag(diag::err_drv_unsupported_option_argument_for_target)
850 << A->getSpelling() << V << Triple.getTriple();
851 }
852 return EnableTLSDESC;
853}
854
856 ArgStringList &CmdArgs, const InputInfo &Output,
857 const InputInfo &Input, bool IsThinLTO) {
859 const bool IsOSAIX = Triple.isOSAIX();
860 const bool IsAMDGCN = Triple.isAMDGCN();
863 const bool IsFatLTO = Args.hasArg(options::OPT_ffat_lto_objects);
864 const bool IsUnifiedLTO = Args.hasArg(options::OPT_funified_lto);
865 if (llvm::sys::path::filename(Linker) != "ld.lld" &&
866 llvm::sys::path::stem(Linker) != "ld.lld" && !Triple.isOSOpenBSD()) {
867
868
869
870 const char *PluginPrefix = IsOSAIX ? "-bplugin:" : "";
871 const char *PluginName = IsOSAIX ? "/libLTO" : "/LLVMgold";
872
873 if (!IsOSAIX)
874 CmdArgs.push_back("-plugin");
875
876#if defined(_WIN32)
877 const char *Suffix = ".dll";
878#elif defined(__APPLE__)
879 const char *Suffix = ".dylib";
880#else
881 const char *Suffix = ".so";
882#endif
883
885 llvm::sys::path::native(Twine(D.Dir) +
886 "/../" CLANG_INSTALL_LIBDIR_BASENAME +
887 PluginName + Suffix,
888 Plugin);
889 CmdArgs.push_back(Args.MakeArgString(Twine(PluginPrefix) + Plugin));
890 } else {
891
892
893 if (IsFatLTO)
894 CmdArgs.push_back("--fat-lto-objects");
895 }
896
897 const char *PluginOptPrefix = IsOSAIX ? "-bplugin_opt:" : "-plugin-opt=";
898 const char *ExtraDash = IsOSAIX ? "-" : "";
899 const char *ParallelismOpt = IsOSAIX ? "-threads=" : "jobs=";
900
901
902
903
904 if (Args.hasArg(options::OPT_gdwarf_aranges)) {
905 CmdArgs.push_back(Args.MakeArgString(Twine(PluginOptPrefix) +
906 "-generate-arange-section"));
907 }
908
909
910 Arg *ArgVecLib = Args.getLastArg(options::OPT_fveclib);
911 if (ArgVecLib && ArgVecLib->getNumValues() == 1) {
912
913
914 std::optional OptVal =
915 llvm::StringSwitch<std::optional>(ArgVecLib->getValue())
916 .Case("Accelerate", "Accelerate")
917 .Case("LIBMVEC", "LIBMVEC-X86")
918 .Case("MASSV", "MASSV")
919 .Case("SVML", "SVML")
920 .Case("SLEEF", "sleefgnuabi")
921 .Case("Darwin_libsystem_m", "Darwin_libsystem_m")
922 .Case("ArmPL", "ArmPL")
923 .Case("none", "none")
924 .Default(std::nullopt);
925
926 if (OptVal)
927 CmdArgs.push_back(Args.MakeArgString(
928 Twine(PluginOptPrefix) + "-vector-library=" + OptVal.value()));
929 }
930
931
932
933
934
935 std::string CPU = getCPUName(D, Args, Triple);
936 if (!CPU.empty())
937 CmdArgs.push_back(
938 Args.MakeArgString(Twine(PluginOptPrefix) + ExtraDash + "mcpu=" + CPU));
939
940 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
941
942
943 StringRef OOpt;
944 if (A->getOption().matches(options::OPT_O4) ||
945 A->getOption().matches(options::OPT_Ofast))
946 OOpt = "3";
947 else if (A->getOption().matches(options::OPT_O)) {
948 OOpt = A->getValue();
949 if (OOpt == "g")
950 OOpt = "1";
951 else if (OOpt == "s" || OOpt == "z")
952 OOpt = "2";
953 } else if (A->getOption().matches(options::OPT_O0))
954 OOpt = "0";
955 if (!OOpt.empty()) {
956 CmdArgs.push_back(
957 Args.MakeArgString(Twine(PluginOptPrefix) + ExtraDash + "O" + OOpt));
958 if (IsAMDGCN)
959 CmdArgs.push_back(Args.MakeArgString(Twine("--lto-CGO") + OOpt));
960 }
961 }
962
963 if (Args.hasArg(options::OPT_gsplit_dwarf))
964 CmdArgs.push_back(Args.MakeArgString(
965 Twine(PluginOptPrefix) + "dwo_dir=" + Output.getFilename() + "_dwo"));
966
967 if (IsThinLTO && !IsOSAIX)
968 CmdArgs.push_back(Args.MakeArgString(Twine(PluginOptPrefix) + "thinlto"));
969 else if (IsThinLTO && IsOSAIX)
970 CmdArgs.push_back(Args.MakeArgString(Twine("-bdbg:thinlto")));
971
972
973
974
975 if ((IsThinLTO || IsFatLTO || IsUnifiedLTO) &&
976 Args.hasArg(options::OPT_fenable_matrix))
977 CmdArgs.push_back(
978 Args.MakeArgString(Twine(PluginOptPrefix) + "-enable-matrix"));
979
981 if (!Parallelism.empty())
982 CmdArgs.push_back(Args.MakeArgString(Twine(PluginOptPrefix) +
983 ParallelismOpt + Parallelism));
984
985
986 if (Arg *A = Args.getLastArg(options::OPT_fglobal_isel,
987 options::OPT_fno_global_isel)) {
988
989
990 CmdArgs.push_back(Args.MakeArgString(
991 Twine(PluginOptPrefix) + "-global-isel=" +
992 (A->getOption().matches(options::OPT_fglobal_isel) ? "1" : "0")));
993 }
994
995
996 if (Arg *A =
997 Args.getLastArg(options::OPT_gTune_Group, options::OPT_ggdbN_Group)) {
998 if (A->getOption().matches(options::OPT_glldb))
999 CmdArgs.push_back(
1000 Args.MakeArgString(Twine(PluginOptPrefix) + "-debugger-tune=lldb"));
1001 else if (A->getOption().matches(options::OPT_gsce))
1002 CmdArgs.push_back(
1003 Args.MakeArgString(Twine(PluginOptPrefix) + "-debugger-tune=sce"));
1004 else if (A->getOption().matches(options::OPT_gdbx))
1005 CmdArgs.push_back(
1006 Args.MakeArgString(Twine(PluginOptPrefix) + "-debugger-tune=dbx"));
1007 else
1008 CmdArgs.push_back(
1009 Args.MakeArgString(Twine(PluginOptPrefix) + "-debugger-tune=gdb"));
1010 }
1011
1012 if (IsOSAIX) {
1014 CmdArgs.push_back(
1015 Args.MakeArgString(Twine(PluginOptPrefix) + "-no-integrated-as=1"));
1016
1017
1018
1019 Arg *A = Args.getLastArg(options::OPT_g_Group);
1020 bool EnableDebugInfo = A && !A->getOption().matches(options::OPT_g0) &&
1021 !A->getOption().matches(options::OPT_ggdb0);
1022 if (EnableDebugInfo && Args.hasFlag(options::OPT_gstrict_dwarf,
1023 options::OPT_gno_strict_dwarf, true))
1024 CmdArgs.push_back(
1025 Args.MakeArgString(Twine(PluginOptPrefix) + "-strict-dwarf=true"));
1026
1027 for (const Arg *A : Args.filtered_reverse(options::OPT_mabi_EQ)) {
1028 StringRef V = A->getValue();
1029 if (V == "vec-default")
1030 break;
1031 if (V == "vec-extabi") {
1032 CmdArgs.push_back(
1033 Args.MakeArgString(Twine(PluginOptPrefix) + "-vec-extabi"));
1034 break;
1035 }
1036 }
1037 }
1038
1039 bool UseSeparateSections =
1041
1042 if (Args.hasFlag(options::OPT_ffunction_sections,
1043 options::OPT_fno_function_sections, UseSeparateSections))
1044 CmdArgs.push_back(
1045 Args.MakeArgString(Twine(PluginOptPrefix) + "-function-sections=1"));
1046 else if (Args.hasArg(options::OPT_fno_function_sections))
1047 CmdArgs.push_back(
1048 Args.MakeArgString(Twine(PluginOptPrefix) + "-function-sections=0"));
1049
1050 bool DataSectionsTurnedOff = false;
1051 if (Args.hasFlag(options::OPT_fdata_sections, options::OPT_fno_data_sections,
1052 UseSeparateSections)) {
1053 CmdArgs.push_back(
1054 Args.MakeArgString(Twine(PluginOptPrefix) + "-data-sections=1"));
1055 } else if (Args.hasArg(options::OPT_fno_data_sections)) {
1056 DataSectionsTurnedOff = true;
1057 CmdArgs.push_back(
1058 Args.MakeArgString(Twine(PluginOptPrefix) + "-data-sections=0"));
1059 }
1060
1061 if (Args.hasArg(options::OPT_mxcoff_roptr) ||
1062 Args.hasArg(options::OPT_mno_xcoff_roptr)) {
1063 bool HasRoptr = Args.hasFlag(options::OPT_mxcoff_roptr,
1064 options::OPT_mno_xcoff_roptr, false);
1065 StringRef OptStr = HasRoptr ? "-mxcoff-roptr" : "-mno-xcoff-roptr";
1066 if (!IsOSAIX)
1067 D.Diag(diag::err_drv_unsupported_opt_for_target)
1068 << OptStr << Triple.str();
1069
1070 if (HasRoptr) {
1071
1072
1073
1074 if (DataSectionsTurnedOff)
1075 D.Diag(diag::err_roptr_requires_data_sections);
1076
1077 CmdArgs.push_back(
1078 Args.MakeArgString(Twine(PluginOptPrefix) + "-mxcoff-roptr"));
1079 }
1080 }
1081
1082
1083 if (auto *A = Args.getLastArg(options::OPT_fsplit_machine_functions,
1084 options::OPT_fno_split_machine_functions)) {
1085 if (A->getOption().matches(options::OPT_fsplit_machine_functions))
1086 CmdArgs.push_back(Args.MakeArgString(Twine(PluginOptPrefix) +
1087 "-split-machine-functions"));
1088 }
1089
1091 StringRef FName = A->getValue();
1092 if (!llvm::sys::fs::exists(FName))
1093 D.Diag(diag::err_drv_no_such_file) << FName;
1094 else
1095 CmdArgs.push_back(Args.MakeArgString(Twine(PluginOptPrefix) +
1096 "sample-profile=" + FName));
1097 }
1098
1100 CmdArgs.push_back(Args.MakeArgString(Twine(PluginOptPrefix) + ExtraDash +
1101 "cs-profile-generate"));
1102 if (CSPGOGenerateArg->getOption().matches(
1103 options::OPT_fcs_profile_generate_EQ)) {
1105 llvm::sys::path::append(Path, "default_%m.profraw");
1106 CmdArgs.push_back(Args.MakeArgString(Twine(PluginOptPrefix) + ExtraDash +
1107 "cs-profile-path=" + Path));
1108 } else
1109 CmdArgs.push_back(
1110 Args.MakeArgString(Twine(PluginOptPrefix) + ExtraDash +
1111 "cs-profile-path=default_%m.profraw"));
1114 ProfileUseArg->getNumValues() == 0 ? "" : ProfileUseArg->getValue());
1115 if (Path.empty() || llvm::sys::fs::is_directory(Path))
1116 llvm::sys::path::append(Path, "default.profdata");
1117 CmdArgs.push_back(Args.MakeArgString(Twine(PluginOptPrefix) + ExtraDash +
1118 "cs-profile-path=" + Path));
1119 }
1120
1121
1122 if (Args.hasFlag(options::OPT_fjmc, options::OPT_fno_jmc, false)) {
1124 CmdArgs.push_back(Args.MakeArgString(Twine(PluginOptPrefix) +
1125 "-enable-jmc-instrument"));
1126 else
1127 D.Diag(clang::diag::warn_drv_fjmc_for_elf_only);
1128 }
1129
1130 if (Args.hasFlag(options::OPT_femulated_tls, options::OPT_fno_emulated_tls,
1131 Triple.hasDefaultEmulatedTLS())) {
1132 CmdArgs.push_back(
1133 Args.MakeArgString(Twine(PluginOptPrefix) + "-emulated-tls"));
1134 }
1136 CmdArgs.push_back(
1137 Args.MakeArgString(Twine(PluginOptPrefix) + "-enable-tlsdesc"));
1138
1139 if (Args.hasFlag(options::OPT_fstack_size_section,
1140 options::OPT_fno_stack_size_section, false))
1141 CmdArgs.push_back(
1142 Args.MakeArgString(Twine(PluginOptPrefix) + "-stack-size-section"));
1143
1144
1146 if (!StatsFile.empty())
1147 CmdArgs.push_back(
1148 Args.MakeArgString(Twine(PluginOptPrefix) + "stats-file=" + StatsFile));
1149
1150
1151 if (Arg *A = Args.getLastArg(options::OPT_fcrash_diagnostics_dir))
1152 CmdArgs.push_back(Args.MakeArgString(
1153 Twine(PluginOptPrefix) + "-crash-diagnostics-dir=" + A->getValue()));
1154
1156
1157
1159
1160
1161
1164 Output, PluginOptPrefix);
1165
1166
1168
1170 true, PluginOptPrefix);
1171
1172 bool IsELF = Triple.isOSBinFormatELF();
1173 bool Crel = false;
1174 bool ImplicitMapSyms = false;
1175 for (const Arg *A : Args.filtered(options::OPT_Wa_COMMA)) {
1176 for (StringRef V : A->getValues()) {
1177 auto Equal = V.split('=');
1178 auto checkArg = [&](bool ValidTarget,
1179 std::initializer_list<const char *> Set) {
1180 if (!ValidTarget) {
1181 D.Diag(diag::err_drv_unsupported_opt_for_target)
1182 << (Twine("-Wa,") + Equal.first + "=").str()
1183 << Triple.getTriple();
1184 } else if (!llvm::is_contained(Set, Equal.second)) {
1185 D.Diag(diag::err_drv_unsupported_option_argument)
1186 << (Twine("-Wa,") + Equal.first + "=").str() << Equal.second;
1187 }
1188 };
1189 if (Equal.first == "-mmapsyms") {
1190 ImplicitMapSyms = Equal.second == "implicit";
1191 checkArg(IsELF && Triple.isAArch64(), {"default", "implicit"});
1192 } else if (V == "--crel")
1193 Crel = true;
1194 else if (V == "--no-crel")
1195 Crel = false;
1196 else
1197 continue;
1198 A->claim();
1199 }
1200 }
1201 if (Crel) {
1202 if (IsELF && !Triple.isMIPS()) {
1203 CmdArgs.push_back(Args.MakeArgString(Twine(PluginOptPrefix) + "-crel"));
1204 } else {
1205 D.Diag(diag::err_drv_unsupported_opt_for_target)
1206 << "-Wa,--crel" << D.getTargetTriple();
1207 }
1208 }
1209 if (ImplicitMapSyms)
1210 CmdArgs.push_back(
1211 Args.MakeArgString(Twine(PluginOptPrefix) + "-implicit-mapsyms"));
1212
1213 if (Args.hasArg(options::OPT_ftime_report))
1214 CmdArgs.push_back(
1215 Args.MakeArgString(Twine(PluginOptPrefix) + "-time-passes"));
1216}
1217
1219 const ArgList &Args,
1220 ArgStringList &CmdArgs) {
1221
1222
1224 llvm::sys::path::parent_path(TC.getDriver().Dir);
1225 llvm::sys::path::append(DefaultLibPath, CLANG_INSTALL_LIBDIR_BASENAME);
1226 CmdArgs.push_back(Args.MakeArgString("-L" + DefaultLibPath));
1227}
1228
1230 ArgStringList &CmdArgs) {
1231 if (!Args.hasFlag(options::OPT_frtlib_add_rpath,
1232 options::OPT_fno_rtlib_add_rpath, false))
1233 return;
1234
1236 if (const auto CandidateRPath = TC.getStdlibPath())
1237 CandidateRPaths.emplace_back(*CandidateRPath);
1238
1239 for (const auto &CandidateRPath : CandidateRPaths) {
1240 if (TC.getVFS().exists(CandidateRPath)) {
1241 CmdArgs.push_back("-rpath");
1242 CmdArgs.push_back(Args.MakeArgString(CandidateRPath));
1243 }
1244 }
1245}
1246
1248 const ToolChain &TC, const ArgList &Args,
1249 bool ForceStaticHostRuntime, bool IsOffloadingHost,
1250 bool GompNeedsRT) {
1251 if (!Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
1252 options::OPT_fno_openmp, false)) {
1253
1254 if (Args.hasFlag(options::OPT_foffload_via_llvm,
1255 options::OPT_fno_offload_via_llvm, false))
1256 CmdArgs.push_back("-lomptarget");
1257 return false;
1258 }
1259
1261
1263
1264 return false;
1265
1266 if (ForceStaticHostRuntime)
1267 CmdArgs.push_back("-Bstatic");
1268
1269 switch (RTKind) {
1271 CmdArgs.push_back("-lomp");
1272 break;
1274 CmdArgs.push_back("-lgomp");
1275 break;
1277 CmdArgs.push_back("-liomp5");
1278 break;
1280 break;
1281 }
1282
1283 if (ForceStaticHostRuntime)
1284 CmdArgs.push_back("-Bdynamic");
1285
1287 CmdArgs.push_back("-lrt");
1288
1289 if (IsOffloadingHost)
1290 CmdArgs.push_back("-lomptarget");
1291
1292 if (IsOffloadingHost && !Args.hasArg(options::OPT_nogpulib))
1293 CmdArgs.push_back("-lomptarget.devicertl");
1294
1296
1298
1299 return true;
1300}
1301
1304 const llvm::opt::ArgList &Args,
1305 llvm::opt::ArgStringList &CmdArgs) {
1307 return;
1308
1309
1310
1311 constexpr llvm::StringLiteral Targets("-fopenmp-targets=");
1312
1315 std::transform(TCRange.first, TCRange.second, std::back_inserter(Triples),
1316 [](auto TC) { return TC.second->getTripleString(); });
1317 CmdArgs.push_back(
1318 Args.MakeArgString(Twine(Targets) + llvm::join(Triples, ",")));
1319}
1320
1321
1323 llvm::opt::ArgStringList &CmdArgs) {
1324
1325
1326
1327
1328 if (!TC.getTriple().isKnownWindowsMSVCEnvironment()) {
1330 F128LibName.consume_front_insensitive("lib");
1331 if (!F128LibName.empty()) {
1332 bool AsNeeded = !TC.getTriple().isOSAIX();
1333 CmdArgs.push_back("-lFortranFloat128Math");
1334 if (AsNeeded)
1336 CmdArgs.push_back(Args.MakeArgString("-l" + F128LibName));
1337 if (AsNeeded)
1339 }
1340 CmdArgs.push_back("-lFortranRuntime");
1341 CmdArgs.push_back("-lFortranDecimal");
1343 }
1344
1345
1346 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,
1347 options::OPT_fno_openmp, false)) {
1352 CmdArgs.push_back("-latomic");
1353 }
1354}
1355
1357 const llvm::opt::ArgList &Args,
1358 ArgStringList &CmdArgs) {
1359
1360
1361
1362
1364 llvm::sys::path::parent_path(TC.getDriver().Dir);
1365 llvm::sys::path::append(DefaultLibPath, "lib");
1366 if (TC.getTriple().isKnownWindowsMSVCEnvironment())
1367 CmdArgs.push_back(Args.MakeArgString("-libpath:" + DefaultLibPath));
1368 else
1369 CmdArgs.push_back(Args.MakeArgString("-L" + DefaultLibPath));
1370}
1371
1373 ArgStringList &CmdArgs, StringRef Sanitizer,
1374 bool IsShared, bool IsWhole) {
1375
1376
1377 if (IsWhole) CmdArgs.push_back("--whole-archive");
1380 if (IsWhole) CmdArgs.push_back("--no-whole-archive");
1381
1382 if (IsShared) {
1384 }
1385}
1386
1387
1388
1390 ArgStringList &CmdArgs,
1391 StringRef Sanitizer) {
1393
1394
1395
1396 if (TC.getTriple().isOSSolaris() && !LinkerIsGnuLd)
1397 return true;
1399 if (llvm::sys::fs::exists(SanRT + ".syms")) {
1400 CmdArgs.push_back(Args.MakeArgString("--dynamic-list=" + SanRT + ".syms"));
1401 return true;
1402 }
1403 return false;
1404}
1405
1407 const llvm::opt::ArgList &Args,
1408 llvm::opt::ArgStringList &CmdArgs,
1409 bool as_needed) {
1410 assert(!TC.getTriple().isOSAIX() &&
1411 "AIX linker does not support any form of --as-needed option yet.");
1413
1414
1415
1416
1417
1418
1419 if (TC.getTriple().isOSSolaris() && !LinkerIsGnuLd) {
1420 CmdArgs.push_back("-z");
1421 CmdArgs.push_back(as_needed ? "ignore" : "record");
1422 } else {
1423 CmdArgs.push_back(as_needed ? "--as-needed" : "--no-as-needed");
1424 }
1425}
1426
1428 const llvm::opt::ArgList &Args,
1429 ArgStringList &CmdArgs) {
1430
1431
1433
1434 if (TC.getTriple().getOS() != llvm::Triple::RTEMS &&
1436 CmdArgs.push_back("-lpthread");
1437 if (!TC.getTriple().isOSOpenBSD())
1438 CmdArgs.push_back("-lrt");
1439 }
1440 CmdArgs.push_back("-lm");
1441
1442 if (!TC.getTriple().isOSFreeBSD() && !TC.getTriple().isOSNetBSD() &&
1443 !TC.getTriple().isOSOpenBSD() &&
1444 TC.getTriple().getOS() != llvm::Triple::RTEMS)
1445 CmdArgs.push_back("-ldl");
1446
1447 if (TC.getTriple().isOSFreeBSD() ||
1450 CmdArgs.push_back("-lexecinfo");
1451
1452
1453
1456 CmdArgs.push_back("-lresolv");
1457}
1458
1459static void
1466 assert(!TC.getTriple().isOSDarwin() && "it's not used by Darwin");
1468
1471 SharedRuntimes.push_back("asan");
1472 if (!Args.hasArg(options::OPT_shared) && !TC.getTriple().isAndroid())
1473 HelperStaticRuntimes.push_back("asan-preinit");
1474 }
1476 SharedRuntimes.push_back("memprof");
1477 if (!Args.hasArg(options::OPT_shared) && !TC.getTriple().isAndroid())
1478 HelperStaticRuntimes.push_back("memprof-preinit");
1479 }
1481 SharedRuntimes.push_back("nsan");
1484 SharedRuntimes.push_back("ubsan_minimal");
1485 else
1486 SharedRuntimes.push_back("ubsan_standalone");
1487 }
1489 SharedRuntimes.push_back("scudo_standalone");
1490 }
1492 SharedRuntimes.push_back("tsan");
1494 SharedRuntimes.push_back("tysan");
1497 SharedRuntimes.push_back("hwasan_aliases");
1498 else
1499 SharedRuntimes.push_back("hwasan");
1500 if (!Args.hasArg(options::OPT_shared))
1501 HelperStaticRuntimes.push_back("hwasan-preinit");
1502 }
1504 SharedRuntimes.push_back("rtsan");
1505 }
1506
1507
1509 StaticRuntimes.push_back("stats_client");
1510
1511
1513 HelperStaticRuntimes.push_back("asan_static");
1514
1515
1516 if (Args.hasArg(options::OPT_shared)) {
1517
1518 return;
1519 }
1520
1521
1522
1523
1525 StaticRuntimes.push_back("asan");
1527 StaticRuntimes.push_back("asan_cxx");
1528 }
1529
1532 StaticRuntimes.push_back("rtsan");
1533
1535 StaticRuntimes.push_back("memprof");
1537 StaticRuntimes.push_back("memprof_cxx");
1538 }
1539
1542 StaticRuntimes.push_back("hwasan_aliases");
1544 StaticRuntimes.push_back("hwasan_aliases_cxx");
1545 } else {
1546 StaticRuntimes.push_back("hwasan");
1548 StaticRuntimes.push_back("hwasan_cxx");
1549 }
1550 }
1552 StaticRuntimes.push_back("dfsan");
1554 StaticRuntimes.push_back("lsan");
1556 StaticRuntimes.push_back("msan");
1558 StaticRuntimes.push_back("msan_cxx");
1559 }
1561 StaticRuntimes.push_back("nsan");
1563 StaticRuntimes.push_back("tsan");
1565 StaticRuntimes.push_back("tsan_cxx");
1566 }
1568 StaticRuntimes.push_back("tysan");
1571 StaticRuntimes.push_back("ubsan_minimal");
1572 } else {
1573 StaticRuntimes.push_back("ubsan_standalone");
1574 }
1575 }
1577 NonWholeStaticRuntimes.push_back("safestack");
1578 RequiredSymbols.push_back("__safestack_init");
1579 }
1582 StaticRuntimes.push_back("cfi");
1584 StaticRuntimes.push_back("cfi_diag");
1585 }
1589 StaticRuntimes.push_back("ubsan_standalone_cxx");
1590 }
1592 NonWholeStaticRuntimes.push_back("stats");
1593 RequiredSymbols.push_back("__sanitizer_stats_register");
1594 }
1596 StaticRuntimes.push_back("scudo_standalone");
1598 StaticRuntimes.push_back("scudo_standalone_cxx");
1599 }
1600}
1601
1602
1603
1605 ArgStringList &CmdArgs) {
1608 NonWholeStaticRuntimes, HelperStaticRuntimes, RequiredSymbols;
1611 NonWholeStaticRuntimes, HelperStaticRuntimes,
1612 RequiredSymbols);
1613 }
1614
1615
1616 for (auto S : RequiredSymbols) {
1617 CmdArgs.push_back("-u");
1618 CmdArgs.push_back(Args.MakeArgString(S));
1619 }
1620
1621
1623 !Args.hasArg(options::OPT_shared)) {
1624
1628 true);
1629 if (!Args.hasArg(clang::driver::options::OPT_nostdlibxx)) {
1630 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
1631 !Args.hasArg(options::OPT_static);
1632 if (OnlyLibstdcxxStatic)
1633 CmdArgs.push_back("-Bstatic");
1635 if (OnlyLibstdcxxStatic)
1636 CmdArgs.push_back("-Bdynamic");
1637 }
1638 }
1639
1640 for (auto RT : SharedRuntimes)
1642 for (auto RT : HelperStaticRuntimes)
1644 bool AddExportDynamic = false;
1645 for (auto RT : StaticRuntimes) {
1648 }
1649 for (auto RT : NonWholeStaticRuntimes) {
1652 }
1653
1654
1655 if (AddExportDynamic)
1656 CmdArgs.push_back("--export-dynamic");
1657
1659 CmdArgs.push_back("--export-dynamic-symbol=__cfi_check");
1660
1662 if (!TC.getTriple().isAndroid()) {
1663 TC.getDriver().Diag(diag::err_drv_unsupported_opt_for_target)
1664 << "-fsanitize=memtag*" << TC.getTriple().str();
1665 }
1666 CmdArgs.push_back(
1667 Args.MakeArgString("--android-memtag-mode=" + SanArgs.getMemtagMode()));
1669 CmdArgs.push_back("--android-memtag-heap");
1671 CmdArgs.push_back("--android-memtag-stack");
1672 }
1673
1674 return !StaticRuntimes.empty() || !NonWholeStaticRuntimes.empty();
1675}
1676
1678 if (Args.hasArg(options::OPT_shared)) {
1680 CmdArgs.push_back("--whole-archive");
1682 CmdArgs.push_back("--no-whole-archive");
1683 return true;
1684 }
1686 CmdArgs.push_back("--whole-archive");
1690 CmdArgs.push_back("--no-whole-archive");
1691 return true;
1692 }
1693
1694 return false;
1695}
1696
1698 const llvm::opt::ArgList &Args,
1699 ArgStringList &CmdArgs) {
1701 CmdArgs.push_back("-lpthread");
1702 if (!TC.getTriple().isOSOpenBSD())
1703 CmdArgs.push_back("-lrt");
1704 CmdArgs.push_back("-lm");
1705
1706 if (!TC.getTriple().isOSFreeBSD() &&
1709 CmdArgs.push_back("-ldl");
1710}
1711
1713
1714 if (Arg *A = Args.getLastArg(options::OPT_O_Group))
1715 return !A->getOption().matches(options::OPT_O0);
1716
1717 return false;
1718}
1719
1723 auto AddPostfix = [JA](auto &F) {
1726 F += ".dwo";
1727 };
1728 if (Arg *A = Args.getLastArg(options::OPT_gsplit_dwarf_EQ))
1729 if (StringRef(A->getValue()) == "single" && Output.isFilename())
1730 return Args.MakeArgString(Output.getFilename());
1731
1733 if (const Arg *A = Args.getLastArg(options::OPT_dumpdir)) {
1734 T = A->getValue();
1735 } else {
1736 Arg *FinalOutput = Args.getLastArg(options::OPT_o, options::OPT__SLASH_o);
1737 if (FinalOutput && Args.hasArg(options::OPT_c)) {
1738 T = FinalOutput->getValue();
1739 llvm::sys::path::remove_filename(T);
1740 llvm::sys::path::append(T,
1741 llvm::sys::path::stem(FinalOutput->getValue()));
1742 AddPostfix(T);
1743 return Args.MakeArgString(T);
1744 }
1745 }
1746
1747 T += llvm::sys::path::stem(Input.getBaseInput());
1748 AddPostfix(T);
1749 return Args.MakeArgString(T);
1750}
1751
1753 const JobAction &JA, const ArgList &Args,
1754 const InputInfo &Output, const char *OutFile) {
1755 ArgStringList ExtractArgs;
1756 ExtractArgs.push_back("--extract-dwo");
1757
1758 ArgStringList StripArgs;
1759 StripArgs.push_back("--strip-dwo");
1760
1761
1762 StripArgs.push_back(Output.getFilename());
1763 ExtractArgs.push_back(Output.getFilename());
1764 ExtractArgs.push_back(OutFile);
1765
1766 const char *Exec =
1767 Args.MakeArgString(TC.GetProgramPath(CLANG_DEFAULT_OBJCOPY));
1769
1770
1771 C.addCommand(std::make_unique(JA, T,
1773 Exec, ExtractArgs, II, Output));
1774
1775
1776 C.addCommand(std::make_unique(
1778}
1779
1780
1781
1782
1784
1785
1786 Args.ClaimAllArgs(options::OPT_flto_EQ);
1787 Args.ClaimAllArgs(options::OPT_flto);
1788 Args.ClaimAllArgs(options::OPT_fno_lto);
1789}
1790
1792 auto *CSPGOGenerateArg = Args.getLastArg(options::OPT_fcs_profile_generate,
1793 options::OPT_fcs_profile_generate_EQ,
1794 options::OPT_fno_profile_generate);
1795 if (CSPGOGenerateArg &&
1796 CSPGOGenerateArg->getOption().matches(options::OPT_fno_profile_generate))
1797 CSPGOGenerateArg = nullptr;
1798
1799 return CSPGOGenerateArg;
1800}
1801
1803 auto *ProfileUseArg = Args.getLastArg(
1804 options::OPT_fprofile_instr_use, options::OPT_fprofile_instr_use_EQ,
1805 options::OPT_fprofile_use, options::OPT_fprofile_use_EQ,
1806 options::OPT_fno_profile_instr_use);
1807
1808 if (ProfileUseArg &&
1809 ProfileUseArg->getOption().matches(options::OPT_fno_profile_instr_use))
1810 ProfileUseArg = nullptr;
1811
1812 return ProfileUseArg;
1813}
1814
1816 auto *ProfileSampleUseArg = Args.getLastArg(
1817 options::OPT_fprofile_sample_use_EQ, options::OPT_fno_profile_sample_use);
1818
1819 if (ProfileSampleUseArg && (ProfileSampleUseArg->getOption().matches(
1820 options::OPT_fno_profile_sample_use)))
1821 return nullptr;
1822
1823 return Args.getLastArg(options::OPT_fprofile_sample_use_EQ);
1824}
1825
1827 switch (Model) {
1828 case llvm::Reloc::Static:
1829 return "static";
1830 case llvm::Reloc::PIC_:
1831 return "pic";
1832 case llvm::Reloc::DynamicNoPIC:
1833 return "dynamic-no-pic";
1834 case llvm::Reloc::ROPI:
1835 return "ropi";
1836 case llvm::Reloc::RWPI:
1837 return "rwpi";
1838 case llvm::Reloc::ROPI_RWPI:
1839 return "ropi-rwpi";
1840 }
1841 llvm_unreachable("Unknown Reloc::Model kind");
1842}
1843
1844
1845
1846
1847
1848std::tuple<llvm::Reloc::Model, unsigned, bool>
1852
1855
1856 if (Triple.isOSBinFormatMachO() && Args.hasArg(options::OPT_static))
1857 PIE = PIC = false;
1858 bool IsPICLevelTwo = PIC;
1859
1860 bool KernelOrKext =
1861 Args.hasArg(options::OPT_mkernel, options::OPT_fapple_kext);
1862
1863
1864 if (Triple.isAndroid()) {
1865 switch (Triple.getArch()) {
1866 case llvm::Triple::x86:
1867 case llvm::Triple::x86_64:
1868 PIC = true;
1869 IsPICLevelTwo = true;
1870 break;
1871
1872 default:
1873 PIC = true;
1874 break;
1875 }
1876 }
1877
1878
1879 if (Triple.isOHOSFamily() && Triple.getArch() == llvm::Triple::aarch64)
1880 PIC = true;
1881
1882
1883 if (Triple.isOSOpenBSD()) {
1885 case llvm::Triple::arm:
1886 case llvm::Triple::aarch64:
1887 case llvm::Triple::mips64:
1888 case llvm::Triple::mips64el:
1889 case llvm::Triple::x86:
1890 case llvm::Triple::x86_64:
1891 IsPICLevelTwo = false;
1892 break;
1893
1894 case llvm::Triple::ppc:
1895 case llvm::Triple::sparcv9:
1896 IsPICLevelTwo = true;
1897 break;
1898
1899 default:
1900 break;
1901 }
1902 }
1903
1904
1905
1906
1907
1908 Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,
1909 options::OPT_fpic, options::OPT_fno_pic,
1910 options::OPT_fPIE, options::OPT_fno_PIE,
1911 options::OPT_fpie, options::OPT_fno_pie);
1912 if (Triple.isOSWindows() && !Triple.isOSCygMing() && LastPICArg &&
1913 LastPICArg == Args.getLastArg(options::OPT_fPIC, options::OPT_fpic,
1914 options::OPT_fPIE, options::OPT_fpie)) {
1916 << LastPICArg->getSpelling() << Triple.str();
1917 if (Triple.getArch() == llvm::Triple::x86_64)
1918 return std::make_tuple(llvm::Reloc::PIC_, 2U, false);
1919 return std::make_tuple(llvm::Reloc::Static, 0U, false);
1920 }
1921
1922
1923
1925 if (LastPICArg) {
1926 Option O = LastPICArg->getOption();
1927 if (O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic) ||
1928 O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie)) {
1929 PIE = O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie);
1930 PIC =
1931 PIE || O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic);
1932 IsPICLevelTwo =
1933 O.matches(options::OPT_fPIE) || O.matches(options::OPT_fPIC);
1934 } else {
1935 PIE = PIC = false;
1936 if (EffectiveTriple.isPS()) {
1937 Arg *ModelArg = Args.getLastArg(options::OPT_mcmodel_EQ);
1938 StringRef Model = ModelArg ? ModelArg->getValue() : "";
1939 if (Model != "kernel") {
1940 PIC = true;
1942 << LastPICArg->getSpelling()
1943 << (EffectiveTriple.isPS4() ? "PS4" : "PS5");
1944 }
1945 }
1946 }
1947 }
1948 }
1949
1950
1951
1952
1953 if (PIC && (Triple.isOSDarwin() || EffectiveTriple.isPS()))
1955
1956
1957
1958 if (KernelOrKext &&
1959 ((!EffectiveTriple.isiOS() || EffectiveTriple.isOSVersionLT(6)) &&
1960 !EffectiveTriple.isWatchOS() && !EffectiveTriple.isDriverKit()))
1961 PIC = PIE = false;
1962
1963 if (Arg *A = Args.getLastArg(options::OPT_mdynamic_no_pic)) {
1964
1965
1966 if (!Triple.isOSDarwin())
1968 << A->getSpelling() << Triple.str();
1969
1970
1971
1972
1973
1974
1976
1977 return std::make_tuple(llvm::Reloc::DynamicNoPIC, PIC ? 2U : 0U, false);
1978 }
1979
1980 bool EmbeddedPISupported;
1981 switch (Triple.getArch()) {
1982 case llvm::Triple::arm:
1983 case llvm::Triple::armeb:
1984 case llvm::Triple::thumb:
1985 case llvm::Triple::thumbeb:
1986 EmbeddedPISupported = true;
1987 break;
1988 default:
1989 EmbeddedPISupported = false;
1990 break;
1991 }
1992
1993 bool ROPI = false, RWPI = false;
1994 Arg* LastROPIArg = Args.getLastArg(options::OPT_fropi, options::OPT_fno_ropi);
1995 if (LastROPIArg && LastROPIArg->getOption().matches(options::OPT_fropi)) {
1996 if (!EmbeddedPISupported)
1998 << LastROPIArg->getSpelling() << Triple.str();
1999 ROPI = true;
2000 }
2001 Arg *LastRWPIArg = Args.getLastArg(options::OPT_frwpi, options::OPT_fno_rwpi);
2002 if (LastRWPIArg && LastRWPIArg->getOption().matches(options::OPT_frwpi)) {
2003 if (!EmbeddedPISupported)
2005 << LastRWPIArg->getSpelling() << Triple.str();
2006 RWPI = true;
2007 }
2008
2009
2010 if ((ROPI || RWPI) && (PIC || PIE))
2012
2013 if (Triple.isMIPS()) {
2014 StringRef CPUName;
2015 StringRef ABIName;
2017
2018
2019
2020 if (ABIName == "n64")
2021 PIC = true;
2022
2023 if(Args.hasArg(options::OPT_mno_abicalls))
2024 return std::make_tuple(llvm::Reloc::Static, 0U, false);
2025
2026
2027 IsPICLevelTwo = false;
2028 }
2029
2030 if (PIC)
2031 return std::make_tuple(llvm::Reloc::PIC_, IsPICLevelTwo ? 2U : 1U, PIE);
2032
2033 llvm::Reloc::Model RelocM = llvm::Reloc::Static;
2034 if (ROPI && RWPI)
2035 RelocM = llvm::Reloc::ROPI_RWPI;
2036 else if (ROPI)
2037 RelocM = llvm::Reloc::ROPI;
2038 else if (RWPI)
2039 RelocM = llvm::Reloc::RWPI;
2040
2041 return std::make_tuple(RelocM, 0U, false);
2042}
2043
2044
2045
2046
2047
2048
2049
2050
2051
2052
2053
2054
2055
2056
2057
2058
2059
2061 const ArgList &Args) {
2062 const Arg *A = Args.getLastArg(options::OPT_falign_functions,
2063 options::OPT_falign_functions_EQ,
2064 options::OPT_fno_align_functions);
2065 if (!A || A->getOption().matches(options::OPT_fno_align_functions))
2066 return 0;
2067
2068 if (A->getOption().matches(options::OPT_falign_functions))
2069 return 0;
2070
2071 unsigned Value = 0;
2072 if (StringRef(A->getValue()).getAsInteger(10, Value) || Value > 65536)
2073 TC.getDriver().Diag(diag::err_drv_invalid_int_value)
2074 << A->getAsString(Args) << A->getValue();
2075 return Value ? llvm::Log2_32_Ceil(std::min(Value, 65536u)) : Value;
2076}
2077
2079 ArgStringList &CmdArgs, llvm::codegenoptions::DebugInfoKind DebugInfoKind) {
2080 switch (DebugInfoKind) {
2081 case llvm::codegenoptions::DebugDirectivesOnly:
2082 CmdArgs.push_back("-debug-info-kind=line-directives-only");
2083 break;
2084 case llvm::codegenoptions::DebugLineTablesOnly:
2085 CmdArgs.push_back("-debug-info-kind=line-tables-only");
2086 break;
2087 case llvm::codegenoptions::DebugInfoConstructor:
2088 CmdArgs.push_back("-debug-info-kind=constructor");
2089 break;
2090 case llvm::codegenoptions::LimitedDebugInfo:
2091 CmdArgs.push_back("-debug-info-kind=limited");
2092 break;
2093 case llvm::codegenoptions::FullDebugInfo:
2094 CmdArgs.push_back("-debug-info-kind=standalone");
2095 break;
2096 case llvm::codegenoptions::UnusedTypeInfo:
2097 CmdArgs.push_back("-debug-info-kind=unused-types");
2098 break;
2099 default:
2100 break;
2101 }
2102}
2103
2104
2105
2107 assert(A.getOption().matches(options::OPT_gN_Group) &&
2108 "Not a -g option that specifies a debug-info level");
2109 if (A.getOption().matches(options::OPT_g0) ||
2110 A.getOption().matches(options::OPT_ggdb0))
2111 return llvm::codegenoptions::NoDebugInfo;
2112 if (A.getOption().matches(options::OPT_gline_tables_only) ||
2113 A.getOption().matches(options::OPT_ggdb1))
2114 return llvm::codegenoptions::DebugLineTablesOnly;
2115 if (A.getOption().matches(options::OPT_gline_directives_only))
2116 return llvm::codegenoptions::DebugDirectivesOnly;
2117 return llvm::codegenoptions::DebugInfoConstructor;
2118}
2119
2121 const ArgList &Args) {
2122 const Arg *A = Args.getLastArg(options::OPT_fdebug_default_version);
2123
2124 if (!A)
2125 return 0;
2126
2127 unsigned Value = 0;
2128 if (StringRef(A->getValue()).getAsInteger(10, Value) || Value > 5 ||
2130 TC.getDriver().Diag(diag::err_drv_invalid_int_value)
2131 << A->getAsString(Args) << A->getValue();
2133}
2134
2136 return llvm::StringSwitch(ArgValue)
2137 .Case("-gdwarf-2", 2)
2138 .Case("-gdwarf-3", 3)
2139 .Case("-gdwarf-4", 4)
2140 .Case("-gdwarf-5", 5)
2141 .Default(0);
2142}
2143
2145 return Args.getLastArg(options::OPT_gdwarf_2, options::OPT_gdwarf_3,
2146 options::OPT_gdwarf_4, options::OPT_gdwarf_5,
2147 options::OPT_gdwarf);
2148}
2149
2151 const llvm::opt::ArgList &Args) {
2153 if (const Arg *GDwarfN = getDwarfNArg(Args))
2155 DwarfVersion = N;
2156 if (DwarfVersion == 5 && TC.getTriple().isOSAIX())
2157 TC.getDriver().Diag(diag::err_drv_unsupported_opt_for_target)
2158 << GDwarfN->getSpelling() << TC.getTriple().str();
2159 }
2160 if (DwarfVersion == 0) {
2162 assert(DwarfVersion && "toolchain default DWARF version must be nonzero");
2163 }
2164 return DwarfVersion;
2165}
2166
2168 ArgStringList &CmdArgs) {
2169 llvm::Reloc::Model RelocationModel;
2170 unsigned PICLevel;
2171 bool IsPIE;
2173
2174 if (RelocationModel != llvm::Reloc::Static)
2175 CmdArgs.push_back("-KPIC");
2176}
2177
2178
2179
2181 return Args.hasFlag(options::OPT_fobjc_arc, options::OPT_fno_objc_arc, false);
2182}
2183
2185
2187 const ArgList &Args) {
2188 if (Args.hasArg(options::OPT_static_libgcc) ||
2189 Args.hasArg(options::OPT_static) || Args.hasArg(options::OPT_static_pie) ||
2190
2193 if (Args.hasArg(options::OPT_shared_libgcc))
2196}
2197
2198
2199
2200
2201
2202
2203
2204
2205
2206
2207
2208
2209
2210
2212 ArgStringList &CmdArgs, const ArgList &Args) {
2214
2216 CmdArgs.push_back("-l:libunwind.a");
2217 return;
2218 }
2219
2220
2224 return;
2225
2231 if (AsNeeded)
2233
2234 switch (UNW) {
2236 return;
2239 CmdArgs.push_back("-lgcc_eh");
2240 else
2241 CmdArgs.push_back("-lgcc_s");
2242 break;
2243 }
2246
2247
2249 CmdArgs.push_back("-lunwind");
2251 CmdArgs.push_back("-l:libunwind.a");
2253 if (TC.getTriple().isOSCygMing())
2254 CmdArgs.push_back("-l:libunwind.dll.a");
2255 else
2256 CmdArgs.push_back("-l:libunwind.so");
2257 } else {
2258
2259
2260 CmdArgs.push_back("-lunwind");
2261 }
2262 break;
2263 }
2264
2265 if (AsNeeded)
2267}
2268
2270 ArgStringList &CmdArgs, const ArgList &Args) {
2274 CmdArgs.push_back("-lgcc");
2278 CmdArgs.push_back("-lgcc");
2279}
2280
2282 ArgStringList &CmdArgs, const ArgList &Args) {
2283
2285
2286 switch (RLT) {
2290 break;
2292
2293 if (TC.getTriple().isKnownWindowsMSVCEnvironment()) {
2294
2295
2296 Arg *A = Args.getLastArg(options::OPT_rtlib_EQ);
2297 if (A && A->getValue() != StringRef("platform")) {
2298 TC.getDriver().Diag(diag::err_drv_unsupported_rtlib_for_platform)
2299 << A->getValue() << "MSVC";
2300 }
2301 } else
2303 break;
2304 }
2305
2306
2307
2308
2309 if (TC.getTriple().isAndroid() && !Args.hasArg(options::OPT_static) &&
2310 !Args.hasArg(options::OPT_static_pie))
2311 CmdArgs.push_back("-ldl");
2312}
2313
2318 const Arg *A = Args.getLastArg(options::OPT_save_stats_EQ);
2319 if (!A && .CCPrintInternalStats)
2320 return {};
2321
2323 if (A) {
2324 StringRef SaveStats = A->getValue();
2325 if (SaveStats == "obj" && Output.isFilename()) {
2327 llvm::sys::path::remove_filename(StatsFile);
2328 } else if (SaveStats != "cwd") {
2329 D.Diag(diag::err_drv_invalid_value) << A->getAsString(Args) << SaveStats;
2330 return {};
2331 }
2332
2333 StringRef BaseName = llvm::sys::path::filename(Input.getBaseInput());
2334 llvm::sys::path::append(StatsFile, BaseName);
2335 llvm::sys::path::replace_extension(StatsFile, "stats");
2336 } else {
2337 assert(D.CCPrintInternalStats);
2338 StatsFile.assign(D.CCPrintInternalStatReportFilename.empty()
2339 ? "-"
2340 : D.CCPrintInternalStatReportFilename);
2341 }
2342 return StatsFile;
2343}
2344
2347 assert(Flag.front() == '-');
2348 if (Enabled) {
2349 Flags.push_back(Flag.str());
2350 } else {
2351 Flags.push_back(("!" + Flag.substr(1)).str());
2352 }
2353}
2354
2356 ArgStringList &CmdArgs, bool IsLTO,
2357 const StringRef PluginOptPrefix) {
2358 auto addArg = [&, IsLTO](const Twine &Arg) {
2359 if (IsLTO) {
2360 assert(!PluginOptPrefix.empty() && "Cannot have empty PluginOptPrefix!");
2361 CmdArgs.push_back(Args.MakeArgString(Twine(PluginOptPrefix) + Arg));
2362 } else {
2363 CmdArgs.push_back("-mllvm");
2364 CmdArgs.push_back(Args.MakeArgString(Arg));
2365 }
2366 };
2367
2368 if (Args.hasArg(options::OPT_mbranches_within_32B_boundaries)) {
2369 addArg(Twine("-x86-branches-within-32B-boundaries"));
2370 }
2371 if (const Arg *A = Args.getLastArg(options::OPT_malign_branch_boundary_EQ)) {
2372 StringRef Value = A->getValue();
2373 unsigned Boundary;
2374 if (Value.getAsInteger(10, Boundary) || Boundary < 16 ||
2375 !llvm::isPowerOf2_64(Boundary)) {
2376 D.Diag(diag::err_drv_invalid_argument_to_option)
2377 << Value << A->getOption().getName();
2378 } else {
2379 addArg("-x86-align-branch-boundary=" + Twine(Boundary));
2380 }
2381 }
2382 if (const Arg *A = Args.getLastArg(options::OPT_malign_branch_EQ)) {
2383 std::string AlignBranch;
2384 for (StringRef T : A->getValues()) {
2385 if (T != "fused" && T != "jcc" && T != "jmp" && T != "call" &&
2386 T != "ret" && T != "indirect")
2387 D.Diag(diag::err_drv_invalid_malign_branch_EQ)
2388 << T << "fused, jcc, jmp, call, ret, indirect";
2389 if (!AlignBranch.empty())
2390 AlignBranch += '+';
2391 AlignBranch += T;
2392 }
2393 addArg("-x86-align-branch=" + Twine(AlignBranch));
2394 }
2395 if (const Arg *A = Args.getLastArg(options::OPT_mpad_max_prefix_size_EQ)) {
2396 StringRef Value = A->getValue();
2397 unsigned PrefixSize;
2398 if (Value.getAsInteger(10, PrefixSize)) {
2399 D.Diag(diag::err_drv_invalid_argument_to_option)
2400 << Value << A->getOption().getName();
2401 } else {
2402 addArg("-x86-pad-max-prefix-size=" + Twine(PrefixSize));
2403 }
2404 }
2405}
2406
2407
2408
2409
2410
2411
2412
2413
2414
2415
2416
2417
2418
2419
2420
2421
2422
2423
2424
2425
2426
2428 llvm::opt::ArgStringList &CC1Args,
2430 StringRef Lib, StringRef Arch, StringRef Target,
2431 bool isBitCodeSDL) {
2433
2434 std::string LibDeviceLoc = "/libdevice";
2435 std::string LibBcPrefix = "/libbc-";
2436 std::string LibPrefix = "/lib";
2437
2438 if (isBitCodeSDL) {
2439
2440
2441
2442
2443
2444
2445
2446
2447
2448
2449
2450
2451
2452
2453 for (StringRef Base : {LibBcPrefix, LibPrefix}) {
2454 const auto *Ext = Base.contains(LibBcPrefix) ? ".a" : ".bc";
2455
2456 for (auto Suffix : {Twine(Lib + "-" + Arch + "-" + Target).str(),
2457 Twine(Lib + "-" + Arch).str(), Twine(Lib).str()}) {
2458 SDLs.push_back(Twine(LibDeviceLoc + Base + Suffix + Ext).str());
2459 SDLs.push_back(Twine(Base + Suffix + Ext).str());
2460 }
2461 }
2462 } else {
2463
2464
2465
2466
2467
2468
2469 const auto *Ext = ".a";
2470
2471 for (auto Suffix : {Twine(Lib + "-" + Arch + "-" + Target).str(),
2472 Twine(Lib + "-" + Arch).str()}) {
2473 SDLs.push_back(Twine(LibDeviceLoc + LibPrefix + Suffix + Ext).str());
2474 SDLs.push_back(Twine(LibPrefix + Suffix + Ext).str());
2475 }
2476 }
2477
2478
2479
2480
2481
2482
2483
2484
2485 bool FoundSDL = false;
2486 for (auto LPath : LibraryPaths) {
2487 for (auto SDL : SDLs) {
2488 auto FullName = Twine(LPath + SDL).str();
2489 if (llvm::sys::fs::exists(FullName)) {
2490 CC1Args.push_back(DriverArgs.MakeArgString(FullName));
2491 FoundSDL = true;
2492 break;
2493 }
2494 }
2495 if (FoundSDL)
2496 break;
2497 }
2498 return FoundSDL;
2499}
2500
2501
2502
2503
2504
2507 const InputInfoList &Inputs, const llvm::opt::ArgList &DriverArgs,
2508 llvm::opt::ArgStringList &CC1Args,
2510 StringRef Arch, StringRef Target, bool isBitCodeSDL) {
2511
2512
2513 if (isBitCodeSDL && Arch.contains("nvptx"))
2514 return;
2515
2516 bool FoundAOB = false;
2517 std::string ArchiveOfBundles;
2518
2519 llvm::Triple Triple(D.getTargetTriple());
2520 bool IsMSVC = Triple.isWindowsMSVCEnvironment();
2521 auto Ext = IsMSVC ? ".lib" : ".a";
2522 if (!Lib.starts_with(":") && !Lib.starts_with("-l")) {
2523 if (llvm::sys::fs::exists(Lib)) {
2524 ArchiveOfBundles = Lib;
2525 FoundAOB = true;
2526 }
2527 } else {
2528 Lib.consume_front("-l");
2529 for (auto LPath : LibraryPaths) {
2530 ArchiveOfBundles.clear();
2531 auto LibFile = (Lib.starts_with(":") ? Lib.drop_front()
2532 : IsMSVC ? Lib + Ext
2533 : "lib" + Lib + Ext)
2534 .str();
2535 for (auto Prefix : {"/libdevice/", "/"}) {
2536 auto AOB = Twine(LPath + Prefix + LibFile).str();
2537 if (llvm::sys::fs::exists(AOB)) {
2538 ArchiveOfBundles = AOB;
2539 FoundAOB = true;
2540 break;
2541 }
2542 }
2543 if (FoundAOB)
2544 break;
2545 }
2546 }
2547
2548 if (!FoundAOB)
2549 return;
2550
2551 llvm::file_magic Magic;
2552 auto EC = llvm::identify_magic(ArchiveOfBundles, Magic);
2553 if (EC || Magic != llvm::file_magic::archive)
2554 return;
2555
2556 StringRef Prefix = isBitCodeSDL ? "libbc-" : "lib";
2557 std::string OutputLib =
2558 D.GetTemporaryPath(Twine(Prefix + llvm::sys::path::filename(Lib) + "-" +
2559 Arch + "-" + Target)
2560 .str(),
2561 "a");
2562
2563 C.addTempFile(C.getArgs().MakeArgString(OutputLib));
2564
2565 ArgStringList CmdArgs;
2568 DeviceTriple += '-';
2569 std::string NormalizedTriple = T.getToolChain().getTriple().normalize();
2570 DeviceTriple += NormalizedTriple;
2571 if (.empty()) {
2572 DeviceTriple += '-';
2573 DeviceTriple += Target;
2574 }
2575
2576 std::string UnbundleArg("-unbundle");
2577 std::string TypeArg("-type=a");
2578 std::string InputArg("-input=" + ArchiveOfBundles);
2579 std::string OffloadArg("-targets=" + std::string(DeviceTriple));
2580 std::string OutputArg("-output=" + OutputLib);
2581
2582 const char *UBProgram = DriverArgs.MakeArgString(
2583 T.getToolChain().GetProgramPath("clang-offload-bundler"));
2584
2585 ArgStringList UBArgs;
2586 UBArgs.push_back(C.getArgs().MakeArgString(UnbundleArg));
2587 UBArgs.push_back(C.getArgs().MakeArgString(TypeArg));
2588 UBArgs.push_back(C.getArgs().MakeArgString(InputArg));
2589 UBArgs.push_back(C.getArgs().MakeArgString(OffloadArg));
2590 UBArgs.push_back(C.getArgs().MakeArgString(OutputArg));
2591
2592
2593
2594 std::string AdditionalArgs("-allow-missing-bundles");
2595 UBArgs.push_back(C.getArgs().MakeArgString(AdditionalArgs));
2596
2597
2598
2599
2600 std::string HipCompatibleArgs("-hip-openmp-compatible");
2601 UBArgs.push_back(C.getArgs().MakeArgString(HipCompatibleArgs));
2602
2603 C.addCommand(std::make_unique(
2605 InputInfo(&JA, C.getArgs().MakeArgString(OutputLib))));
2606
2607 CC1Args.push_back(DriverArgs.MakeArgString(OutputLib));
2608
2609 return;
2610}
2611
2612
2616 const llvm::opt::ArgList &DriverArgs,
2617 llvm::opt::ArgStringList &CC1Args,
2618 StringRef Arch, StringRef Target,
2619 bool isBitCodeSDL) {
2621 Arch, Target, isBitCodeSDL);
2622}
2623
2624
2625
2626
2627
2628
2629
2630
2631
2632
2633
2634
2635
2636
2637
2638
2639
2640
2641
2642
2643
2644
2645
2646
2650 const llvm::opt::ArgList &DriverArgs,
2651 llvm::opt::ArgStringList &CC1Args,
2652 StringRef Arch, StringRef Target,
2653 bool isBitCodeSDL) {
2654
2656
2657 std::optionalstd::string LibPath =
2658 llvm::sys::Process::GetEnv("LIBRARY_PATH");
2659 if (LibPath) {
2661 const char EnvPathSeparatorStr[] = {llvm::sys::EnvPathSeparator, '\0'};
2662 llvm::SplitString(*LibPath, Frags, EnvPathSeparatorStr);
2663 for (StringRef Path : Frags)
2664 LibraryPaths.emplace_back(Path.trim());
2665 }
2666
2667
2668 for (std::string Search_Dir : DriverArgs.getAllArgValues(options::OPT_L))
2669 LibraryPaths.emplace_back(Search_Dir);
2670
2671
2672 SmallString<256> DefaultLibPath = llvm::sys::path::parent_path(D.Dir);
2673 llvm::sys::path::append(DefaultLibPath, CLANG_INSTALL_LIBDIR_BASENAME);
2674 LibraryPaths.emplace_back(DefaultLibPath.c_str());
2675
2676
2677 llvm::SmallSet<std::string, 16> SDLNames;
2678 static const StringRef HostOnlyArchives[] = {
2679 "omp", "cudart", "m", "gcc", "gcc_s", "pthread", "hip_hcc"};
2680 for (auto SDLName : DriverArgs.getAllArgValues(options::OPT_l)) {
2681 if (!llvm::is_contained(HostOnlyArchives, SDLName)) {
2682 SDLNames.insert(std::string("-l") + SDLName);
2683 }
2684 }
2685
2686 for (auto Input : DriverArgs.getAllArgValues(options::OPT_INPUT)) {
2687 auto FileName = StringRef(Input);
2688
2689
2690
2691
2692
2693 const StringRef LibFileExt = ".lib";
2694 if (!llvm::sys::path::has_extension(FileName) ||
2696 llvm::sys::path::extension(FileName).drop_front()) ==
2698 llvm::sys::path::extension(FileName) == LibFileExt)
2699 SDLNames.insert(Input);
2700 }
2701
2702
2703
2704
2705
2706 for (auto SDLName : SDLNames) {
2707
2708 if ((D, DriverArgs, CC1Args, LibraryPaths, SDLName, Arch, Target,
2709 isBitCodeSDL)) {
2711 LibraryPaths, SDLName, Arch, Target,
2712 isBitCodeSDL);
2713 }
2714 }
2715}
2716
2717static llvm::opt::Arg *
2719 return Args.getLastArg(options::OPT_mcode_object_version_EQ);
2720}
2721
2723 const llvm::opt::ArgList &Args) {
2724 const unsigned MinCodeObjVer = 4;
2725 const unsigned MaxCodeObjVer = 6;
2726
2728 if (CodeObjArg->getOption().getID() ==
2729 options::OPT_mcode_object_version_EQ) {
2730 unsigned CodeObjVer = MaxCodeObjVer;
2731 auto Remnant =
2732 StringRef(CodeObjArg->getValue()).getAsInteger(0, CodeObjVer);
2733 if (Remnant || CodeObjVer < MinCodeObjVer || CodeObjVer > MaxCodeObjVer)
2734 D.Diag(diag::err_drv_invalid_int_value)
2735 << CodeObjArg->getAsString(Args) << CodeObjArg->getValue();
2736
2737
2738
2739
2740 if (CodeObjVer == 6)
2741 D.Diag(diag::warn_drv_amdgpu_cov6);
2742 }
2743 }
2744}
2745
2747 const llvm::opt::ArgList &Args) {
2748 unsigned CodeObjVer = 5;
2750 StringRef(CodeObjArg->getValue()).getAsInteger(0, CodeObjVer);
2751 return CodeObjVer;
2752}
2753
2755 const Driver &D, const llvm::opt::ArgList &Args) {
2757}
2758
2760 const llvm::opt::ArgList &Args,
2761 llvm::opt::ArgStringList &CmdArgs,
2762 const llvm::Triple &Triple, bool IsLTO,
2763 const StringRef PluginOptPrefix) {
2764 auto addArg = [&, IsLTO](const Twine &Arg) {
2765 if (IsLTO) {
2766 assert(!PluginOptPrefix.empty() && "Cannot have empty PluginOptPrefix!");
2767 CmdArgs.push_back(Args.MakeArgString(Twine(PluginOptPrefix) + Arg));
2768 } else {
2769 CmdArgs.push_back("-mllvm");
2770 CmdArgs.push_back(Args.MakeArgString(Arg));
2771 }
2772 };
2773
2774 if (Arg *A = Args.getLastArg(options::OPT_moutline,
2775 options::OPT_mno_outline)) {
2776 if (A->getOption().matches(options::OPT_moutline)) {
2777
2778
2779
2780 if (!(Triple.isARM() || Triple.isThumb() || Triple.isAArch64())) {
2781 D.Diag(diag::warn_drv_moutline_unsupported_opt) << Triple.getArchName();
2782 } else {
2783 addArg(Twine("-enable-machine-outliner"));
2784 }
2785 } else {
2786
2787 addArg(Twine("-enable-machine-outliner=never"));
2788 }
2789 }
2790
2791 auto *CodeGenDataGenArg =
2792 Args.getLastArg(options::OPT_fcodegen_data_generate_EQ);
2793 auto *CodeGenDataUseArg = Args.getLastArg(options::OPT_fcodegen_data_use_EQ);
2794
2795
2796 if (CodeGenDataGenArg && CodeGenDataUseArg)
2797 D.Diag(diag::err_drv_argument_not_allowed_with)
2798 << CodeGenDataGenArg->getAsString(Args)
2799 << CodeGenDataUseArg->getAsString(Args);
2800
2801
2802
2803 if (CodeGenDataGenArg)
2804 addArg(Twine("-codegen-data-generate"));
2805
2806
2807 if (CodeGenDataUseArg)
2808 addArg(Twine("-codegen-data-use-path=") + CodeGenDataUseArg->getValue());
2809}
2810
2812 const llvm::opt::ArgList &DriverArgs,
2813 llvm::opt::ArgStringList &CC1Args,
2814 StringRef BitcodeSuffix,
2815 const llvm::Triple &Triple,
2818
2819
2820 std::optionalstd::string LibPath =
2821 llvm::sys::Process::GetEnv("LIBRARY_PATH");
2822 if (LibPath) {
2824 const char EnvPathSeparatorStr[] = {llvm::sys::EnvPathSeparator, '\0'};
2825 llvm::SplitString(*LibPath, Frags, EnvPathSeparatorStr);
2826 for (StringRef Path : Frags)
2827 LibraryPaths.emplace_back(Path.trim());
2828 }
2829
2830
2831 for (const auto &LibPath : HostTC.getFilePaths())
2832 LibraryPaths.emplace_back(LibPath);
2833
2834 OptSpecifier LibomptargetBCPathOpt =
2835 Triple.isAMDGCN() ? options::OPT_libomptarget_amdgpu_bc_path_EQ
2836 : Triple.isNVPTX() ? options::OPT_libomptarget_nvptx_bc_path_EQ
2837 : options::OPT_libomptarget_spirv_bc_path_EQ;
2838
2839 StringRef ArchPrefix = Triple.isAMDGCN() ? "amdgpu"
2840 : Triple.isNVPTX() ? "nvptx"
2841 : "spirv64";
2842 std::string LibOmpTargetName = ("libomptarget-" + ArchPrefix + ".bc").str();
2843
2844
2845 if (const Arg *A = DriverArgs.getLastArg(LibomptargetBCPathOpt)) {
2847 if (llvm::sys::fs::exists(LibOmpTargetFile) &&
2848 llvm::sys::fs::is_directory(LibOmpTargetFile)) {
2849 llvm::sys::path::append(LibOmpTargetFile, LibOmpTargetName);
2850 }
2851
2852 if (llvm::sys::fs::exists(LibOmpTargetFile)) {
2853 CC1Args.push_back("-mlink-builtin-bitcode");
2854 CC1Args.push_back(DriverArgs.MakeArgString(LibOmpTargetFile));
2855 } else {
2856 D.Diag(diag::err_drv_omp_offload_target_bcruntime_not_found)
2857 << LibOmpTargetFile;
2858 }
2859 } else {
2860 bool FoundBCLibrary = false;
2861
2862 for (StringRef LibraryPath : LibraryPaths) {
2864 llvm::sys::path::append(LibOmpTargetFile, LibOmpTargetName);
2865 if (llvm::sys::fs::exists(LibOmpTargetFile)) {
2866 CC1Args.push_back("-mlink-builtin-bitcode");
2867 CC1Args.push_back(DriverArgs.MakeArgString(LibOmpTargetFile));
2868 FoundBCLibrary = true;
2869 break;
2870 }
2871 }
2872
2873 if (!FoundBCLibrary)
2874 D.Diag(diag::err_drv_omp_offload_target_missingbcruntime)
2875 << LibOmpTargetName << ArchPrefix;
2876 }
2877}
2879 const llvm::opt::ArgList &Args,
2880 llvm::opt::ArgStringList &CmdArgs) {
2882 !Args.hasArg(options::OPT_nostdlib) &&
2883 !Args.hasArg(options::OPT_no_hip_rt) && !Args.hasArg(options::OPT_r)) {
2885 } else {
2886
2887 for (auto *Arg : Args.filtered(options::OPT_no_hip_rt)) {
2888 Arg->claim();
2889 }
2890 }
2891}
2892
2894 const llvm::opt::ArgList &Args,
2895 llvm::opt::ArgStringList &CmdArgs,
2896 const llvm::Triple &Triple) {
2897 if (Arg *A = Args.getLastArg(options::OPT_moutline_atomics,
2898 options::OPT_mno_outline_atomics)) {
2899
2900 if (!Triple.isAArch64()) {
2901 D.Diag(diag::warn_drv_moutline_atomics_unsupported_opt)
2902 << Triple.getArchName() << A->getOption().getName();
2903 } else {
2904 if (A->getOption().matches(options::OPT_moutline_atomics)) {
2905 CmdArgs.push_back("-target-feature");
2906 CmdArgs.push_back("+outline-atomics");
2907 } else {
2908 CmdArgs.push_back("-target-feature");
2909 CmdArgs.push_back("-outline-atomics");
2910 }
2911 }
2913 CmdArgs.push_back("-target-feature");
2914 CmdArgs.push_back("+outline-atomics");
2915 }
2916}
2917
2919 llvm::opt::ArgStringList &CmdArgs) {
2920 if (TCArgs.hasFlag(options::OPT_offload_compress,
2921 options::OPT_no_offload_compress, false))
2922 CmdArgs.push_back("-compress");
2923 if (TCArgs.hasArg(options::OPT_v))
2924 CmdArgs.push_back("-verbose");
2925 if (auto *Arg = TCArgs.getLastArg(options::OPT_offload_compression_level_EQ))
2926 CmdArgs.push_back(
2927 TCArgs.MakeArgString(Twine("-compression-level=") + Arg->getValue()));
2928}
2929
2931 const llvm::Triple &Triple,
2932 const llvm::Reloc::Model &RelocationModel,
2933 llvm::opt::ArgStringList &CmdArgs) {
2934 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
2935 StringRef CM = A->getValue();
2936 bool Ok = false;
2937 if (Triple.isOSAIX() && CM == "medium")
2938 CM = "large";
2939 if (Triple.isAArch64(64)) {
2940 Ok = CM == "tiny" || CM == "small" || CM == "large";
2941 if (CM == "large" && !Triple.isOSBinFormatMachO() &&
2942 RelocationModel != llvm::Reloc::Static)
2943 D.Diag(diag::err_drv_argument_only_allowed_with)
2944 << A->getAsString(Args) << "-fno-pic";
2945 } else if (Triple.isLoongArch()) {
2946 if (CM == "extreme" &&
2947 Args.hasFlagNoClaim(options::OPT_fplt, options::OPT_fno_plt, false))
2948 D.Diag(diag::err_drv_argument_not_allowed_with)
2949 << A->getAsString(Args) << "-fplt";
2950 Ok = CM == "normal" || CM == "medium" || CM == "extreme";
2951
2952 if (Ok)
2953 CM = llvm::StringSwitch(CM)
2954 .Case("normal", "small")
2955 .Case("extreme", "large")
2956 .Default(CM);
2957 } else if (Triple.isPPC64() || Triple.isOSAIX()) {
2958 Ok = CM == "small" || CM == "medium" || CM == "large";
2959 } else if (Triple.isRISCV()) {
2960
2961 if (CM == "large" && RelocationModel != llvm::Reloc::Static)
2962 D.Diag(diag::err_drv_argument_not_allowed_with)
2963 << A->getAsString(Args) << "-fpic";
2964 if (CM == "medlow")
2965 CM = "small";
2966 else if (CM == "medany")
2967 CM = "medium";
2968 Ok = CM == "small" || CM == "medium" ||
2969 (CM == "large" && Triple.isRISCV64());
2970 } else if (Triple.getArch() == llvm::Triple::x86_64) {
2971 Ok = llvm::is_contained({"small", "kernel", "medium", "large", "tiny"},
2972 CM);
2973 } else if (Triple.isNVPTX() || Triple.isAMDGPU() || Triple.isSPIRV()) {
2974
2975
2976 Ok = true;
2977 } else if (Triple.isSPARC64()) {
2978 if (CM == "medlow")
2979 CM = "small";
2980 else if (CM == "medmid")
2981 CM = "medium";
2982 else if (CM == "medany")
2983 CM = "large";
2984 Ok = CM == "small" || CM == "medium" || CM == "large";
2985 }
2986 if (Ok) {
2987 CmdArgs.push_back(Args.MakeArgString("-mcmodel=" + CM));
2988 } else {
2989 D.Diag(diag::err_drv_unsupported_option_argument_for_target)
2990 << A->getSpelling() << CM << Triple.getTriple();
2991 }
2992 }
2993
2994 if (Triple.getArch() == llvm::Triple::x86_64) {
2995 bool IsMediumCM = false;
2996 bool IsLargeCM = false;
2997 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {
2998 IsMediumCM = StringRef(A->getValue()) == "medium";
2999 IsLargeCM = StringRef(A->getValue()) == "large";
3000 }
3001 if (Arg *A = Args.getLastArg(options::OPT_mlarge_data_threshold_EQ)) {
3002 if (!IsMediumCM && !IsLargeCM) {
3003 D.Diag(diag::warn_drv_large_data_threshold_invalid_code_model)
3004 << A->getOption().getRenderName();
3005 } else {
3006 A->render(Args, CmdArgs);
3007 }
3008 } else if (IsMediumCM) {
3009 CmdArgs.push_back("-mlarge-data-threshold=65536");
3010 } else if (IsLargeCM) {
3011 CmdArgs.push_back("-mlarge-data-threshold=0");
3012 }
3013 }
3014}
3015
3017 ArgStringList &CmdArgs) {
3018
3019
3020
3021
3022 Args.getLastArg(options::OPT_fcolor_diagnostics,
3023 options::OPT_fno_color_diagnostics);
3024 if (const Arg *A = Args.getLastArg(options::OPT_fdiagnostics_color_EQ)) {
3025 StringRef Value(A->getValue());
3026 if (Value != "always" && Value != "never" && Value != "auto")
3027 D.Diag(diag::err_drv_invalid_argument_to_option)
3028 << Value << A->getOption().getName();
3029 }
3030
3031 if (D.getDiags().getDiagnosticOptions().ShowColors)
3032 CmdArgs.push_back("-fcolor-diagnostics");
3033}
3034
3037 for (; *Arg; ++Arg) {
3038 switch (*Arg) {
3039 default:
3040 break;
3041 case ' ':
3042 case '\\':
3043 Res.push_back('\\');
3044 break;
3045 }
3046 Res.push_back(*Arg);
3047 }
3048}
3049
3051 const llvm::opt::ArgList &Args) {
3053 const char *Exec = D.getClangProgramPath();
3054
3055 llvm::opt::ArgStringList OriginalArgs;
3056 for (const auto &Arg : Args)
3057 Arg->render(Args, OriginalArgs);
3058
3061 for (const char *OriginalArg : OriginalArgs) {
3064 Flags += " ";
3065 Flags += EscapedArg;
3066 }
3067
3068 return Args.MakeArgString(Flags);
3069}
3070
3072 const llvm::opt::ArgList &Args,
3073 bool &FRecordCommandLine,
3074 bool &GRecordCommandLine) {
3077 const std::string &TripleStr = Triple.getTriple();
3078
3079 FRecordCommandLine =
3080 Args.hasFlag(options::OPT_frecord_command_line,
3081 options::OPT_fno_record_command_line, false);
3082 GRecordCommandLine =
3083 Args.hasFlag(options::OPT_grecord_command_line,
3084 options::OPT_gno_record_command_line, false);
3085 if (FRecordCommandLine && !Triple.isOSBinFormatELF() &&
3086 !Triple.isOSBinFormatXCOFF() && !Triple.isOSBinFormatMachO())
3087 D.Diag(diag::err_drv_unsupported_opt_for_target)
3088 << Args.getLastArg(options::OPT_frecord_command_line)->getAsString(Args)
3089 << TripleStr;
3090
3091 return FRecordCommandLine || TC.UseDwarfDebugFlags() || GRecordCommandLine;
3092}
3093
3095 ArgStringList &CmdArgs) {
3096
3097
3098 if (Arg *A = Args.getLastArg(options::OPT_fwrapv, options::OPT_fno_wrapv)) {
3099 if (A->getOption().matches(options::OPT_fwrapv))
3100 CmdArgs.push_back("-fwrapv");
3101 } else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,
3102 options::OPT_fno_strict_overflow)) {
3103 if (A->getOption().matches(options::OPT_fno_strict_overflow))
3104 CmdArgs.push_back("-fwrapv");
3105 }
3106}
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.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.
InputInfo - Wrapper for information about an input source.
const char * getBaseInput() const
const char * getFilename() const
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 needsRtsanRt() const
bool requiresMinimalRuntime() const
bool hasMemtagStack() const
bool needsDfsanRt() const
bool needsScudoRt() const
bool needsUbsanCXXRt() const
const std::string & getMemtagMode() const
bool needsSharedRt() const
bool needsTysanRt() const
bool linkCXXRuntimes() const
bool needsXRayDSORt() 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()