1 //===-- AArch64TargetParser - Parser for AArch64 features -------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements a target parser to recognise AArch64 hardware features
10 // such as FPU/CPU/ARCH and extension names.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #include "llvm/Support/AArch64TargetParser.h"
15 #include "llvm/ADT/StringSwitch.h"
16 #include "llvm/ADT/Triple.h"
17 #include <cctype>
18
19 using namespace llvm;
20
checkArchVersion(llvm::StringRef Arch)21 static unsigned checkArchVersion(llvm::StringRef Arch) {
22 if (Arch.size() >= 2 && Arch[0] == 'v' && std::isdigit(Arch[1]))
23 return (Arch[1] - 48);
24 return 0;
25 }
26
getDefaultFPU(StringRef CPU,AArch64::ArchKind AK)27 unsigned AArch64::getDefaultFPU(StringRef CPU, AArch64::ArchKind AK) {
28 if (CPU == "generic")
29 return AArch64ARCHNames[static_cast<unsigned>(AK)].DefaultFPU;
30
31 return StringSwitch<unsigned>(CPU)
32 #define AARCH64_CPU_NAME(NAME, ID, DEFAULT_FPU, IS_DEFAULT, DEFAULT_EXT) \
33 .Case(NAME, ARM::DEFAULT_FPU)
34 #include "../../include/llvm/Support/AArch64TargetParser.def"
35 .Default(ARM::FK_INVALID);
36 }
37
getDefaultExtensions(StringRef CPU,AArch64::ArchKind AK)38 uint64_t AArch64::getDefaultExtensions(StringRef CPU, AArch64::ArchKind AK) {
39 if (CPU == "generic")
40 return AArch64ARCHNames[static_cast<unsigned>(AK)].ArchBaseExtensions;
41
42 return StringSwitch<uint64_t>(CPU)
43 #define AARCH64_CPU_NAME(NAME, ID, DEFAULT_FPU, IS_DEFAULT, DEFAULT_EXT) \
44 .Case(NAME, AArch64ARCHNames[static_cast<unsigned>(ArchKind::ID)] \
45 .ArchBaseExtensions | \
46 DEFAULT_EXT)
47 #include "../../include/llvm/Support/AArch64TargetParser.def"
48 .Default(AArch64::AEK_INVALID);
49 }
50
getCPUArchKind(StringRef CPU)51 AArch64::ArchKind AArch64::getCPUArchKind(StringRef CPU) {
52 if (CPU == "generic")
53 return ArchKind::ARMV8A;
54
55 return StringSwitch<AArch64::ArchKind>(CPU)
56 #define AARCH64_CPU_NAME(NAME, ID, DEFAULT_FPU, IS_DEFAULT, DEFAULT_EXT) \
57 .Case(NAME, ArchKind::ID)
58 #include "../../include/llvm/Support/AArch64TargetParser.def"
59 .Default(ArchKind::INVALID);
60 }
61
getExtensionFeatures(uint64_t Extensions,std::vector<StringRef> & Features)62 bool AArch64::getExtensionFeatures(uint64_t Extensions,
63 std::vector<StringRef> &Features) {
64 if (Extensions == AArch64::AEK_INVALID)
65 return false;
66
67 #define AARCH64_ARCH_EXT_NAME(NAME, ID, FEATURE, NEGFEATURE) \
68 if (Extensions & ID) { \
69 const char *feature = FEATURE; \
70 /* INVALID and NONE have no feature name. */ \
71 if (feature) \
72 Features.push_back(feature); \
73 }
74 #include "../../include/llvm/Support/AArch64TargetParser.def"
75
76 return true;
77 }
78
getArchFeatures(AArch64::ArchKind AK,std::vector<StringRef> & Features)79 bool AArch64::getArchFeatures(AArch64::ArchKind AK,
80 std::vector<StringRef> &Features) {
81 if (AK == ArchKind::ARMV8A)
82 Features.push_back("+v8a");
83 if (AK == ArchKind::ARMV8_1A)
84 Features.push_back("+v8.1a");
85 if (AK == ArchKind::ARMV8_2A)
86 Features.push_back("+v8.2a");
87 if (AK == ArchKind::ARMV8_3A)
88 Features.push_back("+v8.3a");
89 if (AK == ArchKind::ARMV8_4A)
90 Features.push_back("+v8.4a");
91 if (AK == ArchKind::ARMV8_5A)
92 Features.push_back("+v8.5a");
93 if (AK == AArch64::ArchKind::ARMV8_6A)
94 Features.push_back("+v8.6a");
95 if (AK == AArch64::ArchKind::ARMV8_7A)
96 Features.push_back("+v8.7a");
97 if (AK == AArch64::ArchKind::ARMV8_8A)
98 Features.push_back("+v8.8a");
99 if (AK == AArch64::ArchKind::ARMV9A)
100 Features.push_back("+v9a");
101 if (AK == AArch64::ArchKind::ARMV9_1A)
102 Features.push_back("+v9.1a");
103 if (AK == AArch64::ArchKind::ARMV9_2A)
104 Features.push_back("+v9.2a");
105 if (AK == AArch64::ArchKind::ARMV9_3A)
106 Features.push_back("+v9.3a");
107 if(AK == AArch64::ArchKind::ARMV8R)
108 Features.push_back("+v8r");
109
110 return AK != ArchKind::INVALID;
111 }
112
getArchName(AArch64::ArchKind AK)113 StringRef AArch64::getArchName(AArch64::ArchKind AK) {
114 return AArch64ARCHNames[static_cast<unsigned>(AK)].getName();
115 }
116
getCPUAttr(AArch64::ArchKind AK)117 StringRef AArch64::getCPUAttr(AArch64::ArchKind AK) {
118 return AArch64ARCHNames[static_cast<unsigned>(AK)].getCPUAttr();
119 }
120
getSubArch(AArch64::ArchKind AK)121 StringRef AArch64::getSubArch(AArch64::ArchKind AK) {
122 return AArch64ARCHNames[static_cast<unsigned>(AK)].getSubArch();
123 }
124
getArchAttr(AArch64::ArchKind AK)125 unsigned AArch64::getArchAttr(AArch64::ArchKind AK) {
126 return AArch64ARCHNames[static_cast<unsigned>(AK)].ArchAttr;
127 }
128
getArchExtName(unsigned ArchExtKind)129 StringRef AArch64::getArchExtName(unsigned ArchExtKind) {
130 for (const auto &AE : AArch64ARCHExtNames)
131 if (ArchExtKind == AE.ID)
132 return AE.getName();
133 return StringRef();
134 }
135
getArchExtFeature(StringRef ArchExt)136 StringRef AArch64::getArchExtFeature(StringRef ArchExt) {
137 if (ArchExt.startswith("no")) {
138 StringRef ArchExtBase(ArchExt.substr(2));
139 for (const auto &AE : AArch64ARCHExtNames) {
140 if (AE.NegFeature && ArchExtBase == AE.getName())
141 return StringRef(AE.NegFeature);
142 }
143 }
144
145 for (const auto &AE : AArch64ARCHExtNames)
146 if (AE.Feature && ArchExt == AE.getName())
147 return StringRef(AE.Feature);
148 return StringRef();
149 }
150
getDefaultCPU(StringRef Arch)151 StringRef AArch64::getDefaultCPU(StringRef Arch) {
152 ArchKind AK = parseArch(Arch);
153 if (AK == ArchKind::INVALID)
154 return StringRef();
155
156 // Look for multiple AKs to find the default for pair AK+Name.
157 for (const auto &CPU : AArch64CPUNames)
158 if (CPU.ArchID == AK && CPU.Default)
159 return CPU.getName();
160
161 // If we can't find a default then target the architecture instead
162 return "generic";
163 }
164
fillValidCPUArchList(SmallVectorImpl<StringRef> & Values)165 void AArch64::fillValidCPUArchList(SmallVectorImpl<StringRef> &Values) {
166 for (const auto &Arch : AArch64CPUNames) {
167 if (Arch.ArchID != ArchKind::INVALID)
168 Values.push_back(Arch.getName());
169 }
170 }
171
isX18ReservedByDefault(const Triple & TT)172 bool AArch64::isX18ReservedByDefault(const Triple &TT) {
173 return TT.isAndroid() || TT.isOSDarwin() || TT.isOSFuchsia() ||
174 TT.isOSWindows();
175 }
176
177 // Allows partial match, ex. "v8a" matches "armv8a".
parseArch(StringRef Arch)178 AArch64::ArchKind AArch64::parseArch(StringRef Arch) {
179 Arch = ARM::getCanonicalArchName(Arch);
180 if (checkArchVersion(Arch) < 8)
181 return ArchKind::INVALID;
182
183 StringRef Syn = ARM::getArchSynonym(Arch);
184 for (const auto &A : AArch64ARCHNames) {
185 if (A.getName().endswith(Syn))
186 return A.ID;
187 }
188 return ArchKind::INVALID;
189 }
190
parseArchExt(StringRef ArchExt)191 AArch64::ArchExtKind AArch64::parseArchExt(StringRef ArchExt) {
192 for (const auto &A : AArch64ARCHExtNames) {
193 if (ArchExt == A.getName())
194 return static_cast<ArchExtKind>(A.ID);
195 }
196 return AArch64::AEK_INVALID;
197 }
198
parseCPUArch(StringRef CPU)199 AArch64::ArchKind AArch64::parseCPUArch(StringRef CPU) {
200 for (const auto &C : AArch64CPUNames) {
201 if (CPU == C.getName())
202 return C.ArchID;
203 }
204 return ArchKind::INVALID;
205 }
206