18#include "llvm/ADT/APSInt.h"
19#include "llvm/ADT/ArrayRef.h"
20#include "llvm/ADT/StringExtras.h"
21#include "llvm/ADT/StringSwitch.h"
22#include "llvm/TargetParser/AArch64TargetParser.h"
23#include "llvm/TargetParser/ARMTargetParserCommon.h"
30#define BUILTIN(ID, TYPE, ATTRS) \
31 {#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
32#define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) \
33 {#ID, TYPE, ATTRS, FEATURE, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
34#include "clang/Basic/BuiltinsNEON.def"
36#define BUILTIN(ID, TYPE, ATTRS) \
37 {#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
38#define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) \
39 {#ID, TYPE, ATTRS, FEATURE, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
40#include "clang/Basic/BuiltinsSVE.def"
42#define BUILTIN(ID, TYPE, ATTRS) \
43 {#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
44#define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) \
45 {#ID, TYPE, ATTRS, FEATURE, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
46#include "clang/Basic/BuiltinsSME.def"
48#define BUILTIN(ID, TYPE, ATTRS) \
49 {#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
50#define LANGBUILTIN(ID, TYPE, ATTRS, LANG) \
51 {#ID, TYPE, ATTRS, nullptr, HeaderDesc::NO_HEADER, LANG},
52#define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) \
53 {#ID, TYPE, ATTRS, FEATURE, HeaderDesc::NO_HEADER, ALL_LANGUAGES},
54#define TARGET_HEADER_BUILTIN(ID, TYPE, ATTRS, HEADER, LANGS, FEATURE) \
55 {#ID, TYPE, ATTRS, FEATURE, HeaderDesc::HEADER, LANGS},
56#include "clang/Basic/BuiltinsAArch64.def"
60 if (*ArchInfo == llvm::AArch64::ARMV8R) {
70 }
else if (ArchInfo->Version.getMajor() == 8) {
71 if (ArchInfo->Version.getMinor() >= 7u) {
74 if (ArchInfo->Version.getMinor() >= 6u) {
78 if (ArchInfo->Version.getMinor() >= 5u) {
79 HasAlternativeNZCV =
true;
86 if (ArchInfo->Version.getMinor() >= 4u) {
91 if (ArchInfo->Version.getMinor() >= 3u) {
95 if (ArchInfo->Version.getMinor() >= 2u) {
98 if (ArchInfo->Version.getMinor() >= 1u) {
103 }
else if (ArchInfo->Version.getMajor() == 9) {
104 if (ArchInfo->Version.getMinor() >= 2u) {
107 if (ArchInfo->Version.getMinor() >= 1u) {
114 HasAlternativeNZCV =
true;
152 if (Triple.isArch64Bit())
197 if (Triple.getOS() == llvm::Triple::Linux)
199 else if (Triple.getOS() == llvm::Triple::UnknownOS)
201 Opts.
EABIVersion == llvm::EABI::GNU ?
"\01_mcount" :
"mcount";
207 if (Name !=
"aapcs" && Name !=
"aapcs-soft" && Name !=
"darwinpcs")
215 if (
hasFeature(
"fp") && ABI ==
"aapcs-soft") {
218 Diags.
Report(diag::err_target_unsupported_abi_with_fpu) << ABI;
226 StringRef &Err)
const {
227 llvm::ARM::ParsedBranchProtection PBP;
228 if (!llvm::ARM::parseBranchProtection(Spec, PBP, Err, HasPAuthLR))
232 llvm::StringSwitch<LangOptions::SignReturnAddressScopeKind>(PBP.Scope)
237 if (PBP.Key ==
"a_key")
249 return Name ==
"generic" || llvm::AArch64::parseCpu(Name);
258 llvm::AArch64::fillValidCPUArchList(Values);
263 Builder.defineMacro(
"__ARM_FEATURE_QRDMX",
"1");
274 Builder.defineMacro(
"__ARM_FEATURE_COMPLEX",
"1");
275 Builder.defineMacro(
"__ARM_FEATURE_JCVT",
"1");
288 Builder.defineMacro(
"__ARM_FEATURE_FRINT",
"1");
289 Builder.defineMacro(
"__ARM_FEATURE_BTI",
"1");
364 Builder.defineMacro(
"__amd64__");
365 Builder.defineMacro(
"__amd64");
366 Builder.defineMacro(
"__x86_64");
367 Builder.defineMacro(
"__x86_64__");
368 Builder.defineMacro(
"__arm64ec__");
370 Builder.defineMacro(
"__aarch64__");
374 Builder.defineMacro(
"__GCC_ASM_FLAG_OUTPUTS__");
377 if (CodeModel ==
"default")
379 for (
char &
c : CodeModel)
381 Builder.defineMacro(
"__AARCH64_CMODEL_" + CodeModel +
"__");
384 Builder.defineMacro(
"__ARM_ACLE",
"200");
385 Builder.defineMacro(
"__ARM_ARCH",
386 std::to_string(ArchInfo->Version.getMajor()));
387 Builder.defineMacro(
"__ARM_ARCH_PROFILE",
388 std::string(
"'") + (
char)ArchInfo->Profile +
"'");
390 Builder.defineMacro(
"__ARM_64BIT_STATE",
"1");
391 Builder.defineMacro(
"__ARM_PCS_AAPCS64",
"1");
392 Builder.defineMacro(
"__ARM_ARCH_ISA_A64",
"1");
394 Builder.defineMacro(
"__ARM_FEATURE_CLZ",
"1");
395 Builder.defineMacro(
"__ARM_FEATURE_FMA",
"1");
396 Builder.defineMacro(
"__ARM_FEATURE_LDREX",
"0xF");
397 Builder.defineMacro(
"__ARM_FEATURE_IDIV",
"1");
398 Builder.defineMacro(
"__ARM_FEATURE_DIV");
399 Builder.defineMacro(
"__ARM_FEATURE_NUMERIC_MAXMIN",
"1");
400 Builder.defineMacro(
"__ARM_FEATURE_DIRECTED_ROUNDING",
"1");
402 Builder.defineMacro(
"__ARM_ALIGN_MAX_STACK_PWR",
"4");
406 Builder.defineMacro(
"__ARM_STATE_ZA",
"1");
407 Builder.defineMacro(
"__ARM_STATE_ZT0",
"1");
411 Builder.defineMacro(
"__ARM_FP",
"0xE");
415 Builder.defineMacro(
"__ARM_FP16_FORMAT_IEEE",
"1");
416 Builder.defineMacro(
"__ARM_FP16_ARGS",
"1");
418 if (Opts.UnsafeFPMath)
419 Builder.defineMacro(
"__ARM_FP_FAST",
"1");
421 Builder.defineMacro(
"__ARM_SIZEOF_WCHAR_T",
422 Twine(Opts.WCharSize ? Opts.WCharSize : 4));
424 Builder.defineMacro(
"__ARM_SIZEOF_MINIMAL_ENUM", Opts.ShortEnums ?
"1" :
"4");
426 if (FPU & NeonMode) {
427 Builder.defineMacro(
"__ARM_NEON",
"1");
429 Builder.defineMacro(
"__ARM_NEON_FP",
"0xE");
433 Builder.defineMacro(
"__ARM_FEATURE_SVE",
"1");
435 if ((FPU & NeonMode) && (FPU & SveMode))
436 Builder.defineMacro(
"__ARM_NEON_SVE_BRIDGE",
"1");
439 Builder.defineMacro(
"__ARM_FEATURE_SVE2",
"1");
441 if (HasSVE2 && HasSVE2AES)
442 Builder.defineMacro(
"__ARM_FEATURE_SVE2_AES",
"1");
444 if (HasSVE2 && HasSVE2BitPerm)
445 Builder.defineMacro(
"__ARM_FEATURE_SVE2_BITPERM",
"1");
447 if (HasSVE2 && HasSVE2SHA3)
448 Builder.defineMacro(
"__ARM_FEATURE_SVE2_SHA3",
"1");
450 if (HasSVE2 && HasSVE2SM4)
451 Builder.defineMacro(
"__ARM_FEATURE_SVE2_SM4",
"1");
454 Builder.defineMacro(
"__ARM_FEATURE_SME");
455 Builder.defineMacro(
"__ARM_FEATURE_LOCALLY_STREAMING",
"1");
459 Builder.defineMacro(
"__ARM_FEATURE_SME");
460 Builder.defineMacro(
"__ARM_FEATURE_SME2");
461 Builder.defineMacro(
"__ARM_FEATURE_LOCALLY_STREAMING",
"1");
465 Builder.defineMacro(
"__ARM_FEATURE_CRC32",
"1");
468 Builder.defineMacro(
"__ARM_FEATURE_RCPC",
"3");
470 Builder.defineMacro(
"__ARM_FEATURE_RCPC",
"1");
473 Builder.defineMacro(
"__HAVE_FUNCTION_MULTI_VERSIONING",
"1");
477 if (HasAES && HasSHA2)
478 Builder.defineMacro(
"__ARM_FEATURE_CRYPTO",
"1");
481 Builder.defineMacro(
"__ARM_FEATURE_AES",
"1");
484 Builder.defineMacro(
"__ARM_FEATURE_SHA2",
"1");
487 Builder.defineMacro(
"__ARM_FEATURE_SHA3",
"1");
488 Builder.defineMacro(
"__ARM_FEATURE_SHA512",
"1");
492 Builder.defineMacro(
"__ARM_FEATURE_SM3",
"1");
493 Builder.defineMacro(
"__ARM_FEATURE_SM4",
"1");
497 Builder.defineMacro(
"__ARM_FEATURE_PAUTH",
"1");
500 Builder.defineMacro(
"__ARM_FEATURE_PAUTH_LR",
"1");
503 Builder.defineMacro(
"__ARM_FEATURE_UNALIGNED",
"1");
505 if ((FPU & NeonMode) && HasFullFP16)
506 Builder.defineMacro(
"__ARM_FEATURE_FP16_VECTOR_ARITHMETIC",
"1");
508 Builder.defineMacro(
"__ARM_FEATURE_FP16_SCALAR_ARITHMETIC",
"1");
511 Builder.defineMacro(
"__ARM_FEATURE_DOTPROD",
"1");
514 Builder.defineMacro(
"__ARM_FEATURE_MEMORY_TAGGING",
"1");
517 Builder.defineMacro(
"__ARM_FEATURE_TME",
"1");
520 Builder.defineMacro(
"__ARM_FEATURE_MATMUL_INT8",
"1");
523 Builder.defineMacro(
"__ARM_FEATURE_ATOMICS",
"1");
526 Builder.defineMacro(
"__ARM_FEATURE_BF16",
"1");
527 Builder.defineMacro(
"__ARM_FEATURE_BF16_VECTOR_ARITHMETIC",
"1");
528 Builder.defineMacro(
"__ARM_BF16_FORMAT_ALTERNATIVE",
"1");
529 Builder.defineMacro(
"__ARM_FEATURE_BF16_SCALAR_ARITHMETIC",
"1");
532 if ((FPU & SveMode) && HasBFloat16) {
533 Builder.defineMacro(
"__ARM_FEATURE_SVE_BF16",
"1");
536 if ((FPU & SveMode) && HasMatmulFP64)
537 Builder.defineMacro(
"__ARM_FEATURE_SVE_MATMUL_FP64",
"1");
539 if ((FPU & SveMode) && HasMatmulFP32)
540 Builder.defineMacro(
"__ARM_FEATURE_SVE_MATMUL_FP32",
"1");
542 if ((FPU & SveMode) && HasMatMul)
543 Builder.defineMacro(
"__ARM_FEATURE_SVE_MATMUL_INT8",
"1");
545 if ((FPU & NeonMode) && HasFP16FML)
546 Builder.defineMacro(
"__ARM_FEATURE_FP16_FML",
"1");
564 if (Opts.BranchProtectionPAuthLR)
567 Builder.defineMacro(
"__ARM_FEATURE_PAC_DEFAULT", std::to_string(
Value));
570 if (Opts.BranchTargetEnforcement)
571 Builder.defineMacro(
"__ARM_FEATURE_BTI_DEFAULT",
"1");
573 if (Opts.GuardedControlStack)
574 Builder.defineMacro(
"__ARM_FEATURE_GCS_DEFAULT",
"1");
577 Builder.defineMacro(
"__ARM_FEATURE_LS64",
"1");
580 Builder.defineMacro(
"__ARM_FEATURE_RNG",
"1");
583 Builder.defineMacro(
"__ARM_FEATURE_MOPS",
"1");
586 Builder.defineMacro(
"__ARM_FEATURE_SYSREG128",
"1");
589 Builder.defineMacro(
"__ARM_FEATURE_GCS",
"1");
591 if (*ArchInfo == llvm::AArch64::ARMV8_1A)
593 else if (*ArchInfo == llvm::AArch64::ARMV8_2A)
595 else if (*ArchInfo == llvm::AArch64::ARMV8_3A)
597 else if (*ArchInfo == llvm::AArch64::ARMV8_4A)
599 else if (*ArchInfo == llvm::AArch64::ARMV8_5A)
601 else if (*ArchInfo == llvm::AArch64::ARMV8_6A)
603 else if (*ArchInfo == llvm::AArch64::ARMV8_7A)
605 else if (*ArchInfo == llvm::AArch64::ARMV8_8A)
607 else if (*ArchInfo == llvm::AArch64::ARMV8_9A)
609 else if (*ArchInfo == llvm::AArch64::ARMV9A)
611 else if (*ArchInfo == llvm::AArch64::ARMV9_1A)
613 else if (*ArchInfo == llvm::AArch64::ARMV9_2A)
615 else if (*ArchInfo == llvm::AArch64::ARMV9_3A)
617 else if (*ArchInfo == llvm::AArch64::ARMV9_4A)
619 else if (*ArchInfo == llvm::AArch64::ARMV9_5A)
623 Builder.defineMacro(
"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
624 Builder.defineMacro(
"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
625 Builder.defineMacro(
"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
626 Builder.defineMacro(
"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
627 Builder.defineMacro(
"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16");
630 Builder.defineMacro(
"__FP_FAST_FMA",
"1");
631 Builder.defineMacro(
"__FP_FAST_FMAF",
"1");
635 Builder.defineMacro(
"__ARM_FEATURE_SVE_VECTOR_OPERATORS",
"2");
637 if (Opts.VScaleMin && Opts.VScaleMin == Opts.VScaleMax) {
638 Builder.defineMacro(
"__ARM_FEATURE_SVE_BITS", Twine(Opts.VScaleMin * 128));
647std::optional<std::pair<unsigned, unsigned>>
649 if (LangOpts.VScaleMin || LangOpts.VScaleMax)
650 return std::pair<unsigned, unsigned>(
651 LangOpts.VScaleMin ? LangOpts.VScaleMin : 1, LangOpts.VScaleMax);
654 return std::pair<unsigned, unsigned>(1, 16);
660 if (Name ==
"default")
662 if (
auto Ext = llvm::AArch64::parseArchExtension(Name))
663 return Ext->FmvPriority;
669 return llvm::AArch64::ExtensionInfo::MaxFMVPriority;
673 if (
auto Ext = llvm::AArch64::parseArchExtension(Name))
674 return !Ext->DependentFeatures.empty();
679 if (
auto Ext = llvm::AArch64::parseArchExtension(Name))
680 return Ext->DependentFeatures;
687 FeatureStr.split(Features,
"+");
688 for (
auto &Feature : Features)
689 if (!llvm::AArch64::parseArchExtension(Feature.trim()).has_value())
695 return llvm::StringSwitch<bool>(Feature)
696 .Cases(
"aarch64",
"arm64",
"arm",
true)
698 .Case(
"fp", FPU & FPUMode)
699 .Cases(
"neon",
"simd", FPU & NeonMode)
700 .Case(
"jscvt", HasJSCVT)
701 .Case(
"fcma", HasFCMA)
702 .Case(
"rng", HasRandGen)
703 .Case(
"flagm", HasFlagM)
704 .Case(
"flagm2", HasAlternativeNZCV)
705 .Case(
"fp16fml", HasFP16FML)
706 .Case(
"dotprod", HasDotProd)
711 .Case(
"sha2", HasSHA2)
712 .Case(
"sha3", HasSHA3)
713 .Cases(
"aes",
"pmull", HasAES)
714 .Cases(
"fp16",
"fullfp16", HasFullFP16)
716 .Case(
"dpb", HasCCPP)
717 .Case(
"dpb2", HasCCDP)
718 .Case(
"rcpc", HasRCPC)
719 .Case(
"frintts", HasFRInt3264)
720 .Case(
"i8mm", HasMatMul)
721 .Case(
"bf16", HasBFloat16)
722 .Case(
"sve", FPU & SveMode)
723 .Case(
"sve-bf16", FPU & SveMode && HasBFloat16)
724 .Case(
"sve-i8mm", FPU & SveMode && HasMatMul)
725 .Case(
"f32mm", FPU & SveMode && HasMatmulFP32)
726 .Case(
"f64mm", FPU & SveMode && HasMatmulFP64)
727 .Case(
"sve2", FPU & SveMode && HasSVE2)
728 .Case(
"sve2-pmull128", FPU & SveMode && HasSVE2AES)
729 .Case(
"sve2-bitperm", FPU & SveMode && HasSVE2BitPerm)
730 .Case(
"sve2-sha3", FPU & SveMode && HasSVE2SHA3)
731 .Case(
"sve2-sm4", FPU & SveMode && HasSVE2SM4)
733 .Case(
"sme2", HasSME2)
734 .Case(
"sme-f64f64", HasSMEF64F64)
735 .Case(
"sme-i16i64", HasSMEI16I64)
736 .Case(
"sme-fa64", HasSMEFA64)
737 .Cases(
"memtag",
"memtag2", HasMTE)
739 .Case(
"predres", HasPredRes)
740 .Cases(
"ssbs",
"ssbs2", HasSSBS)
742 .Cases(
"ls64",
"ls64_v",
"ls64_accdata", HasLS64)
743 .Case(
"wfxt", HasWFxT)
744 .Case(
"rcpc3", HasRCPC3)
749 StringRef Name,
bool Enabled)
const {
750 Features[Name] = Enabled;
753 const std::optional<llvm::AArch64::ArchInfo> ArchInfo =
754 llvm::AArch64::ArchInfo::findBySubArch(Name);
763 for (
const auto *OtherArch : llvm::AArch64::ArchInfos)
764 if (ArchInfo->implies(*OtherArch))
765 Features[OtherArch->getSubArch()] =
true;
768 std::vector<StringRef> CPUFeats;
769 if (llvm::AArch64::getExtensionFeatures(ArchInfo->DefaultExts, CPUFeats)) {
770 for (
auto F : CPUFeats) {
771 assert(F[0] ==
'+' &&
"Expected + in target feature!");
772 Features[F.drop_front(1)] =
true;
779 for (
const auto &Feature : Features) {
780 if (Feature ==
"-fp-armv8")
782 if (Feature ==
"-neon")
784 if (Feature ==
"-sve")
787 if (Feature ==
"+neon" || Feature ==
"+fp-armv8")
789 if (Feature ==
"+jscvt") {
793 if (Feature ==
"+fcma") {
798 if (Feature ==
"+sve") {
803 if (Feature ==
"+sve2") {
809 if (Feature ==
"+sve2-aes") {
816 if (Feature ==
"+sve2-sha3") {
823 if (Feature ==
"+sve2-sm4") {
830 if (Feature ==
"+sve2-bitperm") {
835 HasSVE2BitPerm =
true;
837 if (Feature ==
"+f32mm") {
841 HasMatmulFP32 =
true;
843 if (Feature ==
"+f64mm") {
847 HasMatmulFP64 =
true;
849 if (Feature ==
"+sme") {
854 if (Feature ==
"+sme2") {
860 if (Feature ==
"+sme-f64f64") {
866 if (Feature ==
"+sme-i16i64") {
872 if (Feature ==
"+sme-fa64") {
879 if (Feature ==
"+sb")
881 if (Feature ==
"+predres")
883 if (Feature ==
"+ssbs")
885 if (Feature ==
"+bti")
887 if (Feature ==
"+wfxt")
889 if (Feature ==
"-fmv")
891 if (Feature ==
"+crc")
893 if (Feature ==
"+rcpc")
895 if (Feature ==
"+aes") {
899 if (Feature ==
"+sha2") {
903 if (Feature ==
"+sha3") {
908 if (Feature ==
"+rdm") {
912 if (Feature ==
"+dit")
914 if (Feature ==
"+cccp")
916 if (Feature ==
"+ccdp") {
920 if (Feature ==
"+fptoint")
922 if (Feature ==
"+sm4") {
926 if (Feature ==
"+strict-align")
930 if (Feature ==
"+v8a" && ArchInfo->Version < llvm::AArch64::ARMV8A.Version)
931 ArchInfo = &llvm::AArch64::ARMV8A;
932 if (Feature ==
"+v8.1a" &&
933 ArchInfo->Version < llvm::AArch64::ARMV8_1A.Version)
934 ArchInfo = &llvm::AArch64::ARMV8_1A;
935 if (Feature ==
"+v8.2a" &&
936 ArchInfo->Version < llvm::AArch64::ARMV8_2A.Version)
937 ArchInfo = &llvm::AArch64::ARMV8_2A;
938 if (Feature ==
"+v8.3a" &&
939 ArchInfo->Version < llvm::AArch64::ARMV8_3A.Version)
940 ArchInfo = &llvm::AArch64::ARMV8_3A;
941 if (Feature ==
"+v8.4a" &&
942 ArchInfo->Version < llvm::AArch64::ARMV8_4A.Version)
943 ArchInfo = &llvm::AArch64::ARMV8_4A;
944 if (Feature ==
"+v8.5a" &&
945 ArchInfo->Version < llvm::AArch64::ARMV8_5A.Version)
946 ArchInfo = &llvm::AArch64::ARMV8_5A;
947 if (Feature ==
"+v8.6a" &&
948 ArchInfo->Version < llvm::AArch64::ARMV8_6A.Version)
949 ArchInfo = &llvm::AArch64::ARMV8_6A;
950 if (Feature ==
"+v8.7a" &&
951 ArchInfo->Version < llvm::AArch64::ARMV8_7A.Version)
952 ArchInfo = &llvm::AArch64::ARMV8_7A;
953 if (Feature ==
"+v8.8a" &&
954 ArchInfo->Version < llvm::AArch64::ARMV8_8A.Version)
955 ArchInfo = &llvm::AArch64::ARMV8_8A;
956 if (Feature ==
"+v8.9a" &&
957 ArchInfo->Version < llvm::AArch64::ARMV8_9A.Version)
958 ArchInfo = &llvm::AArch64::ARMV8_9A;
959 if (Feature ==
"+v9a" && ArchInfo->Version < llvm::AArch64::ARMV9A.Version)
960 ArchInfo = &llvm::AArch64::ARMV9A;
961 if (Feature ==
"+v9.1a" &&
962 ArchInfo->Version < llvm::AArch64::ARMV9_1A.Version)
963 ArchInfo = &llvm::AArch64::ARMV9_1A;
964 if (Feature ==
"+v9.2a" &&
965 ArchInfo->Version < llvm::AArch64::ARMV9_2A.Version)
966 ArchInfo = &llvm::AArch64::ARMV9_2A;
967 if (Feature ==
"+v9.3a" &&
968 ArchInfo->Version < llvm::AArch64::ARMV9_3A.Version)
969 ArchInfo = &llvm::AArch64::ARMV9_3A;
970 if (Feature ==
"+v9.4a" &&
971 ArchInfo->Version < llvm::AArch64::ARMV9_4A.Version)
972 ArchInfo = &llvm::AArch64::ARMV9_4A;
973 if (Feature ==
"+v9.5a" &&
974 ArchInfo->Version < llvm::AArch64::ARMV9_5A.Version)
975 ArchInfo = &llvm::AArch64::ARMV9_5A;
976 if (Feature ==
"+v8r")
977 ArchInfo = &llvm::AArch64::ARMV8R;
978 if (Feature ==
"+fullfp16") {
982 if (Feature ==
"+dotprod") {
986 if (Feature ==
"+fp16fml") {
991 if (Feature ==
"+mte")
993 if (Feature ==
"+tme")
995 if (Feature ==
"+pauth")
997 if (Feature ==
"+i8mm")
999 if (Feature ==
"+bf16")
1001 if (Feature ==
"+lse")
1003 if (Feature ==
"+ls64")
1005 if (Feature ==
"+rand")
1007 if (Feature ==
"+flagm")
1009 if (Feature ==
"+altnzcv") {
1011 HasAlternativeNZCV =
true;
1013 if (Feature ==
"+mops")
1015 if (Feature ==
"+d128")
1017 if (Feature ==
"+gcs")
1019 if (Feature ==
"+rcpc3")
1021 if (Feature ==
"+pauth-lr") {
1030 for (
const auto &Feature : Features) {
1031 if (Feature ==
"-d128")
1055 const std::vector<std::string> &FeaturesVec)
const {
1056 std::vector<std::string> UpdatedFeaturesVec;
1058 std::optional<llvm::AArch64::CpuInfo> CpuInfo = llvm::AArch64::parseCpu(CPU);
1060 auto Exts = CpuInfo->getImpliedExtensions();
1061 std::vector<StringRef> CPUFeats;
1062 llvm::AArch64::getExtensionFeatures(Exts, CPUFeats);
1063 for (
auto F : CPUFeats) {
1064 assert((F[0] ==
'+' || F[0] ==
'-') &&
"Expected +/- in target feature!");
1065 UpdatedFeaturesVec.push_back(F.str());
1073 for (
const auto &Feature : FeaturesVec)
1074 if (((Feature[0] ==
'?' || Feature[0] ==
'+')) &&
1076 StringRef DepFeatures =
1079 DepFeatures.split(AttrFeatures,
",");
1080 for (
auto F : AttrFeatures)
1081 UpdatedFeaturesVec.push_back(F.str());
1083 for (
const auto &Feature : FeaturesVec)
1084 if (Feature[0] !=
'?') {
1085 std::string UpdatedFeature = Feature;
1086 if (Feature[0] ==
'+') {
1087 std::optional<llvm::AArch64::ExtensionInfo> Extension =
1088 llvm::AArch64::parseArchExtension(Feature.substr(1));
1090 UpdatedFeature = Extension->Feature.str();
1092 UpdatedFeaturesVec.push_back(UpdatedFeature);
1106 if (Features ==
"default")
1109 Features.split(AttrFeatures,
",");
1110 bool FoundArch =
false;
1112 auto SplitAndAddFeatures = [](StringRef FeatString,
1113 std::vector<std::string> &Features) {
1115 FeatString.split(SplitFeatures, StringRef(
"+"), -1,
false);
1116 for (StringRef Feature : SplitFeatures) {
1117 StringRef FeatureName = llvm::AArch64::getArchExtFeature(Feature);
1118 if (!FeatureName.empty())
1119 Features.push_back(FeatureName.str());
1123 if (Feature.starts_with(
"no"))
1124 Features.push_back(
"-" + Feature.drop_front(2).str());
1126 Features.push_back(
"+" + Feature.str());
1130 for (
auto &Feature : AttrFeatures) {
1131 Feature = Feature.trim();
1132 if (Feature.starts_with(
"fpmath="))
1135 if (Feature.starts_with(
"branch-protection=")) {
1136 Ret.BranchProtection = Feature.split(
'=').second.trim();
1140 if (Feature.starts_with(
"arch=")) {
1142 Ret.Duplicate =
"arch=";
1144 std::pair<StringRef, StringRef> Split =
1145 Feature.split(
"=").second.trim().split(
"+");
1146 const llvm::AArch64::ArchInfo *AI = llvm::AArch64::parseArch(Split.first);
1152 Ret.Features.push_back(AI->ArchFeature.str());
1154 SplitAndAddFeatures(Split.second, Ret.Features);
1155 }
else if (Feature.starts_with(
"cpu=")) {
1156 if (!Ret.CPU.empty())
1157 Ret.Duplicate =
"cpu=";
1161 std::pair<StringRef, StringRef> Split =
1162 Feature.split(
"=").second.trim().split(
"+");
1163 Ret.CPU = Split.first;
1164 SplitAndAddFeatures(Split.second, Ret.Features);
1166 }
else if (Feature.starts_with(
"tune=")) {
1167 if (!Ret.Tune.empty())
1168 Ret.Duplicate =
"tune=";
1170 Ret.Tune = Feature.split(
"=").second.trim();
1171 }
else if (Feature.starts_with(
"+")) {
1172 SplitAndAddFeatures(Feature, Ret.Features);
1173 }
else if (Feature.starts_with(
"no-")) {
1174 StringRef FeatureName =
1175 llvm::AArch64::getArchExtFeature(Feature.split(
"-").second);
1176 if (!FeatureName.empty())
1177 Ret.Features.push_back(
"-" + FeatureName.drop_front(1).str());
1179 Ret.Features.push_back(
"-" + Feature.split(
"-").second.str());
1184 StringRef FeatureName = llvm::AArch64::getArchExtFeature(Feature);
1185 if (!FeatureName.empty())
1186 Ret.Features.push_back(FeatureName.str());
1188 Ret.Features.push_back(
"+" + Feature.str());
1222const char *
const AArch64TargetInfo::GCCRegNames[] = {
1226 "w0",
"w1",
"w2",
"w3",
"w4",
"w5",
"w6",
"w7",
"w8",
"w9",
"w10",
"w11",
1227 "w12",
"w13",
"w14",
"w15",
"w16",
"w17",
"w18",
"w19",
"w20",
"w21",
"w22",
1228 "w23",
"w24",
"w25",
"w26",
"w27",
"w28",
"w29",
"w30",
"wsp",
1231 "x0",
"x1",
"x2",
"x3",
"x4",
"x5",
"x6",
"x7",
"x8",
"x9",
"x10",
"x11",
1232 "x12",
"x13",
"x14",
"x15",
"x16",
"x17",
"x18",
"x19",
"x20",
"x21",
"x22",
1233 "x23",
"x24",
"x25",
"x26",
"x27",
"x28",
"fp",
"lr",
"sp",
1236 "s0",
"s1",
"s2",
"s3",
"s4",
"s5",
"s6",
"s7",
"s8",
"s9",
"s10",
"s11",
1237 "s12",
"s13",
"s14",
"s15",
"s16",
"s17",
"s18",
"s19",
"s20",
"s21",
"s22",
1238 "s23",
"s24",
"s25",
"s26",
"s27",
"s28",
"s29",
"s30",
"s31",
1241 "d0",
"d1",
"d2",
"d3",
"d4",
"d5",
"d6",
"d7",
"d8",
"d9",
"d10",
"d11",
1242 "d12",
"d13",
"d14",
"d15",
"d16",
"d17",
"d18",
"d19",
"d20",
"d21",
"d22",
1243 "d23",
"d24",
"d25",
"d26",
"d27",
"d28",
"d29",
"d30",
"d31",
1246 "v0",
"v1",
"v2",
"v3",
"v4",
"v5",
"v6",
"v7",
"v8",
"v9",
"v10",
"v11",
1247 "v12",
"v13",
"v14",
"v15",
"v16",
"v17",
"v18",
"v19",
"v20",
"v21",
"v22",
1248 "v23",
"v24",
"v25",
"v26",
"v27",
"v28",
"v29",
"v30",
"v31",
1251 "z0",
"z1",
"z2",
"z3",
"z4",
"z5",
"z6",
"z7",
"z8",
"z9",
"z10",
1252 "z11",
"z12",
"z13",
"z14",
"z15",
"z16",
"z17",
"z18",
"z19",
"z20",
"z21",
1253 "z22",
"z23",
"z24",
"z25",
"z26",
"z27",
"z28",
"z29",
"z30",
"z31",
1256 "p0",
"p1",
"p2",
"p3",
"p4",
"p5",
"p6",
"p7",
"p8",
"p9",
"p10",
1257 "p11",
"p12",
"p13",
"p14",
"p15",
1260 "pn0",
"pn1",
"pn2",
"pn3",
"pn4",
"pn5",
"pn6",
"pn7",
"pn8",
1261 "pn9",
"pn10",
"pn11",
"pn12",
"pn13",
"pn14",
"pn15",
1306 {{
"r29",
"x29"},
"fp"},
1307 {{
"r30",
"x30"},
"lr"},
1318 constexpr unsigned len = 5;
1319 auto RV = llvm::StringSwitch<unsigned>(Name)
1343 switch (*Constraint) {
1345 R = std::string(
"@3") + std::string(Constraint, 3);
1350 std::string Converted =
"{" + std::string(Constraint, Len) +
"}";
1351 Constraint += Len - 1;
1354 return std::string(1, *Constraint);
1386 if (Name[1] ==
'p' &&
1387 (Name[2] ==
'l' || Name[2] ==
'a' || Name[2] ==
'h')) {
1393 if (Name[1] ==
'c' && (Name[2] ==
'i' || Name[2] ==
'j')) {
1428 StringRef Constraint,
char Modifier,
unsigned Size,
1429 std::string &SuggestedModifier)
const {
1431 Constraint = Constraint.ltrim(
"=+&");
1433 switch (Constraint[0]) {
1453 SuggestedModifier =
"w";
1471 const llvm::APSInt &value)
const {
1472 return 0 <= value && value <= 3;
1481void AArch64leTargetInfo::setDataLayout() {
1484 resetDataLayout(
"e-m:o-p:32:32-i64:64-i128:128-n32:64-S128-Fn32",
"_");
1488 resetDataLayout(
"e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128-Fn32");
1493 Builder.defineMacro(
"__AARCH64EL__");
1503 Builder.defineMacro(
"__AARCH64EB__");
1504 Builder.defineMacro(
"__AARCH_BIG_ENDIAN");
1505 Builder.defineMacro(
"__ARM_BIG_ENDIAN");
1509void AArch64beTargetInfo::setDataLayout() {
1510 assert(!
getTriple().isOSBinFormatMachO());
1511 resetDataLayout(
"E-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128-Fn32");
1520 IntWidth = IntAlign = 32;
1521 LongWidth = LongAlign = 32;
1522 DoubleAlign = LongLongAlign = 64;
1523 LongDoubleWidth = LongDoubleAlign = 64;
1524 LongDoubleFormat = &llvm::APFloat::IEEEdouble();
1525 IntMaxType = SignedLongLong;
1526 Int64Type = SignedLongLong;
1527 SizeType = UnsignedLongLong;
1528 PtrDiffType = SignedLongLong;
1529 IntPtrType = SignedLongLong;
1533 resetDataLayout(Triple.isOSBinFormatMachO()
1534 ?
"e-m:o-i64:64-i128:128-n32:64-S128-Fn32"
1535 :
"e-m:w-p:64:64-i32:32-i64:64-i128:128-n32:64-S128-Fn32",
1536 Triple.isOSBinFormatMachO() ?
"_" :
"");
1548 if (getTriple().isWindowsArm64EC())
1564 return CCCR_Warning;
1571 TheCXXABI.set(TargetCXXABI::Microsoft);
1577 if (getTriple().isWindowsArm64EC()) {
1578 Builder.defineMacro(
"_M_X64",
"100");
1579 Builder.defineMacro(
"_M_AMD64",
"100");
1580 Builder.defineMacro(
"_M_ARM64EC",
"1");
1582 Builder.defineMacro(
"_M_ARM64",
"1");
1588 return CCK_MicrosoftWin64;
1592 bool HasNonWeakDef)
const {
1594 WindowsARM64TargetInfo::getMinGlobalAlign(TypeSize, HasNonWeakDef);
1600 if (TypeSize >= 512) {
1601 Align = std::max(Align, 128u);
1602 }
else if (TypeSize >= 64) {
1603 Align = std::max(Align, 64u);
1604 }
else if (TypeSize >= 16) {
1605 Align = std::max(Align, 32u);
1613 TheCXXABI.set(TargetCXXABI::GenericAArch64);
1619 Int64Type = SignedLongLong;
1620 if (getTriple().isArch32Bit())
1621 IntMaxType = SignedLongLong;
1623 WCharType = SignedInt;
1624 UseSignedCharForObjCBool =
false;
1626 LongDoubleWidth = LongDoubleAlign = SuitableAlign = 64;
1627 LongDoubleFormat = &llvm::APFloat::IEEEdouble();
1629 UseZeroLengthBitfieldAlignment =
false;
1631 if (getTriple().isArch32Bit()) {
1632 UseBitFieldTypeAlignment =
false;
1633 ZeroLengthBitfieldBoundary = 32;
1634 UseZeroLengthBitfieldAlignment =
true;
1635 TheCXXABI.set(TargetCXXABI::WatchOS);
1637 TheCXXABI.set(TargetCXXABI::AppleARM64);
1641 const llvm::Triple &Triple,
1643 Builder.defineMacro(
"__AARCH64_SIMD__");
1644 if (Triple.isArch32Bit())
1645 Builder.defineMacro(
"__ARM64_ARCH_8_32__");
1647 Builder.defineMacro(
"__ARM64_ARCH_8__");
1648 Builder.defineMacro(
"__ARM_NEON__");
1649 Builder.defineMacro(
"__REGISTER_PREFIX__",
"");
1650 Builder.defineMacro(
"__arm64",
"1");
1651 Builder.defineMacro(
"__arm64__",
"1");
1653 if (Triple.isArm64e())
1654 Builder.defineMacro(
"__arm64e__",
"1");
1669 Triple.getEnvironmentName()),
1676 Builder.defineMacro(
"__RENDERSCRIPT__");
Defines the Diagnostic-related interfaces.
static unsigned matchAsmCCConstraint(const char *Name)
static constexpr Builtin::Info BuiltinInfo[]
static constexpr Builtin::Info BuiltinInfo[]
Defines the clang::LangOptions interface.
Enumerates target-specific builtins in their own namespaces within namespace clang.
__device__ __2f16 float c
Concrete class used by the front-end to report problems and issues.
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
@ None
No signing for any function.
@ NonLeaf
Sign the return address of functions that spill LR.
@ All
Sign the return address of all functions,.
@ BKey
Return address signing uses APIB key.
@ AKey
Return address signing uses APIA key.
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
bool isSignReturnAddressWithAKey() const
Check if return address signing uses AKey.
bool hasSignReturnAddress() const
Check if return address signing is enabled.
bool isSignReturnAddressScopeAll() const
Check if leaf functions are also signed.
Exposes information about the current target.
TargetOptions & getTargetOpts() const
Retrieve the target options.
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
unsigned HasAArch64SVETypes
void resetDataLayout(StringRef DL, const char *UserLabelPrefix="")
BuiltinVaListKind
The different kinds of __builtin_va_list types defined by the target implementation.
@ AArch64ABIBuiltinVaList
__builtin_va_list as defined by the AArch64 ABI http://infocenter.arm.com/help/topic/com....
@ CharPtrBuiltinVaList
typedef char* __builtin_va_list;
unsigned IsRenderScriptTarget
unsigned HasUnalignedAccess
unsigned char MaxAtomicPromoteWidth
virtual bool initFeatureMap(llvm::StringMap< bool > &Features, DiagnosticsEngine &Diags, StringRef CPU, const std::vector< std::string > &FeatureVec) const
Initialize the map with the default set of target features for the CPU this should include all legal ...
virtual std::string convertConstraint(const char *&Constraint) const
unsigned char MaxAtomicInlineWidth
unsigned HasBuiltinMSVaList
Options for controlling the target.
llvm::EABI EABIVersion
The EABI version to use.
void getTargetDefinesARMV95A(const LangOptions &Opts, MacroBuilder &Builder) const
unsigned multiVersionSortPriority(StringRef Name) const override
std::string_view getClobbers() const override
Returns a string of target-specific clobbers, in LLVM format.
bool hasFeature(StringRef Feature) const override
Determine whether the given target has the given feature.
std::string convertConstraint(const char *&Constraint) const override
ArrayRef< TargetInfo::GCCRegAlias > getGCCRegAliases() const override
bool hasBFloat16Type() const override
Determine whether the _BFloat16 type is supported on this target.
ParsedTargetAttr parseTargetAttr(StringRef Str) const override
AArch64TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
bool initFeatureMap(llvm::StringMap< bool > &Features, DiagnosticsEngine &Diags, StringRef CPU, const std::vector< std::string > &FeaturesVec) const override
Initialize the map with the default set of target features for the CPU this should include all legal ...
unsigned multiVersionFeatureCost() const override
ArrayRef< const char * > getGCCRegNames() const override
bool handleTargetFeatures(std::vector< std::string > &Features, DiagnosticsEngine &Diags) override
Perform initialization based on the user configured set of features (e.g., +sse4).
void getTargetDefines(const LangOptions &Opts, MacroBuilder &Builder) const override
===-— Other target property query methods -----------------------—===//
void setFeatureEnabled(llvm::StringMap< bool > &Features, StringRef Name, bool Enabled) const override
Enable or disable a specific target feature; the feature name must be valid.
void getTargetDefinesARMV89A(const LangOptions &Opts, MacroBuilder &Builder) const
void getTargetDefinesARMV92A(const LangOptions &Opts, MacroBuilder &Builder) const
StringRef getFeatureDependencies(StringRef Name) const override
For given feature return dependent ones.
bool validateTarget(DiagnosticsEngine &Diags) const override
Check the target is valid after it is fully initialized.
void getTargetDefinesARMV93A(const LangOptions &Opts, MacroBuilder &Builder) const
bool setABI(const std::string &Name) override
Use the specified ABI.
void getTargetDefinesARMV84A(const LangOptions &Opts, MacroBuilder &Builder) const
bool isValidCPUName(StringRef Name) const override
Determine whether this TargetInfo supports the given CPU name.
void fillValidCPUList(SmallVectorImpl< StringRef > &Values) const override
Fill a SmallVectorImpl with the valid values to setCPU.
StringRef getABI() const override
Get the ABI currently in use.
bool hasInt128Type() const override
Determine whether the __int128 type is supported on this target.
void getTargetDefinesARMV88A(const LangOptions &Opts, MacroBuilder &Builder) const
bool validateBranchProtection(StringRef Spec, StringRef Arch, BranchProtectionInfo &BPI, StringRef &Err) const override
Determine if this TargetInfo supports the given branch protection specification.
void getTargetDefinesARMV87A(const LangOptions &Opts, MacroBuilder &Builder) const
void getTargetDefinesARMV9A(const LangOptions &Opts, MacroBuilder &Builder) const
CallingConvCheckResult checkCallingConvention(CallingConv CC) const override
Determines whether a given calling convention is valid for the target.
void getTargetDefinesARMV91A(const LangOptions &Opts, MacroBuilder &Builder) const
BuiltinVaListKind getBuiltinVaListKind() const override
Returns the kind of __builtin_va_list type that should be used with this target.
int getEHDataRegisterNumber(unsigned RegNo) const override
Return the register number that __builtin_eh_return_regno would return with the specified argument.
void getTargetDefinesARMV81A(const LangOptions &Opts, MacroBuilder &Builder) const
ArrayRef< Builtin::Info > getTargetBuiltins() const override
Return information about target-specific builtins for the current primary target, and info about whic...
void getTargetDefinesARMV86A(const LangOptions &Opts, MacroBuilder &Builder) const
bool setCPU(const std::string &Name) override
Target the specified CPU.
std::optional< std::pair< unsigned, unsigned > > getVScaleRange(const LangOptions &LangOpts) const override
Returns target-specific min and max values VScale_Range.
void getTargetDefinesARMV94A(const LangOptions &Opts, MacroBuilder &Builder) const
bool validateConstraintModifier(StringRef Constraint, char Modifier, unsigned Size, std::string &SuggestedModifier) const override
bool isCLZForZeroUndef() const override
The __builtin_clz* and __builtin_ctz* built-in functions are specified to have undefined results for ...
void getTargetDefinesARMV82A(const LangOptions &Opts, MacroBuilder &Builder) const
void getTargetDefinesARMV83A(const LangOptions &Opts, MacroBuilder &Builder) const
bool validateCpuSupports(StringRef FeatureStr) const override
bool validatePointerAuthKey(const llvm::APSInt &value) const override
Determine whether the given pointer-authentication key is valid.
bool validateAsmConstraint(const char *&Name, TargetInfo::ConstraintInfo &Info) const override
bool doesFeatureAffectCodeGen(StringRef Name) const override
Returns true if feature has an impact on target code generation.
void getTargetDefinesARMV85A(const LangOptions &Opts, MacroBuilder &Builder) const
void getTargetDefines(const LangOptions &Opts, MacroBuilder &Builder) const override
===-— Other target property query methods -----------------------—===//
AArch64beTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
AArch64leTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
void getTargetDefines(const LangOptions &Opts, MacroBuilder &Builder) const override
===-— Other target property query methods -----------------------—===//
DarwinAArch64TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, MacroBuilder &Builder) const override
BuiltinVaListKind getBuiltinVaListKind() const override
unsigned getMinGlobalAlign(uint64_t TypeSize, bool HasNonWeakDef) const override
MicrosoftARM64TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
TargetInfo::CallingConvKind getCallingConvKind(bool ClangABICompat4) const override
void getTargetDefines(const LangOptions &Opts, MacroBuilder &Builder) const override
MinGWARM64TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
void getTargetDefines(const LangOptions &Opts, MacroBuilder &Builder) const override
RenderScript64TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
void getTargetDefines(const LangOptions &Opts, MacroBuilder &Builder) const override
===-— Other target property query methods -----------------------—===//
BuiltinVaListKind getBuiltinVaListKind() const override
WindowsARM64TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
void setDataLayout() override
CallingConvCheckResult checkCallingConvention(CallingConv CC) const override
Defines the clang::TargetInfo interface.
void getDarwinDefines(MacroBuilder &Builder, const LangOptions &Opts, const llvm::Triple &Triple, StringRef &PlatformName, VersionTuple &PlatformMinVersion)
The JSON file list parser is used to communicate input to InstallAPI.
CallingConv
CallingConv - Specifies the calling convention that a function uses.
Diagnostic wrappers for TextAPI types for error reporting.
Contains information gathered from parsing the contents of TargetAttr.
LangOptions::SignReturnAddressScopeKind SignReturnAddr
LangOptions::SignReturnAddressKeyKind SignKey
bool BranchProtectionPAuthLR
bool BranchTargetEnforcement
unsigned UseZeroLengthBitfieldAlignment
Whether zero length bitfields (e.g., int : 0;) force alignment of the next bitfield.
unsigned short SuitableAlign
unsigned char PointerWidth
const llvm::fltSemantics * LongDoubleFormat
std::optional< unsigned > BitIntMaxAlign
unsigned UseBitFieldTypeAlignment
Control whether the alignment of bit-field types is respected when laying out structures.
unsigned char PointerAlign
unsigned char BFloat16Width
unsigned char LongDoubleAlign
unsigned char LongDoubleWidth
unsigned char BFloat16Align
const llvm::fltSemantics * BFloat16Format