Debian Codegraph @

llvm-project/llvm/unittests/TargetParser/TargetParserTest.cpp

raw
1 //===----------- TargetParser.cpp - Target Parser -------------------------===//
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 #include "llvm/TargetParser/TargetParser.h"
10 #include "llvm/ADT/STLExtras.h"
11 #include "llvm/ADT/StringExtras.h"
12 #include "llvm/Support/ARMBuildAttributes.h"
13 #include "llvm/Support/FormatVariadic.h"
14 #include "llvm/TargetParser/AArch64TargetParser.h"
15 #include "llvm/TargetParser/ARMTargetParser.h"
16 #include "llvm/TargetParser/ARMTargetParserCommon.h"
17 #include "llvm/TargetParser/Triple.h"
18 #include "gmock/gmock.h"
19 #include "gtest/gtest.h"
20 #include <string>
21
22 using namespace llvm;
23
24 namespace {
25 const char *ARMArch[] = {
26 "armv4", "armv4t", "armv5", "armv5t", "armv5e",
27 "armv5te", "armv5tej", "armv6", "armv6j", "armv6k",
28 "armv6hl", "armv6t2", "armv6kz", "armv6z", "armv6zk",
29 "armv6-m", "armv6m", "armv6sm", "armv6s-m", "armv7-a",
30 "armv7", "armv7a", "armv7ve", "armv7hl", "armv7l",
31 "armv7-r", "armv7r", "armv7-m", "armv7m", "armv7k",
32 "armv7s", "armv7e-m", "armv7em", "armv8-a", "armv8",
33 "armv8a", "armv8l", "armv8.1-a", "armv8.1a", "armv8.2-a",
34 "armv8.2a", "armv8.3-a", "armv8.3a", "armv8.4-a", "armv8.4a",
35 "armv8.5-a", "armv8.5a", "armv8.6-a", "armv8.6a", "armv8.7-a",
36 "armv8.7a", "armv8.8-a", "armv8.8a", "armv8.9-a", "armv8.9a",
37 "armv8-r", "armv8r", "armv8-m.base", "armv8m.base", "armv8-m.main",
38 "armv8m.main", "iwmmxt", "iwmmxt2", "xscale", "armv8.1-m.main",
39 "armv9-a", "armv9", "armv9a", "armv9.1-a", "armv9.1a",
40 "armv9.2-a", "armv9.2a", "armv9.3-a", "armv9.3a", "armv9.4-a",
41 "armv9.4a",
42 };
43
44 template <ARM::ISAKind ISAKind>
45 std::string FormatExtensionFlags(uint64_t Flags) {
46 std::vector<StringRef> Features;
47
48 if (ISAKind == ARM::ISAKind::AARCH64) {
49 // AEK_NONE is not meant to be shown to the user so the target parser
50 // does not recognise it. It is relevant here though.
51 if (Flags & AArch64::AEK_NONE)
52 Features.push_back("none");
53 AArch64::getExtensionFeatures(Flags, Features);
54 } else {
55 if (Flags & ARM::AEK_NONE)
56 Features.push_back("none");
57 ARM::getExtensionFeatures(Flags, Features);
58 }
59
60 // The target parser also includes every extension you don't have.
61 // E.g. if AEK_CRC is not set then it adds "-crc". Not useful here.
62 Features.erase(std::remove_if(Features.begin(), Features.end(),
63 [](StringRef extension) {
64 return extension.startswith("-");
65 }),
66 Features.end());
67
68 return llvm::join(Features, ", ");
69 }
70
71 template <ARM::ISAKind ISAKind> struct AssertSameExtensionFlags {
72 AssertSameExtensionFlags(StringRef CPUName) : CPUName(CPUName) {}
73
74 testing::AssertionResult operator()(const char *m_expr, const char *n_expr,
75 uint64_t ExpectedFlags,
76 uint64_t GotFlags) {
77 if (ExpectedFlags == GotFlags)
78 return testing::AssertionSuccess();
79
80 return testing::AssertionFailure() << llvm::formatv(
81 "CPU: {4}\n"
82 "Expected extension flags: {0} ({1:x})\n"
83 " Got extension flags: {2} ({3:x})\n",
84 FormatExtensionFlags<ISAKind>(ExpectedFlags), ExpectedFlags,
85 FormatExtensionFlags<ISAKind>(GotFlags), GotFlags, CPUName);
86 }
87
88 private:
89 StringRef CPUName;
90 };
91
92 struct ARMCPUTestParams {
93 ARMCPUTestParams(StringRef CPUName, StringRef ExpectedArch,
94 StringRef ExpectedFPU, uint64_t ExpectedFlags,
95 StringRef CPUAttr)
96 : CPUName(CPUName), ExpectedArch(ExpectedArch), ExpectedFPU(ExpectedFPU),
97 ExpectedFlags(ExpectedFlags), CPUAttr(CPUAttr) {}
98
99 friend std::ostream &operator<<(std::ostream &os,
100 const ARMCPUTestParams &params) {
101 return os << "\"" << params.CPUName.str() << "\", \""
102 << params.ExpectedArch.str() << "\", \""
103 << params.ExpectedFPU.str() << "\", 0x" << std::hex
104 << params.ExpectedFlags << ", \"" << params.CPUAttr.str() << "\"";
105 }
106
107 StringRef CPUName;
108 StringRef ExpectedArch;
109 StringRef ExpectedFPU;
110 uint64_t ExpectedFlags;
111 StringRef CPUAttr;
112 };
113
114 class ARMCPUTestFixture : public ::testing::TestWithParam<ARMCPUTestParams> {};
115
116 TEST_P(ARMCPUTestFixture, ARMCPUTests) {
117 auto params = GetParam();
118
119 ARM::ArchKind AK = ARM::parseCPUArch(params.CPUName);
120 EXPECT_EQ(params.ExpectedArch, ARM::getArchName(AK));
121
122 unsigned FPUKind = ARM::getDefaultFPU(params.CPUName, AK);
123 EXPECT_EQ(params.ExpectedFPU, ARM::getFPUName(FPUKind));
124
125 uint64_t default_extensions = ARM::getDefaultExtensions(params.CPUName, AK);
126 EXPECT_PRED_FORMAT2(
127 AssertSameExtensionFlags<ARM::ISAKind::ARM>(params.CPUName),
128 params.ExpectedFlags, default_extensions);
129
130 EXPECT_EQ(params.CPUAttr, ARM::getCPUAttr(AK));
131 }
132
133 // Note that we include ARM::AEK_NONE even when there are other extensions
134 // we expect. This is because the default extensions for a CPU are the sum
135 // of the default extensions for its architecture and for the CPU.
136 // So if a CPU has no extra extensions, it adds AEK_NONE.
137 INSTANTIATE_TEST_SUITE_P(
138 ARMCPUTestsPart1, ARMCPUTestFixture,
139 ::testing::Values(
140 ARMCPUTestParams("invalid", "invalid", "invalid", ARM::AEK_NONE, ""),
141 ARMCPUTestParams("generic", "invalid", "none", ARM::AEK_NONE, ""),
142
143 ARMCPUTestParams("arm8", "armv4", "none", ARM::AEK_NONE, "4"),
144 ARMCPUTestParams("arm810", "armv4", "none", ARM::AEK_NONE, "4"),
145 ARMCPUTestParams("strongarm", "armv4", "none", ARM::AEK_NONE, "4"),
146 ARMCPUTestParams("strongarm110", "armv4", "none", ARM::AEK_NONE, "4"),
147 ARMCPUTestParams("strongarm1100", "armv4", "none", ARM::AEK_NONE, "4"),
148 ARMCPUTestParams("strongarm1110", "armv4", "none", ARM::AEK_NONE, "4"),
149 ARMCPUTestParams("arm7tdmi", "armv4t", "none", ARM::AEK_NONE, "4T"),
150 ARMCPUTestParams("arm7tdmi-s", "armv4t", "none", ARM::AEK_NONE, "4T"),
151 ARMCPUTestParams("arm710t", "armv4t", "none", ARM::AEK_NONE, "4T"),
152 ARMCPUTestParams("arm720t", "armv4t", "none", ARM::AEK_NONE, "4T"),
153 ARMCPUTestParams("arm9", "armv4t", "none", ARM::AEK_NONE, "4T"),
154 ARMCPUTestParams("arm9tdmi", "armv4t", "none", ARM::AEK_NONE, "4T"),
155 ARMCPUTestParams("arm920", "armv4t", "none", ARM::AEK_NONE, "4T"),
156 ARMCPUTestParams("arm920t", "armv4t", "none", ARM::AEK_NONE, "4T"),
157 ARMCPUTestParams("arm922t", "armv4t", "none", ARM::AEK_NONE, "4T"),
158 ARMCPUTestParams("arm940t", "armv4t", "none", ARM::AEK_NONE, "4T"),
159 ARMCPUTestParams("ep9312", "armv4t", "none", ARM::AEK_NONE, "4T"),
160 ARMCPUTestParams("arm10tdmi", "armv5t", "none", ARM::AEK_NONE, "5T"),
161 ARMCPUTestParams("arm1020t", "armv5t", "none", ARM::AEK_NONE, "5T"),
162 ARMCPUTestParams("arm9e", "armv5te", "none",
163 ARM::AEK_NONE | ARM::AEK_DSP, "5TE"),
164 ARMCPUTestParams("arm946e-s", "armv5te", "none",
165 ARM::AEK_NONE | ARM::AEK_DSP, "5TE"),
166 ARMCPUTestParams("arm966e-s", "armv5te", "none",
167 ARM::AEK_NONE | ARM::AEK_DSP, "5TE"),
168 ARMCPUTestParams("arm968e-s", "armv5te", "none",
169 ARM::AEK_NONE | ARM::AEK_DSP, "5TE"),
170 ARMCPUTestParams("arm10e", "armv5te", "none",
171 ARM::AEK_NONE | ARM::AEK_DSP, "5TE"),
172 ARMCPUTestParams("arm1020e", "armv5te", "none",
173 ARM::AEK_NONE | ARM::AEK_DSP, "5TE"),
174 ARMCPUTestParams("arm1022e", "armv5te", "none",
175 ARM::AEK_NONE | ARM::AEK_DSP, "5TE"),
176 ARMCPUTestParams("arm926ej-s", "armv5tej", "none",
177 ARM::AEK_NONE | ARM::AEK_DSP, "5TEJ"),
178 ARMCPUTestParams("arm1136j-s", "armv6", "none",
179 ARM::AEK_NONE | ARM::AEK_DSP, "6"),
180 ARMCPUTestParams("arm1136jf-s", "armv6", "vfpv2",
181 ARM::AEK_NONE | ARM::AEK_DSP, "6"),
182 ARMCPUTestParams("arm1176jz-s", "armv6kz", "none",
183 ARM::AEK_NONE | ARM::AEK_SEC | ARM::AEK_DSP, "6KZ"),
184 ARMCPUTestParams("mpcore", "armv6k", "vfpv2",
185 ARM::AEK_NONE | ARM::AEK_DSP, "6K"),
186 ARMCPUTestParams("mpcorenovfp", "armv6k", "none",
187 ARM::AEK_NONE | ARM::AEK_DSP, "6K"),
188 ARMCPUTestParams("arm1176jzf-s", "armv6kz", "vfpv2",
189 ARM::AEK_NONE | ARM::AEK_SEC | ARM::AEK_DSP, "6KZ"),
190 ARMCPUTestParams("arm1156t2-s", "armv6t2", "none",
191 ARM::AEK_NONE | ARM::AEK_DSP, "6T2"),
192 ARMCPUTestParams("arm1156t2f-s", "armv6t2", "vfpv2",
193 ARM::AEK_NONE | ARM::AEK_DSP, "6T2"),
194 ARMCPUTestParams("cortex-m0", "armv6-m", "none", ARM::AEK_NONE, "6-M"),
195 ARMCPUTestParams("cortex-m0plus", "armv6-m", "none", ARM::AEK_NONE,
196 "6-M"),
197 ARMCPUTestParams("cortex-m1", "armv6-m", "none", ARM::AEK_NONE, "6-M"),
198 ARMCPUTestParams("sc000", "armv6-m", "none", ARM::AEK_NONE, "6-M"),
199 ARMCPUTestParams("cortex-a5", "armv7-a", "neon-vfpv4",
200 ARM::AEK_MP | ARM::AEK_SEC | ARM::AEK_DSP, "7-A"),
201 ARMCPUTestParams("cortex-a7", "armv7-a", "neon-vfpv4",
202 ARM::AEK_HWDIVTHUMB | ARM::AEK_HWDIVARM | ARM::AEK_MP |
203 ARM::AEK_SEC | ARM::AEK_VIRT | ARM::AEK_DSP,
204 "7-A"),
205 ARMCPUTestParams("cortex-a8", "armv7-a", "neon",
206 ARM::AEK_SEC | ARM::AEK_DSP, "7-A")));
207
208 // gtest in llvm has a limit of 50 test cases when using ::Values so we split
209 // them into 2 blocks
210 INSTANTIATE_TEST_SUITE_P(
211 ARMCPUTestsPart2, ARMCPUTestFixture,
212 ::testing::Values(
213 ARMCPUTestParams("cortex-a9", "armv7-a", "neon-fp16",
214 ARM::AEK_MP | ARM::AEK_SEC | ARM::AEK_DSP, "7-A"),
215 ARMCPUTestParams("cortex-a12", "armv7-a", "neon-vfpv4",
216 ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_VIRT |
217 ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB |
218 ARM::AEK_DSP,
219 "7-A"),
220 ARMCPUTestParams("cortex-a15", "armv7-a", "neon-vfpv4",
221 ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_VIRT |
222 ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB |
223 ARM::AEK_DSP,
224 "7-A"),
225 ARMCPUTestParams("cortex-a17", "armv7-a", "neon-vfpv4",
226 ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_VIRT |
227 ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB |
228 ARM::AEK_DSP,
229 "7-A"),
230 ARMCPUTestParams("krait", "armv7-a", "neon-vfpv4",
231 ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP,
232 "7-A"),
233 ARMCPUTestParams("cortex-r4", "armv7-r", "none",
234 ARM::AEK_NONE | ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP,
235 "7-R"),
236 ARMCPUTestParams("cortex-r4f", "armv7-r", "vfpv3-d16",
237 ARM::AEK_NONE | ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP,
238 "7-R"),
239 ARMCPUTestParams("cortex-r5", "armv7-r", "vfpv3-d16",
240 ARM::AEK_MP | ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB |
241 ARM::AEK_DSP,
242 "7-R"),
243 ARMCPUTestParams("cortex-r7", "armv7-r", "vfpv3-d16-fp16",
244 ARM::AEK_MP | ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB |
245 ARM::AEK_DSP,
246 "7-R"),
247 ARMCPUTestParams("cortex-r8", "armv7-r", "vfpv3-d16-fp16",
248 ARM::AEK_MP | ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB |
249 ARM::AEK_DSP,
250 "7-R"),
251 ARMCPUTestParams("cortex-r52", "armv8-r", "neon-fp-armv8",
252 ARM::AEK_NONE | ARM::AEK_CRC | ARM::AEK_MP |
253 ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
254 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP,
255 "8-R"),
256 ARMCPUTestParams("sc300", "armv7-m", "none",
257 ARM::AEK_NONE | ARM::AEK_HWDIVTHUMB, "7-M"),
258 ARMCPUTestParams("cortex-m3", "armv7-m", "none",
259 ARM::AEK_NONE | ARM::AEK_HWDIVTHUMB, "7-M"),
260 ARMCPUTestParams("cortex-m4", "armv7e-m", "fpv4-sp-d16",
261 ARM::AEK_NONE | ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP,
262 "7E-M"),
263 ARMCPUTestParams("cortex-m7", "armv7e-m", "fpv5-d16",
264 ARM::AEK_NONE | ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP,
265 "7E-M"),
266 ARMCPUTestParams("cortex-a32", "armv8-a", "crypto-neon-fp-armv8",
267 ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
268 ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
269 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP,
270 "8-A"),
271 ARMCPUTestParams("cortex-a35", "armv8-a", "crypto-neon-fp-armv8",
272 ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
273 ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
274 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP,
275 "8-A"),
276 ARMCPUTestParams("cortex-a53", "armv8-a", "crypto-neon-fp-armv8",
277 ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
278 ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
279 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP,
280 "8-A"),
281 ARMCPUTestParams("cortex-a55", "armv8.2-a", "crypto-neon-fp-armv8",
282 ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
283 ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
284 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP |
285 ARM::AEK_FP16 | ARM::AEK_RAS | ARM::AEK_DOTPROD,
286 "8.2-A"),
287 ARMCPUTestParams("cortex-a57", "armv8-a", "crypto-neon-fp-armv8",
288 ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
289 ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
290 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP,
291 "8-A"),
292 ARMCPUTestParams("cortex-a72", "armv8-a", "crypto-neon-fp-armv8",
293 ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
294 ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
295 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP,
296 "8-A"),
297 ARMCPUTestParams("cortex-a73", "armv8-a", "crypto-neon-fp-armv8",
298 ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
299 ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
300 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP,
301 "8-A"),
302 ARMCPUTestParams("cortex-a75", "armv8.2-a", "crypto-neon-fp-armv8",
303 ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
304 ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
305 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP |
306 ARM::AEK_FP16 | ARM::AEK_RAS | ARM::AEK_DOTPROD,
307 "8.2-A"),
308 ARMCPUTestParams("cortex-a76", "armv8.2-a", "crypto-neon-fp-armv8",
309 ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
310 ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
311 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP |
312 ARM::AEK_FP16 | ARM::AEK_RAS | ARM::AEK_DOTPROD,
313 "8.2-A"),
314 ARMCPUTestParams("cortex-a76ae", "armv8.2-a", "crypto-neon-fp-armv8",
315 ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
316 ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
317 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP |
318 ARM::AEK_FP16 | ARM::AEK_RAS | ARM::AEK_DOTPROD,
319 "8.2-A"),
320 ARMCPUTestParams("cortex-a78c", "armv8.2-a", "crypto-neon-fp-armv8",
321 ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_VIRT |
322 ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB |
323 ARM::AEK_DSP | ARM::AEK_CRC | ARM::AEK_RAS |
324 ARM::AEK_FP16 | ARM::AEK_DOTPROD,
325 "8.2-A"),
326 ARMCPUTestParams("cortex-a710", "armv9-a", "neon-fp-armv8",
327 ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_VIRT |
328 ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB |
329 ARM::AEK_DSP | ARM::AEK_CRC | ARM::AEK_RAS |
330 ARM::AEK_DOTPROD | ARM::AEK_FP16FML |
331 ARM::AEK_BF16 | ARM::AEK_I8MM | ARM::AEK_SB,
332 "9-A"),
333 ARMCPUTestParams("cortex-a77", "armv8.2-a", "crypto-neon-fp-armv8",
334 ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
335 ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
336 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP |
337 ARM::AEK_FP16 | ARM::AEK_RAS | ARM::AEK_DOTPROD,
338 "8.2-A"),
339 ARMCPUTestParams("cortex-a78", "armv8.2-a", "crypto-neon-fp-armv8",
340 ARM::AEK_DOTPROD | ARM::AEK_FP16 | ARM::AEK_SEC |
341 ARM::AEK_MP | ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
342 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP | ARM::AEK_CRC |
343 ARM::AEK_RAS,
344 "8.2-A"),
345 ARMCPUTestParams("cortex-x1", "armv8.2-a", "crypto-neon-fp-armv8",
346 ARM::AEK_RAS | ARM::AEK_FP16 | ARM::AEK_DOTPROD |
347 ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_VIRT |
348 ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB |
349 ARM::AEK_DSP | ARM::AEK_CRC,
350 "8.2-A"),
351 ARMCPUTestParams("cortex-x1c", "armv8.2-a", "crypto-neon-fp-armv8",
352 ARM::AEK_RAS | ARM::AEK_FP16 | ARM::AEK_DOTPROD |
353 ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_VIRT |
354 ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB |
355 ARM::AEK_DSP | ARM::AEK_CRC,
356 "8.2-A"),
357 ARMCPUTestParams("neoverse-n1", "armv8.2-a", "crypto-neon-fp-armv8",
358 ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
359 ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
360 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP |
361 ARM::AEK_FP16 | ARM::AEK_RAS | ARM::AEK_DOTPROD,
362 "8.2-A"),
363 ARMCPUTestParams("neoverse-n2", "armv8.5-a", "crypto-neon-fp-armv8",
364 ARM::AEK_CRC | ARM::AEK_HWDIVTHUMB |
365 ARM::AEK_HWDIVARM | ARM::AEK_MP | ARM::AEK_SEC |
366 ARM::AEK_VIRT | ARM::AEK_DSP | ARM::AEK_BF16 |
367 ARM::AEK_DOTPROD | ARM::AEK_RAS | ARM::AEK_I8MM |
368 ARM::AEK_SB,
369 "8.5-A"),
370 ARMCPUTestParams("neoverse-v1", "armv8.4-a", "crypto-neon-fp-armv8",
371 ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_VIRT |
372 ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB |
373 ARM::AEK_DSP | ARM::AEK_CRC | ARM::AEK_RAS |
374 ARM::AEK_FP16 | ARM::AEK_BF16 | ARM::AEK_DOTPROD,
375 "8.4-A"),
376 ARMCPUTestParams("cyclone", "armv8-a", "crypto-neon-fp-armv8",
377 ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
378 ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
379 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP,
380 "8-A"),
381 ARMCPUTestParams("exynos-m3", "armv8-a", "crypto-neon-fp-armv8",
382 ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
383 ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
384 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP,
385 "8-A"),
386 ARMCPUTestParams("exynos-m4", "armv8.2-a", "crypto-neon-fp-armv8",
387 ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
388 ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
389 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP |
390 ARM::AEK_DOTPROD | ARM::AEK_FP16 | ARM::AEK_RAS,
391 "8.2-A"),
392 ARMCPUTestParams("exynos-m5", "armv8.2-a", "crypto-neon-fp-armv8",
393 ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
394 ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
395 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP |
396 ARM::AEK_DOTPROD | ARM::AEK_FP16 | ARM::AEK_RAS,
397 "8.2-A"),
398 ARMCPUTestParams("cortex-m23", "armv8-m.base", "none",
399 ARM::AEK_NONE | ARM::AEK_HWDIVTHUMB, "8-M.Baseline"),
400 ARMCPUTestParams("cortex-m33", "armv8-m.main", "fpv5-sp-d16",
401 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP, "8-M.Mainline"),
402 ARMCPUTestParams("cortex-m35p", "armv8-m.main", "fpv5-sp-d16",
403 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP, "8-M.Mainline"),
404 ARMCPUTestParams("cortex-m55", "armv8.1-m.main",
405 "fp-armv8-fullfp16-d16",
406 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP | ARM::AEK_SIMD |
407 ARM::AEK_FP | ARM::AEK_RAS | ARM::AEK_LOB |
408 ARM::AEK_FP16,
409 "8.1-M.Mainline"),
410 ARMCPUTestParams("cortex-m85", "armv8.1-m.main",
411 "fp-armv8-fullfp16-d16",
412 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP | ARM::AEK_SIMD |
413 ARM::AEK_FP | ARM::AEK_RAS | ARM::AEK_LOB |
414 ARM::AEK_FP16 | ARM::AEK_PACBTI,
415 "8.1-M.Mainline"),
416 ARMCPUTestParams("iwmmxt", "iwmmxt", "none", ARM::AEK_NONE, "iwmmxt"),
417 ARMCPUTestParams("xscale", "xscale", "none", ARM::AEK_NONE, "xscale"),
418 ARMCPUTestParams("swift", "armv7s", "neon-vfpv4",
419 ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP,
420 "7-S")));
421
422 static constexpr unsigned NumARMCPUArchs = 89;
423
424 TEST(TargetParserTest, testARMCPUArchList) {
425 SmallVector<StringRef, NumARMCPUArchs> List;
426 ARM::fillValidCPUArchList(List);
427
428 // No list exists for these in this test suite, so ensure all are
429 // valid, and match the expected 'magic' count.
430 EXPECT_EQ(List.size(), NumARMCPUArchs);
431 for(StringRef CPU : List) {
432 EXPECT_NE(ARM::parseCPUArch(CPU), ARM::ArchKind::INVALID);
433 }
434 }
435
436 TEST(TargetParserTest, testInvalidARMArch) {
437 auto InvalidArchStrings = {"armv", "armv99", "noarm"};
438 for (const char* InvalidArch : InvalidArchStrings)
439 EXPECT_EQ(ARM::parseArch(InvalidArch), ARM::ArchKind::INVALID);
440 }
441
442 bool testARMArch(StringRef Arch, StringRef DefaultCPU, StringRef SubArch,
443 unsigned ArchAttr) {
444 ARM::ArchKind AK = ARM::parseArch(Arch);
445 bool Result = (AK != ARM::ArchKind::INVALID);
446 Result &= ARM::getDefaultCPU(Arch).equals(DefaultCPU);
447 Result &= ARM::getSubArch(AK).equals(SubArch);
448 Result &= (ARM::getArchAttr(AK) == ArchAttr);
449 return Result;
450 }
451
452 TEST(TargetParserTest, testARMArch) {
453 EXPECT_TRUE(
454 testARMArch("armv4", "strongarm", "v4",
455 ARMBuildAttrs::CPUArch::v4));
456 EXPECT_TRUE(
457 testARMArch("armv4t", "arm7tdmi", "v4t",
458 ARMBuildAttrs::CPUArch::v4T));
459 EXPECT_TRUE(
460 testARMArch("armv5t", "arm10tdmi", "v5",
461 ARMBuildAttrs::CPUArch::v5T));
462 EXPECT_TRUE(
463 testARMArch("armv5te", "arm1022e", "v5e",
464 ARMBuildAttrs::CPUArch::v5TE));
465 EXPECT_TRUE(
466 testARMArch("armv5tej", "arm926ej-s", "v5e",
467 ARMBuildAttrs::CPUArch::v5TEJ));
468 EXPECT_TRUE(
469 testARMArch("armv6", "arm1136jf-s", "v6",
470 ARMBuildAttrs::CPUArch::v6));
471 EXPECT_TRUE(
472 testARMArch("armv6k", "mpcore", "v6k",
473 ARMBuildAttrs::CPUArch::v6K));
474 EXPECT_TRUE(
475 testARMArch("armv6t2", "arm1156t2-s", "v6t2",
476 ARMBuildAttrs::CPUArch::v6T2));
477 EXPECT_TRUE(
478 testARMArch("armv6kz", "arm1176jzf-s", "v6kz",
479 ARMBuildAttrs::CPUArch::v6KZ));
480 EXPECT_TRUE(
481 testARMArch("armv6-m", "cortex-m0", "v6m",
482 ARMBuildAttrs::CPUArch::v6_M));
483 EXPECT_TRUE(
484 testARMArch("armv7-a", "generic", "v7",
485 ARMBuildAttrs::CPUArch::v7));
486 EXPECT_TRUE(
487 testARMArch("armv7ve", "generic", "v7ve",
488 ARMBuildAttrs::CPUArch::v7));
489 EXPECT_TRUE(
490 testARMArch("armv7-r", "cortex-r4", "v7r",
491 ARMBuildAttrs::CPUArch::v7));
492 EXPECT_TRUE(
493 testARMArch("armv7-m", "cortex-m3", "v7m",
494 ARMBuildAttrs::CPUArch::v7));
495 EXPECT_TRUE(
496 testARMArch("armv7e-m", "cortex-m4", "v7em",
497 ARMBuildAttrs::CPUArch::v7E_M));
498 EXPECT_TRUE(
499 testARMArch("armv8-a", "generic", "v8a",
500 ARMBuildAttrs::CPUArch::v8_A));
501 EXPECT_TRUE(
502 testARMArch("armv8.1-a", "generic", "v8.1a",
503 ARMBuildAttrs::CPUArch::v8_A));
504 EXPECT_TRUE(
505 testARMArch("armv8.2-a", "generic", "v8.2a",
506 ARMBuildAttrs::CPUArch::v8_A));
507 EXPECT_TRUE(
508 testARMArch("armv8.3-a", "generic", "v8.3a",
509 ARMBuildAttrs::CPUArch::v8_A));
510 EXPECT_TRUE(
511 testARMArch("armv8.4-a", "generic", "v8.4a",
512 ARMBuildAttrs::CPUArch::v8_A));
513 EXPECT_TRUE(
514 testARMArch("armv8.5-a", "generic", "v8.5a",
515 ARMBuildAttrs::CPUArch::v8_A));
516 EXPECT_TRUE(
517 testARMArch("armv8.6-a", "generic", "v8.6a",
518 ARMBuildAttrs::CPUArch::v8_A));
519 EXPECT_TRUE(
520 testARMArch("armv8.7-a", "generic", "v8.7a",
521 ARMBuildAttrs::CPUArch::v8_A));
522 EXPECT_TRUE(testARMArch("armv8.8-a", "generic", "v8.8a",
523 ARMBuildAttrs::CPUArch::v8_A));
524 EXPECT_TRUE(
525 testARMArch("armv8.9-a", "generic", "v8.9a",
526 ARMBuildAttrs::CPUArch::v8_A));
527 EXPECT_TRUE(
528 testARMArch("armv9-a", "generic", "v9a",
529 ARMBuildAttrs::CPUArch::v9_A));
530 EXPECT_TRUE(
531 testARMArch("armv9.1-a", "generic", "v9.1a",
532 ARMBuildAttrs::CPUArch::v9_A));
533 EXPECT_TRUE(
534 testARMArch("armv9.2-a", "generic", "v9.2a",
535 ARMBuildAttrs::CPUArch::v9_A));
536 EXPECT_TRUE(
537 testARMArch("armv9.3-a", "generic", "v9.3a",
538 ARMBuildAttrs::CPUArch::v9_A));
539 EXPECT_TRUE(
540 testARMArch("armv9.4-a", "generic", "v9.4a",
541 ARMBuildAttrs::CPUArch::v9_A));
542 EXPECT_TRUE(
543 testARMArch("armv8-r", "cortex-r52", "v8r",
544 ARMBuildAttrs::CPUArch::v8_R));
545 EXPECT_TRUE(
546 testARMArch("armv8-m.base", "generic", "v8m.base",
547 ARMBuildAttrs::CPUArch::v8_M_Base));
548 EXPECT_TRUE(
549 testARMArch("armv8-m.main", "generic", "v8m.main",
550 ARMBuildAttrs::CPUArch::v8_M_Main));
551 EXPECT_TRUE(
552 testARMArch("armv8.1-m.main", "generic", "v8.1m.main",
553 ARMBuildAttrs::CPUArch::v8_1_M_Main));
554 EXPECT_TRUE(
555 testARMArch("iwmmxt", "iwmmxt", "",
556 ARMBuildAttrs::CPUArch::v5TE));
557 EXPECT_TRUE(
558 testARMArch("iwmmxt2", "generic", "",
559 ARMBuildAttrs::CPUArch::v5TE));
560 EXPECT_TRUE(
561 testARMArch("xscale", "xscale", "v5e",
562 ARMBuildAttrs::CPUArch::v5TE));
563 EXPECT_TRUE(
564 testARMArch("armv7s", "swift", "v7s",
565 ARMBuildAttrs::CPUArch::v7));
566 EXPECT_TRUE(
567 testARMArch("armv7k", "generic", "v7k",
568 ARMBuildAttrs::CPUArch::v7));
569 }
570
571 bool testARMExtension(StringRef CPUName,ARM::ArchKind ArchKind, StringRef ArchExt) {
572 return ARM::getDefaultExtensions(CPUName, ArchKind) &
573 ARM::parseArchExt(ArchExt);
574 }
575
576 TEST(TargetParserTest, testARMExtension) {
577 EXPECT_FALSE(testARMExtension("strongarm", ARM::ArchKind::INVALID, "dsp"));
578 EXPECT_FALSE(testARMExtension("arm7tdmi", ARM::ArchKind::INVALID, "dsp"));
579 EXPECT_FALSE(testARMExtension("arm10tdmi",
580 ARM::ArchKind::INVALID, "simd"));
581 EXPECT_FALSE(testARMExtension("arm1022e", ARM::ArchKind::INVALID, "simd"));
582 EXPECT_FALSE(testARMExtension("arm926ej-s",
583 ARM::ArchKind::INVALID, "simd"));
584 EXPECT_FALSE(testARMExtension("arm1136jf-s",
585 ARM::ArchKind::INVALID, "crypto"));
586 EXPECT_FALSE(testARMExtension("arm1156t2-s",
587 ARM::ArchKind::INVALID, "crypto"));
588 EXPECT_FALSE(testARMExtension("arm1176jzf-s",
589 ARM::ArchKind::INVALID, "crypto"));
590 EXPECT_FALSE(testARMExtension("cortex-m0",
591 ARM::ArchKind::INVALID, "crypto"));
592 EXPECT_FALSE(testARMExtension("cortex-a8",
593 ARM::ArchKind::INVALID, "crypto"));
594 EXPECT_FALSE(testARMExtension("cortex-r4",
595 ARM::ArchKind::INVALID, "crypto"));
596 EXPECT_FALSE(testARMExtension("cortex-m3",
597 ARM::ArchKind::INVALID, "crypto"));
598 EXPECT_FALSE(testARMExtension("cortex-a53",
599 ARM::ArchKind::INVALID, "ras"));
600 EXPECT_FALSE(testARMExtension("cortex-a53",
601 ARM::ArchKind::INVALID, "fp16"));
602 EXPECT_TRUE(testARMExtension("cortex-a55",
603 ARM::ArchKind::INVALID, "fp16"));
604 EXPECT_FALSE(testARMExtension("cortex-a55",
605 ARM::ArchKind::INVALID, "fp16fml"));
606 EXPECT_TRUE(testARMExtension("cortex-a75",
607 ARM::ArchKind::INVALID, "fp16"));
608 EXPECT_FALSE(testARMExtension("cortex-a75",
609 ARM::ArchKind::INVALID, "fp16fml"));
610 EXPECT_FALSE(testARMExtension("cortex-r52",
611 ARM::ArchKind::INVALID, "ras"));
612 EXPECT_FALSE(testARMExtension("iwmmxt", ARM::ArchKind::INVALID, "crc"));
613 EXPECT_FALSE(testARMExtension("xscale", ARM::ArchKind::INVALID, "crc"));
614 EXPECT_FALSE(testARMExtension("swift", ARM::ArchKind::INVALID, "crc"));
615
616 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV4, "dsp"));
617 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV4T, "dsp"));
618 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV5T, "simd"));
619 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV5TE, "simd"));
620 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV5TEJ, "simd"));
621 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV6, "crypto"));
622 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV6K, "crypto"));
623 EXPECT_FALSE(testARMExtension("generic",
624 ARM::ArchKind::ARMV6T2, "crypto"));
625 EXPECT_FALSE(testARMExtension("generic",
626 ARM::ArchKind::ARMV6KZ, "crypto"));
627 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV6M, "crypto"));
628 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV7A, "crypto"));
629 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV7R, "crypto"));
630 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV7M, "crypto"));
631 EXPECT_FALSE(testARMExtension("generic",
632 ARM::ArchKind::ARMV7EM, "crypto"));
633 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV8A, "ras"));
634 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV8_1A, "ras"));
635 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV8_2A, "profile"));
636 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV8_2A, "fp16"));
637 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV8_2A, "fp16fml"));
638 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV8_3A, "fp16"));
639 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV8_3A, "fp16fml"));
640 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV8_4A, "fp16"));
641 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV8_4A, "fp16fml"));
642 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV8R, "ras"));
643 EXPECT_FALSE(testARMExtension("generic",
644 ARM::ArchKind::ARMV8MBaseline, "crc"));
645 EXPECT_FALSE(testARMExtension("generic",
646 ARM::ArchKind::ARMV8MMainline, "crc"));
647 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::IWMMXT, "crc"));
648 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::IWMMXT2, "crc"));
649 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::XSCALE, "crc"));
650 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV7S, "crypto"));
651 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV7K, "crypto"));
652 }
653
654 TEST(TargetParserTest, ARMFPUVersion) {
655 for (ARM::FPUKind FK = static_cast<ARM::FPUKind>(0);
656 FK <= ARM::FPUKind::FK_LAST;
657 FK = static_cast<ARM::FPUKind>(static_cast<unsigned>(FK) + 1))
658 if (FK == ARM::FK_LAST || ARM::getFPUName(FK) == "invalid" ||
659 ARM::getFPUName(FK) == "none" || ARM::getFPUName(FK) == "softvfp")
660 EXPECT_EQ(ARM::FPUVersion::NONE, ARM::getFPUVersion(FK));
661 else
662 EXPECT_NE(ARM::FPUVersion::NONE, ARM::getFPUVersion(FK));
663 }
664
665 TEST(TargetParserTest, ARMFPUNeonSupportLevel) {
666 for (ARM::FPUKind FK = static_cast<ARM::FPUKind>(0);
667 FK <= ARM::FPUKind::FK_LAST;
668 FK = static_cast<ARM::FPUKind>(static_cast<unsigned>(FK) + 1))
669 if (FK == ARM::FK_LAST ||
670 ARM::getFPUName(FK).find("neon") == std::string::npos)
671 EXPECT_EQ(ARM::NeonSupportLevel::None,
672 ARM::getFPUNeonSupportLevel(FK));
673 else
674 EXPECT_NE(ARM::NeonSupportLevel::None,
675 ARM::getFPUNeonSupportLevel(FK));
676 }
677
678 TEST(TargetParserTest, ARMFPURestriction) {
679 for (ARM::FPUKind FK = static_cast<ARM::FPUKind>(0);
680 FK <= ARM::FPUKind::FK_LAST;
681 FK = static_cast<ARM::FPUKind>(static_cast<unsigned>(FK) + 1)) {
682 if (FK == ARM::FK_LAST ||
683 (ARM::getFPUName(FK).find("d16") == std::string::npos &&
684 ARM::getFPUName(FK).find("vfpv3xd") == std::string::npos))
685 EXPECT_EQ(ARM::FPURestriction::None, ARM::getFPURestriction(FK));
686 else
687 EXPECT_NE(ARM::FPURestriction::None, ARM::getFPURestriction(FK));
688 }
689 }
690
691 TEST(TargetParserTest, ARMExtensionFeatures) {
692 std::map<uint64_t, std::vector<StringRef>> Extensions;
693
694 for (auto &Ext : ARM::ARCHExtNames) {
695 if (!Ext.Feature.empty() && !Ext.NegFeature.empty())
696 Extensions[Ext.ID] = {Ext.Feature, Ext.NegFeature};
697 }
698
699 Extensions[ARM::AEK_HWDIVARM] = { "+hwdiv-arm", "-hwdiv-arm" };
700 Extensions[ARM::AEK_HWDIVTHUMB] = { "+hwdiv", "-hwdiv" };
701
702 std::vector<StringRef> Features;
703
704 EXPECT_FALSE(ARM::getExtensionFeatures(ARM::AEK_INVALID, Features));
705
706 for (auto &E : Extensions) {
707 // test +extension
708 Features.clear();
709 ARM::getExtensionFeatures(E.first, Features);
710 EXPECT_TRUE(llvm::is_contained(Features, E.second.at(0)));
711 EXPECT_EQ(Extensions.size(), Features.size());
712
713 // test -extension
714 Features.clear();
715 ARM::getExtensionFeatures(~E.first, Features);
716 EXPECT_TRUE(llvm::is_contained(Features, E.second.at(1)));
717 EXPECT_EQ(Extensions.size(), Features.size());
718 }
719 }
720
721 TEST(TargetParserTest, ARMFPUFeatures) {
722 std::vector<StringRef> Features;
723 for (ARM::FPUKind FK = static_cast<ARM::FPUKind>(0);
724 FK <= ARM::FPUKind::FK_LAST;
725 FK = static_cast<ARM::FPUKind>(static_cast<unsigned>(FK) + 1)) {
726 if (FK == ARM::FK_INVALID || FK >= ARM::FK_LAST)
727 EXPECT_FALSE(ARM::getFPUFeatures(FK, Features));
728 else
729 EXPECT_TRUE(ARM::getFPUFeatures(FK, Features));
730 }
731 }
732
733 TEST(TargetParserTest, ARMArchExtFeature) {
734 const char *ArchExt[][4] = {{"crc", "nocrc", "+crc", "-crc"},
735 {"crypto", "nocrypto", "+crypto", "-crypto"},
736 {"dsp", "nodsp", "+dsp", "-dsp"},
737 {"fp", "nofp", nullptr, nullptr},
738 {"idiv", "noidiv", nullptr, nullptr},
739 {"mp", "nomp", nullptr, nullptr},
740 {"simd", "nosimd", nullptr, nullptr},
741 {"sec", "nosec", nullptr, nullptr},
742 {"virt", "novirt", nullptr, nullptr},
743 {"fp16", "nofp16", "+fullfp16", "-fullfp16"},
744 {"fp16fml", "nofp16fml", "+fp16fml", "-fp16fml"},
745 {"ras", "noras", "+ras", "-ras"},
746 {"dotprod", "nodotprod", "+dotprod", "-dotprod"},
747 {"os", "noos", nullptr, nullptr},
748 {"iwmmxt", "noiwmmxt", nullptr, nullptr},
749 {"iwmmxt2", "noiwmmxt2", nullptr, nullptr},
750 {"maverick", "maverick", nullptr, nullptr},
751 {"xscale", "noxscale", nullptr, nullptr},
752 {"sb", "nosb", "+sb", "-sb"},
753 {"i8mm", "noi8mm", "+i8mm", "-i8mm"},
754 {"mve", "nomve", "+mve", "-mve"},
755 {"mve.fp", "nomve.fp", "+mve.fp", "-mve.fp"}};
756
757 for (unsigned i = 0; i < std::size(ArchExt); i++) {
758 EXPECT_EQ(StringRef(ArchExt[i][2]), ARM::getArchExtFeature(ArchExt[i][0]));
759 EXPECT_EQ(StringRef(ArchExt[i][3]), ARM::getArchExtFeature(ArchExt[i][1]));
760 }
761 }
762
763 static bool
764 testArchExtDependency(const char *ArchExt,
765 const std::initializer_list<const char *> &Expected) {
766 std::vector<StringRef> Features;
767 unsigned FPUID;
768
769 if (!ARM::appendArchExtFeatures("", ARM::ArchKind::ARMV8_1MMainline, ArchExt,
770 Features, FPUID))
771 return false;
772
773 return llvm::all_of(Expected, [&](StringRef Ext) {
774 return llvm::is_contained(Features, Ext);
775 });
776 }
777
778 TEST(TargetParserTest, ARMArchExtDependencies) {
779 EXPECT_TRUE(testArchExtDependency("mve", {"+mve", "+dsp"}));
780 EXPECT_TRUE(testArchExtDependency("mve.fp", {"+mve.fp", "+mve", "+dsp"}));
781 EXPECT_TRUE(testArchExtDependency("nodsp", {"-dsp", "-mve", "-mve.fp"}));
782 EXPECT_TRUE(testArchExtDependency("nomve", {"-mve", "-mve.fp"}));
783 }
784
785 TEST(TargetParserTest, ARMparseHWDiv) {
786 const char *hwdiv[] = {"thumb", "arm", "arm,thumb", "thumb,arm"};
787
788 for (unsigned i = 0; i < std::size(hwdiv); i++)
789 EXPECT_NE(ARM::AEK_INVALID, ARM::parseHWDiv((StringRef)hwdiv[i]));
790 }
791
792 TEST(TargetParserTest, ARMparseArchEndianAndISA) {
793 const char *Arch[] = {
794 "v2", "v2a", "v3", "v3m", "v4", "v4t",
795 "v5", "v5t", "v5e", "v5te", "v5tej", "v6",
796 "v6j", "v6k", "v6hl", "v6t2", "v6kz", "v6z",
797 "v6zk", "v6-m", "v6m", "v6sm", "v6s-m", "v7-a",
798 "v7", "v7a", "v7ve", "v7hl", "v7l", "v7-r",
799 "v7r", "v7-m", "v7m", "v7k", "v7s", "v7e-m",
800 "v7em", "v8-a", "v8", "v8a", "v8l", "v8.1-a",
801 "v8.1a", "v8.2-a", "v8.2a", "v8.3-a", "v8.3a", "v8.4-a",
802 "v8.4a", "v8.5-a", "v8.5a", "v8.6-a", "v8.6a", "v8.7-a",
803 "v8.7a", "v8.8-a", "v8.8a", "v8-r", "v8m.base", "v8m.main",
804 "v8.1m.main"};
805
806 for (unsigned i = 0; i < std::size(Arch); i++) {
807 std::string arm_1 = "armeb" + (std::string)(Arch[i]);
808 std::string arm_2 = "arm" + (std::string)(Arch[i]) + "eb";
809 std::string arm_3 = "arm" + (std::string)(Arch[i]);
810 std::string thumb_1 = "thumbeb" + (std::string)(Arch[i]);
811 std::string thumb_2 = "thumb" + (std::string)(Arch[i]) + "eb";
812 std::string thumb_3 = "thumb" + (std::string)(Arch[i]);
813
814 EXPECT_EQ(ARM::EndianKind::BIG, ARM::parseArchEndian(arm_1));
815 EXPECT_EQ(ARM::EndianKind::BIG, ARM::parseArchEndian(arm_2));
816 EXPECT_EQ(ARM::EndianKind::LITTLE, ARM::parseArchEndian(arm_3));
817
818 EXPECT_EQ(ARM::ISAKind::ARM, ARM::parseArchISA(arm_1));
819 EXPECT_EQ(ARM::ISAKind::ARM, ARM::parseArchISA(arm_2));
820 EXPECT_EQ(ARM::ISAKind::ARM, ARM::parseArchISA(arm_3));
821 if (i >= 4) {
822 EXPECT_EQ(ARM::EndianKind::BIG, ARM::parseArchEndian(thumb_1));
823 EXPECT_EQ(ARM::EndianKind::BIG, ARM::parseArchEndian(thumb_2));
824 EXPECT_EQ(ARM::EndianKind::LITTLE, ARM::parseArchEndian(thumb_3));
825
826 EXPECT_EQ(ARM::ISAKind::THUMB, ARM::parseArchISA(thumb_1));
827 EXPECT_EQ(ARM::ISAKind::THUMB, ARM::parseArchISA(thumb_2));
828 EXPECT_EQ(ARM::ISAKind::THUMB, ARM::parseArchISA(thumb_3));
829 }
830 }
831
832 EXPECT_EQ(ARM::EndianKind::LITTLE, ARM::parseArchEndian("aarch64"));
833 EXPECT_EQ(ARM::EndianKind::LITTLE, ARM::parseArchEndian("arm64_32"));
834 EXPECT_EQ(ARM::EndianKind::BIG, ARM::parseArchEndian("aarch64_be"));
835
836 EXPECT_EQ(ARM::ISAKind::AARCH64, ARM::parseArchISA("aarch64"));
837 EXPECT_EQ(ARM::ISAKind::AARCH64, ARM::parseArchISA("aarch64_be"));
838 EXPECT_EQ(ARM::ISAKind::AARCH64, ARM::parseArchISA("arm64"));
839 EXPECT_EQ(ARM::ISAKind::AARCH64, ARM::parseArchISA("arm64_be"));
840 EXPECT_EQ(ARM::ISAKind::AARCH64, ARM::parseArchISA("arm64_32"));
841 EXPECT_EQ(ARM::ISAKind::AARCH64, ARM::parseArchISA("aarch64_32"));
842 }
843
844 TEST(TargetParserTest, ARMparseArchProfile) {
845 for (unsigned i = 0; i < std::size(ARMArch); i++) {
846 switch (ARM::parseArch(ARMArch[i])) {
847 case ARM::ArchKind::ARMV6M:
848 case ARM::ArchKind::ARMV7M:
849 case ARM::ArchKind::ARMV7EM:
850 case ARM::ArchKind::ARMV8MMainline:
851 case ARM::ArchKind::ARMV8MBaseline:
852 case ARM::ArchKind::ARMV8_1MMainline:
853 EXPECT_EQ(ARM::ProfileKind::M, ARM::parseArchProfile(ARMArch[i]));
854 break;
855 case ARM::ArchKind::ARMV7R:
856 case ARM::ArchKind::ARMV8R:
857 EXPECT_EQ(ARM::ProfileKind::R, ARM::parseArchProfile(ARMArch[i]));
858 break;
859 case ARM::ArchKind::ARMV7A:
860 case ARM::ArchKind::ARMV7VE:
861 case ARM::ArchKind::ARMV7K:
862 case ARM::ArchKind::ARMV8A:
863 case ARM::ArchKind::ARMV8_1A:
864 case ARM::ArchKind::ARMV8_2A:
865 case ARM::ArchKind::ARMV8_3A:
866 case ARM::ArchKind::ARMV8_4A:
867 case ARM::ArchKind::ARMV8_5A:
868 case ARM::ArchKind::ARMV8_6A:
869 case ARM::ArchKind::ARMV8_7A:
870 case ARM::ArchKind::ARMV8_8A:
871 case ARM::ArchKind::ARMV8_9A:
872 case ARM::ArchKind::ARMV9A:
873 case ARM::ArchKind::ARMV9_1A:
874 case ARM::ArchKind::ARMV9_2A:
875 case ARM::ArchKind::ARMV9_3A:
876 case ARM::ArchKind::ARMV9_4A:
877 EXPECT_EQ(ARM::ProfileKind::A, ARM::parseArchProfile(ARMArch[i]));
878 break;
879 default:
880 EXPECT_EQ(ARM::ProfileKind::INVALID, ARM::parseArchProfile(ARMArch[i]));
881 break;
882 }
883 }
884 }
885
886 TEST(TargetParserTest, ARMparseArchVersion) {
887 for (unsigned i = 0; i < std::size(ARMArch); i++)
888 if (((std::string)ARMArch[i]).substr(0, 4) == "armv")
889 EXPECT_EQ((ARMArch[i][4] - 48u), ARM::parseArchVersion(ARMArch[i]));
890 else
891 EXPECT_EQ(5u, ARM::parseArchVersion(ARMArch[i]));
892 }
893
894 TEST(TargetParserTest, getARMCPUForArch) {
895 // Platform specific defaults.
896 {
897 llvm::Triple Triple("arm--nacl");
898 EXPECT_EQ("cortex-a8", ARM::getARMCPUForArch(Triple));
899 }
900 {
901 llvm::Triple Triple("arm--openbsd");
902 EXPECT_EQ("cortex-a8", ARM::getARMCPUForArch(Triple));
903 }
904 {
905 llvm::Triple Triple("armv6-unknown-freebsd");
906 EXPECT_EQ("arm1176jzf-s", ARM::getARMCPUForArch(Triple));
907 }
908 {
909 llvm::Triple Triple("thumbv6-unknown-freebsd");
910 EXPECT_EQ("arm1176jzf-s", ARM::getARMCPUForArch(Triple));
911 }
912 {
913 llvm::Triple Triple("armebv6-unknown-freebsd");
914 EXPECT_EQ("arm1176jzf-s", ARM::getARMCPUForArch(Triple));
915 }
916 {
917 llvm::Triple Triple("arm--win32");
918 EXPECT_EQ("cortex-a9", ARM::getARMCPUForArch(Triple));
919 EXPECT_EQ("generic", ARM::getARMCPUForArch(Triple, "armv8-a"));
920 }
921 // Some alternative architectures
922 {
923 llvm::Triple Triple("armv7k-apple-ios9");
924 EXPECT_EQ("cortex-a7", ARM::getARMCPUForArch(Triple));
925 }
926 {
927 llvm::Triple Triple("armv7k-apple-watchos3");
928 EXPECT_EQ("cortex-a7", ARM::getARMCPUForArch(Triple));
929 }
930 {
931 llvm::Triple Triple("armv7k-apple-tvos9");
932 EXPECT_EQ("cortex-a7", ARM::getARMCPUForArch(Triple));
933 }
934 // armeb is permitted, but armebeb is not
935 {
936 llvm::Triple Triple("armeb-none-eabi");
937 EXPECT_EQ("arm7tdmi", ARM::getARMCPUForArch(Triple));
938 }
939 {
940 llvm::Triple Triple("armebeb-none-eabi");
941 EXPECT_EQ("", ARM::getARMCPUForArch(Triple));
942 }
943 {
944 llvm::Triple Triple("armebv6eb-none-eabi");
945 EXPECT_EQ("", ARM::getARMCPUForArch(Triple));
946 }
947 // xscaleeb is permitted, but armebxscale is not
948 {
949 llvm::Triple Triple("xscaleeb-none-eabi");
950 EXPECT_EQ("xscale", ARM::getARMCPUForArch(Triple));
951 }
952 {
953 llvm::Triple Triple("armebxscale-none-eabi");
954 EXPECT_EQ("", ARM::getARMCPUForArch(Triple));
955 }
956 }
957
958 class AArch64CPUTestFixture
959 : public ::testing::TestWithParam<ARMCPUTestParams> {};
960
961 TEST_P(AArch64CPUTestFixture, testAArch64CPU) {
962 ARMCPUTestParams params = GetParam();
963
964 const AArch64::ArchInfo &AI = AArch64::parseCpu(params.CPUName).Arch;
965 EXPECT_EQ(params.ExpectedArch, AI.Name);
966
967 uint64_t default_extensions =
968 AArch64::getDefaultExtensions(params.CPUName, AI);
969 EXPECT_PRED_FORMAT2(
970 AssertSameExtensionFlags<ARM::ISAKind::AARCH64>(params.CPUName),
971 params.ExpectedFlags, default_extensions);
972 }
973
974 INSTANTIATE_TEST_SUITE_P(
975 AArch64CPUTests, AArch64CPUTestFixture,
976 ::testing::Values(
977 ARMCPUTestParams("invalid", "invalid", "invalid", AArch64::AEK_NONE,
978 ""),
979 ARMCPUTestParams("generic", "invalid", "none", AArch64::AEK_NONE, ""),
980
981 ARMCPUTestParams("cortex-a34", "armv8-a", "crypto-neon-fp-armv8",
982 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
983 AArch64::AEK_FP | AArch64::AEK_SIMD,
984 "8-A"),
985 ARMCPUTestParams("cortex-a35", "armv8-a", "crypto-neon-fp-armv8",
986 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
987 AArch64::AEK_FP | AArch64::AEK_SIMD,
988 "8-A"),
989 ARMCPUTestParams("cortex-a53", "armv8-a", "crypto-neon-fp-armv8",
990 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
991 AArch64::AEK_FP | AArch64::AEK_SIMD,
992 "8-A"),
993 ARMCPUTestParams("cortex-a55", "armv8.2-a", "crypto-neon-fp-armv8",
994 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
995 AArch64::AEK_FP | AArch64::AEK_SIMD |
996 AArch64::AEK_RAS | AArch64::AEK_LSE |
997 AArch64::AEK_RDM | AArch64::AEK_FP16 |
998 AArch64::AEK_DOTPROD | AArch64::AEK_RCPC,
999 "8.2-A"),
1000 ARMCPUTestParams(
1001 "cortex-a510", "armv9-a", "neon-fp-armv8",
1002 AArch64::AEK_CRC | AArch64::AEK_FP | AArch64::AEK_SIMD |
1003 AArch64::AEK_RAS | AArch64::AEK_LSE | AArch64::AEK_RDM |
1004 AArch64::AEK_RCPC | AArch64::AEK_DOTPROD | AArch64::AEK_BF16 |
1005 AArch64::AEK_I8MM | AArch64::AEK_SVE | AArch64::AEK_SVE2 |
1006 AArch64::AEK_SVE2BITPERM | AArch64::AEK_PAUTH |
1007 AArch64::AEK_MTE | AArch64::AEK_SSBS | AArch64::AEK_FP16 |
1008 AArch64::AEK_FP16FML | AArch64::AEK_SB,
1009 "9-A"),
1010 ARMCPUTestParams("cortex-a57", "armv8-a", "crypto-neon-fp-armv8",
1011 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1012 AArch64::AEK_FP | AArch64::AEK_SIMD,
1013 "8-A"),
1014 ARMCPUTestParams("cortex-a65", "armv8.2-a", "crypto-neon-fp-armv8",
1015 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1016 AArch64::AEK_DOTPROD | AArch64::AEK_FP |
1017 AArch64::AEK_FP16 | AArch64::AEK_LSE |
1018 AArch64::AEK_RAS | AArch64::AEK_RCPC |
1019 AArch64::AEK_RDM | AArch64::AEK_SIMD |
1020 AArch64::AEK_SSBS,
1021 "8.2-A"),
1022 ARMCPUTestParams("cortex-a65ae", "armv8.2-a", "crypto-neon-fp-armv8",
1023 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1024 AArch64::AEK_DOTPROD | AArch64::AEK_FP |
1025 AArch64::AEK_FP16 | AArch64::AEK_LSE |
1026 AArch64::AEK_RAS | AArch64::AEK_RCPC |
1027 AArch64::AEK_RDM | AArch64::AEK_SIMD |
1028 AArch64::AEK_SSBS,
1029 "8.2-A"),
1030 ARMCPUTestParams("cortex-a72", "armv8-a", "crypto-neon-fp-armv8",
1031 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1032 AArch64::AEK_FP | AArch64::AEK_SIMD,
1033 "8-A"),
1034 ARMCPUTestParams("cortex-a73", "armv8-a", "crypto-neon-fp-armv8",
1035 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1036 AArch64::AEK_FP | AArch64::AEK_SIMD,
1037 "8-A"),
1038 ARMCPUTestParams("cortex-a75", "armv8.2-a", "crypto-neon-fp-armv8",
1039 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1040 AArch64::AEK_FP | AArch64::AEK_SIMD |
1041 AArch64::AEK_RAS | AArch64::AEK_LSE |
1042 AArch64::AEK_RDM | AArch64::AEK_FP16 |
1043 AArch64::AEK_DOTPROD | AArch64::AEK_RCPC,
1044 "8.2-A"),
1045 ARMCPUTestParams("cortex-a76", "armv8.2-a", "crypto-neon-fp-armv8",
1046 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1047 AArch64::AEK_FP | AArch64::AEK_RDM |
1048 AArch64::AEK_SIMD | AArch64::AEK_RAS |
1049 AArch64::AEK_LSE | AArch64::AEK_FP16 |
1050 AArch64::AEK_DOTPROD | AArch64::AEK_RCPC |
1051 AArch64::AEK_SSBS,
1052 "8.2-A"),
1053 ARMCPUTestParams("cortex-a76ae", "armv8.2-a", "crypto-neon-fp-armv8",
1054 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1055 AArch64::AEK_FP | AArch64::AEK_RDM |
1056 AArch64::AEK_SIMD | AArch64::AEK_RAS |
1057 AArch64::AEK_LSE | AArch64::AEK_FP16 |
1058 AArch64::AEK_DOTPROD | AArch64::AEK_RCPC |
1059 AArch64::AEK_SSBS,
1060 "8.2-A"),
1061 ARMCPUTestParams("cortex-a77", "armv8.2-a", "crypto-neon-fp-armv8",
1062 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1063 AArch64::AEK_FP | AArch64::AEK_RDM |
1064 AArch64::AEK_SIMD | AArch64::AEK_RAS |
1065 AArch64::AEK_LSE | AArch64::AEK_FP16 |
1066 AArch64::AEK_DOTPROD | AArch64::AEK_RCPC |
1067 AArch64::AEK_SSBS,
1068 "8.2-A"),
1069 ARMCPUTestParams("cortex-a78", "armv8.2-a", "crypto-neon-fp-armv8",
1070 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1071 AArch64::AEK_FP | AArch64::AEK_RDM |
1072 AArch64::AEK_SIMD | AArch64::AEK_RAS |
1073 AArch64::AEK_LSE | AArch64::AEK_FP16 |
1074 AArch64::AEK_DOTPROD | AArch64::AEK_RCPC |
1075 AArch64::AEK_SSBS | AArch64::AEK_PROFILE,
1076 "8.2-A"),
1077 ARMCPUTestParams("cortex-a78c", "armv8.2-a", "crypto-neon-fp-armv8",
1078 AArch64::AEK_RAS | AArch64::AEK_CRC |
1079 AArch64::AEK_CRYPTO | AArch64::AEK_FP |
1080 AArch64::AEK_SIMD | AArch64::AEK_RAS |
1081 AArch64::AEK_LSE | AArch64::AEK_RDM |
1082 AArch64::AEK_FP16 | AArch64::AEK_DOTPROD |
1083 AArch64::AEK_RCPC | AArch64::AEK_SSBS |
1084 AArch64::AEK_PROFILE | AArch64::AEK_FLAGM |
1085 AArch64::AEK_PAUTH | AArch64::AEK_FP16FML,
1086 "8.2-A"),
1087 ARMCPUTestParams(
1088 "cortex-a710", "armv9-a", "neon-fp-armv8",
1089 AArch64::AEK_CRC | AArch64::AEK_FP | AArch64::AEK_SIMD |
1090 AArch64::AEK_RAS | AArch64::AEK_LSE | AArch64::AEK_RDM |
1091 AArch64::AEK_RCPC | AArch64::AEK_DOTPROD | AArch64::AEK_MTE |
1092 AArch64::AEK_FP16 | AArch64::AEK_FP16FML | AArch64::AEK_SVE |
1093 AArch64::AEK_SVE2 | AArch64::AEK_SVE2BITPERM |
1094 AArch64::AEK_PAUTH | AArch64::AEK_FLAGM | AArch64::AEK_SB |
1095 AArch64::AEK_I8MM | AArch64::AEK_BF16,
1096 "9-A"),
1097 ARMCPUTestParams(
1098 "cortex-a715", "armv9-a", "neon-fp-armv8",
1099 AArch64::AEK_CRC | AArch64::AEK_FP | AArch64::AEK_BF16 |
1100 AArch64::AEK_SIMD | AArch64::AEK_RAS | AArch64::AEK_LSE |
1101 AArch64::AEK_RDM | AArch64::AEK_RCPC | AArch64::AEK_DOTPROD |
1102 AArch64::AEK_MTE | AArch64::AEK_PAUTH | AArch64::AEK_SVE |
1103 AArch64::AEK_SVE2 | AArch64::AEK_SVE2BITPERM |
1104 AArch64::AEK_SSBS | AArch64::AEK_SB | AArch64::AEK_I8MM |
1105 AArch64::AEK_PERFMON | AArch64::AEK_PREDRES |
1106 AArch64::AEK_PROFILE | AArch64::AEK_FP16FML |
1107 AArch64::AEK_FP16 | AArch64::AEK_FLAGM,
1108 "9-A"),
1109 ARMCPUTestParams(
1110 "neoverse-v1", "armv8.4-a", "crypto-neon-fp-armv8",
1111 AArch64::AEK_RAS | AArch64::AEK_SVE | AArch64::AEK_SSBS |
1112 AArch64::AEK_RCPC | AArch64::AEK_CRC | AArch64::AEK_FP |
1113 AArch64::AEK_SIMD | AArch64::AEK_RAS | AArch64::AEK_LSE |
1114 AArch64::AEK_RDM | AArch64::AEK_RCPC | AArch64::AEK_DOTPROD |
1115 AArch64::AEK_CRYPTO | AArch64::AEK_FP16 | AArch64::AEK_BF16 |
1116 AArch64::AEK_PROFILE | AArch64::AEK_RAND |
1117 AArch64::AEK_FP16FML | AArch64::AEK_I8MM,
1118 "8.4-A"),
1119 ARMCPUTestParams("neoverse-v2", "armv9-a", "neon-fp-armv8",
1120 AArch64::AEK_RAS | AArch64::AEK_SVE |
1121 AArch64::AEK_SSBS | AArch64::AEK_RCPC |
1122 AArch64::AEK_CRC | AArch64::AEK_FP |
1123 AArch64::AEK_SIMD | AArch64::AEK_MTE |
1124 AArch64::AEK_LSE | AArch64::AEK_RDM |
1125 AArch64::AEK_RCPC | AArch64::AEK_DOTPROD |
1126 AArch64::AEK_FP16 | AArch64::AEK_BF16 |
1127 AArch64::AEK_SVE2 | AArch64::AEK_PROFILE |
1128 AArch64::AEK_FP16FML | AArch64::AEK_I8MM |
1129 AArch64::AEK_SVE2BITPERM | AArch64::AEK_RAND,
1130 "9-A"),
1131 ARMCPUTestParams("cortex-r82", "armv8-r", "crypto-neon-fp-armv8",
1132 AArch64::AEK_CRC | AArch64::AEK_RDM |
1133 AArch64::AEK_SSBS | AArch64::AEK_DOTPROD |
1134 AArch64::AEK_FP | AArch64::AEK_SIMD |
1135 AArch64::AEK_FP16 | AArch64::AEK_FP16FML |
1136 AArch64::AEK_RAS | AArch64::AEK_RCPC |
1137 AArch64::AEK_LSE | AArch64::AEK_SB,
1138 "8-R"),
1139 ARMCPUTestParams("cortex-x1", "armv8.2-a", "crypto-neon-fp-armv8",
1140 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1141 AArch64::AEK_FP | AArch64::AEK_RDM |
1142 AArch64::AEK_SIMD | AArch64::AEK_RAS |
1143 AArch64::AEK_LSE | AArch64::AEK_FP16 |
1144 AArch64::AEK_DOTPROD | AArch64::AEK_RCPC |
1145 AArch64::AEK_SSBS | AArch64::AEK_PROFILE,
1146 "8.2-A"),
1147 ARMCPUTestParams("cortex-x1c", "armv8.2-a", "crypto-neon-fp-armv8",
1148 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1149 AArch64::AEK_FP | AArch64::AEK_RDM |
1150 AArch64::AEK_SIMD | AArch64::AEK_RAS |
1151 AArch64::AEK_LSE | AArch64::AEK_FP16 |
1152 AArch64::AEK_DOTPROD | AArch64::AEK_RCPC |
1153 AArch64::AEK_SSBS | AArch64::AEK_PAUTH |
1154 AArch64::AEK_PROFILE,
1155 "8.2-A"),
1156 ARMCPUTestParams("cortex-x2", "armv9-a", "neon-fp-armv8",
1157 AArch64::AEK_CRC | AArch64::AEK_FP |
1158 AArch64::AEK_SIMD | AArch64::AEK_RAS |
1159 AArch64::AEK_LSE | AArch64::AEK_RDM |
1160 AArch64::AEK_RCPC | AArch64::AEK_DOTPROD |
1161 AArch64::AEK_MTE | AArch64::AEK_PAUTH |
1162 AArch64::AEK_I8MM | AArch64::AEK_BF16 |
1163 AArch64::AEK_SVE | AArch64::AEK_SVE2 |
1164 AArch64::AEK_SVE2BITPERM | AArch64::AEK_SSBS |
1165 AArch64::AEK_SB | AArch64::AEK_FP16 |
1166 AArch64::AEK_FP16FML,
1167 "9-A"),
1168 ARMCPUTestParams(
1169 "cortex-x3",
1170 "armv9-a", "neon-fp-armv8",
1171 AArch64::AEK_CRC | AArch64::AEK_FP | AArch64::AEK_BF16 |
1172 AArch64::AEK_SIMD | AArch64::AEK_RAS | AArch64::AEK_LSE |
1173 AArch64::AEK_RDM | AArch64::AEK_RCPC | AArch64::AEK_DOTPROD |
1174 AArch64::AEK_MTE | AArch64::AEK_PAUTH | AArch64::AEK_SVE |
1175 AArch64::AEK_SVE2 | AArch64::AEK_SVE2BITPERM | AArch64::AEK_SB |
1176 AArch64::AEK_PROFILE | AArch64::AEK_PERFMON |
1177 AArch64::AEK_I8MM | AArch64::AEK_FP16 | AArch64::AEK_FP16FML |
1178 AArch64::AEK_PREDRES | AArch64::AEK_FLAGM | AArch64::AEK_SSBS,
1179 "9-A"),
1180 ARMCPUTestParams("cyclone", "armv8-a", "crypto-neon-fp-armv8",
1181 AArch64::AEK_NONE | AArch64::AEK_CRYPTO |
1182 AArch64::AEK_FP | AArch64::AEK_SIMD,
1183 "8-A"),
1184 ARMCPUTestParams("apple-a7", "armv8-a", "crypto-neon-fp-armv8",
1185 AArch64::AEK_NONE | AArch64::AEK_CRYPTO |
1186 AArch64::AEK_FP | AArch64::AEK_SIMD,
1187 "8-A"),
1188 ARMCPUTestParams("apple-a8", "armv8-a", "crypto-neon-fp-armv8",
1189 AArch64::AEK_NONE | AArch64::AEK_CRYPTO |
1190 AArch64::AEK_FP | AArch64::AEK_SIMD,
1191 "8-A"),
1192 ARMCPUTestParams("apple-a9", "armv8-a", "crypto-neon-fp-armv8",
1193 AArch64::AEK_NONE | AArch64::AEK_CRYPTO |
1194 AArch64::AEK_FP | AArch64::AEK_SIMD,
1195 "8-A"),
1196 ARMCPUTestParams("apple-a10", "armv8-a", "crypto-neon-fp-armv8",
1197 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1198 AArch64::AEK_FP | AArch64::AEK_RDM |
1199 AArch64::AEK_SIMD,
1200 "8-A"),
1201 ARMCPUTestParams("apple-a11", "armv8.2-a", "crypto-neon-fp-armv8",
1202 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1203 AArch64::AEK_FP | AArch64::AEK_LSE |
1204 AArch64::AEK_RAS | AArch64::AEK_RDM |
1205 AArch64::AEK_SIMD | AArch64::AEK_FP16,
1206 "8.2-A"),
1207 ARMCPUTestParams("apple-a12", "armv8.3-a", "crypto-neon-fp-armv8",
1208 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1209 AArch64::AEK_FP | AArch64::AEK_SIMD |
1210 AArch64::AEK_LSE | AArch64::AEK_RAS |
1211 AArch64::AEK_RDM | AArch64::AEK_RCPC |
1212 AArch64::AEK_FP16,
1213 "8.3-A"),
1214 ARMCPUTestParams("apple-a13", "armv8.4-a", "crypto-neon-fp-armv8",
1215 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1216 AArch64::AEK_FP | AArch64::AEK_SIMD |
1217 AArch64::AEK_LSE | AArch64::AEK_RAS |
1218 AArch64::AEK_RDM | AArch64::AEK_RCPC |
1219 AArch64::AEK_DOTPROD | AArch64::AEK_FP16 |
1220 AArch64::AEK_FP16FML | AArch64::AEK_SHA3,
1221 "8.4-A"),
1222 ARMCPUTestParams("apple-a14", "armv8.5-a", "crypto-neon-fp-armv8",
1223 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1224 AArch64::AEK_FP | AArch64::AEK_SIMD |
1225 AArch64::AEK_LSE | AArch64::AEK_RAS |
1226 AArch64::AEK_RDM | AArch64::AEK_RCPC |
1227 AArch64::AEK_DOTPROD | AArch64::AEK_FP16 |
1228 AArch64::AEK_FP16FML | AArch64::AEK_SHA3,
1229 "8.5-A"),
1230 ARMCPUTestParams("apple-a15", "armv8.5-a", "crypto-neon-fp-armv8",
1231 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1232 AArch64::AEK_FP | AArch64::AEK_SIMD |
1233 AArch64::AEK_LSE | AArch64::AEK_RAS |
1234 AArch64::AEK_RDM | AArch64::AEK_RCPC |
1235 AArch64::AEK_DOTPROD | AArch64::AEK_FP16 |
1236 AArch64::AEK_FP16FML | AArch64::AEK_SHA3 |
1237 AArch64::AEK_BF16 | AArch64::AEK_I8MM,
1238 "8.5-A"),
1239 ARMCPUTestParams("apple-a16", "armv8.5-a", "crypto-neon-fp-armv8",
1240 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1241 AArch64::AEK_FP | AArch64::AEK_SIMD |
1242 AArch64::AEK_LSE | AArch64::AEK_RAS |
1243 AArch64::AEK_RDM | AArch64::AEK_RCPC |
1244 AArch64::AEK_DOTPROD | AArch64::AEK_FP16 |
1245 AArch64::AEK_FP16FML | AArch64::AEK_SHA3 |
1246 AArch64::AEK_BF16 | AArch64::AEK_I8MM,
1247 "8.5-A"),
1248 ARMCPUTestParams("apple-m1", "armv8.5-a", "crypto-neon-fp-armv8",
1249 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1250 AArch64::AEK_FP | AArch64::AEK_SIMD |
1251 AArch64::AEK_LSE | AArch64::AEK_RAS |
1252 AArch64::AEK_RDM | AArch64::AEK_RCPC |
1253 AArch64::AEK_DOTPROD | AArch64::AEK_FP16 |
1254 AArch64::AEK_FP16FML | AArch64::AEK_SHA3,
1255 "8.5-A"),
1256 ARMCPUTestParams("apple-m2", "armv8.5-a", "crypto-neon-fp-armv8",
1257 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1258 AArch64::AEK_FP | AArch64::AEK_SIMD |
1259 AArch64::AEK_LSE | AArch64::AEK_RAS |
1260 AArch64::AEK_RDM | AArch64::AEK_RCPC |
1261 AArch64::AEK_DOTPROD | AArch64::AEK_FP16 |
1262 AArch64::AEK_FP16FML | AArch64::AEK_SHA3 |
1263 AArch64::AEK_BF16 | AArch64::AEK_I8MM,
1264 "8.5-A"),
1265 ARMCPUTestParams("apple-s4", "armv8.3-a", "crypto-neon-fp-armv8",
1266 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1267 AArch64::AEK_FP | AArch64::AEK_SIMD |
1268 AArch64::AEK_LSE | AArch64::AEK_RAS |
1269 AArch64::AEK_RDM | AArch64::AEK_RCPC |
1270 AArch64::AEK_FP16,
1271 "8.3-A"),
1272 ARMCPUTestParams("apple-s5", "armv8.3-a", "crypto-neon-fp-armv8",
1273 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1274 AArch64::AEK_FP | AArch64::AEK_SIMD |
1275 AArch64::AEK_LSE | AArch64::AEK_RAS |
1276 AArch64::AEK_RDM | AArch64::AEK_RCPC |
1277 AArch64::AEK_FP16,
1278 "8.3-A"),
1279 ARMCPUTestParams("exynos-m3", "armv8-a", "crypto-neon-fp-armv8",
1280 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1281 AArch64::AEK_FP | AArch64::AEK_SIMD,
1282 "8-A"),
1283 ARMCPUTestParams("exynos-m4", "armv8.2-a", "crypto-neon-fp-armv8",
1284 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1285 AArch64::AEK_DOTPROD | AArch64::AEK_FP |
1286 AArch64::AEK_FP16 | AArch64::AEK_LSE |
1287 AArch64::AEK_RAS | AArch64::AEK_RDM |
1288 AArch64::AEK_SIMD,
1289 "8.2-A"),
1290 ARMCPUTestParams("exynos-m5", "armv8.2-a", "crypto-neon-fp-armv8",
1291 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1292 AArch64::AEK_DOTPROD | AArch64::AEK_FP |
1293 AArch64::AEK_FP16 | AArch64::AEK_LSE |
1294 AArch64::AEK_RAS | AArch64::AEK_RDM |
1295 AArch64::AEK_SIMD,
1296 "8.2-A"),
1297 ARMCPUTestParams("falkor", "armv8-a", "crypto-neon-fp-armv8",
1298 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1299 AArch64::AEK_FP | AArch64::AEK_SIMD |
1300 AArch64::AEK_RDM,
1301 "8-A"),
1302 ARMCPUTestParams("kryo", "armv8-a", "crypto-neon-fp-armv8",
1303 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1304 AArch64::AEK_FP | AArch64::AEK_SIMD,
1305 "8-A"),
1306 ARMCPUTestParams("neoverse-e1", "armv8.2-a", "crypto-neon-fp-armv8",
1307 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1308 AArch64::AEK_DOTPROD | AArch64::AEK_FP |
1309 AArch64::AEK_FP16 | AArch64::AEK_LSE |
1310 AArch64::AEK_RAS | AArch64::AEK_RCPC |
1311 AArch64::AEK_RDM | AArch64::AEK_SIMD |
1312 AArch64::AEK_SSBS,
1313 "8.2-A"),
1314 ARMCPUTestParams("neoverse-n1", "armv8.2-a", "crypto-neon-fp-armv8",
1315 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1316 AArch64::AEK_DOTPROD | AArch64::AEK_FP |
1317 AArch64::AEK_FP16 | AArch64::AEK_LSE |
1318 AArch64::AEK_PROFILE | AArch64::AEK_RAS |
1319 AArch64::AEK_RCPC | AArch64::AEK_RDM |
1320 AArch64::AEK_SIMD | AArch64::AEK_SSBS,
1321 "8.2-A"),
1322 ARMCPUTestParams("neoverse-n2", "armv8.5-a", "crypto-neon-fp-armv8",
1323 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1324 AArch64::AEK_FP | AArch64::AEK_SIMD |
1325 AArch64::AEK_FP16 | AArch64::AEK_RAS |
1326 AArch64::AEK_LSE | AArch64::AEK_SVE |
1327 AArch64::AEK_DOTPROD | AArch64::AEK_RCPC |
1328 AArch64::AEK_RDM | AArch64::AEK_MTE |
1329 AArch64::AEK_SSBS | AArch64::AEK_SB |
1330 AArch64::AEK_SVE2 | AArch64::AEK_SVE2BITPERM |
1331 AArch64::AEK_BF16 | AArch64::AEK_I8MM,
1332 "8.5-A"),
1333 ARMCPUTestParams(
1334 "ampere1", "armv8.6-a", "crypto-neon-fp-armv8",
1335 AArch64::AEK_CRC | AArch64::AEK_FP | AArch64::AEK_FP16 |
1336 AArch64::AEK_SIMD | AArch64::AEK_RAS | AArch64::AEK_LSE |
1337 AArch64::AEK_RDM | AArch64::AEK_RCPC | AArch64::AEK_DOTPROD |
1338 AArch64::AEK_SHA3 | AArch64::AEK_BF16 | AArch64::AEK_SHA2 |
1339 AArch64::AEK_AES | AArch64::AEK_I8MM | AArch64::AEK_SSBS |
1340 AArch64::AEK_SB | AArch64::AEK_RAND,
1341 "8.6-A"),
1342 ARMCPUTestParams(
1343 "ampere1a", "armv8.6-a", "crypto-neon-fp-armv8",
1344 AArch64::AEK_CRC | AArch64::AEK_FP | AArch64::AEK_FP16 |
1345 AArch64::AEK_SIMD | AArch64::AEK_RAS | AArch64::AEK_LSE |
1346 AArch64::AEK_RDM | AArch64::AEK_RCPC | AArch64::AEK_DOTPROD |
1347 AArch64::AEK_SM4 | AArch64::AEK_SHA3 | AArch64::AEK_BF16 |
1348 AArch64::AEK_SHA2 | AArch64::AEK_AES | AArch64::AEK_I8MM |
1349 AArch64::AEK_SSBS | AArch64::AEK_SB | AArch64::AEK_RAND |
1350 AArch64::AEK_MTE,
1351 "8.6-A"),
1352 ARMCPUTestParams(
1353 "neoverse-512tvb", "armv8.4-a", "crypto-neon-fp-armv8",
1354 AArch64::AEK_RAS | AArch64::AEK_SVE | AArch64::AEK_SSBS |
1355 AArch64::AEK_RCPC | AArch64::AEK_CRC | AArch64::AEK_FP |
1356 AArch64::AEK_SIMD | AArch64::AEK_RAS | AArch64::AEK_LSE |
1357 AArch64::AEK_RDM | AArch64::AEK_RCPC | AArch64::AEK_DOTPROD |
1358 AArch64::AEK_CRYPTO | AArch64::AEK_FP16 | AArch64::AEK_BF16 |
1359 AArch64::AEK_PROFILE | AArch64::AEK_RAND |
1360 AArch64::AEK_FP16FML | AArch64::AEK_I8MM,
1361 "8.4-A"),
1362 ARMCPUTestParams("thunderx2t99", "armv8.1-a", "crypto-neon-fp-armv8",
1363 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1364 AArch64::AEK_LSE | AArch64::AEK_RDM |
1365 AArch64::AEK_FP | AArch64::AEK_SIMD,
1366 "8.1-A"),
1367 ARMCPUTestParams("thunderx3t110", "armv8.3-a", "crypto-neon-fp-armv8",
1368 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1369 AArch64::AEK_LSE | AArch64::AEK_RDM |
1370 AArch64::AEK_FP | AArch64::AEK_SIMD |
1371 AArch64::AEK_RAS | AArch64::AEK_RCPC,
1372 "8.3-A"),
1373 ARMCPUTestParams("thunderx", "armv8-a", "crypto-neon-fp-armv8",
1374 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1375 AArch64::AEK_SIMD | AArch64::AEK_FP,
1376 "8-A"),
1377 ARMCPUTestParams("thunderxt81", "armv8-a", "crypto-neon-fp-armv8",
1378 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1379 AArch64::AEK_SIMD | AArch64::AEK_FP,
1380 "8-A"),
1381 ARMCPUTestParams("thunderxt83", "armv8-a", "crypto-neon-fp-armv8",
1382 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1383 AArch64::AEK_SIMD | AArch64::AEK_FP,
1384 "8-A"),
1385 ARMCPUTestParams("thunderxt88", "armv8-a", "crypto-neon-fp-armv8",
1386 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1387 AArch64::AEK_SIMD | AArch64::AEK_FP,
1388 "8-A"),
1389 ARMCPUTestParams("tsv110", "armv8.2-a", "crypto-neon-fp-armv8",
1390 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1391 AArch64::AEK_FP | AArch64::AEK_SIMD |
1392 AArch64::AEK_RAS | AArch64::AEK_LSE |
1393 AArch64::AEK_RDM | AArch64::AEK_PROFILE |
1394 AArch64::AEK_FP16 | AArch64::AEK_FP16FML |
1395 AArch64::AEK_DOTPROD,
1396 "8.2-A"),
1397 ARMCPUTestParams("a64fx", "armv8.2-a", "crypto-neon-fp-armv8",
1398 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1399 AArch64::AEK_FP | AArch64::AEK_SIMD |
1400 AArch64::AEK_FP16 | AArch64::AEK_RAS |
1401 AArch64::AEK_LSE | AArch64::AEK_SVE |
1402 AArch64::AEK_RDM,
1403 "8.2-A"),
1404 ARMCPUTestParams("carmel", "armv8.2-a", "crypto-neon-fp-armv8",
1405 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1406 AArch64::AEK_FP | AArch64::AEK_SIMD |
1407 AArch64::AEK_FP16 | AArch64::AEK_RAS |
1408 AArch64::AEK_LSE | AArch64::AEK_RDM,
1409 "8.2-A")));
1410
1411 // Note: number of CPUs includes aliases.
1412 static constexpr unsigned NumAArch64CPUArchs = 62;
1413
1414 TEST(TargetParserTest, testAArch64CPUArchList) {
1415 SmallVector<StringRef, NumAArch64CPUArchs> List;
1416 AArch64::fillValidCPUArchList(List);
1417
1418 // No list exists for these in this test suite, so ensure all are
1419 // valid, and match the expected 'magic' count.
1420 EXPECT_EQ(List.size(), NumAArch64CPUArchs);
1421 for(StringRef CPU : List) {
1422 EXPECT_NE(AArch64::parseCpu(CPU).Arch, AArch64::INVALID);
1423 }
1424 }
1425
1426 bool testAArch64Arch(StringRef Arch, StringRef DefaultCPU, StringRef SubArch,
1427 unsigned ArchAttr) {
1428 const AArch64::ArchInfo &AI = AArch64::parseArch(Arch);
1429 return AI != AArch64::INVALID;
1430 }
1431
1432 TEST(TargetParserTest, testAArch64Arch) {
1433 EXPECT_TRUE(testAArch64Arch("armv8-a", "cortex-a53", "v8a",
1434 ARMBuildAttrs::CPUArch::v8_A));
1435 EXPECT_TRUE(testAArch64Arch("armv8.1-a", "generic", "v8.1a",
1436 ARMBuildAttrs::CPUArch::v8_A));
1437 EXPECT_TRUE(testAArch64Arch("armv8.2-a", "generic", "v8.2a",
1438 ARMBuildAttrs::CPUArch::v8_A));
1439 EXPECT_TRUE(testAArch64Arch("armv8.3-a", "generic", "v8.3a",
1440 ARMBuildAttrs::CPUArch::v8_A));
1441 EXPECT_TRUE(testAArch64Arch("armv8.4-a", "generic", "v8.4a",
1442 ARMBuildAttrs::CPUArch::v8_A));
1443 EXPECT_TRUE(testAArch64Arch("armv8.5-a", "generic", "v8.5a",
1444 ARMBuildAttrs::CPUArch::v8_A));
1445 EXPECT_TRUE(testAArch64Arch("armv8.6-a", "generic", "v8.6a",
1446 ARMBuildAttrs::CPUArch::v8_A));
1447 EXPECT_TRUE(testAArch64Arch("armv8.7-a", "generic", "v8.7a",
1448 ARMBuildAttrs::CPUArch::v8_A));
1449 EXPECT_TRUE(testAArch64Arch("armv8.8-a", "generic", "v8.8a",
1450 ARMBuildAttrs::CPUArch::v8_A));
1451 EXPECT_TRUE(testAArch64Arch("armv8.9-a", "generic", "v8.9a",
1452 ARMBuildAttrs::CPUArch::v8_A));
1453 EXPECT_TRUE(testAArch64Arch("armv9-a", "generic", "v9a",
1454 ARMBuildAttrs::CPUArch::v8_A));
1455 EXPECT_TRUE(testAArch64Arch("armv9.1-a", "generic", "v9.1a",
1456 ARMBuildAttrs::CPUArch::v8_A));
1457 EXPECT_TRUE(testAArch64Arch("armv9.2-a", "generic", "v9.2a",
1458 ARMBuildAttrs::CPUArch::v8_A));
1459 EXPECT_TRUE(testAArch64Arch("armv9.3-a", "generic", "v9.3a",
1460 ARMBuildAttrs::CPUArch::v8_A));
1461 EXPECT_TRUE(testAArch64Arch("armv9.4-a", "generic", "v9.4a",
1462 ARMBuildAttrs::CPUArch::v8_A));
1463 }
1464
1465 bool testAArch64Extension(StringRef CPUName, const AArch64::ArchInfo &AI,
1466 StringRef ArchExt) {
1467 return AArch64::getDefaultExtensions(CPUName, AI) &
1468 AArch64::parseArchExt(ArchExt);
1469 }
1470
1471 TEST(TargetParserTest, testAArch64Extension) {
1472 EXPECT_FALSE(testAArch64Extension("cortex-a34", AArch64::INVALID, "ras"));
1473 EXPECT_FALSE(testAArch64Extension("cortex-a35", AArch64::INVALID, "ras"));
1474 EXPECT_FALSE(testAArch64Extension("cortex-a53", AArch64::INVALID, "ras"));
1475 EXPECT_TRUE(testAArch64Extension("cortex-a55", AArch64::INVALID, "ras"));
1476 EXPECT_TRUE(testAArch64Extension("cortex-a55", AArch64::INVALID, "fp16"));
1477 EXPECT_FALSE(testAArch64Extension("cortex-a55", AArch64::INVALID, "fp16fml"));
1478 EXPECT_TRUE(testAArch64Extension("cortex-a55", AArch64::INVALID, "dotprod"));
1479 EXPECT_FALSE(testAArch64Extension("cortex-a57", AArch64::INVALID, "ras"));
1480 EXPECT_FALSE(testAArch64Extension("cortex-a72", AArch64::INVALID, "ras"));
1481 EXPECT_FALSE(testAArch64Extension("cortex-a73", AArch64::INVALID, "ras"));
1482 EXPECT_TRUE(testAArch64Extension("cortex-a75", AArch64::INVALID, "ras"));
1483 EXPECT_TRUE(testAArch64Extension("cortex-a75", AArch64::INVALID, "fp16"));
1484 EXPECT_FALSE(testAArch64Extension("cortex-a75", AArch64::INVALID, "fp16fml"));
1485 EXPECT_TRUE(testAArch64Extension("cortex-a75", AArch64::INVALID, "dotprod"));
1486 EXPECT_TRUE(testAArch64Extension("cortex-r82", AArch64::INVALID, "ras"));
1487 EXPECT_TRUE(testAArch64Extension("cortex-r82", AArch64::INVALID, "fp16"));
1488 EXPECT_TRUE(testAArch64Extension("cortex-r82", AArch64::INVALID, "fp16fml"));
1489 EXPECT_TRUE(testAArch64Extension("cortex-r82", AArch64::INVALID, "dotprod"));
1490 EXPECT_TRUE(testAArch64Extension("cortex-r82", AArch64::INVALID, "lse"));
1491 EXPECT_FALSE(testAArch64Extension("cyclone", AArch64::INVALID, "ras"));
1492 EXPECT_FALSE(testAArch64Extension("exynos-m3", AArch64::INVALID, "ras"));
1493 EXPECT_TRUE(testAArch64Extension("exynos-m4", AArch64::INVALID, "dotprod"));
1494 EXPECT_TRUE(testAArch64Extension("exynos-m4", AArch64::INVALID, "fp16"));
1495 EXPECT_TRUE(testAArch64Extension("exynos-m4", AArch64::INVALID, "lse"));
1496 EXPECT_TRUE(testAArch64Extension("exynos-m4", AArch64::INVALID, "ras"));
1497 EXPECT_TRUE(testAArch64Extension("exynos-m4", AArch64::INVALID, "rdm"));
1498 EXPECT_TRUE(testAArch64Extension("exynos-m5", AArch64::INVALID, "dotprod"));
1499 EXPECT_TRUE(testAArch64Extension("exynos-m5", AArch64::INVALID, "fp16"));
1500 EXPECT_TRUE(testAArch64Extension("exynos-m5", AArch64::INVALID, "lse"));
1501 EXPECT_TRUE(testAArch64Extension("exynos-m5", AArch64::INVALID, "ras"));
1502 EXPECT_TRUE(testAArch64Extension("exynos-m5", AArch64::INVALID, "rdm"));
1503 EXPECT_TRUE(testAArch64Extension("falkor", AArch64::INVALID, "rdm"));
1504 EXPECT_FALSE(testAArch64Extension("kryo", AArch64::INVALID, "ras"));
1505 EXPECT_TRUE(testAArch64Extension("saphira", AArch64::INVALID, "crc"));
1506 EXPECT_TRUE(testAArch64Extension("saphira", AArch64::INVALID, "lse"));
1507 EXPECT_TRUE(testAArch64Extension("saphira", AArch64::INVALID, "rdm"));
1508 EXPECT_TRUE(testAArch64Extension("saphira", AArch64::INVALID, "ras"));
1509 EXPECT_TRUE(testAArch64Extension("saphira", AArch64::INVALID, "rcpc"));
1510 EXPECT_TRUE(testAArch64Extension("saphira", AArch64::INVALID, "profile"));
1511 EXPECT_FALSE(testAArch64Extension("saphira", AArch64::INVALID, "fp16"));
1512 EXPECT_FALSE(testAArch64Extension("thunderx2t99", AArch64::INVALID, "ras"));
1513 EXPECT_FALSE(testAArch64Extension("thunderx", AArch64::INVALID, "lse"));
1514 EXPECT_FALSE(testAArch64Extension("thunderxt81", AArch64::INVALID, "lse"));
1515 EXPECT_FALSE(testAArch64Extension("thunderxt83", AArch64::INVALID, "lse"));
1516 EXPECT_FALSE(testAArch64Extension("thunderxt88", AArch64::INVALID, "lse"));
1517 EXPECT_TRUE(testAArch64Extension("tsv110", AArch64::INVALID, "crypto"));
1518 EXPECT_FALSE(testAArch64Extension("tsv110", AArch64::INVALID, "sha3"));
1519 EXPECT_FALSE(testAArch64Extension("tsv110", AArch64::INVALID, "sm4"));
1520 EXPECT_TRUE(testAArch64Extension("tsv110", AArch64::INVALID, "ras"));
1521 EXPECT_TRUE(testAArch64Extension("tsv110", AArch64::INVALID, "profile"));
1522 EXPECT_TRUE(testAArch64Extension("tsv110", AArch64::INVALID, "fp16"));
1523 EXPECT_TRUE(testAArch64Extension("tsv110", AArch64::INVALID, "fp16fml"));
1524 EXPECT_TRUE(testAArch64Extension("tsv110", AArch64::INVALID, "dotprod"));
1525 EXPECT_TRUE(testAArch64Extension("a64fx", AArch64::INVALID, "fp16"));
1526 EXPECT_TRUE(testAArch64Extension("a64fx", AArch64::INVALID, "sve"));
1527 EXPECT_FALSE(testAArch64Extension("a64fx", AArch64::INVALID, "sve2"));
1528 EXPECT_TRUE(testAArch64Extension("carmel", AArch64::INVALID, "crypto"));
1529 EXPECT_TRUE(testAArch64Extension("carmel", AArch64::INVALID, "fp16"));
1530
1531 EXPECT_FALSE(testAArch64Extension("generic", AArch64::ARMV8A, "ras"));
1532 EXPECT_FALSE(testAArch64Extension("generic", AArch64::ARMV8_1A, "ras"));
1533 EXPECT_FALSE(testAArch64Extension("generic", AArch64::ARMV8_2A, "profile"));
1534 EXPECT_FALSE(testAArch64Extension("generic", AArch64::ARMV8_2A, "fp16"));
1535 EXPECT_FALSE(testAArch64Extension("generic", AArch64::ARMV8_2A, "fp16fml"));
1536 EXPECT_FALSE(testAArch64Extension("generic", AArch64::ARMV8_3A, "fp16"));
1537 EXPECT_FALSE(testAArch64Extension("generic", AArch64::ARMV8_3A, "fp16fml"));
1538 EXPECT_FALSE(testAArch64Extension("generic", AArch64::ARMV8_4A, "fp16"));
1539 EXPECT_FALSE(testAArch64Extension("generic", AArch64::ARMV8_4A, "fp16fml"));
1540 }
1541
1542 TEST(TargetParserTest, AArch64ExtensionFeatures) {
1543 std::vector<uint64_t> Extensions = {
1544 AArch64::AEK_CRC, AArch64::AEK_LSE, AArch64::AEK_RDM,
1545 AArch64::AEK_CRYPTO, AArch64::AEK_SM4, AArch64::AEK_SHA3,
1546 AArch64::AEK_SHA2, AArch64::AEK_AES, AArch64::AEK_DOTPROD,
1547 AArch64::AEK_FP, AArch64::AEK_SIMD, AArch64::AEK_FP16,
1548 AArch64::AEK_FP16FML, AArch64::AEK_PROFILE, AArch64::AEK_RAS,
1549 AArch64::AEK_SVE, AArch64::AEK_SVE2, AArch64::AEK_SVE2AES,
1550 AArch64::AEK_SVE2SM4, AArch64::AEK_SVE2SHA3, AArch64::AEK_SVE2BITPERM,
1551 AArch64::AEK_RCPC, AArch64::AEK_RAND, AArch64::AEK_MTE,
1552 AArch64::AEK_SSBS, AArch64::AEK_SB, AArch64::AEK_PREDRES,
1553 AArch64::AEK_BF16, AArch64::AEK_I8MM, AArch64::AEK_F32MM,
1554 AArch64::AEK_F64MM, AArch64::AEK_TME, AArch64::AEK_LS64,
1555 AArch64::AEK_BRBE, AArch64::AEK_PAUTH, AArch64::AEK_FLAGM,
1556 AArch64::AEK_SME, AArch64::AEK_SMEF64F64, AArch64::AEK_SMEI16I64,
1557 AArch64::AEK_SME2, AArch64::AEK_HBC, AArch64::AEK_MOPS,
1558 AArch64::AEK_PERFMON, AArch64::AEK_SVE2p1, AArch64::AEK_SME2p1,
1559 AArch64::AEK_B16B16, AArch64::AEK_SMEF16F16, AArch64::AEK_CSSC,
1560 AArch64::AEK_RCPC3, AArch64::AEK_THE, AArch64::AEK_D128,
1561 AArch64::AEK_LSE128, AArch64::AEK_SPECRES2, AArch64::AEK_RASv2,
1562 AArch64::AEK_ITE,
1563 };
1564
1565 std::vector<StringRef> Features;
1566
1567 uint64_t ExtVal = 0;
1568 for (auto Ext : Extensions)
1569 ExtVal |= Ext;
1570
1571 // INVALID and NONE have no feature names.
1572 EXPECT_FALSE(AArch64::getExtensionFeatures(AArch64::AEK_INVALID, Features));
1573 EXPECT_TRUE(!Features.size());
1574 // We return True here because NONE is a valid choice.
1575 EXPECT_TRUE(AArch64::getExtensionFeatures(AArch64::AEK_NONE, Features));
1576 EXPECT_TRUE(!Features.size());
1577
1578 AArch64::getExtensionFeatures(ExtVal, Features);
1579 EXPECT_EQ(Extensions.size(), Features.size());
1580
1581 EXPECT_TRUE(llvm::is_contained(Features, "+crc"));
1582 EXPECT_TRUE(llvm::is_contained(Features, "+lse"));
1583 EXPECT_TRUE(llvm::is_contained(Features, "+rdm"));
1584 EXPECT_TRUE(llvm::is_contained(Features, "+crypto"));
1585 EXPECT_TRUE(llvm::is_contained(Features, "+sm4"));
1586 EXPECT_TRUE(llvm::is_contained(Features, "+sha3"));
1587 EXPECT_TRUE(llvm::is_contained(Features, "+sha2"));
1588 EXPECT_TRUE(llvm::is_contained(Features, "+aes"));
1589 EXPECT_TRUE(llvm::is_contained(Features, "+dotprod"));
1590 EXPECT_TRUE(llvm::is_contained(Features, "+fp-armv8"));
1591 EXPECT_TRUE(llvm::is_contained(Features, "+neon"));
1592 EXPECT_TRUE(llvm::is_contained(Features, "+fullfp16"));
1593 EXPECT_TRUE(llvm::is_contained(Features, "+fp16fml"));
1594 EXPECT_TRUE(llvm::is_contained(Features, "+spe"));
1595 EXPECT_TRUE(llvm::is_contained(Features, "+ras"));
1596 EXPECT_TRUE(llvm::is_contained(Features, "+sve"));
1597 EXPECT_TRUE(llvm::is_contained(Features, "+sve2"));
1598 EXPECT_TRUE(llvm::is_contained(Features, "+sve2-aes"));
1599 EXPECT_TRUE(llvm::is_contained(Features, "+sve2-sm4"));
1600 EXPECT_TRUE(llvm::is_contained(Features, "+sve2-sha3"));
1601 EXPECT_TRUE(llvm::is_contained(Features, "+sve2-bitperm"));
1602 EXPECT_TRUE(llvm::is_contained(Features, "+sve2p1"));
1603 EXPECT_TRUE(llvm::is_contained(Features, "+b16b16"));
1604 EXPECT_TRUE(llvm::is_contained(Features, "+rcpc"));
1605 EXPECT_TRUE(llvm::is_contained(Features, "+rand"));
1606 EXPECT_TRUE(llvm::is_contained(Features, "+mte"));
1607 EXPECT_TRUE(llvm::is_contained(Features, "+ssbs"));
1608 EXPECT_TRUE(llvm::is_contained(Features, "+sb"));
1609 EXPECT_TRUE(llvm::is_contained(Features, "+predres"));
1610 EXPECT_TRUE(llvm::is_contained(Features, "+bf16"));
1611 EXPECT_TRUE(llvm::is_contained(Features, "+i8mm"));
1612 EXPECT_TRUE(llvm::is_contained(Features, "+f32mm"));
1613 EXPECT_TRUE(llvm::is_contained(Features, "+f64mm"));
1614 EXPECT_TRUE(llvm::is_contained(Features, "+tme"));
1615 EXPECT_TRUE(llvm::is_contained(Features, "+ls64"));
1616 EXPECT_TRUE(llvm::is_contained(Features, "+brbe"));
1617 EXPECT_TRUE(llvm::is_contained(Features, "+pauth"));
1618 EXPECT_TRUE(llvm::is_contained(Features, "+flagm"));
1619 EXPECT_TRUE(llvm::is_contained(Features, "+sme"));
1620 EXPECT_TRUE(llvm::is_contained(Features, "+sme-f64f64"));
1621 EXPECT_TRUE(llvm::is_contained(Features, "+sme-i16i64"));
1622 EXPECT_TRUE(llvm::is_contained(Features, "+sme-f16f16"));
1623 EXPECT_TRUE(llvm::is_contained(Features, "+sme2"));
1624 EXPECT_TRUE(llvm::is_contained(Features, "+sme2p1"));
1625 EXPECT_TRUE(llvm::is_contained(Features, "+hbc"));
1626 EXPECT_TRUE(llvm::is_contained(Features, "+mops"));
1627 EXPECT_TRUE(llvm::is_contained(Features, "+perfmon"));
1628 EXPECT_TRUE(llvm::is_contained(Features, "+cssc"));
1629 EXPECT_TRUE(llvm::is_contained(Features, "+rcpc3"));
1630 EXPECT_TRUE(llvm::is_contained(Features, "+the"));
1631 EXPECT_TRUE(llvm::is_contained(Features, "+d128"));
1632 EXPECT_TRUE(llvm::is_contained(Features, "+lse128"));
1633 EXPECT_TRUE(llvm::is_contained(Features, "+specres2"));
1634 EXPECT_TRUE(llvm::is_contained(Features, "+ite"));
1635
1636 // Assuming we listed every extension above, this should produce the same
1637 // result. (note that AEK_NONE doesn't have a name so it won't be in the
1638 // result despite its bit being set)
1639 std::vector<StringRef> AllFeatures;
1640 EXPECT_TRUE(AArch64::getExtensionFeatures(-1, AllFeatures));
1641 EXPECT_THAT(Features, ::testing::ContainerEq(AllFeatures));
1642 }
1643
1644 TEST(TargetParserTest, AArch64ArchFeatures) {
1645 EXPECT_EQ(AArch64::INVALID.ArchFeature, "+");
1646 EXPECT_EQ(AArch64::ARMV8A.ArchFeature, "+v8a");
1647 EXPECT_EQ(AArch64::ARMV8_1A.ArchFeature, "+v8.1a");
1648 EXPECT_EQ(AArch64::ARMV8_2A.ArchFeature, "+v8.2a");
1649 EXPECT_EQ(AArch64::ARMV8_3A.ArchFeature, "+v8.3a");
1650 EXPECT_EQ(AArch64::ARMV8_4A.ArchFeature, "+v8.4a");
1651 EXPECT_EQ(AArch64::ARMV8_5A.ArchFeature, "+v8.5a");
1652 EXPECT_EQ(AArch64::ARMV8_6A.ArchFeature, "+v8.6a");
1653 EXPECT_EQ(AArch64::ARMV8_7A.ArchFeature, "+v8.7a");
1654 EXPECT_EQ(AArch64::ARMV8_8A.ArchFeature, "+v8.8a");
1655 EXPECT_EQ(AArch64::ARMV8_9A.ArchFeature, "+v8.9a");
1656 EXPECT_EQ(AArch64::ARMV9A.ArchFeature, "+v9a");
1657 EXPECT_EQ(AArch64::ARMV9_1A.ArchFeature, "+v9.1a");
1658 EXPECT_EQ(AArch64::ARMV9_2A.ArchFeature, "+v9.2a");
1659 EXPECT_EQ(AArch64::ARMV9_3A.ArchFeature, "+v9.3a");
1660 EXPECT_EQ(AArch64::ARMV9_4A.ArchFeature, "+v9.4a");
1661 EXPECT_EQ(AArch64::ARMV8R.ArchFeature, "+v8r");
1662 }
1663
1664 TEST(TargetParserTest, AArch64ArchPartialOrder) {
1665 EXPECT_FALSE(AArch64::INVALID.implies(AArch64::INVALID));
1666
1667 for (const auto *A : AArch64::ArchInfos) {
1668 EXPECT_EQ(*A, *A);
1669 // Comparison with invalid is always false
1670 EXPECT_FALSE(A->implies(AArch64::INVALID));
1671 EXPECT_FALSE(AArch64::INVALID.implies(*A));
1672
1673 // v8r has no relation to other valid architectures
1674 if (*A != AArch64::ARMV8R) {
1675 EXPECT_FALSE(A->implies(AArch64::ARMV8R));
1676 EXPECT_FALSE(AArch64::ARMV8R.implies(*A));
1677 }
1678 }
1679
1680 for (const auto *A : {
1681 &AArch64::ARMV8_1A,
1682 &AArch64::ARMV8_2A,
1683 &AArch64::ARMV8_3A,
1684 &AArch64::ARMV8_4A,
1685 &AArch64::ARMV8_5A,
1686 &AArch64::ARMV8_6A,
1687 &AArch64::ARMV8_7A,
1688 &AArch64::ARMV8_8A,
1689 &AArch64::ARMV8_9A,
1690 })
1691 EXPECT_TRUE(A->implies(AArch64::ARMV8A));
1692
1693 for (const auto *A : {&AArch64::ARMV9_1A, &AArch64::ARMV9_2A,
1694 &AArch64::ARMV9_3A, &AArch64::ARMV9_4A})
1695 EXPECT_TRUE(A->implies(AArch64::ARMV9A));
1696
1697 EXPECT_TRUE(AArch64::ARMV8_1A.implies(AArch64::ARMV8A));
1698 EXPECT_TRUE(AArch64::ARMV8_2A.implies(AArch64::ARMV8_1A));
1699 EXPECT_TRUE(AArch64::ARMV8_3A.implies(AArch64::ARMV8_2A));
1700 EXPECT_TRUE(AArch64::ARMV8_4A.implies(AArch64::ARMV8_3A));
1701 EXPECT_TRUE(AArch64::ARMV8_5A.implies(AArch64::ARMV8_4A));
1702 EXPECT_TRUE(AArch64::ARMV8_6A.implies(AArch64::ARMV8_5A));
1703 EXPECT_TRUE(AArch64::ARMV8_7A.implies(AArch64::ARMV8_6A));
1704 EXPECT_TRUE(AArch64::ARMV8_8A.implies(AArch64::ARMV8_7A));
1705 EXPECT_TRUE(AArch64::ARMV8_9A.implies(AArch64::ARMV8_8A));
1706
1707 EXPECT_TRUE(AArch64::ARMV9_1A.implies(AArch64::ARMV9A));
1708 EXPECT_TRUE(AArch64::ARMV9_2A.implies(AArch64::ARMV9_1A));
1709 EXPECT_TRUE(AArch64::ARMV9_3A.implies(AArch64::ARMV9_2A));
1710 EXPECT_TRUE(AArch64::ARMV9_4A.implies(AArch64::ARMV9_3A));
1711
1712 EXPECT_TRUE(AArch64::ARMV9A.implies(AArch64::ARMV8_5A));
1713 EXPECT_TRUE(AArch64::ARMV9_1A.implies(AArch64::ARMV8_6A));
1714 EXPECT_TRUE(AArch64::ARMV9_2A.implies(AArch64::ARMV8_7A));
1715 EXPECT_TRUE(AArch64::ARMV9_3A.implies(AArch64::ARMV8_8A));
1716 EXPECT_TRUE(AArch64::ARMV9_4A.implies(AArch64::ARMV8_9A));
1717 }
1718
1719 TEST(TargetParserTest, AArch64ArchExtFeature) {
1720 const char *ArchExt[][4] = {
1721 {"crc", "nocrc", "+crc", "-crc"},
1722 {"crypto", "nocrypto", "+crypto", "-crypto"},
1723 {"flagm", "noflagm", "+flagm", "-flagm"},
1724 {"fp", "nofp", "+fp-armv8", "-fp-armv8"},
1725 {"simd", "nosimd", "+neon", "-neon"},
1726 {"fp16", "nofp16", "+fullfp16", "-fullfp16"},
1727 {"fp16fml", "nofp16fml", "+fp16fml", "-fp16fml"},
1728 {"profile", "noprofile", "+spe", "-spe"},
1729 {"ras", "noras", "+ras", "-ras"},
1730 {"lse", "nolse", "+lse", "-lse"},
1731 {"rdm", "nordm", "+rdm", "-rdm"},
1732 {"sve", "nosve", "+sve", "-sve"},
1733 {"sve2", "nosve2", "+sve2", "-sve2"},
1734 {"sve2-aes", "nosve2-aes", "+sve2-aes", "-sve2-aes"},
1735 {"sve2-sm4", "nosve2-sm4", "+sve2-sm4", "-sve2-sm4"},
1736 {"sve2-sha3", "nosve2-sha3", "+sve2-sha3", "-sve2-sha3"},
1737 {"sve2p1", "nosve2p1", "+sve2p1", "-sve2p1"},
1738 {"b16b16", "nob16b16", "+b16b16", "-b16b16"},
1739 {"sve2-bitperm", "nosve2-bitperm", "+sve2-bitperm", "-sve2-bitperm"},
1740 {"dotprod", "nodotprod", "+dotprod", "-dotprod"},
1741 {"rcpc", "norcpc", "+rcpc", "-rcpc"},
1742 {"rng", "norng", "+rand", "-rand"},
1743 {"memtag", "nomemtag", "+mte", "-mte"},
1744 {"tme", "notme", "+tme", "-tme"},
1745 {"pauth", "nopauth", "+pauth", "-pauth"},
1746 {"ssbs", "nossbs", "+ssbs", "-ssbs"},
1747 {"sb", "nosb", "+sb", "-sb"},
1748 {"predres", "nopredres", "+predres", "-predres"},
1749 {"i8mm", "noi8mm", "+i8mm", "-i8mm"},
1750 {"f32mm", "nof32mm", "+f32mm", "-f32mm"},
1751 {"f64mm", "nof64mm", "+f64mm", "-f64mm"},
1752 {"sme", "nosme", "+sme", "-sme"},
1753 {"sme-f64f64", "nosme-f64f64", "+sme-f64f64", "-sme-f64f64"},
1754 {"sme-i16i64", "nosme-i16i64", "+sme-i16i64", "-sme-i16i64"},
1755 {"sme-f16f16", "nosme-f16f16", "+sme-f16f16", "-sme-f16f16"},
1756 {"sme2", "nosme2", "+sme2", "-sme2"},
1757 {"sme2p1", "nosme2p1", "+sme2p1", "-sme2p1"},
1758 {"hbc", "nohbc", "+hbc", "-hbc"},
1759 {"mops", "nomops", "+mops", "-mops"},
1760 {"pmuv3", "nopmuv3", "+perfmon", "-perfmon"},
1761 {"predres2", "nopredres2", "+specres2", "-specres2"},
1762 {"rasv2", "norasv2", "+rasv2", "-rasv2"},
1763 };
1764
1765 for (unsigned i = 0; i < std::size(ArchExt); i++) {
1766 EXPECT_EQ(StringRef(ArchExt[i][2]),
1767 AArch64::getArchExtFeature(ArchExt[i][0]));
1768 EXPECT_EQ(StringRef(ArchExt[i][3]),
1769 AArch64::getArchExtFeature(ArchExt[i][1]));
1770 }
1771 }
1772
1773 } // namespace