24 using namespace AArch64;
42 #define ARM_FPU(NAME, KIND, VERSION, NEON_SUPPORT, RESTRICTION) \
43 { NAME, sizeof(NAME) - 1, KIND, VERSION, NEON_SUPPORT, RESTRICTION },
44 #include "llvm/Support/ARMTargetParser.def"
55 template <
typename T>
struct ArchNames {
58 const char *CPUAttrCStr;
60 const char *SubArchCStr;
63 unsigned ArchBaseExtensions;
75 ArchNames<ARM::ArchKind> ARCHNames[] = {
76 #define ARM_ARCH(NAME, ID, CPU_ATTR, SUB_ARCH, ARCH_ATTR, ARCH_FPU, ARCH_BASE_EXT) \
77 {NAME, sizeof(NAME) - 1, CPU_ATTR, sizeof(CPU_ATTR) - 1, SUB_ARCH, \
78 sizeof(SUB_ARCH) - 1, ARCH_FPU, ARCH_BASE_EXT, ID, ARCH_ATTR},
79 #include "llvm/Support/ARMTargetParser.def"
82 ArchNames<AArch64::ArchKind> AArch64ARCHNames[] = {
83 #define AARCH64_ARCH(NAME, ID, CPU_ATTR, SUB_ARCH, ARCH_ATTR, ARCH_FPU, ARCH_BASE_EXT) \
84 {NAME, sizeof(NAME) - 1, CPU_ATTR, sizeof(CPU_ATTR) - 1, SUB_ARCH, \
85 sizeof(SUB_ARCH) - 1, ARCH_FPU, ARCH_BASE_EXT, AArch64::ArchKind::ID, ARCH_ATTR},
86 #include "llvm/Support/AArch64TargetParser.def"
97 const char *NegFeature;
101 #define ARM_ARCH_EXT_NAME(NAME, ID, FEATURE, NEGFEATURE) \
102 { NAME, sizeof(NAME) - 1, ID, FEATURE, NEGFEATURE },
103 #include "llvm/Support/ARMTargetParser.def"
104 },AArch64ARCHExtNames[] = {
105 #define AARCH64_ARCH_EXT_NAME(NAME, ID, FEATURE, NEGFEATURE) \
106 { NAME, sizeof(NAME) - 1, ID, FEATURE, NEGFEATURE },
107 #include "llvm/Support/AArch64TargetParser.def"
113 static const struct {
114 const char *NameCStr;
120 #define ARM_HW_DIV_NAME(NAME, ID) { NAME, sizeof(NAME) - 1, ID },
121 #include "llvm/Support/ARMTargetParser.def"
129 template <
typename T>
struct CpuNames {
130 const char *NameCStr;
134 unsigned DefaultExtensions;
138 CpuNames<ARM::ArchKind> CPUNames[] = {
139 #define ARM_CPU_NAME(NAME, ID, DEFAULT_FPU, IS_DEFAULT, DEFAULT_EXT) \
140 { NAME, sizeof(NAME) - 1, ID, IS_DEFAULT, DEFAULT_EXT },
141 #include "llvm/Support/ARMTargetParser.def"
144 CpuNames<AArch64::ArchKind> AArch64CPUNames[] = {
145 #define AARCH64_CPU_NAME(NAME, ID, DEFAULT_FPU, IS_DEFAULT, DEFAULT_EXT) \
146 { NAME, sizeof(NAME) - 1, AArch64::ArchKind::ID, IS_DEFAULT, DEFAULT_EXT },
147 #include "llvm/Support/AArch64TargetParser.def"
157 if (FPUKind >= ARM::FK_LAST)
159 return FPUNames[
FPUKind].getName();
163 if (FPUKind >= ARM::FK_LAST)
165 return FPUNames[
FPUKind].FPUVersion;
169 if (FPUKind >= ARM::FK_LAST)
171 return FPUNames[
FPUKind].NeonSupport;
175 if (FPUKind >= ARM::FK_LAST)
177 return FPUNames[
FPUKind].Restriction;
181 if (CPU ==
"generic")
182 return ARCHNames[
ArchKind].DefaultFPU;
185 #define
ARM_CPU_NAME(NAME,
ID, DEFAULT_FPU, IS_DEFAULT, DEFAULT_EXT) \
186 .Case(NAME, DEFAULT_FPU)
187 #include "llvm/Support/ARMTargetParser.def"
188 .Default(ARM::FK_INVALID);
192 if (CPU ==
"generic")
193 return ARCHNames[
ArchKind].ArchBaseExtensions;
196 #define
ARM_CPU_NAME(NAME,
ID, DEFAULT_FPU, IS_DEFAULT, DEFAULT_EXT) \
197 .Case(NAME, ARCHNames[
ID].ArchBaseExtensions | DEFAULT_EXT)
198 #include "llvm/Support/ARMTargetParser.def"
209 Features.push_back(
"+hwdiv-arm");
211 Features.push_back(
"-hwdiv-arm");
214 Features.push_back(
"+hwdiv");
216 Features.push_back(
"-hwdiv");
228 Features.push_back(
"+crc");
230 Features.push_back(
"-crc");
233 Features.push_back(
"+dsp");
235 Features.push_back(
"-dsp");
243 if (FPUKind >= ARM::FK_LAST || FPUKind == ARM::FK_INVALID)
248 switch (FPUNames[FPUKind].Restriction) {
250 Features.push_back(
"+fp-only-sp");
251 Features.push_back(
"+d16");
254 Features.push_back(
"-fp-only-sp");
255 Features.push_back(
"+d16");
258 Features.push_back(
"-fp-only-sp");
259 Features.push_back(
"-d16");
269 Features.push_back(
"+fp-armv8");
272 Features.push_back(
"+vfp4");
273 Features.push_back(
"-fp-armv8");
276 Features.push_back(
"+vfp3");
277 Features.push_back(
"+fp16");
278 Features.push_back(
"-vfp4");
279 Features.push_back(
"-fp-armv8");
282 Features.push_back(
"+vfp3");
283 Features.push_back(
"-fp16");
284 Features.push_back(
"-vfp4");
285 Features.push_back(
"-fp-armv8");
288 Features.push_back(
"+vfp2");
289 Features.push_back(
"-vfp3");
290 Features.push_back(
"-fp16");
291 Features.push_back(
"-vfp4");
292 Features.push_back(
"-fp-armv8");
295 Features.push_back(
"-vfp2");
296 Features.push_back(
"-vfp3");
297 Features.push_back(
"-fp16");
298 Features.push_back(
"-vfp4");
299 Features.push_back(
"-fp-armv8");
304 switch (FPUNames[FPUKind].NeonSupport) {
306 Features.push_back(
"+neon");
307 Features.push_back(
"+crypto");
310 Features.push_back(
"+neon");
311 Features.push_back(
"-crypto");
314 Features.push_back(
"-neon");
315 Features.push_back(
"-crypto");
323 if (ArchKind >= ARM::AK_LAST)
325 return ARCHNames[
ArchKind].getName();
329 if (ArchKind == ARM::AK_INVALID || ArchKind >= ARM::AK_LAST)
331 return ARCHNames[
ArchKind].getCPUAttr();
335 if (ArchKind == ARM::AK_INVALID || ArchKind >= ARM::AK_LAST)
337 return ARCHNames[
ArchKind].getSubArch();
341 if (ArchKind >= ARM::AK_LAST)
343 return ARCHNames[
ArchKind].ArchAttr;
347 for (
const auto AE : ARCHExtNames) {
348 if (ArchExtKind == AE.ID)
357 for (
const auto AE : ARCHExtNames) {
358 if (AE.NegFeature && ArchExtBase == AE.getName())
362 for (
const auto AE : ARCHExtNames) {
363 if (AE.Feature && ArchExt == AE.getName())
371 for (
const auto D : HWDivNames) {
372 if (HWDivKind ==
D.ID)
380 if (AK == ARM::AK_INVALID)
384 for (
const auto CPU : CPUNames) {
385 if (CPU.ArchID == AK && CPU.Default)
386 return CPU.getName();
410 if (CPU ==
"generic")
411 return AArch64ARCHNames[
ArchKind].DefaultFPU;
415 .Case(NAME, DEFAULT_FPU)
416 #include "llvm/Support/AArch64TargetParser.def"
417 .Default(ARM::FK_INVALID);
421 if (CPU ==
"generic")
422 return AArch64ARCHNames[
ArchKind].ArchBaseExtensions;
426 .Case(NAME, DEFAULT_EXT)
427 #include "llvm/Support/AArch64TargetParser.def"
438 Features.push_back(
"+fp-armv8");
440 Features.push_back(
"+neon");
442 Features.push_back(
"+crc");
444 Features.push_back(
"+crypto");
446 Features.push_back(
"+fullfp16");
448 Features.push_back(
"+spe");
450 Features.push_back(
"+ras");
456 std::vector<StringRef> &Features) {
461 std::vector<StringRef> &Features) {
462 if (ArchKind == static_cast<unsigned>(AArch64::ArchKind::AK_ARMV8_1A))
463 Features.push_back(
"+v8.1a");
464 if (ArchKind == static_cast<unsigned>(AArch64::ArchKind::AK_ARMV8_2A))
465 Features.push_back(
"+v8.2a");
467 return ArchKind >
static_cast<unsigned>(AArch64::ArchKind::AK_INVALID) &&
468 ArchKind < static_cast<unsigned>(AArch64::ArchKind::AK_LAST);
472 if (ArchKind >= static_cast<unsigned>(AArch64::ArchKind::AK_LAST))
474 return AArch64ARCHNames[
ArchKind].getName();
478 if (ArchKind == static_cast<unsigned>(AArch64::ArchKind::AK_INVALID) ||
479 ArchKind >= static_cast<unsigned>(AArch64::ArchKind::AK_LAST))
481 return AArch64ARCHNames[
ArchKind].getCPUAttr();
485 if (ArchKind == static_cast<unsigned>(AArch64::ArchKind::AK_INVALID) ||
486 ArchKind >= static_cast<unsigned>(AArch64::ArchKind::AK_LAST))
488 return AArch64ARCHNames[
ArchKind].getSubArch();
492 if (ArchKind >= static_cast<unsigned>(AArch64::ArchKind::AK_LAST))
494 return AArch64ARCHNames[
ArchKind].ArchAttr;
498 for (
const auto &AE : AArch64ARCHExtNames)
499 if (ArchExtKind == AE.ID)
507 for (
const auto &AE : AArch64ARCHExtNames) {
508 if (AE.NegFeature && ArchExtBase == AE.getName())
513 for (
const auto &AE : AArch64ARCHExtNames)
514 if (AE.Feature && ArchExt == AE.getName())
521 if (AK == static_cast<unsigned>(AArch64::ArchKind::AK_INVALID))
525 for (
const auto &CPU : AArch64CPUNames)
526 if (static_cast<unsigned>(CPU.ArchID) == AK && CPU.Default)
527 return CPU.getName();
534 if (Arch[0] ==
'v' && std::isdigit(Arch[1]))
535 return (Arch[1] - 48);
545 .Case(
"thumb,arm",
"arm,thumb")
551 .
Cases(
"fpa",
"fpe2",
"fpe3",
"maverick",
"invalid")
552 .Case(
"vfp2",
"vfpv2")
553 .Case(
"vfp3",
"vfpv3")
554 .Case(
"vfp4",
"vfpv4")
555 .Case(
"vfp3-d16",
"vfpv3-d16")
556 .Case(
"vfp4-d16",
"vfpv4-d16")
557 .Cases(
"fp4-sp-d16",
"vfpv4-sp-d16",
"fpv4-sp-d16")
558 .Cases(
"fp4-dp-d16",
"fpv4-dp-d16",
"vfpv4-d16")
559 .Case(
"fp5-sp-d16",
"fpv5-sp-d16")
560 .Cases(
"fp5-dp-d16",
"fpv5-dp-d16",
"fpv5-d16")
562 .Case(
"neon-vfpv3",
"neon")
572 .
Cases(
"v6m",
"v6sm",
"v6s-m",
"v6-m")
573 .
Cases(
"v6z",
"v6zk",
"v6kz")
574 .
Cases(
"v7",
"v7a",
"v7hl",
"v7l",
"v7-a")
577 .
Case(
"v7em",
"v7e-m")
578 .
Cases(
"v8",
"v8a",
"aarch64",
"arm64",
"v8-a")
579 .
Case(
"v8.1a",
"v8.1-a")
580 .
Case(
"v8.2a",
"v8.2-a")
582 .
Case(
"v8m.base",
"v8-m.base")
583 .
Case(
"v8m.main",
"v8-m.main")
608 if (A.
substr(offset, 3) ==
"_be")
629 if (A[0] !=
'v' || !std::isdigit(A[1]))
642 for (
const auto D : HWDivNames) {
643 if (Syn ==
D.getName())
651 for (
const auto F : FPUNames) {
652 if (Syn ==
F.getName())
655 return ARM::FK_INVALID;
662 for (
const auto A : ARCHNames) {
663 if (
A.getName().endswith(Syn))
666 return ARM::AK_INVALID;
670 for (
const auto A : ARCHExtNames) {
671 if (ArchExt ==
A.getName())
678 for (
const auto C : CPUNames) {
679 if (CPU ==
C.getName())
682 return ARM::AK_INVALID;
720 case ARM::AK_ARMV7EM:
721 case ARM::AK_ARMV8MMainline:
722 case ARM::AK_ARMV8MBaseline:
730 case ARM::AK_ARMV8_1A:
731 case ARM::AK_ARMV8_2A:
751 case ARM::AK_ARMV5TE:
753 case ARM::AK_IWMMXT2:
755 case ARM::AK_ARMV5TEJ:
759 case ARM::AK_ARMV6T2:
760 case ARM::AK_ARMV6KZ:
767 case ARM::AK_ARMV7EM:
771 case ARM::AK_ARMV8_1A:
772 case ARM::AK_ARMV8_2A:
774 case ARM::AK_ARMV8MBaseline:
775 case ARM::AK_ARMV8MMainline:
793 return static_cast<unsigned>(AArch64::ArchKind::AK_INVALID);
796 for (
const auto A : AArch64ARCHNames) {
797 if (
A.getName().endswith(Syn))
798 return static_cast<unsigned>(
A.ID);
800 return static_cast<unsigned>(AArch64::ArchKind::AK_INVALID);
804 for (
const auto A : AArch64ARCHExtNames) {
805 if (ArchExt ==
A.getName())
812 for (
const auto C : AArch64CPUNames) {
813 if (CPU ==
C.getName())
814 return static_cast<unsigned>(
C.ArchID);
816 return static_cast<unsigned>(AArch64::ArchKind::AK_INVALID);
unsigned parseArchEndian(StringRef Arch)
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool endswith(StringRef Suffix) const
Check if this string ends with the given Suffix.
unsigned getFPURestriction(unsigned FPUKind)
unsigned parseCPUArch(StringRef CPU)
unsigned checkArchVersion(StringRef Arch)
unsigned getFPUNeonSupportLevel(unsigned FPUKind)
StringRef getArchExtFeature(StringRef ArchExt)
StringRef getDefaultCPU(StringRef Arch)
unsigned parseArchISA(StringRef Arch)
unsigned parseFPU(StringRef FPU)
static StringRef getHWDivSynonym(StringRef HWDiv)
unsigned parseArchProfile(StringRef Arch)
StringRef getArchExtName(unsigned ArchExtKind)
StringRef getFPUName(unsigned FPUKind)
unsigned getArchAttr(unsigned ArchKind)
bool getHWDivFeatures(unsigned HWDivKind, std::vector< StringRef > &Features)
StringRef getArchName(unsigned ArchKind)
StringRef getArchName(unsigned ArchKind)
unsigned parseArchExt(StringRef ArchExt)
StringRef getArchExtName(unsigned ArchExtKind)
static GCRegistry::Add< StatepointGC > D("statepoint-example","an example strategy for statepoint")
StringRef getArchExtFeature(StringRef ArchExt)
LLVM_ATTRIBUTE_ALWAYS_INLINE R Default(const T &Value) const
static StringRef getName(Value *V)
bool getExtensionFeatures(unsigned Extensions, std::vector< StringRef > &Features)
unsigned getFPUNeonSupportLevel(unsigned FPUKind)
unsigned parseCPUArch(StringRef CPU)
LLVM_ATTRIBUTE_ALWAYS_INLINE StringSwitch & Case(const char(&S)[N], const T &Value)
static StringRef getArchSynonym(StringRef Arch)
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool startswith(StringRef Prefix) const
Check if this string starts with the given Prefix.
unsigned parseArchISA(StringRef Arch)
StringRef getCPUAttr(unsigned ArchKind)
bool getArchFeatures(unsigned ArchKind, std::vector< StringRef > &Features)
unsigned getDefaultFPU(StringRef CPU, unsigned ArchKind)
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE size_t size() const
size - Get the string size.
Only single-precision instructions, with 16 D registers.
unsigned getFPUVersion(unsigned FPUKind)
unsigned parseArchVersion(StringRef Arch)
A switch()-like statement whose cases are string literals.
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE size_t find(char C, size_t From=0) const
Search for the first character C in the string.
StringRef getCanonicalArchName(StringRef Arch)
unsigned parseArchEndian(StringRef Arch)
static const struct @305 Extensions[]
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE StringRef substr(size_t Start, size_t N=npos) const
Return a reference to the substring from [Start, Start + N).
unsigned getFPUVersion(unsigned FPUKind)
bool getFPUFeatures(unsigned FPUKind, std::vector< StringRef > &Features)
static StringRef getFPUSynonym(StringRef FPU)
bool getExtensionFeatures(unsigned Extensions, std::vector< StringRef > &Features)
bool getFPUFeatures(unsigned FPUKind, std::vector< StringRef > &Features)
unsigned parseArch(StringRef Arch)
#define ARM_CPU_NAME(NAME, ID, DEFAULT_FPU, IS_DEFAULT, DEFAULT_EXT)
StringRef getHWDivName(unsigned HWDivKind)
static GCRegistry::Add< ShadowStackGC > C("shadow-stack","Very portable GC for uncooperative code generators")
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool empty() const
empty - Check if the string is empty.
LLVM_ATTRIBUTE_ALWAYS_INLINE StringSwitch & Cases(const char(&S0)[N0], const char(&S1)[N1], const T &Value)
StringRef getCPUAttr(unsigned ArchKind)
unsigned getArchAttr(unsigned ArchKind)
StringRef getSubArch(unsigned ArchKind)
unsigned parseArchProfile(StringRef Arch)
StringRef getSubArch(unsigned ArchKind)
#define AARCH64_CPU_NAME(NAME, ID, DEFAULT_FPU, IS_DEFAULT, DEFAULT_EXT)
unsigned parseArchExt(StringRef ArchExt)
unsigned getDefaultExtensions(StringRef CPU, unsigned ArchKind)
unsigned parseArch(StringRef Arch)
unsigned parseFPU(StringRef FPU)
Lightweight error class with error context and mandatory checking.
const FeatureBitset Features
unsigned parseHWDiv(StringRef HWDiv)
StringRef - Represent a constant reference to a string, i.e.
StringRef getCanonicalArchName(StringRef Arch)
unsigned getDefaultFPU(StringRef CPU, unsigned ArchKind)
unsigned getDefaultExtensions(StringRef CPU, unsigned ArchKind)
LLVM_ATTRIBUTE_ALWAYS_INLINE StringSwitch & StartsWith(const char(&S)[N], const T &Value)
static GCRegistry::Add< ErlangGC > A("erlang","erlang-compatible garbage collector")
StringRef getDefaultCPU(StringRef Arch)
StringRef getFPUName(unsigned FPUKind)
unsigned getFPURestriction(unsigned FPUKind)
unsigned parseArchVersion(StringRef Arch)