13#include "llvm/ADT/StringSwitch.h"
14#include "llvm/Option/ArgList.h"
15#include "llvm/TargetParser/ARMTargetParser.h"
16#include "llvm/TargetParser/Host.h"
25 llvm::StringRef Arch = Triple.getArchName();
26 return llvm::ARM::parseArchVersion(Arch);
31 llvm::StringRef Arch = Triple.getArchName();
32 return llvm::ARM::parseArchProfile(Arch) == llvm::ARM::ProfileKind::M;
40 if (Arg *A = Args.getLastArg(options::OPT_mlittle_endian,
41 options::OPT_mbig_endian)) {
42 return !A->getOption().matches(options::OPT_mlittle_endian);
45 return Triple.getArch() == llvm::Triple::armeb ||
46 Triple.getArch() == llvm::Triple::thumbeb;
51 llvm::StringRef Arch = Triple.getArchName();
52 return llvm::ARM::parseArchProfile(Arch) == llvm::ARM::ProfileKind::A;
57 auto arch = Triple.getArch();
58 if (
arch != llvm::Triple::arm &&
arch != llvm::Triple::thumb &&
59 arch != llvm::Triple::armeb &&
arch != llvm::Triple::thumbeb)
62 if (Triple.getVendor() != llvm::Triple::UnknownVendor)
65 if (Triple.getOS() != llvm::Triple::UnknownOS)
68 if (Triple.getEnvironment() != llvm::Triple::EABI &&
69 Triple.getEnvironment() != llvm::Triple::EABIHF)
77 llvm::StringRef &CPU,
bool FromAs) {
78 if (
const Arg *A = Args.getLastArg(clang::driver::options::OPT_mcpu_EQ))
80 if (
const Arg *A = Args.getLastArg(options::OPT_march_EQ))
86 Args.filtered(options::OPT_Wa_COMMA, options::OPT_Xassembler)) {
89 for (StringRef
Value : A->getValues()) {
90 if (
Value.starts_with(
"-mcpu="))
91 CPU =
Value.substr(6);
92 if (
Value.starts_with(
"-march="))
93 Arch =
Value.substr(7);
101 const ArgList &Args, StringRef HWDiv,
102 std::vector<StringRef> &Features) {
103 uint64_t HWDivID = llvm::ARM::parseHWDiv(HWDiv);
104 if (!llvm::ARM::getHWDivFeatures(HWDivID, Features))
105 D.Diag(clang::diag::err_drv_clang_unsupported) << A->getAsString(Args);
110 const ArgList &Args, StringRef FPU,
111 std::vector<StringRef> &Features) {
112 llvm::ARM::FPUKind FPUKind = llvm::ARM::parseFPU(FPU);
113 if (!llvm::ARM::getFPUFeatures(FPUKind, Features))
114 D.Diag(clang::diag::err_drv_clang_unsupported) << A->getAsString(Args);
120 llvm::ARM::ArchKind ArchKind,
121 std::vector<StringRef> &Features,
122 llvm::ARM::FPUKind &ArgFPUKind) {
124 text.split(
Split, StringRef(
"+"), -1,
false);
126 for (StringRef Feature :
Split) {
127 if (!appendArchExtFeatures(CPU, ArchKind, Feature, Features, ArgFPUKind))
134 std::vector<StringRef> &Features) {
135 CPU = CPU.split(
"+").first;
136 if (CPU !=
"generic") {
137 llvm::ARM::ArchKind ArchKind = llvm::ARM::parseCPUArch(CPU);
138 uint64_t Extension = llvm::ARM::getDefaultExtensions(CPU, ArchKind);
139 llvm::ARM::getExtensionFeatures(Extension, Features);
147 llvm::StringRef ArchName, llvm::StringRef CPUName,
148 std::vector<StringRef> &Features,
149 const llvm::Triple &Triple,
150 llvm::ARM::FPUKind &ArgFPUKind) {
151 std::pair<StringRef, StringRef>
Split = ArchName.split(
"+");
154 llvm::ARM::ArchKind ArchKind = llvm::ARM::parseArch(MArch);
155 if (ArchKind == llvm::ARM::ArchKind::INVALID ||
156 (
Split.second.size() &&
159 D.Diag(clang::diag::err_drv_unsupported_option_argument)
160 << A->getSpelling() << A->getValue();
165 llvm::StringRef CPUName, llvm::StringRef ArchName,
166 std::vector<StringRef> &Features,
167 const llvm::Triple &Triple,
168 llvm::ARM::FPUKind &ArgFPUKind) {
169 std::pair<StringRef, StringRef>
Split = CPUName.split(
"+");
172 llvm::ARM::ArchKind ArchKind =
174 if (ArchKind == llvm::ARM::ArchKind::INVALID ||
176 Features, ArgFPUKind)))
177 D.Diag(clang::diag::err_drv_unsupported_option_argument)
178 << A->getSpelling() << A->getValue();
188 Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float,
189 options::OPT_mfloat_abi_EQ);
190 if (A && (A->getOption().matches(options::OPT_mhard_float) ||
191 (A->getOption().matches(options::OPT_mfloat_abi_EQ) &&
192 A->getValue() == StringRef(
"hard"))))
193 D.Diag(clang::diag::warn_drv_no_floating_point_registers)
194 << A->getAsString(Args);
200 return T.getEnvironment() == llvm::Triple::EABI ||
201 T.getEnvironment() == llvm::Triple::EABIHF ||
210 llvm::ARM::ArchKind AK = llvm::ARM::parseArch(Triple.getArchName());
211 return Triple.isARM() || AK == llvm::ARM::ArchKind::ARMV6T2 ||
212 (Ver >= 7 && AK != llvm::ARM::ArchKind::ARMV8MBaseline);
217 const llvm::Triple &Triple,
bool ForAS) {
218 if (Arg *A = Args.getLastArg(options::OPT_mtp_mode_EQ)) {
220 llvm::StringSwitch<arm::ReadTPMode>(A->getValue())
221 .Case(
"cp15", ReadTPMode::TPIDRURO)
222 .Case(
"tpidrurw", ReadTPMode::TPIDRURW)
223 .Case(
"tpidruro", ReadTPMode::TPIDRURO)
224 .Case(
"tpidrprw", ReadTPMode::TPIDRPRW)
225 .Case(
"soft", ReadTPMode::Soft)
226 .Default(ReadTPMode::Invalid);
227 if ((ThreadPointer == ReadTPMode::TPIDRURW ||
228 ThreadPointer == ReadTPMode::TPIDRURO ||
229 ThreadPointer == ReadTPMode::TPIDRPRW) &&
230 !isHardTPSupported(Triple) && !ForAS) {
231 D.Diag(diag::err_target_unsupported_tp_hard) << Triple.getArchName();
232 return ReadTPMode::Invalid;
234 if (ThreadPointer != ReadTPMode::Invalid)
235 return ThreadPointer;
236 if (StringRef(A->getValue()).empty())
237 D.Diag(diag::err_drv_missing_arg_mtp) << A->getAsString(Args);
239 D.Diag(diag::err_drv_invalid_mtp) << A->getAsString(Args);
240 return ReadTPMode::Invalid;
242 return ReadTPMode::Soft;
246 types::ID InputType, llvm::Triple &Triple) {
247 StringRef MCPU, MArch;
248 if (
const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
249 MCPU = A->getValue();
250 if (
const Arg *A = Args.getLastArg(options::OPT_march_EQ))
251 MArch = A->getValue();
253 std::string CPU = Triple.isOSBinFormatMachO()
258 bool IsBigEndian = Triple.getArch() == llvm::Triple::armeb ||
259 Triple.getArch() == llvm::Triple::thumbeb;
262 if (Arg *A = Args.getLastArg(options::OPT_mlittle_endian,
263 options::OPT_mbig_endian)) {
264 IsBigEndian = !A->getOption().matches(options::OPT_mlittle_endian);
266 std::string ArchName = IsBigEndian ?
"armeb" :
"arm";
270 llvm::ARM::parseArchProfile(Suffix) == llvm::ARM::ProfileKind::M;
271 bool ThumbDefault = IsMProfile ||
273 (llvm::ARM::parseArchVersion(Suffix) == 7 &&
274 Triple.isOSBinFormatMachO()) ||
276 Triple.isOSWindows();
280 bool ARMModeRequested =
281 !Args.hasFlag(options::OPT_mthumb, options::OPT_mno_thumb, ThumbDefault);
282 if (IsMProfile && ARMModeRequested) {
284 D.Diag(diag::err_cpu_unsupported_isa) << CPU <<
"ARM";
286 D.Diag(diag::err_arch_unsupported_isa)
293 bool IsThumb =
false;
294 if (InputType != types::TY_PP_Asm)
296 Args.hasFlag(options::OPT_mthumb, options::OPT_mno_thumb, ThumbDefault);
301 llvm::StringRef WaMArch, WaMCPU;
303 Args.filtered(options::OPT_Wa_COMMA, options::OPT_Xassembler)) {
304 for (StringRef
Value : A->getValues()) {
306 if (
Value ==
"-mthumb")
308 else if (
Value.starts_with(
"-march="))
309 WaMArch =
Value.substr(7);
310 else if (
Value.starts_with(
"-mcpu="))
311 WaMCPU =
Value.substr(6);
315 if (WaMCPU.size() || WaMArch.size()) {
325 if (IsThumb || IsMProfile || Triple.isOSWindows()) {
327 ArchName =
"thumbeb";
331 Triple.setArchName(ArchName + Suffix.str());
335 llvm::Triple &Triple) {
336 if (Triple.isOSLiteOS()) {
337 Triple.setEnvironment(llvm::Triple::OpenHOS);
344 switch (Triple.getEnvironment()) {
345 case llvm::Triple::GNUEABI:
346 case llvm::Triple::GNUEABIHF:
347 Triple.setEnvironment(isHardFloat ? llvm::Triple::GNUEABIHF
348 : llvm::Triple::GNUEABI);
350 case llvm::Triple::GNUEABIT64:
351 case llvm::Triple::GNUEABIHFT64:
352 Triple.setEnvironment(isHardFloat ? llvm::Triple::GNUEABIHFT64
353 : llvm::Triple::GNUEABIT64);
355 case llvm::Triple::EABI:
356 case llvm::Triple::EABIHF:
357 Triple.setEnvironment(isHardFloat ? llvm::Triple::EABIHF
358 : llvm::Triple::EABI);
360 case llvm::Triple::MuslEABI:
361 case llvm::Triple::MuslEABIHF:
362 Triple.setEnvironment(isHardFloat ? llvm::Triple::MuslEABIHF
363 : llvm::Triple::MuslEABI);
365 case llvm::Triple::OpenHOS:
369 if (DefaultABI != arm::FloatABI::Invalid &&
370 isHardFloat != (DefaultABI == arm::FloatABI::Hard)) {
372 Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float,
373 options::OPT_mfloat_abi_EQ);
374 assert(ABIArg &&
"Non-default float abi expected to be from arg");
375 D.Diag(diag::err_drv_unsupported_opt_for_target)
376 << ABIArg->getAsString(Args) << Triple.getTriple();
389 switch (Triple.getOS()) {
390 case llvm::Triple::Darwin:
391 case llvm::Triple::MacOSX:
392 case llvm::Triple::IOS:
393 case llvm::Triple::TvOS:
394 case llvm::Triple::DriverKit:
395 case llvm::Triple::XROS:
397 if (Triple.isWatchABI())
398 return FloatABI::Hard;
400 return (SubArch == 6 || SubArch == 7) ? FloatABI::SoftFP : FloatABI::Soft;
402 case llvm::Triple::WatchOS:
403 return FloatABI::Hard;
406 case llvm::Triple::Win32:
410 return FloatABI::Soft;
411 return FloatABI::Hard;
413 case llvm::Triple::NetBSD:
414 switch (Triple.getEnvironment()) {
415 case llvm::Triple::EABIHF:
416 case llvm::Triple::GNUEABIHF:
417 return FloatABI::Hard;
419 return FloatABI::Soft;
423 case llvm::Triple::FreeBSD:
424 switch (Triple.getEnvironment()) {
425 case llvm::Triple::GNUEABIHF:
426 return FloatABI::Hard;
429 return FloatABI::Soft;
433 case llvm::Triple::Haiku:
434 case llvm::Triple::OpenBSD:
435 return FloatABI::SoftFP;
438 if (Triple.isOHOSFamily())
439 return FloatABI::Soft;
440 switch (Triple.getEnvironment()) {
441 case llvm::Triple::GNUEABIHF:
442 case llvm::Triple::GNUEABIHFT64:
443 case llvm::Triple::MuslEABIHF:
444 case llvm::Triple::EABIHF:
445 return FloatABI::Hard;
446 case llvm::Triple::Android:
447 case llvm::Triple::GNUEABI:
448 case llvm::Triple::GNUEABIT64:
449 case llvm::Triple::MuslEABI:
450 case llvm::Triple::EABI:
452 return FloatABI::SoftFP;
454 return FloatABI::Invalid;
457 return FloatABI::Invalid;
463 const ArgList &Args) {
466 Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float,
467 options::OPT_mfloat_abi_EQ)) {
468 if (A->getOption().matches(options::OPT_msoft_float)) {
469 ABI = FloatABI::Soft;
470 }
else if (A->getOption().matches(options::OPT_mhard_float)) {
471 ABI = FloatABI::Hard;
473 ABI = llvm::StringSwitch<arm::FloatABI>(A->getValue())
474 .Case(
"soft", FloatABI::Soft)
475 .Case(
"softfp", FloatABI::SoftFP)
476 .Case(
"hard", FloatABI::Hard)
477 .Default(FloatABI::Invalid);
478 if (ABI == FloatABI::Invalid && !StringRef(A->getValue()).empty()) {
479 D.Diag(diag::err_drv_invalid_mfloat_abi) << A->getAsString(Args);
480 ABI = FloatABI::Soft;
486 if (ABI == FloatABI::Invalid)
489 if (ABI == FloatABI::Invalid) {
491 if (Triple.isOSBinFormatMachO() &&
492 Triple.getSubArch() == llvm::Triple::ARMSubArch_v7em)
493 ABI = FloatABI::Hard;
495 ABI = FloatABI::Soft;
497 if (Triple.getOS() != llvm::Triple::UnknownOS ||
498 !Triple.isOSBinFormatMachO())
499 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) <<
"soft";
502 assert(ABI != FloatABI::Invalid &&
"must select an ABI");
507 auto MVE = llvm::find(llvm::reverse(F),
"+mve");
508 auto NoMVE = llvm::find(llvm::reverse(F),
"-mve");
509 return MVE != F.rend() &&
510 (NoMVE == F.rend() || std::distance(MVE, NoMVE) > 0);
514 const llvm::Triple &Triple,
516 std::vector<StringRef> &Features,
517 bool ForAS,
bool ForMultilib) {
519 Args.hasArg(options::OPT_mkernel, options::OPT_fapple_kext);
521 std::optional<std::pair<const Arg *, StringRef>> WaCPU, WaFPU, WaHDiv, WaArch;
528 std::vector<StringRef> ExtensionFeatures;
544 if (ABI == arm::FloatABI::Soft)
545 Features.push_back(
"+soft-float");
548 if (ABI != arm::FloatABI::Hard)
549 Features.push_back(
"+soft-float-abi");
554 Args.filtered(options::OPT_Wa_COMMA, options::OPT_Xassembler)) {
557 for (StringRef
Value : A->getValues()) {
558 if (
Value.starts_with(
"-mfpu=")) {
559 WaFPU = std::make_pair(A,
Value.substr(6));
560 }
else if (
Value.starts_with(
"-mcpu=")) {
561 WaCPU = std::make_pair(A,
Value.substr(6));
562 }
else if (
Value.starts_with(
"-mhwdiv=")) {
563 WaHDiv = std::make_pair(A,
Value.substr(8));
564 }
else if (
Value.starts_with(
"-march=")) {
565 WaArch = std::make_pair(A,
Value.substr(7));
573 if (Arg *A = Args.getLastArgNoClaim(options::OPT_mabi_EQ))
574 A->ignoreTargetSpecific();
577 if (
getReadTPMode(
D, Args, Triple, ForAS) == ReadTPMode::TPIDRURW)
578 Features.push_back(
"+read-tp-tpidrurw");
579 if (
getReadTPMode(
D, Args, Triple, ForAS) == ReadTPMode::TPIDRURO)
580 Features.push_back(
"+read-tp-tpidruro");
581 if (
getReadTPMode(
D, Args, Triple, ForAS) == ReadTPMode::TPIDRPRW)
582 Features.push_back(
"+read-tp-tpidrprw");
584 const Arg *ArchArg = Args.getLastArg(options::OPT_march_EQ);
585 const Arg *CPUArg = Args.getLastArg(options::OPT_mcpu_EQ);
588 llvm::ARM::FPUKind ArchArgFPUKind = llvm::ARM::FK_INVALID;
589 llvm::ARM::FPUKind CPUArgFPUKind = llvm::ARM::FK_INVALID;
594 D.Diag(clang::diag::warn_drv_unused_argument)
595 << CPUArg->getAsString(Args);
596 CPUName = WaCPU->second;
597 CPUArg = WaCPU->first;
599 CPUName = CPUArg->getValue();
604 D.Diag(clang::diag::warn_drv_unused_argument)
605 << ArchArg->getAsString(Args);
606 ArchName = WaArch->second;
609 ExtensionFeatures, Triple, ArchArgFPUKind);
612 }
else if (ArchArg) {
613 ArchName = ArchArg->getValue();
615 Triple, ArchArgFPUKind);
619 if (CPUName ==
"native") {
620 for (
auto &F : llvm::sys::getHostCPUFeatures())
622 Args.MakeArgString((F.second ?
"+" :
"-") + F.first()));
623 }
else if (!CPUName.empty()) {
633 Triple, CPUArgFPUKind);
637 (void)Args.getLastArg(options::OPT_mtune_EQ);
640 llvm::ARM::FPUKind FPUKind = llvm::ARM::FK_INVALID;
641 const Arg *FPUArg = Args.getLastArg(options::OPT_mfpu_EQ);
644 D.Diag(clang::diag::warn_drv_unused_argument)
645 << FPUArg->getAsString(Args);
650 const char *AndroidFPU =
"neon";
651 FPUKind = llvm::ARM::parseFPU(AndroidFPU);
652 if (!llvm::ARM::getFPUFeatures(FPUKind, Features))
653 D.Diag(clang::diag::err_drv_clang_unsupported)
654 << std::string(
"-mfpu=") + AndroidFPU;
655 }
else if (ArchArgFPUKind != llvm::ARM::FK_INVALID ||
656 CPUArgFPUKind != llvm::ARM::FK_INVALID) {
658 CPUArgFPUKind != llvm::ARM::FK_INVALID ? CPUArgFPUKind : ArchArgFPUKind;
659 (void)llvm::ARM::getFPUFeatures(FPUKind, Features);
664 if (CPU !=
"generic")
666 llvm::ARM::ArchKind ArchKind =
668 FPUKind = llvm::ARM::getDefaultFPU(CPU, ArchKind);
669 (void)llvm::ARM::getFPUFeatures(FPUKind, Features);
671 if (
Generic && (Triple.isOSWindows() || Triple.isOSDarwin()) &&
673 FPUKind = llvm::ARM::parseFPU(
"neon");
674 (void)llvm::ARM::getFPUFeatures(FPUKind, Features);
681 Features.insert(std::end(Features),
682 std::begin(ExtensionFeatures), std::end(ExtensionFeatures));
685 const Arg *HDivArg = Args.getLastArg(options::OPT_mhwdiv_EQ);
688 D.Diag(clang::diag::warn_drv_unused_argument)
689 << HDivArg->getAsString(Args);
698 const auto ItRNoFullFP16 = std::find(Features.rbegin(), Features.rend(),
"-fullfp16");
699 const auto ItRFP16FML = std::find(Features.rbegin(), Features.rend(),
"+fp16fml");
700 if (Triple.getSubArch() == llvm::Triple::SubArchType::ARMSubArch_v8_4a) {
701 const auto ItRFullFP16 = std::find(Features.rbegin(), Features.rend(),
"+fullfp16");
702 if (ItRFullFP16 < ItRNoFullFP16 && ItRFullFP16 < ItRFP16FML) {
705 if (std::find(Features.rbegin(), ItRFullFP16,
"-fp16fml") == ItRFullFP16)
706 Features.push_back(
"+fp16fml");
709 goto fp16_fml_fallthrough;
715 if (ItRNoFullFP16 < ItRFP16FML)
716 Features.push_back(
"-fp16fml");
717 else if (ItRNoFullFP16 > ItRFP16FML)
718 Features.push_back(
"+fullfp16");
725 bool HasFPRegs =
true;
726 if (ABI == arm::FloatABI::Soft) {
727 llvm::ARM::getFPUFeatures(llvm::ARM::FK_NONE, Features);
731 Features.insert(Features.end(),
732 {
"-dotprod",
"-fp16fml",
"-bf16",
"-mve",
"-mve.fp"});
734 FPUKind = llvm::ARM::FK_NONE;
735 }
else if (FPUKind == llvm::ARM::FK_NONE ||
736 ArchArgFPUKind == llvm::ARM::FK_NONE ||
737 CPUArgFPUKind == llvm::ARM::FK_NONE) {
742 Features.insert(Features.end(),
743 {
"-dotprod",
"-fp16fml",
"-bf16",
"-mve.fp"});
745 FPUKind = llvm::ARM::FK_NONE;
748 Features.emplace_back(
"-fpregs");
751 if (Arg *A = Args.getLastArg(options::OPT_mcrc, options::OPT_mnocrc)) {
752 if (A->getOption().matches(options::OPT_mcrc))
753 Features.push_back(
"+crc");
755 Features.push_back(
"-crc");
764 if (FPUKind == llvm::ARM::FK_FPV5_D16 || FPUKind == llvm::ARM::FK_FPV5_SP_D16)
765 Features.push_back(
"-mve.fp");
775 bool HasSHA2 =
false;
777 const auto ItCrypto =
778 llvm::find_if(llvm::reverse(Features), [](
const StringRef F) {
779 return F.contains(
"crypto");
782 llvm::find_if(llvm::reverse(Features), [](
const StringRef F) {
783 return F.contains(
"crypto") || F.contains(
"sha2");
786 llvm::find_if(llvm::reverse(Features), [](
const StringRef F) {
787 return F.contains(
"crypto") || F.contains(
"aes");
789 const bool FoundSHA2 = ItSHA2 != Features.rend();
790 const bool FoundAES = ItAES != Features.rend();
792 HasSHA2 = ItSHA2->take_front() ==
"+";
794 HasAES = ItAES->take_front() ==
"+";
795 if (ItCrypto != Features.rend()) {
796 if (HasSHA2 && HasAES)
797 Features.push_back(
"+crypto");
799 Features.push_back(
"-crypto");
801 Features.push_back(
"+sha2");
803 Features.push_back(
"-sha2");
805 Features.push_back(
"+aes");
807 Features.push_back(
"-aes");
810 if (HasSHA2 || HasAES) {
813 llvm::ARM::ProfileKind ArchProfile =
814 llvm::ARM::parseArchProfile(ArchSuffix);
815 if (!((llvm::ARM::parseArchVersion(ArchSuffix) >= 8) &&
816 (ArchProfile == llvm::ARM::ProfileKind::A ||
817 ArchProfile == llvm::ARM::ProfileKind::R))) {
819 D.Diag(clang::diag::warn_target_unsupported_extension)
821 << llvm::ARM::getArchName(llvm::ARM::parseArch(ArchSuffix));
823 D.Diag(clang::diag::warn_target_unsupported_extension)
825 << llvm::ARM::getArchName(llvm::ARM::parseArch(ArchSuffix));
831 if (!Args.hasArg(options::OPT_fno_integrated_as)) {
832 Features.push_back(
"-sha2");
833 Features.push_back(
"-aes");
839 if (Arg *A = Args.getLastArg(options::OPT_mframe_chain)) {
840 StringRef FrameChainOption = A->getValue();
841 if (FrameChainOption.starts_with(
"aapcs"))
842 Features.push_back(
"+aapcs-frame-chain");
846 if (Args.getLastArg(options::OPT_mcmse))
847 Features.push_back(
"+8msecext");
849 if (Arg *A = Args.getLastArg(options::OPT_mfix_cmse_cve_2021_35465,
850 options::OPT_mno_fix_cmse_cve_2021_35465)) {
851 if (!Args.getLastArg(options::OPT_mcmse))
852 D.Diag(diag::err_opt_not_valid_without_opt)
853 << A->getOption().getName() <<
"-mcmse";
855 if (A->getOption().matches(options::OPT_mfix_cmse_cve_2021_35465))
856 Features.push_back(
"+fix-cmse-cve-2021-35465");
858 Features.push_back(
"-fix-cmse-cve-2021-35465");
862 if (Arg *A = Args.getLastArg(options::OPT_mfix_cortex_a57_aes_1742098,
863 options::OPT_mno_fix_cortex_a57_aes_1742098)) {
864 if (A->getOption().matches(options::OPT_mfix_cortex_a57_aes_1742098)) {
865 Features.push_back(
"+fix-cortex-a57-aes-1742098");
867 Features.push_back(
"-fix-cortex-a57-aes-1742098");
874 if (Arg *A = Args.getLastArg(options::OPT_mlong_calls,
875 options::OPT_mno_long_calls)) {
876 if (A->getOption().matches(options::OPT_mlong_calls))
877 Features.push_back(
"+long-calls");
878 }
else if (KernelOrKext && (!Triple.isiOS() || Triple.isOSVersionLT(6)) &&
879 !Triple.isWatchOS() && !Triple.isXROS()) {
880 Features.push_back(
"+long-calls");
887 if (!ForAS && !ForMultilib) {
890 if (Arg *A = Args.getLastArg(options::OPT_mexecute_only, options::OPT_mno_execute_only)) {
891 if (A->getOption().matches(options::OPT_mexecute_only)) {
893 llvm::ARM::parseArch(Triple.getArchName()) != llvm::ARM::ArchKind::ARMV6T2 &&
894 llvm::ARM::parseArch(Triple.getArchName()) != llvm::ARM::ArchKind::ARMV6M)
895 D.Diag(diag::err_target_unsupported_execute_only) << Triple.getArchName();
896 else if (llvm::ARM::parseArch(Triple.getArchName()) == llvm::ARM::ArchKind::ARMV6M) {
897 if (Arg *PIArg = Args.getLastArg(options::OPT_fropi, options::OPT_frwpi,
898 options::OPT_fpic, options::OPT_fpie,
899 options::OPT_fPIC, options::OPT_fPIE))
900 D.Diag(diag::err_opt_not_valid_with_opt_on_target)
901 << A->getAsString(Args) << PIArg->getAsString(Args) << Triple.getArchName();
902 }
else if (Arg *B = Args.getLastArg(options::OPT_mno_movt))
903 D.Diag(diag::err_opt_not_valid_with_opt)
904 << A->getAsString(Args) << B->getAsString(Args);
905 Features.push_back(
"+execute-only");
910 if (Arg *A = Args.getLastArg(options::OPT_mno_unaligned_access,
911 options::OPT_munaligned_access,
912 options::OPT_mstrict_align,
913 options::OPT_mno_strict_align)) {
916 A->getOption().matches(options::OPT_mno_unaligned_access) ||
917 A->getOption().matches(options::OPT_mstrict_align)) {
918 Features.push_back(
"+strict-align");
921 if (Triple.getSubArch() == llvm::Triple::SubArchType::ARMSubArch_v6m)
922 D.Diag(diag::err_target_unsupported_unaligned) <<
"v6m";
925 else if (Triple.getSubArch() == llvm::Triple::SubArchType::ARMSubArch_v8m_baseline)
926 D.Diag(diag::err_target_unsupported_unaligned) <<
"v8m.base";
943 if (Triple.isOSDarwin() || Triple.isOSNetBSD()) {
944 if (VersionNum < 6 ||
945 Triple.getSubArch() == llvm::Triple::SubArchType::ARMSubArch_v6m)
946 Features.push_back(
"+strict-align");
947 }
else if (Triple.getVendor() == llvm::Triple::Apple &&
948 Triple.isOSBinFormatMachO()) {
950 Features.push_back(
"+strict-align");
951 }
else if (VersionNum < 7 ||
952 Triple.getSubArch() ==
953 llvm::Triple::SubArchType::ARMSubArch_v6m ||
954 Triple.getSubArch() ==
955 llvm::Triple::SubArchType::ARMSubArch_v8m_baseline) {
956 Features.push_back(
"+strict-align");
963 if (Args.hasArg(options::OPT_ffixed_r9))
964 Features.push_back(
"+reserve-r9");
967 if (KernelOrKext || Args.hasArg(options::OPT_mno_movt))
968 Features.push_back(
"+no-movt");
970 if (Args.hasArg(options::OPT_mno_neg_immediates))
971 Features.push_back(
"+no-neg-immediates");
974 if (Arg *A = Args.getLastArg(options::OPT_mharden_sls_EQ)) {
975 StringRef
Scope = A->getValue();
976 bool EnableRetBr =
false;
977 bool EnableBlr =
false;
978 bool DisableComdat =
false;
979 if (
Scope !=
"none") {
981 Scope.split(Opts,
",");
982 for (
auto Opt : Opts) {
989 if (Opt ==
"retbr") {
997 if (Opt ==
"comdat") {
998 DisableComdat =
false;
1001 if (Opt ==
"nocomdat") {
1002 DisableComdat =
true;
1005 D.Diag(diag::err_drv_unsupported_option_argument)
1006 << A->getSpelling() <<
Scope;
1011 if (EnableRetBr || EnableBlr)
1013 D.Diag(diag::err_sls_hardening_arm_not_supported)
1014 <<
Scope << A->getAsString(Args);
1017 Features.push_back(
"+harden-sls-retbr");
1019 Features.push_back(
"+harden-sls-blr");
1020 if (DisableComdat) {
1021 Features.push_back(
"+harden-sls-nocomdat");
1025 if (Args.getLastArg(options::OPT_mno_bti_at_return_twice))
1026 Features.push_back(
"+no-bti-at-return-twice");
1033std::string
arm::getARMArch(StringRef Arch,
const llvm::Triple &Triple) {
1036 MArch = std::string(Arch);
1038 MArch = std::string(Triple.getArchName());
1039 MArch = StringRef(MArch).split(
"+").first.lower();
1042 if (MArch ==
"native") {
1043 std::string CPU = std::string(llvm::sys::getHostCPUName());
1044 if (CPU !=
"generic") {
1052 MArch = std::string(
"arm") + Suffix.str();
1061 std::string MArch =
getARMArch(Arch, Triple);
1069 return llvm::ARM::getARMCPUForArch(Triple, MArch);
1074 const llvm::Triple &Triple) {
1078 std::string MCPU = StringRef(CPU).split(
"+").first.lower();
1080 if (MCPU ==
"native")
1081 return std::string(llvm::sys::getHostCPUName());
1094 const llvm::Triple &Triple) {
1095 llvm::ARM::ArchKind ArchKind;
1096 if (CPU ==
"generic" || CPU.empty()) {
1098 ArchKind = llvm::ARM::parseArch(ARMArch);
1099 if (ArchKind == llvm::ARM::ArchKind::INVALID)
1103 llvm::ARM::parseCPUArch(llvm::ARM::getARMCPUForArch(Triple, ARMArch));
1107 ArchKind = (Arch ==
"armv7k" || Arch ==
"thumbv7k")
1108 ? llvm::ARM::ArchKind::ARMV7K
1109 : llvm::ARM::parseCPUArch(CPU);
1118 const llvm::Triple &Triple) {
1119 llvm::ARM::ArchKind ArchKind = getLLVMArchKindForARM(CPU, Arch, Triple);
1120 if (ArchKind == llvm::ARM::ArchKind::INVALID)
1122 return llvm::ARM::getSubArch(ArchKind);
1126 const llvm::Triple &Triple) {
1127 if (Args.hasArg(options::OPT_r))
1133 CmdArgs.push_back(
"--be8");
Scope - A scope is a transient data structure that is used while parsing the program.
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
The JSON file list parser is used to communicate input to InstallAPI.
const FunctionProtoType * T
@ Generic
not a target-specific vector type