18#include "llvm/ADT/APSInt.h"
19#include "llvm/ADT/ArrayRef.h"
20#include "llvm/ADT/StringSwitch.h"
21#include "llvm/TargetParser/AArch64TargetParser.h"
22#include "llvm/TargetParser/ARMTargetParserCommon.h"
47#define GET_NEON_BUILTIN_STR_TABLE
48#include "clang/Basic/arm_neon.inc"
49#undef GET_NEON_BUILTIN_STR_TABLE
51static constexpr std::array<Builtin::Info, NumNeonBuiltins>
BuiltinInfos = {
52#define GET_NEON_BUILTIN_INFOS
53#include "clang/Basic/arm_neon.inc"
54#undef GET_NEON_BUILTIN_INFOS
58#define GET_NEON_BUILTIN_STR_TABLE
59#include "clang/Basic/arm_fp16.inc"
60#undef GET_NEON_BUILTIN_STR_TABLE
62static constexpr std::array<Builtin::Info, NumFp16Builtins>
BuiltinInfos = {
63#define GET_NEON_BUILTIN_INFOS
64#include "clang/Basic/arm_fp16.inc"
65#undef GET_NEON_BUILTIN_INFOS
71#define GET_SVE_BUILTIN_STR_TABLE
72#include "clang/Basic/arm_sve_builtins.inc"
73#undef GET_SVE_BUILTIN_STR_TABLE
75static constexpr std::array<Builtin::Info, NumSVEBuiltins>
BuiltinInfos = {
76#define GET_SVE_BUILTIN_INFOS
77#include "clang/Basic/arm_sve_builtins.inc"
78#undef GET_SVE_BUILTIN_INFOS
83#define GET_SME_BUILTIN_STR_TABLE
84#include "clang/Basic/arm_sme_builtins.inc"
85#undef GET_SME_BUILTIN_STR_TABLE
87static constexpr std::array<Builtin::Info, NumSMEBuiltins>
BuiltinInfos = {
88#define GET_SME_BUILTIN_INFOS
89#include "clang/Basic/arm_sme_builtins.inc"
90#undef GET_SME_BUILTIN_INFOS
97#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_STR_TABLE
98#define GET_SVE_BUILTINS
99#include "clang/Basic/BuiltinsAArch64NeonSVEBridge.def"
100#undef GET_SVE_BUILTINS
105#define BUILTIN CLANG_BUILTIN_STR_TABLE
106#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_STR_TABLE
107#define TARGET_HEADER_BUILTIN CLANG_TARGET_HEADER_BUILTIN_STR_TABLE
108#include "clang/Basic/BuiltinsAArch64.def"
113#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_ENTRY
114#define GET_SVE_BUILTINS
115#include "clang/Basic/BuiltinsAArch64NeonSVEBridge.def"
116#undef GET_SVE_BUILTINS
121#define BUILTIN CLANG_BUILTIN_ENTRY
122#define TARGET_BUILTIN CLANG_TARGET_BUILTIN_ENTRY
123#define LANGBUILTIN CLANG_LANGBUILTIN_ENTRY
124#define TARGET_HEADER_BUILTIN CLANG_TARGET_HEADER_BUILTIN_ENTRY
125#include "clang/Basic/BuiltinsAArch64.def"
150 if (Triple.isArch64Bit())
197 TheCXXABI.set(TargetCXXABI::GenericAArch64);
199 if (Triple.getOS() == llvm::Triple::Linux)
200 this->MCountName =
"\01_mcount";
201 else if (Triple.getOS() == llvm::Triple::UnknownOS)
203 Opts.
EABIVersion == llvm::EABI::GNU ?
"\01_mcount" :
"mcount";
209 if (Name !=
"aapcs" && Name !=
"aapcs-soft" && Name !=
"darwinpcs" &&
218 if (
hasFeature(
"fp") && ABI ==
"aapcs-soft") {
221 Diags.
Report(diag::err_target_unsupported_abi_with_fpu) << ABI;
224 if (
getTriple().getEnvironment() == llvm::Triple::PAuthTest &&
225 getTriple().getOS() != llvm::Triple::Linux) {
226 Diags.
Report(diag::err_target_unsupported_abi_for_triple)
234 StringRef RegName,
unsigned RegSize,
bool &HasSizeMismatch)
const {
235 if (RegName ==
"sp") {
236 HasSizeMismatch = RegSize != 64;
239 if (RegName.starts_with(
"w"))
240 HasSizeMismatch = RegSize != 32;
241 else if (RegName.starts_with(
"x"))
242 HasSizeMismatch = RegSize != 64;
245 StringRef RegNum = RegName.drop_front();
248 return RegNum ==
"0" ||
250 llvm::AArch64::isX18ReservedByDefault(
getTriple())) ||
257 StringRef &Err)
const {
258 llvm::ARM::ParsedBranchProtection PBP;
259 if (!llvm::ARM::parseBranchProtection(Spec, PBP, Err, HasPAuthLR))
264 if (LO.PointerAuthReturns &&
265 (PBP.Scope !=
"none" || PBP.BranchProtectionPAuthLR ||
266 PBP.GuardedControlStack))
270 llvm::StringSwitch<LangOptions::SignReturnAddressScopeKind>(PBP.Scope)
275 if (PBP.Key ==
"a_key")
287 return llvm::AArch64::parseCpu(Name).has_value();
296 llvm::AArch64::fillValidCPUArchList(Values);
301 Builder.defineMacro(
"__ARM_FEATURE_QRDMX",
"1");
312 Builder.defineMacro(
"__ARM_FEATURE_COMPLEX",
"1");
313 Builder.defineMacro(
"__ARM_FEATURE_JCVT",
"1");
326 Builder.defineMacro(
"__ARM_FEATURE_FRINT",
"1");
407 Builder.defineMacro(
"__amd64__");
408 Builder.defineMacro(
"__amd64");
409 Builder.defineMacro(
"__x86_64");
410 Builder.defineMacro(
"__x86_64__");
411 Builder.defineMacro(
"__arm64ec__");
413 Builder.defineMacro(
"__aarch64__");
417 Builder.defineMacro(
"__GCC_ASM_FLAG_OUTPUTS__");
420 if (CodeModel ==
"default")
422 for (
char &
c : CodeModel)
424 Builder.defineMacro(
"__AARCH64_CMODEL_" + CodeModel +
"__");
427 Builder.defineMacro(
"__ARM_ACLE_VERSION(year, quarter, patch)",
428 "(100 * (year) + 10 * (quarter) + (patch))");
429#define ARM_ACLE_VERSION(Y, Q, P) (100 * (Y) + 10 * (Q) + (P))
431 Builder.defineMacro(
"__FUNCTION_MULTI_VERSIONING_SUPPORT_LEVEL",
433#undef ARM_ACLE_VERSION
434 Builder.defineMacro(
"__ARM_ARCH",
435 std::to_string(ArchInfo->Version.getMajor()));
436 Builder.defineMacro(
"__ARM_ARCH_PROFILE",
437 std::string(
"'") + (
char)ArchInfo->Profile +
"'");
439 Builder.defineMacro(
"__ARM_64BIT_STATE",
"1");
440 Builder.defineMacro(
"__ARM_PCS_AAPCS64",
"1");
441 Builder.defineMacro(
"__ARM_ARCH_ISA_A64",
"1");
443 Builder.defineMacro(
"__ARM_FEATURE_CLZ",
"1");
444 Builder.defineMacro(
"__ARM_FEATURE_FMA",
"1");
445 Builder.defineMacro(
"__ARM_FEATURE_LDREX",
"0xF");
446 Builder.defineMacro(
"__ARM_FEATURE_IDIV",
"1");
447 Builder.defineMacro(
"__ARM_FEATURE_DIV");
448 Builder.defineMacro(
"__ARM_FEATURE_NUMERIC_MAXMIN",
"1");
449 Builder.defineMacro(
"__ARM_FEATURE_DIRECTED_ROUNDING",
"1");
451 Builder.defineMacro(
"__ARM_ALIGN_MAX_STACK_PWR",
"4");
455 Builder.defineMacro(
"__ARM_STATE_ZA",
"1");
456 Builder.defineMacro(
"__ARM_STATE_ZT0",
"1");
460 Builder.defineMacro(
"__ARM_FP",
"0xE");
464 Builder.defineMacro(
"__ARM_FP16_FORMAT_IEEE",
"1");
465 Builder.defineMacro(
"__ARM_FP16_ARGS",
"1");
468 Builder.defineMacro(
"__ARM_NEON_SVE_BRIDGE",
"1");
470 if (Opts.UnsafeFPMath)
471 Builder.defineMacro(
"__ARM_FP_FAST",
"1");
473 Builder.defineMacro(
"__ARM_SIZEOF_WCHAR_T",
474 Twine(Opts.WCharSize ? Opts.WCharSize : 4));
476 Builder.defineMacro(
"__ARM_SIZEOF_MINIMAL_ENUM", Opts.ShortEnums ?
"1" :
"4");
478 if (FPU & NeonMode) {
479 Builder.defineMacro(
"__ARM_NEON",
"1");
481 Builder.defineMacro(
"__ARM_NEON_FP",
"0xE");
485 Builder.defineMacro(
"__ARM_FEATURE_SVE",
"1");
488 Builder.defineMacro(
"__ARM_FEATURE_SVE2",
"1");
491 Builder.defineMacro(
"__ARM_FEATURE_SVE2p1",
"1");
493 if (HasSVE2 && HasSVEAES)
494 Builder.defineMacro(
"__ARM_FEATURE_SVE2_AES",
"1");
496 if (HasSVE2 && HasSVEBitPerm)
497 Builder.defineMacro(
"__ARM_FEATURE_SVE2_BITPERM",
"1");
499 if (HasSVE2 && HasSVE2SHA3)
500 Builder.defineMacro(
"__ARM_FEATURE_SVE2_SHA3",
"1");
502 if (HasSVE2 && HasSVE2SM4)
503 Builder.defineMacro(
"__ARM_FEATURE_SVE2_SM4",
"1");
506 Builder.defineMacro(
"__ARM_FEATURE_SVE_B16B16",
"1");
509 Builder.defineMacro(
"__ARM_FEATURE_SME");
510 Builder.defineMacro(
"__ARM_FEATURE_LOCALLY_STREAMING",
"1");
514 Builder.defineMacro(
"__ARM_FEATURE_SME2",
"1");
517 Builder.defineMacro(
"__ARM_FEATURE_SME2p1",
"1");
520 Builder.defineMacro(
"__ARM_FEATURE_SME_F16F16",
"1");
523 Builder.defineMacro(
"__ARM_FEATURE_SME_B16B16",
"1");
526 Builder.defineMacro(
"__ARM_FEATURE_FP8",
"1");
529 Builder.defineMacro(
"__ARM_FEATURE_FP8FMA",
"1");
532 Builder.defineMacro(
"__ARM_FEATURE_FP8DOT2",
"1");
535 Builder.defineMacro(
"__ARM_FEATURE_FP8DOT4",
"1");
538 Builder.defineMacro(
"__ARM_FEATURE_SSVE_FP8DOT2",
"1");
541 Builder.defineMacro(
"__ARM_FEATURE_SSVE_FP8DOT4",
"1");
544 Builder.defineMacro(
"__ARM_FEATURE_SSVE_FP8FMA",
"1");
547 Builder.defineMacro(
"__ARM_FEATURE_SME_F8F32",
"1");
550 Builder.defineMacro(
"__ARM_FEATURE_SME_F8F16",
"1");
553 Builder.defineMacro(
"__ARM_FEATURE_CRC32",
"1");
556 Builder.defineMacro(
"__ARM_FEATURE_CSSC",
"1");
559 Builder.defineMacro(
"__ARM_FEATURE_RCPC",
"3");
561 Builder.defineMacro(
"__ARM_FEATURE_RCPC",
"1");
564 Builder.defineMacro(
"__HAVE_FUNCTION_MULTI_VERSIONING",
"1");
568 if (HasAES && HasSHA2)
569 Builder.defineMacro(
"__ARM_FEATURE_CRYPTO",
"1");
572 Builder.defineMacro(
"__ARM_FEATURE_AES",
"1");
575 Builder.defineMacro(
"__ARM_FEATURE_SHA2",
"1");
578 Builder.defineMacro(
"__ARM_FEATURE_SHA3",
"1");
579 Builder.defineMacro(
"__ARM_FEATURE_SHA512",
"1");
583 Builder.defineMacro(
"__ARM_FEATURE_SM3",
"1");
584 Builder.defineMacro(
"__ARM_FEATURE_SM4",
"1");
588 Builder.defineMacro(
"__ARM_FEATURE_PAUTH",
"1");
591 Builder.defineMacro(
"__ARM_FEATURE_PAUTH_LR",
"1");
594 Builder.defineMacro(
"__ARM_FEATURE_BTI",
"1");
597 Builder.defineMacro(
"__ARM_FEATURE_UNALIGNED",
"1");
599 if ((FPU & NeonMode) && HasFullFP16)
600 Builder.defineMacro(
"__ARM_FEATURE_FP16_VECTOR_ARITHMETIC",
"1");
602 Builder.defineMacro(
"__ARM_FEATURE_FP16_SCALAR_ARITHMETIC",
"1");
605 Builder.defineMacro(
"__ARM_FEATURE_DOTPROD",
"1");
608 Builder.defineMacro(
"__ARM_FEATURE_MEMORY_TAGGING",
"1");
611 Builder.defineMacro(
"__ARM_FEATURE_TME",
"1");
614 Builder.defineMacro(
"__ARM_FEATURE_MATMUL_INT8",
"1");
617 Builder.defineMacro(
"__ARM_FEATURE_ATOMICS",
"1");
620 Builder.defineMacro(
"__ARM_FEATURE_BF16",
"1");
621 Builder.defineMacro(
"__ARM_FEATURE_BF16_VECTOR_ARITHMETIC",
"1");
622 Builder.defineMacro(
"__ARM_BF16_FORMAT_ALTERNATIVE",
"1");
623 Builder.defineMacro(
"__ARM_FEATURE_BF16_SCALAR_ARITHMETIC",
"1");
626 if ((FPU & SveMode) && HasBFloat16) {
627 Builder.defineMacro(
"__ARM_FEATURE_SVE_BF16",
"1");
630 if ((FPU & SveMode) && HasMatmulFP64)
631 Builder.defineMacro(
"__ARM_FEATURE_SVE_MATMUL_FP64",
"1");
633 if ((FPU & SveMode) && HasMatmulFP32)
634 Builder.defineMacro(
"__ARM_FEATURE_SVE_MATMUL_FP32",
"1");
636 if ((FPU & SveMode) && HasMatMul)
637 Builder.defineMacro(
"__ARM_FEATURE_SVE_MATMUL_INT8",
"1");
639 if ((FPU & NeonMode) && HasFP16FML)
640 Builder.defineMacro(
"__ARM_FEATURE_FP16_FML",
"1");
658 if (Opts.BranchProtectionPAuthLR)
661 Builder.defineMacro(
"__ARM_FEATURE_PAC_DEFAULT", std::to_string(
Value));
664 if (Opts.BranchTargetEnforcement)
665 Builder.defineMacro(
"__ARM_FEATURE_BTI_DEFAULT",
"1");
667 if (Opts.GuardedControlStack)
668 Builder.defineMacro(
"__ARM_FEATURE_GCS_DEFAULT",
"1");
671 Builder.defineMacro(
"__ARM_FEATURE_LS64",
"1");
674 Builder.defineMacro(
"__ARM_FEATURE_RNG",
"1");
677 Builder.defineMacro(
"__ARM_FEATURE_MOPS",
"1");
680 Builder.defineMacro(
"__ARM_FEATURE_SYSREG128",
"1");
683 Builder.defineMacro(
"__ARM_FEATURE_GCS",
"1");
685 if (*ArchInfo == llvm::AArch64::ARMV8_1A)
687 else if (*ArchInfo == llvm::AArch64::ARMV8_2A)
689 else if (*ArchInfo == llvm::AArch64::ARMV8_3A)
691 else if (*ArchInfo == llvm::AArch64::ARMV8_4A)
693 else if (*ArchInfo == llvm::AArch64::ARMV8_5A)
695 else if (*ArchInfo == llvm::AArch64::ARMV8_6A)
697 else if (*ArchInfo == llvm::AArch64::ARMV8_7A)
699 else if (*ArchInfo == llvm::AArch64::ARMV8_8A)
701 else if (*ArchInfo == llvm::AArch64::ARMV8_9A)
703 else if (*ArchInfo == llvm::AArch64::ARMV9A)
705 else if (*ArchInfo == llvm::AArch64::ARMV9_1A)
707 else if (*ArchInfo == llvm::AArch64::ARMV9_2A)
709 else if (*ArchInfo == llvm::AArch64::ARMV9_3A)
711 else if (*ArchInfo == llvm::AArch64::ARMV9_4A)
713 else if (*ArchInfo == llvm::AArch64::ARMV9_5A)
715 else if (*ArchInfo == llvm::AArch64::ARMV9_6A)
719 Builder.defineMacro(
"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
720 Builder.defineMacro(
"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
721 Builder.defineMacro(
"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
722 Builder.defineMacro(
"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
723 Builder.defineMacro(
"__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16");
726 Builder.defineMacro(
"__FP_FAST_FMA",
"1");
727 Builder.defineMacro(
"__FP_FAST_FMAF",
"1");
731 Builder.defineMacro(
"__ARM_FEATURE_SVE_VECTOR_OPERATORS",
"2");
733 if (Opts.VScaleMin && Opts.VScaleMin == Opts.VScaleMax) {
734 Builder.defineMacro(
"__ARM_FEATURE_SVE_BITS", Twine(Opts.VScaleMin * 128));
751std::optional<std::pair<unsigned, unsigned>>
754 llvm::StringMap<bool> *FeatureMap)
const {
756 (LangOpts.VScaleMin || LangOpts.VScaleMax))
757 return std::pair<unsigned, unsigned>(
758 LangOpts.VScaleMin ? LangOpts.VScaleMin : 1,
759 LangOpts.VScaleMax ? LangOpts.VScaleMax : 16);
762 (LangOpts.VScaleStreamingMin || LangOpts.VScaleStreamingMax))
763 return std::pair<unsigned, unsigned>(
764 LangOpts.VScaleStreamingMin ? LangOpts.VScaleStreamingMin : 1,
765 LangOpts.VScaleStreamingMax ? LangOpts.VScaleStreamingMax : 16);
768 ((LangOpts.VScaleMin && LangOpts.VScaleStreamingMin) ||
769 (LangOpts.VScaleMax && LangOpts.VScaleStreamingMax))) {
771 std::min(LangOpts.VScaleMin ? LangOpts.VScaleMin : 1,
772 LangOpts.VScaleStreamingMin ? LangOpts.VScaleStreamingMin : 1);
773 unsigned Max = std::max(
774 LangOpts.VScaleMax ? LangOpts.VScaleMax : 16,
775 LangOpts.VScaleStreamingMax ? LangOpts.VScaleStreamingMax : 16);
776 return std::pair(
Min,
Max);
779 if (
hasFeature(
"sve") || (FeatureMap && (FeatureMap->lookup(
"sve"))))
780 return std::pair<unsigned, unsigned>(1, 16);
783 (
hasFeature(
"sme") || (FeatureMap && (FeatureMap->lookup(
"sme")))))
784 return std::pair<unsigned, unsigned>(1, 16);
791 return llvm::AArch64::getFMVPriority(Features);
796 if (
auto Ext = llvm::AArch64::parseFMVExtension(Name))
797 return Ext->ID.has_value();
804 FeatureStr.split(Features,
"+");
806 if (!llvm::AArch64::parseFMVExtension(
Feature.trim()).has_value())
812 return llvm::StringSwitch<bool>(
Feature)
813 .Cases(
"aarch64",
"arm64",
"arm",
true)
815 .Case(
"fp", FPU & FPUMode)
816 .Cases(
"neon",
"simd", FPU & NeonMode)
817 .Case(
"jscvt", HasJSCVT)
818 .Case(
"fcma", HasFCMA)
819 .Case(
"rng", HasRandGen)
820 .Case(
"flagm", HasFlagM)
821 .Case(
"flagm2", HasAlternativeNZCV)
822 .Case(
"fp16fml", HasFP16FML)
823 .Case(
"dotprod", HasDotProd)
828 .Case(
"cssc", HasCSSC)
829 .Case(
"sha2", HasSHA2)
830 .Case(
"sha3", HasSHA3)
831 .Cases(
"aes",
"pmull", HasAES)
832 .Cases(
"fp16",
"fullfp16", HasFullFP16)
834 .Case(
"dpb", HasCCPP)
835 .Case(
"dpb2", HasCCDP)
836 .Case(
"rcpc", HasRCPC)
837 .Case(
"frintts", HasFRInt3264)
838 .Case(
"i8mm", HasMatMul)
839 .Case(
"bf16", HasBFloat16)
840 .Case(
"sve", FPU & SveMode)
841 .Case(
"sve-b16b16", HasSVEB16B16)
842 .Case(
"f32mm", FPU & SveMode && HasMatmulFP32)
843 .Case(
"f64mm", FPU & SveMode && HasMatmulFP64)
844 .Case(
"sve2", FPU & SveMode && HasSVE2)
845 .Case(
"sve-aes", HasSVEAES)
846 .Case(
"sve-bitperm", FPU & HasSVEBitPerm)
847 .Case(
"sve2-sha3", FPU & SveMode && HasSVE2SHA3)
848 .Case(
"sve2-sm4", FPU & SveMode && HasSVE2SM4)
849 .Case(
"sve2p1", FPU & SveMode && HasSVE2p1)
851 .Case(
"sme2", HasSME2)
852 .Case(
"sme2p1", HasSME2p1)
853 .Case(
"sme-f64f64", HasSMEF64F64)
854 .Case(
"sme-i16i64", HasSMEI16I64)
855 .Case(
"sme-fa64", HasSMEFA64)
856 .Case(
"sme-f16f16", HasSMEF16F16)
857 .Case(
"sme-b16b16", HasSMEB16B16)
858 .Case(
"memtag", HasMTE)
860 .Case(
"predres", HasPredRes)
861 .Cases(
"ssbs",
"ssbs2", HasSSBS)
863 .Cases(
"ls64",
"ls64_v",
"ls64_accdata", HasLS64)
864 .Case(
"wfxt", HasWFxT)
865 .Case(
"rcpc3", HasRCPC3)
867 .Case(
"fp8fma", HasFP8FMA)
868 .Case(
"fp8dot2", HasFP8DOT2)
869 .Case(
"fp8dot4", HasFP8DOT4)
870 .Case(
"ssve-fp8dot2", HasSSVE_FP8DOT2)
871 .Case(
"ssve-fp8dot4", HasSSVE_FP8DOT4)
872 .Case(
"ssve-fp8fma", HasSSVE_FP8FMA)
873 .Case(
"sme-f8f32", HasSME_F8F32)
874 .Case(
"sme-f8f16", HasSME_F8F16)
879 StringRef Name,
bool Enabled)
const {
880 Features[Name] = Enabled;
883 const std::optional<llvm::AArch64::ArchInfo> ArchInfo =
884 llvm::AArch64::ArchInfo::findBySubArch(Name);
893 for (
const auto *OtherArch : llvm::AArch64::ArchInfos)
894 if (ArchInfo->implies(*OtherArch))
895 Features[OtherArch->getSubArch()] =
true;
898 std::vector<StringRef> CPUFeats;
899 if (llvm::AArch64::getExtensionFeatures(ArchInfo->DefaultExts, CPUFeats)) {
900 for (
auto F : CPUFeats) {
901 assert(F[0] ==
'+' &&
"Expected + in target feature!");
902 Features[F.drop_front(1)] =
true;
909 for (
const auto &
Feature : Features) {
967 if (
Feature ==
"+sve-bitperm") {
970 HasSVEBitPerm =
true;
976 HasMatmulFP32 =
true;
982 HasMatmulFP64 =
true;
1002 if (
Feature ==
"+sme-f64f64") {
1004 HasSMEF64F64 =
true;
1008 if (
Feature ==
"+sme-i16i64") {
1010 HasSMEI16I64 =
true;
1021 if (
Feature ==
"+sme-f16f16") {
1026 HasSMEF16F16 =
true;
1028 if (
Feature ==
"+sme-b16b16") {
1033 HasSVEB16B16 =
true;
1034 HasSMEB16B16 =
true;
1045 if (
Feature ==
"+ssve-fp8dot2")
1046 HasSSVE_FP8DOT2 =
true;
1047 if (
Feature ==
"+ssve-fp8dot4")
1048 HasSSVE_FP8DOT4 =
true;
1049 if (
Feature ==
"+ssve-fp8fma")
1050 HasSSVE_FP8FMA =
true;
1052 HasSME_F8F32 =
true;
1054 HasSME_F8F16 =
true;
1097 HasFRInt3264 =
true;
1102 if (
Feature ==
"+strict-align")
1106 if (
Feature ==
"+v8a" && ArchInfo->Version < llvm::AArch64::ARMV8A.Version)
1107 ArchInfo = &llvm::AArch64::ARMV8A;
1109 ArchInfo->Version < llvm::AArch64::ARMV8_1A.Version)
1110 ArchInfo = &llvm::AArch64::ARMV8_1A;
1112 ArchInfo->Version < llvm::AArch64::ARMV8_2A.Version)
1113 ArchInfo = &llvm::AArch64::ARMV8_2A;
1115 ArchInfo->Version < llvm::AArch64::ARMV8_3A.Version)
1116 ArchInfo = &llvm::AArch64::ARMV8_3A;
1118 ArchInfo->Version < llvm::AArch64::ARMV8_4A.Version)
1119 ArchInfo = &llvm::AArch64::ARMV8_4A;
1121 ArchInfo->Version < llvm::AArch64::ARMV8_5A.Version)
1122 ArchInfo = &llvm::AArch64::ARMV8_5A;
1124 ArchInfo->Version < llvm::AArch64::ARMV8_6A.Version)
1125 ArchInfo = &llvm::AArch64::ARMV8_6A;
1127 ArchInfo->Version < llvm::AArch64::ARMV8_7A.Version)
1128 ArchInfo = &llvm::AArch64::ARMV8_7A;
1130 ArchInfo->Version < llvm::AArch64::ARMV8_8A.Version)
1131 ArchInfo = &llvm::AArch64::ARMV8_8A;
1133 ArchInfo->Version < llvm::AArch64::ARMV8_9A.Version)
1134 ArchInfo = &llvm::AArch64::ARMV8_9A;
1135 if (
Feature ==
"+v9a" && ArchInfo->Version < llvm::AArch64::ARMV9A.Version)
1136 ArchInfo = &llvm::AArch64::ARMV9A;
1138 ArchInfo->Version < llvm::AArch64::ARMV9_1A.Version)
1139 ArchInfo = &llvm::AArch64::ARMV9_1A;
1141 ArchInfo->Version < llvm::AArch64::ARMV9_2A.Version)
1142 ArchInfo = &llvm::AArch64::ARMV9_2A;
1144 ArchInfo->Version < llvm::AArch64::ARMV9_3A.Version)
1145 ArchInfo = &llvm::AArch64::ARMV9_3A;
1147 ArchInfo->Version < llvm::AArch64::ARMV9_4A.Version)
1148 ArchInfo = &llvm::AArch64::ARMV9_4A;
1150 ArchInfo->Version < llvm::AArch64::ARMV9_5A.Version)
1151 ArchInfo = &llvm::AArch64::ARMV9_5A;
1153 ArchInfo->Version < llvm::AArch64::ARMV9_6A.Version)
1154 ArchInfo = &llvm::AArch64::ARMV9_6A;
1156 ArchInfo = &llvm::AArch64::ARMV8R;
1190 HasAlternativeNZCV =
true;
1211 for (
const auto &
Feature : Features) {
1246 if (Features ==
"default")
1249 Features.split(AttrFeatures,
",");
1250 bool FoundArch =
false;
1252 auto SplitAndAddFeatures = [](StringRef FeatString,
1253 std::vector<std::string> &Features,
1254 llvm::AArch64::ExtensionSet &FeatureBits) {
1256 FeatString.split(SplitFeatures, StringRef(
"+"), -1,
false);
1257 for (StringRef
Feature : SplitFeatures) {
1258 if (FeatureBits.parseModifier(
Feature))
1266 if (
Feature.starts_with(
"no"))
1267 Features.push_back(
"-" +
Feature.drop_front(2).str());
1269 Features.push_back(
"+" +
Feature.str());
1273 llvm::AArch64::ExtensionSet FeatureBits;
1275 FeatureBits.reconstructFromParsedFeatures(
getTargetOpts().FeaturesAsWritten,
1278 for (
auto &
Feature : AttrFeatures) {
1280 if (
Feature.starts_with(
"fpmath="))
1283 if (
Feature.starts_with(
"branch-protection=")) {
1284 Ret.BranchProtection =
Feature.split(
'=').second.trim();
1288 if (
Feature.starts_with(
"arch=")) {
1290 Ret.Duplicate =
"arch=";
1292 std::pair<StringRef, StringRef> Split =
1293 Feature.split(
"=").second.trim().split(
"+");
1294 const llvm::AArch64::ArchInfo *AI = llvm::AArch64::parseArch(Split.first);
1300 FeatureBits.addArchDefaults(*AI);
1302 SplitAndAddFeatures(Split.second, Ret.Features, FeatureBits);
1303 }
else if (
Feature.starts_with(
"cpu=")) {
1304 if (!Ret.CPU.empty())
1305 Ret.Duplicate =
"cpu=";
1309 std::pair<StringRef, StringRef> Split =
1310 Feature.split(
"=").second.trim().split(
"+");
1311 Ret.CPU = Split.first;
1312 if (
auto CpuInfo = llvm::AArch64::parseCpu(Ret.CPU)) {
1313 FeatureBits.addCPUDefaults(*CpuInfo);
1314 SplitAndAddFeatures(Split.second, Ret.Features, FeatureBits);
1317 }
else if (
Feature.starts_with(
"tune=")) {
1318 if (!Ret.Tune.empty())
1319 Ret.Duplicate =
"tune=";
1321 Ret.Tune =
Feature.split(
"=").second.trim();
1322 }
else if (
Feature.starts_with(
"+")) {
1323 SplitAndAddFeatures(
Feature, Ret.Features, FeatureBits);
1325 if (FeatureBits.parseModifier(
Feature,
true))
1333 if (
Feature.starts_with(
"no-"))
1334 Ret.Features.push_back(
"-" +
Feature.drop_front(3).str());
1336 Ret.Features.push_back(
"+" +
Feature.str());
1339 FeatureBits.toLLVMFeatureList(Ret.Features);
1372const char *
const AArch64TargetInfo::GCCRegNames[] = {
1376 "w0",
"w1",
"w2",
"w3",
"w4",
"w5",
"w6",
"w7",
"w8",
"w9",
"w10",
"w11",
1377 "w12",
"w13",
"w14",
"w15",
"w16",
"w17",
"w18",
"w19",
"w20",
"w21",
"w22",
1378 "w23",
"w24",
"w25",
"w26",
"w27",
"w28",
"w29",
"w30",
"wsp",
1381 "x0",
"x1",
"x2",
"x3",
"x4",
"x5",
"x6",
"x7",
"x8",
"x9",
"x10",
"x11",
1382 "x12",
"x13",
"x14",
"x15",
"x16",
"x17",
"x18",
"x19",
"x20",
"x21",
"x22",
1383 "x23",
"x24",
"x25",
"x26",
"x27",
"x28",
"fp",
"lr",
"sp",
1386 "s0",
"s1",
"s2",
"s3",
"s4",
"s5",
"s6",
"s7",
"s8",
"s9",
"s10",
"s11",
1387 "s12",
"s13",
"s14",
"s15",
"s16",
"s17",
"s18",
"s19",
"s20",
"s21",
"s22",
1388 "s23",
"s24",
"s25",
"s26",
"s27",
"s28",
"s29",
"s30",
"s31",
1391 "d0",
"d1",
"d2",
"d3",
"d4",
"d5",
"d6",
"d7",
"d8",
"d9",
"d10",
"d11",
1392 "d12",
"d13",
"d14",
"d15",
"d16",
"d17",
"d18",
"d19",
"d20",
"d21",
"d22",
1393 "d23",
"d24",
"d25",
"d26",
"d27",
"d28",
"d29",
"d30",
"d31",
1396 "v0",
"v1",
"v2",
"v3",
"v4",
"v5",
"v6",
"v7",
"v8",
"v9",
"v10",
"v11",
1397 "v12",
"v13",
"v14",
"v15",
"v16",
"v17",
"v18",
"v19",
"v20",
"v21",
"v22",
1398 "v23",
"v24",
"v25",
"v26",
"v27",
"v28",
"v29",
"v30",
"v31",
1401 "z0",
"z1",
"z2",
"z3",
"z4",
"z5",
"z6",
"z7",
"z8",
"z9",
"z10",
1402 "z11",
"z12",
"z13",
"z14",
"z15",
"z16",
"z17",
"z18",
"z19",
"z20",
"z21",
1403 "z22",
"z23",
"z24",
"z25",
"z26",
"z27",
"z28",
"z29",
"z30",
"z31",
1406 "p0",
"p1",
"p2",
"p3",
"p4",
"p5",
"p6",
"p7",
"p8",
"p9",
"p10",
1407 "p11",
"p12",
"p13",
"p14",
"p15",
1410 "pn0",
"pn1",
"pn2",
"pn3",
"pn4",
"pn5",
"pn6",
"pn7",
"pn8",
1411 "pn9",
"pn10",
"pn11",
"pn12",
"pn13",
"pn14",
"pn15",
1456 {{
"r29",
"x29"},
"fp"},
1457 {{
"r30",
"x30"},
"lr"},
1468 constexpr unsigned len = 5;
1469 auto RV = llvm::StringSwitch<unsigned>(Name)
1493 switch (*Constraint) {
1495 R = std::string(
"@3") + std::string(Constraint, 3);
1500 std::string Converted =
"{" + std::string(Constraint, Len) +
"}";
1501 Constraint += Len - 1;
1504 return std::string(1, *Constraint);
1536 if (Name[1] ==
'p' &&
1537 (Name[2] ==
'l' || Name[2] ==
'a' || Name[2] ==
'h')) {
1543 if (Name[1] ==
'c' && (Name[2] ==
'i' || Name[2] ==
'j')) {
1578 StringRef Constraint,
char Modifier,
unsigned Size,
1579 std::string &SuggestedModifier)
const {
1581 Constraint = Constraint.ltrim(
"=+&");
1583 switch (Constraint[0]) {
1603 SuggestedModifier =
"w";
1621 const llvm::APSInt &value)
const {
1622 return 0 <= value && value <= 3;
1631void AArch64leTargetInfo::setDataLayout() {
1634 resetDataLayout(
"e-m:o-p:32:32-p270:32:32-p271:32:32-p272:64:64-i64:64-"
1635 "i128:128-n32:64-S128-Fn32",
1638 resetDataLayout(
"e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-"
1642 resetDataLayout(
"e-m:e-p270:32:32-p271:32:32-p272:64:64-i8:8:32-i16:16:32-"
1643 "i64:64-i128:128-n32:64-S128-Fn32");
1648 Builder.defineMacro(
"__AARCH64EL__");
1658 Builder.defineMacro(
"__AARCH64EB__");
1659 Builder.defineMacro(
"__AARCH_BIG_ENDIAN");
1660 Builder.defineMacro(
"__ARM_BIG_ENDIAN");
1664void AArch64beTargetInfo::setDataLayout() {
1665 assert(!
getTriple().isOSBinFormatMachO());
1666 resetDataLayout(
"E-m:e-p270:32:32-p271:32:32-p272:64:64-i8:8:32-i16:16:32-"
1667 "i64:64-i128:128-n32:64-S128-Fn32");
1690 ?
"e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:"
1691 "128-n32:64-S128-Fn32"
1692 :
"e-m:w-p270:32:32-p271:32:32-p272:64:64-p:64:64-i32:32-"
1693 "i64:64-i128:128-n32:64-S128-Fn32",
1694 Triple.isOSBinFormatMachO() ?
"_" :
"");
1737 Builder.defineMacro(
"_M_X64",
"100");
1738 Builder.defineMacro(
"_M_AMD64",
"100");
1739 Builder.defineMacro(
"_M_ARM64EC",
"1");
1741 Builder.defineMacro(
"_M_ARM64",
"1");
1751 bool HasNonWeakDef)
const {
1759 if (TypeSize >= 512) {
1760 Align = std::max(Align, 128u);
1761 }
else if (TypeSize >= 64) {
1762 Align = std::max(Align, 64u);
1763 }
else if (TypeSize >= 16) {
1764 Align = std::max(Align, 32u);
1772 TheCXXABI.set(TargetCXXABI::GenericAArch64);
1800 TheCXXABI.set(TargetCXXABI::AppleARM64);
1805 const llvm::Triple &Triple) {
1806 Builder.defineMacro(
"__AARCH64_SIMD__");
1807 if (Triple.isArch32Bit())
1808 Builder.defineMacro(
"__ARM64_ARCH_8_32__");
1810 Builder.defineMacro(
"__ARM64_ARCH_8__");
1811 Builder.defineMacro(
"__ARM_NEON__");
1812 Builder.defineMacro(
"__REGISTER_PREFIX__",
"");
1813 Builder.defineMacro(
"__arm64",
"1");
1814 Builder.defineMacro(
"__arm64__",
"1");
1816 if (Triple.isArm64e())
1817 Builder.defineMacro(
"__arm64e__",
"1");
1821 const llvm::Triple &Triple,
1829 const llvm::Triple &Triple,
Defines the Diagnostic-related interfaces.
static unsigned matchAsmCCConstraint(const char *Name)
static constexpr int NumAArch64Builtins
#define ARM_ACLE_VERSION(Y, Q, P)
static constexpr int NumSVEBuiltins
static constexpr int NumFp16Builtins
static constexpr int NumSMEBuiltins
static constexpr auto BuiltinAArch64Infos
static constexpr llvm::StringTable BuiltinSVENeonBridgeStrings
static constexpr int NumSVENeonBridgeBuiltins
static constexpr int NumNeonBuiltins
static constexpr llvm::StringTable BuiltinAArch64Strings
static constexpr auto BuiltinSVENeonBridgeInfos
static constexpr unsigned NumBuiltins
#define CLANG_BUILTIN_STR_TABLE_START
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.
LangOptions::SignReturnAddressScopeKind SignReturnAddr
LangOptions::SignReturnAddressKeyKind SignKey
bool BranchProtectionPAuthLR
bool BranchTargetEnforcement
TargetOptions & getTargetOpts() const
Retrieve the target options.
TargetInfo(const llvm::Triple &T)
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
const LangASMap * AddrSpaceMap
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;
virtual void getTargetDefines(const LangOptions &Opts, MacroBuilder &Builder) const =0
===-— Other target property query methods -----------------------—===//
unsigned HasUnalignedAccess
unsigned char MaxAtomicPromoteWidth
virtual unsigned getMinGlobalAlign(uint64_t Size, bool HasNonWeakDef) const
getMinGlobalAlign - Return the minimum alignment of a global variable, unless its alignment is explic...
unsigned HasAArch64ACLETypes
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.
llvm::StringMap< bool > FeatureMap
The map of which features have been enabled disabled based on the command line.
void getTargetDefinesARMV95A(const LangOptions &Opts, MacroBuilder &Builder) const
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
void getTargetDefinesARMV96A(const LangOptions &Opts, MacroBuilder &Builder) const
AArch64TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
ArrayRef< const char * > getGCCRegNames() const override
bool validateGlobalRegisterVariable(StringRef RegName, unsigned RegSize, bool &HasSizeMismatch) const override
Validate register name used for global register variables.
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.
llvm::SmallVector< Builtin::InfosShard > getTargetBuiltins() const override
Return information about target-specific builtins for the current primary target, and info about whic...
void getTargetDefinesARMV89A(const LangOptions &Opts, MacroBuilder &Builder) const
void getTargetDefinesARMV92A(const LangOptions &Opts, MacroBuilder &Builder) const
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
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
std::optional< std::pair< unsigned, unsigned > > getVScaleRange(const LangOptions &LangOpts, ArmStreamingKind Mode, llvm::StringMap< bool > *FeatureMap=nullptr) const override
Returns target-specific min and max values VScale_Range.
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
bool validateBranchProtection(StringRef Spec, StringRef Arch, BranchProtectionInfo &BPI, const LangOptions &LO, StringRef &Err) const override
Determine if this TargetInfo supports the given branch protection specification.
void getTargetDefinesARMV86A(const LangOptions &Opts, MacroBuilder &Builder) const
bool setCPU(const std::string &Name) override
Target the specified CPU.
void getTargetDefinesARMV94A(const LangOptions &Opts, MacroBuilder &Builder) const
llvm::APInt getFMVPriority(ArrayRef< StringRef > Features) const override
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 -----------------------—===//
void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, MacroBuilder &Builder) const override
AppleMachOAArch64TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, MacroBuilder &Builder) const override
AppleMachOTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
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
Returns the kind of __builtin_va_list type that should be used with this target.
void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, MacroBuilder &Builder) const override
DarwinTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
unsigned getMinGlobalAlign(uint64_t TypeSize, bool HasNonWeakDef) const override
getMinGlobalAlign - Return the minimum alignment of a global variable, unless its alignment is explic...
MicrosoftARM64TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
TargetInfo::CallingConvKind getCallingConvKind(bool ClangABICompat4) const override
void getTargetDefines(const LangOptions &Opts, MacroBuilder &Builder) const override
===-— Other target property query methods -----------------------—===//
MinGWARM64TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
BuiltinVaListKind getBuiltinVaListKind() const override
Returns the kind of __builtin_va_list type that should be used with this target.
WindowsARM64TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
void setDataLayout() override
CallingConvCheckResult checkCallingConvention(CallingConv CC) const override
Determines whether a given calling convention is valid for the target.
WindowsTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
Defines the clang::TargetInfo interface.
static constexpr std::array< Info, N > MakeInfos(std::array< Info, N > Infos)
A constexpr function to construct an infos array from X-macros.
static constexpr std::array< Builtin::Info, NumFp16Builtins > BuiltinInfos
static constexpr std::array< Builtin::Info, NumNeonBuiltins > BuiltinInfos
static constexpr std::array< Builtin::Info, NumSMEBuiltins > BuiltinInfos
static constexpr std::array< Builtin::Info, NumSVEBuiltins > BuiltinInfos
void getAppleMachOAArch64Defines(MacroBuilder &Builder, const LangOptions &Opts, const llvm::Triple &Triple)
static const unsigned ARM64AddrSpaceMap[]
The JSON file list parser is used to communicate input to InstallAPI.
if(T->getSizeExpr()) TRY_TO(TraverseStmt(const_cast< Expr * >(T -> getSizeExpr())))
CallingConv
CallingConv - Specifies the calling convention that a function uses.
Contains information gathered from parsing the contents of TargetAttr.
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
unsigned ZeroLengthBitfieldBoundary
If non-zero, specifies a fixed alignment value for bitfields that follow zero length bitfield,...
std::optional< unsigned > BitIntMaxAlign
unsigned LargestOverSizedBitfieldContainer
The largest container size which should be used for an over-sized bitfield, in bits.
unsigned char LongLongAlign
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
unsigned char DoubleAlign
unsigned UseSignedCharForObjCBool
Whether Objective-C's built-in boolean type should be signed char.
const llvm::fltSemantics * BFloat16Format