?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[JITLink] Add support of R_X86_64_32S relocation
[llvm-project.git] / llvm / unittests / Support / TargetParserTest.cpp
bloba465eb0c57c73c95225dba5d634f106debf8bac4
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/Support/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 "gtest/gtest.h"
15 #include <string>
16
17 using namespace llvm;
18
19 namespace {
20 const char *ARMArch[] = {
21 "armv2", "armv2a", "armv3", "armv3m", "armv4",
22 "armv4t", "armv5", "armv5t", "armv5e", "armv5te",
23 "armv5tej", "armv6", "armv6j", "armv6k", "armv6hl",
24 "armv6t2", "armv6kz", "armv6z", "armv6zk", "armv6-m",
25 "armv6m", "armv6sm", "armv6s-m", "armv7-a", "armv7",
26 "armv7a", "armv7ve", "armv7hl", "armv7l", "armv7-r",
27 "armv7r", "armv7-m", "armv7m", "armv7k", "armv7s",
28 "armv7e-m", "armv7em", "armv8-a", "armv8", "armv8a",
29 "armv8l", "armv8.1-a", "armv8.1a", "armv8.2-a", "armv8.2a",
30 "armv8.3-a", "armv8.3a", "armv8.4-a", "armv8.4a", "armv8.5-a",
31 "armv8.5a", "armv8.6-a", "armv8.6a", "armv8.7-a", "armv8.7a",
32 "armv8-r", "armv8r", "armv8-m.base","armv8m.base", "armv8-m.main",
33 "armv8m.main", "iwmmxt", "iwmmxt2", "xscale", "armv8.1-m.main",
34 };
35
36 template <ARM::ISAKind ISAKind>
37 std::string FormatExtensionFlags(uint64_t Flags) {
38 std::vector<StringRef> Features;
39
40 if (ISAKind == ARM::ISAKind::AARCH64) {
41 // AEK_NONE is not meant to be shown to the user so the target parser
42 // does not recognise it. It is relevant here though.
43 if (Flags & AArch64::AEK_NONE)
44 Features.push_back("none");
45 AArch64::getExtensionFeatures(Flags, Features);
46 } else {
47 if (Flags & ARM::AEK_NONE)
48 Features.push_back("none");
49 ARM::getExtensionFeatures(Flags, Features);
50 }
51
52 // The target parser also includes every extension you don't have.
53 // E.g. if AEK_CRC is not set then it adds "-crc". Not useful here.
54 Features.erase(std::remove_if(Features.begin(), Features.end(),
55 [](StringRef extension) {
56 return extension.startswith("-");
57 }),
58 Features.end());
59
60 return llvm::join(Features, ", ");
61 }
62
63 template <ARM::ISAKind ISAKind>
64 testing::AssertionResult
65 AssertSameExtensionFlags(const char *m_expr, const char *n_expr,
66 uint64_t ExpectedFlags, uint64_t GotFlags) {
67 if (ExpectedFlags == GotFlags)
68 return testing::AssertionSuccess();
69
70 return testing::AssertionFailure() << llvm::formatv(
71 "Expected extension flags: {0} ({1:x})\n"
72 " Got extension flags: {2} ({3:x})\n",
73 FormatExtensionFlags<ISAKind>(ExpectedFlags), ExpectedFlags,
74 FormatExtensionFlags<ISAKind>(GotFlags), GotFlags);
75 }
76
77 struct ARMCPUTestParams {
78 ARMCPUTestParams(StringRef CPUName, StringRef ExpectedArch,
79 StringRef ExpectedFPU, uint64_t ExpectedFlags,
80 StringRef CPUAttr)
81 : CPUName(CPUName), ExpectedArch(ExpectedArch), ExpectedFPU(ExpectedFPU),
82 ExpectedFlags(ExpectedFlags), CPUAttr(CPUAttr) {}
83
84 friend std::ostream &operator<<(std::ostream &os,
85 const ARMCPUTestParams &params) {
86 return os << "\"" << params.CPUName.str() << "\", \""
87 << params.ExpectedArch.str() << "\", \""
88 << params.ExpectedFPU.str() << "\", 0x" << std::hex
89 << params.ExpectedFlags << ", \"" << params.CPUAttr.str() << "\"";
90 }
91
92 StringRef CPUName;
93 StringRef ExpectedArch;
94 StringRef ExpectedFPU;
95 uint64_t ExpectedFlags;
96 StringRef CPUAttr;
97 };
98
99 class ARMCPUTestFixture : public ::testing::TestWithParam<ARMCPUTestParams> {};
100
101 TEST_P(ARMCPUTestFixture, ARMCPUTests) {
102 auto params = GetParam();
103
104 ARM::ArchKind AK = ARM::parseCPUArch(params.CPUName);
105 EXPECT_EQ(params.ExpectedArch, ARM::getArchName(AK));
106
107 unsigned FPUKind = ARM::getDefaultFPU(params.CPUName, AK);
108 EXPECT_EQ(params.ExpectedFPU, ARM::getFPUName(FPUKind));
109
110 uint64_t default_extensions = ARM::getDefaultExtensions(params.CPUName, AK);
111 EXPECT_PRED_FORMAT2(AssertSameExtensionFlags<ARM::ISAKind::ARM>,
112 params.ExpectedFlags, default_extensions);
113
114 EXPECT_EQ(params.CPUAttr, ARM::getCPUAttr(AK));
115 }
116
117 // Note that we include ARM::AEK_NONE even when there are other extensions
118 // we expect. This is because the default extensions for a CPU are the sum
119 // of the default extensions for its architecture and for the CPU.
120 // So if a CPU has no extra extensions, it adds AEK_NONE.
121 INSTANTIATE_TEST_SUITE_P(
122 ARMCPUTestsPart1, ARMCPUTestFixture,
123 ::testing::Values(
124 ARMCPUTestParams("invalid", "invalid", "invalid", ARM::AEK_NONE, ""),
125 ARMCPUTestParams("generic", "invalid", "none", ARM::AEK_NONE, ""),
126
127 ARMCPUTestParams("arm8", "armv4", "none", ARM::AEK_NONE, "4"),
128 ARMCPUTestParams("arm810", "armv4", "none", ARM::AEK_NONE, "4"),
129 ARMCPUTestParams("strongarm", "armv4", "none", ARM::AEK_NONE, "4"),
130 ARMCPUTestParams("strongarm110", "armv4", "none", ARM::AEK_NONE, "4"),
131 ARMCPUTestParams("strongarm1100", "armv4", "none", ARM::AEK_NONE, "4"),
132 ARMCPUTestParams("strongarm1110", "armv4", "none", ARM::AEK_NONE, "4"),
133 ARMCPUTestParams("arm7tdmi", "armv4t", "none", ARM::AEK_NONE, "4T"),
134 ARMCPUTestParams("arm7tdmi-s", "armv4t", "none", ARM::AEK_NONE, "4T"),
135 ARMCPUTestParams("arm710t", "armv4t", "none", ARM::AEK_NONE, "4T"),
136 ARMCPUTestParams("arm720t", "armv4t", "none", ARM::AEK_NONE, "4T"),
137 ARMCPUTestParams("arm9", "armv4t", "none", ARM::AEK_NONE, "4T"),
138 ARMCPUTestParams("arm9tdmi", "armv4t", "none", ARM::AEK_NONE, "4T"),
139 ARMCPUTestParams("arm920", "armv4t", "none", ARM::AEK_NONE, "4T"),
140 ARMCPUTestParams("arm920t", "armv4t", "none", ARM::AEK_NONE, "4T"),
141 ARMCPUTestParams("arm922t", "armv4t", "none", ARM::AEK_NONE, "4T"),
142 ARMCPUTestParams("arm940t", "armv4t", "none", ARM::AEK_NONE, "4T"),
143 ARMCPUTestParams("ep9312", "armv4t", "none", ARM::AEK_NONE, "4T"),
144 ARMCPUTestParams("arm10tdmi", "armv5t", "none", ARM::AEK_NONE, "5T"),
145 ARMCPUTestParams("arm1020t", "armv5t", "none", ARM::AEK_NONE, "5T"),
146 ARMCPUTestParams("arm9e", "armv5te", "none",
147 ARM::AEK_NONE | ARM::AEK_DSP, "5TE"),
148 ARMCPUTestParams("arm946e-s", "armv5te", "none",
149 ARM::AEK_NONE | ARM::AEK_DSP, "5TE"),
150 ARMCPUTestParams("arm966e-s", "armv5te", "none",
151 ARM::AEK_NONE | ARM::AEK_DSP, "5TE"),
152 ARMCPUTestParams("arm968e-s", "armv5te", "none",
153 ARM::AEK_NONE | ARM::AEK_DSP, "5TE"),
154 ARMCPUTestParams("arm10e", "armv5te", "none",
155 ARM::AEK_NONE | ARM::AEK_DSP, "5TE"),
156 ARMCPUTestParams("arm1020e", "armv5te", "none",
157 ARM::AEK_NONE | ARM::AEK_DSP, "5TE"),
158 ARMCPUTestParams("arm1022e", "armv5te", "none",
159 ARM::AEK_NONE | ARM::AEK_DSP, "5TE"),
160 ARMCPUTestParams("arm926ej-s", "armv5tej", "none",
161 ARM::AEK_NONE | ARM::AEK_DSP, "5TEJ"),
162 ARMCPUTestParams("arm1136j-s", "armv6", "none",
163 ARM::AEK_NONE | ARM::AEK_DSP, "6"),
164 ARMCPUTestParams("arm1136jf-s", "armv6", "vfpv2",
165 ARM::AEK_NONE | ARM::AEK_DSP, "6"),
166 ARMCPUTestParams("arm1176jz-s", "armv6kz", "none",
167 ARM::AEK_NONE | ARM::AEK_SEC | ARM::AEK_DSP, "6KZ"),
168 ARMCPUTestParams("mpcore", "armv6k", "vfpv2",
169 ARM::AEK_NONE | ARM::AEK_DSP, "6K"),
170 ARMCPUTestParams("mpcorenovfp", "armv6k", "none",
171 ARM::AEK_NONE | ARM::AEK_DSP, "6K"),
172 ARMCPUTestParams("arm1176jzf-s", "armv6kz", "vfpv2",
173 ARM::AEK_NONE | ARM::AEK_SEC | ARM::AEK_DSP, "6KZ"),
174 ARMCPUTestParams("arm1156t2-s", "armv6t2", "none",
175 ARM::AEK_NONE | ARM::AEK_DSP, "6T2"),
176 ARMCPUTestParams("arm1156t2f-s", "armv6t2", "vfpv2",
177 ARM::AEK_NONE | ARM::AEK_DSP, "6T2"),
178 ARMCPUTestParams("cortex-m0", "armv6-m", "none", ARM::AEK_NONE, "6-M"),
179 ARMCPUTestParams("cortex-m0plus", "armv6-m", "none", ARM::AEK_NONE,
180 "6-M"),
181 ARMCPUTestParams("cortex-m1", "armv6-m", "none", ARM::AEK_NONE, "6-M"),
182 ARMCPUTestParams("sc000", "armv6-m", "none", ARM::AEK_NONE, "6-M"),
183 ARMCPUTestParams("cortex-a5", "armv7-a", "neon-vfpv4",
184 ARM::AEK_MP | ARM::AEK_SEC | ARM::AEK_DSP, "7-A"),
185 ARMCPUTestParams("cortex-a7", "armv7-a", "neon-vfpv4",
186 ARM::AEK_HWDIVTHUMB | ARM::AEK_HWDIVARM | ARM::AEK_MP |
187 ARM::AEK_SEC | ARM::AEK_VIRT | ARM::AEK_DSP,
188 "7-A"),
189 ARMCPUTestParams("cortex-a8", "armv7-a", "neon",
190 ARM::AEK_SEC | ARM::AEK_DSP, "7-A")));
191
192 // gtest in llvm has a limit of 50 test cases when using ::Values so we split
193 // them into 2 blocks
194 INSTANTIATE_TEST_SUITE_P(
195 ARMCPUTestsPart2, ARMCPUTestFixture,
196 ::testing::Values(
197 ARMCPUTestParams("cortex-a9", "armv7-a", "neon-fp16",
198 ARM::AEK_MP | ARM::AEK_SEC | ARM::AEK_DSP, "7-A"),
199 ARMCPUTestParams("cortex-a12", "armv7-a", "neon-vfpv4",
200 ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_VIRT |
201 ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB |
202 ARM::AEK_DSP,
203 "7-A"),
204 ARMCPUTestParams("cortex-a15", "armv7-a", "neon-vfpv4",
205 ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_VIRT |
206 ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB |
207 ARM::AEK_DSP,
208 "7-A"),
209 ARMCPUTestParams("cortex-a17", "armv7-a", "neon-vfpv4",
210 ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_VIRT |
211 ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB |
212 ARM::AEK_DSP,
213 "7-A"),
214 ARMCPUTestParams("krait", "armv7-a", "neon-vfpv4",
215 ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP,
216 "7-A"),
217 ARMCPUTestParams("cortex-r4", "armv7-r", "none",
218 ARM::AEK_NONE | ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP,
219 "7-R"),
220 ARMCPUTestParams("cortex-r4f", "armv7-r", "vfpv3-d16",
221 ARM::AEK_NONE | ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP,
222 "7-R"),
223 ARMCPUTestParams("cortex-r5", "armv7-r", "vfpv3-d16",
224 ARM::AEK_MP | ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB |
225 ARM::AEK_DSP,
226 "7-R"),
227 ARMCPUTestParams("cortex-r7", "armv7-r", "vfpv3-d16-fp16",
228 ARM::AEK_MP | ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB |
229 ARM::AEK_DSP,
230 "7-R"),
231 ARMCPUTestParams("cortex-r8", "armv7-r", "vfpv3-d16-fp16",
232 ARM::AEK_MP | ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB |
233 ARM::AEK_DSP,
234 "7-R"),
235 ARMCPUTestParams("cortex-r52", "armv8-r", "neon-fp-armv8",
236 ARM::AEK_NONE | ARM::AEK_CRC | ARM::AEK_MP |
237 ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
238 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP,
239 "8-R"),
240 ARMCPUTestParams("sc300", "armv7-m", "none",
241 ARM::AEK_NONE | ARM::AEK_HWDIVTHUMB, "7-M"),
242 ARMCPUTestParams("cortex-m3", "armv7-m", "none",
243 ARM::AEK_NONE | ARM::AEK_HWDIVTHUMB, "7-M"),
244 ARMCPUTestParams("cortex-m4", "armv7e-m", "fpv4-sp-d16",
245 ARM::AEK_NONE | ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP,
246 "7E-M"),
247 ARMCPUTestParams("cortex-m7", "armv7e-m", "fpv5-d16",
248 ARM::AEK_NONE | ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP,
249 "7E-M"),
250 ARMCPUTestParams("cortex-a32", "armv8-a", "crypto-neon-fp-armv8",
251 ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
252 ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
253 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP,
254 "8-A"),
255 ARMCPUTestParams("cortex-a35", "armv8-a", "crypto-neon-fp-armv8",
256 ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
257 ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
258 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP,
259 "8-A"),
260 ARMCPUTestParams("cortex-a53", "armv8-a", "crypto-neon-fp-armv8",
261 ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
262 ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
263 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP,
264 "8-A"),
265 ARMCPUTestParams("cortex-a55", "armv8.2-a", "crypto-neon-fp-armv8",
266 ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
267 ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
268 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP |
269 ARM::AEK_FP16 | ARM::AEK_RAS | ARM::AEK_DOTPROD,
270 "8.2-A"),
271 ARMCPUTestParams("cortex-a57", "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-a72", "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-a73", "armv8-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 "8-A"),
286 ARMCPUTestParams("cortex-a75", "armv8.2-a", "crypto-neon-fp-armv8",
287 ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
288 ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
289 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP |
290 ARM::AEK_FP16 | ARM::AEK_RAS | ARM::AEK_DOTPROD,
291 "8.2-A"),
292 ARMCPUTestParams("cortex-a76", "armv8.2-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 ARM::AEK_FP16 | ARM::AEK_RAS | ARM::AEK_DOTPROD,
297 "8.2-A"),
298 ARMCPUTestParams("cortex-a76ae", "armv8.2-a", "crypto-neon-fp-armv8",
299 ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
300 ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
301 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP |
302 ARM::AEK_FP16 | ARM::AEK_RAS | ARM::AEK_DOTPROD,
303 "8.2-A"),
304 ARMCPUTestParams("cortex-a78c", "armv8.2-a", "crypto-neon-fp-armv8",
305 ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_VIRT |
306 ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB |
307 ARM::AEK_DSP | ARM::AEK_CRC | ARM::AEK_RAS |
308 ARM::AEK_FP16 | ARM::AEK_DOTPROD,
309 "8.2-A"),
310 ARMCPUTestParams("cortex-a77", "armv8.2-a", "crypto-neon-fp-armv8",
311 ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
312 ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
313 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP |
314 ARM::AEK_FP16 | ARM::AEK_RAS | ARM::AEK_DOTPROD,
315 "8.2-A"),
316 ARMCPUTestParams("cortex-a78", "armv8.2-a", "crypto-neon-fp-armv8",
317 ARM::AEK_DOTPROD | ARM::AEK_FP16 | ARM::AEK_SEC |
318 ARM::AEK_MP | ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
319 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP | ARM::AEK_CRC |
320 ARM::AEK_RAS,
321 "8.2-A"),
322 ARMCPUTestParams("cortex-x1", "armv8.2-a", "crypto-neon-fp-armv8",
323 ARM::AEK_RAS | ARM::AEK_FP16 | ARM::AEK_DOTPROD |
324 ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_VIRT |
325 ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB |
326 ARM::AEK_DSP | ARM::AEK_CRC | ARM::AEK_RAS,
327 "8.2-A"),
328 ARMCPUTestParams("neoverse-n1", "armv8.2-a", "crypto-neon-fp-armv8",
329 ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
330 ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
331 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP |
332 ARM::AEK_FP16 | ARM::AEK_RAS | ARM::AEK_DOTPROD,
333 "8.2-A"),
334 ARMCPUTestParams("neoverse-n2", "armv8.5-a", "crypto-neon-fp-armv8",
335 ARM::AEK_CRC | ARM::AEK_HWDIVTHUMB |
336 ARM::AEK_HWDIVARM | ARM::AEK_MP | ARM::AEK_SEC |
337 ARM::AEK_VIRT | ARM::AEK_DSP | ARM::AEK_BF16 |
338 ARM::AEK_DOTPROD | ARM::AEK_RAS | ARM::AEK_I8MM |
339 ARM::AEK_SB,
340 "8.5-A"),
341 ARMCPUTestParams("neoverse-v1", "armv8.4-a", "crypto-neon-fp-armv8",
342 ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_VIRT |
343 ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB |
344 ARM::AEK_DSP | ARM::AEK_CRC | ARM::AEK_RAS |
345 ARM::AEK_FP16 | ARM::AEK_BF16 | ARM::AEK_DOTPROD,
346 "8.4-A"),
347 ARMCPUTestParams("cyclone", "armv8-a", "crypto-neon-fp-armv8",
348 ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
349 ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
350 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP,
351 "8-A"),
352 ARMCPUTestParams("exynos-m3", "armv8-a", "crypto-neon-fp-armv8",
353 ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
354 ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
355 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP,
356 "8-A"),
357 ARMCPUTestParams("exynos-m4", "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_DOTPROD | ARM::AEK_FP16 | ARM::AEK_RAS,
362 "8.2-A"),
363 ARMCPUTestParams("exynos-m5", "armv8.2-a", "crypto-neon-fp-armv8",
364 ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
365 ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
366 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP |
367 ARM::AEK_DOTPROD | ARM::AEK_FP16 | ARM::AEK_RAS,
368 "8.2-A"),
369 ARMCPUTestParams("cortex-m23", "armv8-m.base", "none",
370 ARM::AEK_NONE | ARM::AEK_HWDIVTHUMB, "8-M.Baseline"),
371 ARMCPUTestParams("cortex-m33", "armv8-m.main", "fpv5-sp-d16",
372 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP, "8-M.Mainline"),
373 ARMCPUTestParams("cortex-m35p", "armv8-m.main", "fpv5-sp-d16",
374 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP, "8-M.Mainline"),
375 ARMCPUTestParams("cortex-m55", "armv8.1-m.main",
376 "fp-armv8-fullfp16-d16",
377 ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP | ARM::AEK_SIMD |
378 ARM::AEK_FP | ARM::AEK_RAS | ARM::AEK_LOB |
379 ARM::AEK_FP16,
380 "8.1-M.Mainline"),
381 ARMCPUTestParams("iwmmxt", "iwmmxt", "none", ARM::AEK_NONE, "iwmmxt"),
382 ARMCPUTestParams("xscale", "xscale", "none", ARM::AEK_NONE, "xscale"),
383 ARMCPUTestParams("swift", "armv7s", "neon-vfpv4",
384 ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP,
385 "7-S")));
386
387 static constexpr unsigned NumARMCPUArchs = 86;
388
389 TEST(TargetParserTest, testARMCPUArchList) {
390 SmallVector<StringRef, NumARMCPUArchs> List;
391 ARM::fillValidCPUArchList(List);
392
393 // No list exists for these in this test suite, so ensure all are
394 // valid, and match the expected 'magic' count.
395 EXPECT_EQ(List.size(), NumARMCPUArchs);
396 for(StringRef CPU : List) {
397 EXPECT_NE(ARM::parseCPUArch(CPU), ARM::ArchKind::INVALID);
398 }
399 }
400
401 TEST(TargetParserTest, testInvalidARMArch) {
402 auto InvalidArchStrings = {"armv", "armv99", "noarm"};
403 for (const char* InvalidArch : InvalidArchStrings)
404 EXPECT_EQ(ARM::parseArch(InvalidArch), ARM::ArchKind::INVALID);
405 }
406
407 bool testARMArch(StringRef Arch, StringRef DefaultCPU, StringRef SubArch,
408 unsigned ArchAttr) {
409 ARM::ArchKind AK = ARM::parseArch(Arch);
410 bool Result = (AK != ARM::ArchKind::INVALID);
411 Result &= ARM::getDefaultCPU(Arch).equals(DefaultCPU);
412 Result &= ARM::getSubArch(AK).equals(SubArch);
413 Result &= (ARM::getArchAttr(AK) == ArchAttr);
414 return Result;
415 }
416
417 TEST(TargetParserTest, testARMArch) {
418 EXPECT_TRUE(
419 testARMArch("armv2", "generic", "v2", ARMBuildAttrs::CPUArch::Pre_v4));
420 EXPECT_TRUE(
421 testARMArch("armv2a", "generic", "v2a", ARMBuildAttrs::CPUArch::Pre_v4));
422 EXPECT_TRUE(
423 testARMArch("armv3", "generic", "v3", ARMBuildAttrs::CPUArch::Pre_v4));
424 EXPECT_TRUE(
425 testARMArch("armv3m", "generic", "v3m", ARMBuildAttrs::CPUArch::Pre_v4));
426 EXPECT_TRUE(
427 testARMArch("armv4", "strongarm", "v4",
428 ARMBuildAttrs::CPUArch::v4));
429 EXPECT_TRUE(
430 testARMArch("armv4t", "arm7tdmi", "v4t",
431 ARMBuildAttrs::CPUArch::v4T));
432 EXPECT_TRUE(
433 testARMArch("armv5t", "arm10tdmi", "v5",
434 ARMBuildAttrs::CPUArch::v5T));
435 EXPECT_TRUE(
436 testARMArch("armv5te", "arm1022e", "v5e",
437 ARMBuildAttrs::CPUArch::v5TE));
438 EXPECT_TRUE(
439 testARMArch("armv5tej", "arm926ej-s", "v5e",
440 ARMBuildAttrs::CPUArch::v5TEJ));
441 EXPECT_TRUE(
442 testARMArch("armv6", "arm1136jf-s", "v6",
443 ARMBuildAttrs::CPUArch::v6));
444 EXPECT_TRUE(
445 testARMArch("armv6k", "mpcore", "v6k",
446 ARMBuildAttrs::CPUArch::v6K));
447 EXPECT_TRUE(
448 testARMArch("armv6t2", "arm1156t2-s", "v6t2",
449 ARMBuildAttrs::CPUArch::v6T2));
450 EXPECT_TRUE(
451 testARMArch("armv6kz", "arm1176jzf-s", "v6kz",
452 ARMBuildAttrs::CPUArch::v6KZ));
453 EXPECT_TRUE(
454 testARMArch("armv6-m", "cortex-m0", "v6m",
455 ARMBuildAttrs::CPUArch::v6_M));
456 EXPECT_TRUE(
457 testARMArch("armv7-a", "generic", "v7",
458 ARMBuildAttrs::CPUArch::v7));
459 EXPECT_TRUE(
460 testARMArch("armv7ve", "generic", "v7ve",
461 ARMBuildAttrs::CPUArch::v7));
462 EXPECT_TRUE(
463 testARMArch("armv7-r", "cortex-r4", "v7r",
464 ARMBuildAttrs::CPUArch::v7));
465 EXPECT_TRUE(
466 testARMArch("armv7-m", "cortex-m3", "v7m",
467 ARMBuildAttrs::CPUArch::v7));
468 EXPECT_TRUE(
469 testARMArch("armv7e-m", "cortex-m4", "v7em",
470 ARMBuildAttrs::CPUArch::v7E_M));
471 EXPECT_TRUE(
472 testARMArch("armv8-a", "generic", "v8",
473 ARMBuildAttrs::CPUArch::v8_A));
474 EXPECT_TRUE(
475 testARMArch("armv8.1-a", "generic", "v8.1a",
476 ARMBuildAttrs::CPUArch::v8_A));
477 EXPECT_TRUE(
478 testARMArch("armv8.2-a", "generic", "v8.2a",
479 ARMBuildAttrs::CPUArch::v8_A));
480 EXPECT_TRUE(
481 testARMArch("armv8.3-a", "generic", "v8.3a",
482 ARMBuildAttrs::CPUArch::v8_A));
483 EXPECT_TRUE(
484 testARMArch("armv8.4-a", "generic", "v8.4a",
485 ARMBuildAttrs::CPUArch::v8_A));
486 EXPECT_TRUE(
487 testARMArch("armv8.5-a", "generic", "v8.5a",
488 ARMBuildAttrs::CPUArch::v8_A));
489 EXPECT_TRUE(
490 testARMArch("armv8.6-a", "generic", "v8.6a",
491 ARMBuildAttrs::CPUArch::v8_A));
492 EXPECT_TRUE(
493 testARMArch("armv8.7-a", "generic", "v8.7a",
494 ARMBuildAttrs::CPUArch::v8_A));
495 EXPECT_TRUE(
496 testARMArch("armv8-r", "cortex-r52", "v8r",
497 ARMBuildAttrs::CPUArch::v8_R));
498 EXPECT_TRUE(
499 testARMArch("armv8-m.base", "generic", "v8m.base",
500 ARMBuildAttrs::CPUArch::v8_M_Base));
501 EXPECT_TRUE(
502 testARMArch("armv8-m.main", "generic", "v8m.main",
503 ARMBuildAttrs::CPUArch::v8_M_Main));
504 EXPECT_TRUE(
505 testARMArch("armv8.1-m.main", "generic", "v8.1m.main",
506 ARMBuildAttrs::CPUArch::v8_1_M_Main));
507 EXPECT_TRUE(
508 testARMArch("iwmmxt", "iwmmxt", "",
509 ARMBuildAttrs::CPUArch::v5TE));
510 EXPECT_TRUE(
511 testARMArch("iwmmxt2", "generic", "",
512 ARMBuildAttrs::CPUArch::v5TE));
513 EXPECT_TRUE(
514 testARMArch("xscale", "xscale", "v5e",
515 ARMBuildAttrs::CPUArch::v5TE));
516 EXPECT_TRUE(
517 testARMArch("armv7s", "swift", "v7s",
518 ARMBuildAttrs::CPUArch::v7));
519 EXPECT_TRUE(
520 testARMArch("armv7k", "generic", "v7k",
521 ARMBuildAttrs::CPUArch::v7));
522 }
523
524 bool testARMExtension(StringRef CPUName,ARM::ArchKind ArchKind, StringRef ArchExt) {
525 return ARM::getDefaultExtensions(CPUName, ArchKind) &
526 ARM::parseArchExt(ArchExt);
527 }
528
529 TEST(TargetParserTest, testARMExtension) {
530 EXPECT_FALSE(testARMExtension("strongarm", ARM::ArchKind::INVALID, "dsp"));
531 EXPECT_FALSE(testARMExtension("arm7tdmi", ARM::ArchKind::INVALID, "dsp"));
532 EXPECT_FALSE(testARMExtension("arm10tdmi",
533 ARM::ArchKind::INVALID, "simd"));
534 EXPECT_FALSE(testARMExtension("arm1022e", ARM::ArchKind::INVALID, "simd"));
535 EXPECT_FALSE(testARMExtension("arm926ej-s",
536 ARM::ArchKind::INVALID, "simd"));
537 EXPECT_FALSE(testARMExtension("arm1136jf-s",
538 ARM::ArchKind::INVALID, "crypto"));
539 EXPECT_FALSE(testARMExtension("arm1156t2-s",
540 ARM::ArchKind::INVALID, "crypto"));
541 EXPECT_FALSE(testARMExtension("arm1176jzf-s",
542 ARM::ArchKind::INVALID, "crypto"));
543 EXPECT_FALSE(testARMExtension("cortex-m0",
544 ARM::ArchKind::INVALID, "crypto"));
545 EXPECT_FALSE(testARMExtension("cortex-a8",
546 ARM::ArchKind::INVALID, "crypto"));
547 EXPECT_FALSE(testARMExtension("cortex-r4",
548 ARM::ArchKind::INVALID, "crypto"));
549 EXPECT_FALSE(testARMExtension("cortex-m3",
550 ARM::ArchKind::INVALID, "crypto"));
551 EXPECT_FALSE(testARMExtension("cortex-a53",
552 ARM::ArchKind::INVALID, "ras"));
553 EXPECT_FALSE(testARMExtension("cortex-a53",
554 ARM::ArchKind::INVALID, "fp16"));
555 EXPECT_TRUE(testARMExtension("cortex-a55",
556 ARM::ArchKind::INVALID, "fp16"));
557 EXPECT_FALSE(testARMExtension("cortex-a55",
558 ARM::ArchKind::INVALID, "fp16fml"));
559 EXPECT_TRUE(testARMExtension("cortex-a75",
560 ARM::ArchKind::INVALID, "fp16"));
561 EXPECT_FALSE(testARMExtension("cortex-a75",
562 ARM::ArchKind::INVALID, "fp16fml"));
563 EXPECT_FALSE(testARMExtension("cortex-r52",
564 ARM::ArchKind::INVALID, "ras"));
565 EXPECT_FALSE(testARMExtension("iwmmxt", ARM::ArchKind::INVALID, "crc"));
566 EXPECT_FALSE(testARMExtension("xscale", ARM::ArchKind::INVALID, "crc"));
567 EXPECT_FALSE(testARMExtension("swift", ARM::ArchKind::INVALID, "crc"));
568
569 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV2, "thumb"));
570 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV2A, "thumb"));
571 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV3, "thumb"));
572 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV3M, "thumb"));
573 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV4, "dsp"));
574 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV4T, "dsp"));
575 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV5T, "simd"));
576 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV5TE, "simd"));
577 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV5TEJ, "simd"));
578 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV6, "crypto"));
579 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV6K, "crypto"));
580 EXPECT_FALSE(testARMExtension("generic",
581 ARM::ArchKind::ARMV6T2, "crypto"));
582 EXPECT_FALSE(testARMExtension("generic",
583 ARM::ArchKind::ARMV6KZ, "crypto"));
584 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV6M, "crypto"));
585 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV7A, "crypto"));
586 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV7R, "crypto"));
587 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV7M, "crypto"));
588 EXPECT_FALSE(testARMExtension("generic",
589 ARM::ArchKind::ARMV7EM, "crypto"));
590 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV8A, "ras"));
591 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV8_1A, "ras"));
592 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV8_2A, "profile"));
593 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV8_2A, "fp16"));
594 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV8_2A, "fp16fml"));
595 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV8_3A, "fp16"));
596 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV8_3A, "fp16fml"));
597 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV8_4A, "fp16"));
598 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV8_4A, "fp16fml"));
599 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV8R, "ras"));
600 EXPECT_FALSE(testARMExtension("generic",
601 ARM::ArchKind::ARMV8MBaseline, "crc"));
602 EXPECT_FALSE(testARMExtension("generic",
603 ARM::ArchKind::ARMV8MMainline, "crc"));
604 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::IWMMXT, "crc"));
605 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::IWMMXT2, "crc"));
606 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::XSCALE, "crc"));
607 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV7S, "crypto"));
608 EXPECT_FALSE(testARMExtension("generic", ARM::ArchKind::ARMV7K, "crypto"));
609 }
610
611 TEST(TargetParserTest, ARMFPUVersion) {
612 for (ARM::FPUKind FK = static_cast<ARM::FPUKind>(0);
613 FK <= ARM::FPUKind::FK_LAST;
614 FK = static_cast<ARM::FPUKind>(static_cast<unsigned>(FK) + 1))
615 if (FK == ARM::FK_LAST || ARM::getFPUName(FK) == "invalid" ||
616 ARM::getFPUName(FK) == "none" || ARM::getFPUName(FK) == "softvfp")
617 EXPECT_EQ(ARM::FPUVersion::NONE, ARM::getFPUVersion(FK));
618 else
619 EXPECT_NE(ARM::FPUVersion::NONE, ARM::getFPUVersion(FK));
620 }
621
622 TEST(TargetParserTest, ARMFPUNeonSupportLevel) {
623 for (ARM::FPUKind FK = static_cast<ARM::FPUKind>(0);
624 FK <= ARM::FPUKind::FK_LAST;
625 FK = static_cast<ARM::FPUKind>(static_cast<unsigned>(FK) + 1))
626 if (FK == ARM::FK_LAST ||
627 ARM::getFPUName(FK).find("neon") == std::string::npos)
628 EXPECT_EQ(ARM::NeonSupportLevel::None,
629 ARM::getFPUNeonSupportLevel(FK));
630 else
631 EXPECT_NE(ARM::NeonSupportLevel::None,
632 ARM::getFPUNeonSupportLevel(FK));
633 }
634
635 TEST(TargetParserTest, ARMFPURestriction) {
636 for (ARM::FPUKind FK = static_cast<ARM::FPUKind>(0);
637 FK <= ARM::FPUKind::FK_LAST;
638 FK = static_cast<ARM::FPUKind>(static_cast<unsigned>(FK) + 1)) {
639 if (FK == ARM::FK_LAST ||
640 (ARM::getFPUName(FK).find("d16") == std::string::npos &&
641 ARM::getFPUName(FK).find("vfpv3xd") == std::string::npos))
642 EXPECT_EQ(ARM::FPURestriction::None, ARM::getFPURestriction(FK));
643 else
644 EXPECT_NE(ARM::FPURestriction::None, ARM::getFPURestriction(FK));
645 }
646 }
647
648 TEST(TargetParserTest, ARMExtensionFeatures) {
649 std::map<uint64_t, std::vector<StringRef>> Extensions;
650
651 for (auto &Ext : ARM::ARCHExtNames) {
652 if (Ext.Feature && Ext.NegFeature)
653 Extensions[Ext.ID] = { StringRef(Ext.Feature),
654 StringRef(Ext.NegFeature) };
655 }
656
657 Extensions[ARM::AEK_HWDIVARM] = { "+hwdiv-arm", "-hwdiv-arm" };
658 Extensions[ARM::AEK_HWDIVTHUMB] = { "+hwdiv", "-hwdiv" };
659
660 std::vector<StringRef> Features;
661
662 EXPECT_FALSE(ARM::getExtensionFeatures(ARM::AEK_INVALID, Features));
663
664 for (auto &E : Extensions) {
665 // test +extension
666 Features.clear();
667 ARM::getExtensionFeatures(E.first, Features);
668 EXPECT_TRUE(llvm::is_contained(Features, E.second.at(0)));
669 EXPECT_TRUE(Extensions.size() == Features.size());
670
671 // test -extension
672 Features.clear();
673 ARM::getExtensionFeatures(~E.first, Features);
674 EXPECT_TRUE(llvm::is_contained(Features, E.second.at(1)));
675 EXPECT_TRUE(Extensions.size() == Features.size());
676 }
677 }
678
679 TEST(TargetParserTest, ARMFPUFeatures) {
680 std::vector<StringRef> Features;
681 for (ARM::FPUKind FK = static_cast<ARM::FPUKind>(0);
682 FK <= ARM::FPUKind::FK_LAST;
683 FK = static_cast<ARM::FPUKind>(static_cast<unsigned>(FK) + 1))
684 EXPECT_TRUE((FK == ARM::FK_INVALID || FK >= ARM::FK_LAST)
685 ? !ARM::getFPUFeatures(FK, Features)
686 : ARM::getFPUFeatures(FK, Features));
687 }
688
689 TEST(TargetParserTest, ARMArchExtFeature) {
690 const char *ArchExt[][4] = {{"crc", "nocrc", "+crc", "-crc"},
691 {"crypto", "nocrypto", "+crypto", "-crypto"},
692 {"dsp", "nodsp", "+dsp", "-dsp"},
693 {"fp", "nofp", nullptr, nullptr},
694 {"idiv", "noidiv", nullptr, nullptr},
695 {"mp", "nomp", nullptr, nullptr},
696 {"simd", "nosimd", nullptr, nullptr},
697 {"sec", "nosec", nullptr, nullptr},
698 {"virt", "novirt", nullptr, nullptr},
699 {"fp16", "nofp16", "+fullfp16", "-fullfp16"},
700 {"fp16fml", "nofp16fml", "+fp16fml", "-fp16fml"},
701 {"ras", "noras", "+ras", "-ras"},
702 {"dotprod", "nodotprod", "+dotprod", "-dotprod"},
703 {"os", "noos", nullptr, nullptr},
704 {"iwmmxt", "noiwmmxt", nullptr, nullptr},
705 {"iwmmxt2", "noiwmmxt2", nullptr, nullptr},
706 {"maverick", "maverick", nullptr, nullptr},
707 {"xscale", "noxscale", nullptr, nullptr},
708 {"sb", "nosb", "+sb", "-sb"},
709 {"i8mm", "noi8mm", "+i8mm", "-i8mm"},
710 {"mve", "nomve", "+mve", "-mve"},
711 {"mve.fp", "nomve.fp", "+mve.fp", "-mve.fp"}};
712
713 for (unsigned i = 0; i < array_lengthof(ArchExt); i++) {
714 EXPECT_EQ(StringRef(ArchExt[i][2]), ARM::getArchExtFeature(ArchExt[i][0]));
715 EXPECT_EQ(StringRef(ArchExt[i][3]), ARM::getArchExtFeature(ArchExt[i][1]));
716 }
717 }
718
719 static bool
720 testArchExtDependency(const char *ArchExt,
721 const std::initializer_list<const char *> &Expected) {
722 std::vector<StringRef> Features;
723 unsigned FPUID;
724
725 if (!ARM::appendArchExtFeatures("", ARM::ArchKind::ARMV8_1MMainline, ArchExt,
726 Features, FPUID))
727 return false;
728
729 return llvm::all_of(Expected, [&](StringRef Ext) {
730 return llvm::is_contained(Features, Ext);
731 });
732 }
733
734 TEST(TargetParserTest, ARMArchExtDependencies) {
735 EXPECT_TRUE(testArchExtDependency("mve", {"+mve", "+dsp"}));
736 EXPECT_TRUE(testArchExtDependency("mve.fp", {"+mve.fp", "+mve", "+dsp"}));
737 EXPECT_TRUE(testArchExtDependency("nodsp", {"-dsp", "-mve", "-mve.fp"}));
738 EXPECT_TRUE(testArchExtDependency("nomve", {"-mve", "-mve.fp"}));
739 }
740
741 TEST(TargetParserTest, ARMparseHWDiv) {
742 const char *hwdiv[] = {"thumb", "arm", "arm,thumb", "thumb,arm"};
743
744 for (unsigned i = 0; i < array_lengthof(hwdiv); i++)
745 EXPECT_NE(ARM::AEK_INVALID, ARM::parseHWDiv((StringRef)hwdiv[i]));
746 }
747
748 TEST(TargetParserTest, ARMparseArchEndianAndISA) {
749 const char *Arch[] = {
750 "v2", "v2a", "v3", "v3m", "v4", "v4t", "v5", "v5t",
751 "v5e", "v5te", "v5tej", "v6", "v6j", "v6k", "v6hl", "v6t2",
752 "v6kz", "v6z", "v6zk", "v6-m", "v6m", "v6sm", "v6s-m", "v7-a",
753 "v7", "v7a", "v7ve", "v7hl", "v7l", "v7-r", "v7r", "v7-m",
754 "v7m", "v7k", "v7s", "v7e-m", "v7em", "v8-a", "v8", "v8a",
755 "v8l", "v8.1-a", "v8.1a", "v8.2-a", "v8.2a", "v8.3-a", "v8.3a", "v8.4-a",
756 "v8.4a", "v8.5-a","v8.5a", "v8.6-a", "v8.6a", "v8.7-a", "v8.7a", "v8-r",
757 "v8m.base", "v8m.main", "v8.1m.main"
758 };
759
760 for (unsigned i = 0; i < array_lengthof(Arch); i++) {
761 std::string arm_1 = "armeb" + (std::string)(Arch[i]);
762 std::string arm_2 = "arm" + (std::string)(Arch[i]) + "eb";
763 std::string arm_3 = "arm" + (std::string)(Arch[i]);
764 std::string thumb_1 = "thumbeb" + (std::string)(Arch[i]);
765 std::string thumb_2 = "thumb" + (std::string)(Arch[i]) + "eb";
766 std::string thumb_3 = "thumb" + (std::string)(Arch[i]);
767
768 EXPECT_EQ(ARM::EndianKind::BIG, ARM::parseArchEndian(arm_1));
769 EXPECT_EQ(ARM::EndianKind::BIG, ARM::parseArchEndian(arm_2));
770 EXPECT_EQ(ARM::EndianKind::LITTLE, ARM::parseArchEndian(arm_3));
771
772 EXPECT_EQ(ARM::ISAKind::ARM, ARM::parseArchISA(arm_1));
773 EXPECT_EQ(ARM::ISAKind::ARM, ARM::parseArchISA(arm_2));
774 EXPECT_EQ(ARM::ISAKind::ARM, ARM::parseArchISA(arm_3));
775 if (i >= 4) {
776 EXPECT_EQ(ARM::EndianKind::BIG, ARM::parseArchEndian(thumb_1));
777 EXPECT_EQ(ARM::EndianKind::BIG, ARM::parseArchEndian(thumb_2));
778 EXPECT_EQ(ARM::EndianKind::LITTLE, ARM::parseArchEndian(thumb_3));
779
780 EXPECT_EQ(ARM::ISAKind::THUMB, ARM::parseArchISA(thumb_1));
781 EXPECT_EQ(ARM::ISAKind::THUMB, ARM::parseArchISA(thumb_2));
782 EXPECT_EQ(ARM::ISAKind::THUMB, ARM::parseArchISA(thumb_3));
783 }
784 }
785
786 EXPECT_EQ(ARM::EndianKind::LITTLE, ARM::parseArchEndian("aarch64"));
787 EXPECT_EQ(ARM::EndianKind::LITTLE, ARM::parseArchEndian("arm64_32"));
788 EXPECT_EQ(ARM::EndianKind::BIG, ARM::parseArchEndian("aarch64_be"));
789
790 EXPECT_EQ(ARM::ISAKind::AARCH64, ARM::parseArchISA("aarch64"));
791 EXPECT_EQ(ARM::ISAKind::AARCH64, ARM::parseArchISA("aarch64_be"));
792 EXPECT_EQ(ARM::ISAKind::AARCH64, ARM::parseArchISA("arm64"));
793 EXPECT_EQ(ARM::ISAKind::AARCH64, ARM::parseArchISA("arm64_be"));
794 EXPECT_EQ(ARM::ISAKind::AARCH64, ARM::parseArchISA("arm64_32"));
795 EXPECT_EQ(ARM::ISAKind::AARCH64, ARM::parseArchISA("aarch64_32"));
796 }
797
798 TEST(TargetParserTest, ARMparseArchProfile) {
799 for (unsigned i = 0; i < array_lengthof(ARMArch); i++) {
800 switch (ARM::parseArch(ARMArch[i])) {
801 case ARM::ArchKind::ARMV6M:
802 case ARM::ArchKind::ARMV7M:
803 case ARM::ArchKind::ARMV7EM:
804 case ARM::ArchKind::ARMV8MMainline:
805 case ARM::ArchKind::ARMV8MBaseline:
806 case ARM::ArchKind::ARMV8_1MMainline:
807 EXPECT_EQ(ARM::ProfileKind::M, ARM::parseArchProfile(ARMArch[i]));
808 break;
809 case ARM::ArchKind::ARMV7R:
810 case ARM::ArchKind::ARMV8R:
811 EXPECT_EQ(ARM::ProfileKind::R, ARM::parseArchProfile(ARMArch[i]));
812 break;
813 case ARM::ArchKind::ARMV7A:
814 case ARM::ArchKind::ARMV7VE:
815 case ARM::ArchKind::ARMV7K:
816 case ARM::ArchKind::ARMV8A:
817 case ARM::ArchKind::ARMV8_1A:
818 case ARM::ArchKind::ARMV8_2A:
819 case ARM::ArchKind::ARMV8_3A:
820 case ARM::ArchKind::ARMV8_4A:
821 case ARM::ArchKind::ARMV8_5A:
822 case ARM::ArchKind::ARMV8_6A:
823 case ARM::ArchKind::ARMV8_7A:
824 EXPECT_EQ(ARM::ProfileKind::A, ARM::parseArchProfile(ARMArch[i]));
825 break;
826 default:
827 EXPECT_EQ(ARM::ProfileKind::INVALID, ARM::parseArchProfile(ARMArch[i]));
828 break;
829 }
830 }
831 }
832
833 TEST(TargetParserTest, ARMparseArchVersion) {
834 for (unsigned i = 0; i < array_lengthof(ARMArch); i++)
835 if (((std::string)ARMArch[i]).substr(0, 4) == "armv")
836 EXPECT_EQ((ARMArch[i][4] - 48u), ARM::parseArchVersion(ARMArch[i]));
837 else
838 EXPECT_EQ(5u, ARM::parseArchVersion(ARMArch[i]));
839 }
840
841 class AArch64CPUTestFixture
842 : public ::testing::TestWithParam<ARMCPUTestParams> {};
843
844 TEST_P(AArch64CPUTestFixture, testAArch64CPU) {
845 ARMCPUTestParams params = GetParam();
846
847 AArch64::ArchKind AK = AArch64::parseCPUArch(params.CPUName);
848 EXPECT_EQ(params.ExpectedArch, AArch64::getArchName(AK));
849
850 uint64_t default_extensions =
851 AArch64::getDefaultExtensions(params.CPUName, AK);
852 EXPECT_PRED_FORMAT2(AssertSameExtensionFlags<ARM::ISAKind::AARCH64>,
853 params.ExpectedFlags, default_extensions);
854
855 unsigned FPUKind = AArch64::getDefaultFPU(params.CPUName, AK);
856 EXPECT_EQ(params.ExpectedFPU, ARM::getFPUName(FPUKind));
857
858 EXPECT_EQ(params.CPUAttr, AArch64::getCPUAttr(AK));
859 }
860
861 INSTANTIATE_TEST_SUITE_P(
862 AArch64CPUTests, AArch64CPUTestFixture,
863 ::testing::Values(
864 ARMCPUTestParams("invalid", "invalid", "invalid", AArch64::AEK_NONE,
865 ""),
866 ARMCPUTestParams("generic", "invalid", "none", AArch64::AEK_NONE, ""),
867
868 ARMCPUTestParams("cortex-a34", "armv8-a", "crypto-neon-fp-armv8",
869 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
870 AArch64::AEK_FP | AArch64::AEK_SIMD,
871 "8-A"),
872 ARMCPUTestParams("cortex-a35", "armv8-a", "crypto-neon-fp-armv8",
873 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
874 AArch64::AEK_FP | AArch64::AEK_SIMD,
875 "8-A"),
876 ARMCPUTestParams("cortex-a53", "armv8-a", "crypto-neon-fp-armv8",
877 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
878 AArch64::AEK_FP | AArch64::AEK_SIMD,
879 "8-A"),
880 ARMCPUTestParams("cortex-a55", "armv8.2-a", "crypto-neon-fp-armv8",
881 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
882 AArch64::AEK_FP | AArch64::AEK_SIMD |
883 AArch64::AEK_RAS | AArch64::AEK_LSE |
884 AArch64::AEK_RDM | AArch64::AEK_FP16 |
885 AArch64::AEK_DOTPROD | AArch64::AEK_RCPC,
886 "8.2-A"),
887 ARMCPUTestParams("cortex-a57", "armv8-a", "crypto-neon-fp-armv8",
888 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
889 AArch64::AEK_FP | AArch64::AEK_SIMD,
890 "8-A"),
891 ARMCPUTestParams("cortex-a65", "armv8.2-a", "crypto-neon-fp-armv8",
892 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
893 AArch64::AEK_DOTPROD | AArch64::AEK_FP |
894 AArch64::AEK_FP16 | AArch64::AEK_LSE |
895 AArch64::AEK_RAS | AArch64::AEK_RCPC |
896 AArch64::AEK_RDM | AArch64::AEK_SIMD |
897 AArch64::AEK_SSBS,
898 "8.2-A"),
899 ARMCPUTestParams("cortex-a65ae", "armv8.2-a", "crypto-neon-fp-armv8",
900 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
901 AArch64::AEK_DOTPROD | AArch64::AEK_FP |
902 AArch64::AEK_FP16 | AArch64::AEK_LSE |
903 AArch64::AEK_RAS | AArch64::AEK_RCPC |
904 AArch64::AEK_RDM | AArch64::AEK_SIMD |
905 AArch64::AEK_SSBS,
906 "8.2-A"),
907 ARMCPUTestParams("cortex-a72", "armv8-a", "crypto-neon-fp-armv8",
908 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
909 AArch64::AEK_FP | AArch64::AEK_SIMD,
910 "8-A"),
911 ARMCPUTestParams("cortex-a73", "armv8-a", "crypto-neon-fp-armv8",
912 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
913 AArch64::AEK_FP | AArch64::AEK_SIMD,
914 "8-A"),
915 ARMCPUTestParams("cortex-a75", "armv8.2-a", "crypto-neon-fp-armv8",
916 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
917 AArch64::AEK_FP | AArch64::AEK_SIMD |
918 AArch64::AEK_RAS | AArch64::AEK_LSE |
919 AArch64::AEK_RDM | AArch64::AEK_FP16 |
920 AArch64::AEK_DOTPROD | AArch64::AEK_RCPC,
921 "8.2-A"),
922 ARMCPUTestParams("cortex-a76", "armv8.2-a", "crypto-neon-fp-armv8",
923 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
924 AArch64::AEK_FP | AArch64::AEK_RDM |
925 AArch64::AEK_SIMD | AArch64::AEK_RAS |
926 AArch64::AEK_LSE | AArch64::AEK_FP16 |
927 AArch64::AEK_DOTPROD | AArch64::AEK_RCPC |
928 AArch64::AEK_SSBS,
929 "8.2-A"),
930 ARMCPUTestParams("cortex-a76ae", "armv8.2-a", "crypto-neon-fp-armv8",
931 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
932 AArch64::AEK_FP | AArch64::AEK_RDM |
933 AArch64::AEK_SIMD | AArch64::AEK_RAS |
934 AArch64::AEK_LSE | AArch64::AEK_FP16 |
935 AArch64::AEK_DOTPROD | AArch64::AEK_RCPC |
936 AArch64::AEK_SSBS,
937 "8.2-A"),
938 ARMCPUTestParams("cortex-a77", "armv8.2-a", "crypto-neon-fp-armv8",
939 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
940 AArch64::AEK_FP | AArch64::AEK_RDM |
941 AArch64::AEK_SIMD | AArch64::AEK_RAS |
942 AArch64::AEK_LSE | AArch64::AEK_FP16 |
943 AArch64::AEK_DOTPROD | AArch64::AEK_RCPC |
944 AArch64::AEK_SSBS,
945 "8.2-A"),
946 ARMCPUTestParams("cortex-a78", "armv8.2-a", "crypto-neon-fp-armv8",
947 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
948 AArch64::AEK_FP | AArch64::AEK_RDM |
949 AArch64::AEK_SIMD | AArch64::AEK_RAS |
950 AArch64::AEK_LSE | AArch64::AEK_FP16 |
951 AArch64::AEK_DOTPROD | AArch64::AEK_RCPC |
952 AArch64::AEK_SSBS,
953 "8.2-A"),
954 ARMCPUTestParams("cortex-a78c", "armv8.2-a", "crypto-neon-fp-armv8",
955 AArch64::AEK_RAS | AArch64::AEK_CRC |
956 AArch64::AEK_CRYPTO | AArch64::AEK_FP |
957 AArch64::AEK_SIMD | AArch64::AEK_RAS |
958 AArch64::AEK_LSE | AArch64::AEK_RDM |
959 AArch64::AEK_FP16 | AArch64::AEK_DOTPROD |
960 AArch64::AEK_RCPC | AArch64::AEK_SSBS,
961 "8.2-A"),
962 ARMCPUTestParams(
963 "neoverse-v1", "armv8.4-a", "crypto-neon-fp-armv8",
964 AArch64::AEK_RAS | AArch64::AEK_SVE | AArch64::AEK_SSBS |
965 AArch64::AEK_RCPC | AArch64::AEK_CRC | AArch64::AEK_FP |
966 AArch64::AEK_SIMD | AArch64::AEK_RAS | AArch64::AEK_LSE |
967 AArch64::AEK_RDM | AArch64::AEK_RCPC | AArch64::AEK_DOTPROD |
968 AArch64::AEK_CRYPTO | AArch64::AEK_FP16 | AArch64::AEK_BF16,
969 "8.4-A"),
970 ARMCPUTestParams("cortex-r82", "armv8-r", "crypto-neon-fp-armv8",
971 AArch64::AEK_CRC | AArch64::AEK_RDM |
972 AArch64::AEK_SSBS | AArch64::AEK_DOTPROD |
973 AArch64::AEK_FP | AArch64::AEK_SIMD |
974 AArch64::AEK_FP16 | AArch64::AEK_FP16FML |
975 AArch64::AEK_RAS | AArch64::AEK_RCPC |
976 AArch64::AEK_LSE | AArch64::AEK_SB,
977 "8-R"),
978 ARMCPUTestParams("cortex-x1", "armv8.2-a", "crypto-neon-fp-armv8",
979 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
980 AArch64::AEK_FP | AArch64::AEK_RDM |
981 AArch64::AEK_SIMD | AArch64::AEK_RAS |
982 AArch64::AEK_LSE | AArch64::AEK_FP16 |
983 AArch64::AEK_DOTPROD | AArch64::AEK_RCPC |
984 AArch64::AEK_SSBS,
985 "8.2-A"),
986 ARMCPUTestParams("cyclone", "armv8-a", "crypto-neon-fp-armv8",
987 AArch64::AEK_NONE | AArch64::AEK_CRYPTO |
988 AArch64::AEK_FP | AArch64::AEK_SIMD,
989 "8-A"),
990 ARMCPUTestParams("apple-a7", "armv8-a", "crypto-neon-fp-armv8",
991 AArch64::AEK_NONE | AArch64::AEK_CRYPTO |
992 AArch64::AEK_FP | AArch64::AEK_SIMD,
993 "8-A"),
994 ARMCPUTestParams("apple-a8", "armv8-a", "crypto-neon-fp-armv8",
995 AArch64::AEK_NONE | AArch64::AEK_CRYPTO |
996 AArch64::AEK_FP | AArch64::AEK_SIMD,
997 "8-A"),
998 ARMCPUTestParams("apple-a9", "armv8-a", "crypto-neon-fp-armv8",
999 AArch64::AEK_NONE | AArch64::AEK_CRYPTO |
1000 AArch64::AEK_FP | AArch64::AEK_SIMD,
1001 "8-A"),
1002 ARMCPUTestParams("apple-a10", "armv8-a", "crypto-neon-fp-armv8",
1003 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1004 AArch64::AEK_FP | AArch64::AEK_RDM |
1005 AArch64::AEK_SIMD,
1006 "8-A"),
1007 ARMCPUTestParams("apple-a11", "armv8.2-a", "crypto-neon-fp-armv8",
1008 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1009 AArch64::AEK_FP | AArch64::AEK_LSE |
1010 AArch64::AEK_RAS | AArch64::AEK_RDM |
1011 AArch64::AEK_SIMD | AArch64::AEK_FP16,
1012 "8.2-A"),
1013 ARMCPUTestParams("apple-a12", "armv8.3-a", "crypto-neon-fp-armv8",
1014 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1015 AArch64::AEK_FP | AArch64::AEK_SIMD |
1016 AArch64::AEK_LSE | AArch64::AEK_RAS |
1017 AArch64::AEK_RDM | AArch64::AEK_RCPC |
1018 AArch64::AEK_FP16,
1019 "8.3-A"),
1020 ARMCPUTestParams("apple-a13", "armv8.4-a", "crypto-neon-fp-armv8",
1021 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1022 AArch64::AEK_FP | AArch64::AEK_SIMD |
1023 AArch64::AEK_LSE | AArch64::AEK_RAS |
1024 AArch64::AEK_RDM | AArch64::AEK_RCPC |
1025 AArch64::AEK_DOTPROD | AArch64::AEK_FP16 |
1026 AArch64::AEK_FP16FML,
1027 "8.4-A"),
1028 ARMCPUTestParams("apple-a14", "armv8.5-a", "crypto-neon-fp-armv8",
1029 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1030 AArch64::AEK_FP | AArch64::AEK_SIMD |
1031 AArch64::AEK_LSE | AArch64::AEK_RAS |
1032 AArch64::AEK_RDM | AArch64::AEK_RCPC |
1033 AArch64::AEK_DOTPROD | AArch64::AEK_FP16 |
1034 AArch64::AEK_FP16FML,
1035 "8.5-A"),
1036 ARMCPUTestParams("apple-m1", "armv8.5-a", "crypto-neon-fp-armv8",
1037 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1038 AArch64::AEK_FP | AArch64::AEK_SIMD |
1039 AArch64::AEK_LSE | AArch64::AEK_RAS |
1040 AArch64::AEK_RDM | AArch64::AEK_RCPC |
1041 AArch64::AEK_DOTPROD | AArch64::AEK_FP16 |
1042 AArch64::AEK_FP16FML,
1043 "8.5-A"),
1044 ARMCPUTestParams("apple-s4", "armv8.3-a", "crypto-neon-fp-armv8",
1045 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1046 AArch64::AEK_FP | AArch64::AEK_SIMD |
1047 AArch64::AEK_LSE | AArch64::AEK_RAS |
1048 AArch64::AEK_RDM | AArch64::AEK_RCPC |
1049 AArch64::AEK_FP16,
1050 "8.3-A"),
1051 ARMCPUTestParams("apple-s5", "armv8.3-a", "crypto-neon-fp-armv8",
1052 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1053 AArch64::AEK_FP | AArch64::AEK_SIMD |
1054 AArch64::AEK_LSE | AArch64::AEK_RAS |
1055 AArch64::AEK_RDM | AArch64::AEK_RCPC |
1056 AArch64::AEK_FP16,
1057 "8.3-A"),
1058 ARMCPUTestParams("exynos-m3", "armv8-a", "crypto-neon-fp-armv8",
1059 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1060 AArch64::AEK_FP | AArch64::AEK_SIMD,
1061 "8-A"),
1062 ARMCPUTestParams("exynos-m4", "armv8.2-a", "crypto-neon-fp-armv8",
1063 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1064 AArch64::AEK_DOTPROD | AArch64::AEK_FP |
1065 AArch64::AEK_FP16 | AArch64::AEK_LSE |
1066 AArch64::AEK_RAS | AArch64::AEK_RDM |
1067 AArch64::AEK_SIMD,
1068 "8.2-A"),
1069 ARMCPUTestParams("exynos-m5", "armv8.2-a", "crypto-neon-fp-armv8",
1070 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1071 AArch64::AEK_DOTPROD | AArch64::AEK_FP |
1072 AArch64::AEK_FP16 | AArch64::AEK_LSE |
1073 AArch64::AEK_RAS | AArch64::AEK_RDM |
1074 AArch64::AEK_SIMD,
1075 "8.2-A"),
1076 ARMCPUTestParams("falkor", "armv8-a", "crypto-neon-fp-armv8",
1077 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1078 AArch64::AEK_FP | AArch64::AEK_SIMD |
1079 AArch64::AEK_RDM,
1080 "8-A"),
1081 ARMCPUTestParams("kryo", "armv8-a", "crypto-neon-fp-armv8",
1082 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1083 AArch64::AEK_FP | AArch64::AEK_SIMD,
1084 "8-A"),
1085 ARMCPUTestParams("neoverse-e1", "armv8.2-a", "crypto-neon-fp-armv8",
1086 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1087 AArch64::AEK_DOTPROD | AArch64::AEK_FP |
1088 AArch64::AEK_FP16 | AArch64::AEK_LSE |
1089 AArch64::AEK_RAS | AArch64::AEK_RCPC |
1090 AArch64::AEK_RDM | AArch64::AEK_SIMD |
1091 AArch64::AEK_SSBS,
1092 "8.2-A"),
1093 ARMCPUTestParams("neoverse-n1", "armv8.2-a", "crypto-neon-fp-armv8",
1094 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1095 AArch64::AEK_DOTPROD | AArch64::AEK_FP |
1096 AArch64::AEK_FP16 | AArch64::AEK_LSE |
1097 AArch64::AEK_PROFILE | AArch64::AEK_RAS |
1098 AArch64::AEK_RCPC | AArch64::AEK_RDM |
1099 AArch64::AEK_SIMD | AArch64::AEK_SSBS,
1100 "8.2-A"),
1101 ARMCPUTestParams("neoverse-n2", "armv8.5-a", "crypto-neon-fp-armv8",
1102 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1103 AArch64::AEK_FP | AArch64::AEK_SIMD |
1104 AArch64::AEK_FP16 | AArch64::AEK_RAS |
1105 AArch64::AEK_LSE | AArch64::AEK_SVE |
1106 AArch64::AEK_DOTPROD | AArch64::AEK_RCPC |
1107 AArch64::AEK_RDM | AArch64::AEK_MTE |
1108 AArch64::AEK_SSBS | AArch64::AEK_SB |
1109 AArch64::AEK_SVE2 | AArch64::AEK_SVE2BITPERM |
1110 AArch64::AEK_BF16 | AArch64::AEK_I8MM,
1111 "8.5-A"),
1112 ARMCPUTestParams("thunderx2t99", "armv8.1-a", "crypto-neon-fp-armv8",
1113 AArch64::AEK_NONE | AArch64::AEK_CRC |
1114 AArch64::AEK_CRYPTO | AArch64::AEK_LSE |
1115 AArch64::AEK_RDM | AArch64::AEK_FP |
1116 AArch64::AEK_SIMD,
1117 "8.1-A"),
1118 ARMCPUTestParams("thunderx3t110", "armv8.3-a", "crypto-neon-fp-armv8",
1119 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1120 AArch64::AEK_LSE | AArch64::AEK_RDM |
1121 AArch64::AEK_FP | AArch64::AEK_SIMD |
1122 AArch64::AEK_PROFILE | AArch64::AEK_RAS |
1123 AArch64::AEK_RAND | AArch64::AEK_RCPC,
1124 "8.3-A"),
1125 ARMCPUTestParams("thunderx", "armv8-a", "crypto-neon-fp-armv8",
1126 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1127 AArch64::AEK_SIMD | AArch64::AEK_FP |
1128 AArch64::AEK_PROFILE,
1129 "8-A"),
1130 ARMCPUTestParams("thunderxt81", "armv8-a", "crypto-neon-fp-armv8",
1131 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1132 AArch64::AEK_SIMD | AArch64::AEK_FP |
1133 AArch64::AEK_PROFILE,
1134 "8-A"),
1135 ARMCPUTestParams("thunderxt83", "armv8-a", "crypto-neon-fp-armv8",
1136 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1137 AArch64::AEK_SIMD | AArch64::AEK_FP |
1138 AArch64::AEK_PROFILE,
1139 "8-A"),
1140 ARMCPUTestParams("thunderxt88", "armv8-a", "crypto-neon-fp-armv8",
1141 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1142 AArch64::AEK_SIMD | AArch64::AEK_FP |
1143 AArch64::AEK_PROFILE,
1144 "8-A"),
1145 ARMCPUTestParams("tsv110", "armv8.2-a", "crypto-neon-fp-armv8",
1146 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1147 AArch64::AEK_FP | AArch64::AEK_SIMD |
1148 AArch64::AEK_RAS | AArch64::AEK_LSE |
1149 AArch64::AEK_RDM | AArch64::AEK_PROFILE |
1150 AArch64::AEK_FP16 | AArch64::AEK_FP16FML |
1151 AArch64::AEK_DOTPROD,
1152 "8.2-A"),
1153 ARMCPUTestParams("a64fx", "armv8.2-a", "crypto-neon-fp-armv8",
1154 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1155 AArch64::AEK_FP | AArch64::AEK_SIMD |
1156 AArch64::AEK_FP16 | AArch64::AEK_RAS |
1157 AArch64::AEK_LSE | AArch64::AEK_SVE |
1158 AArch64::AEK_RDM,
1159 "8.2-A"),
1160 ARMCPUTestParams("carmel", "armv8.2-a", "crypto-neon-fp-armv8",
1161 AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
1162 AArch64::AEK_FP | AArch64::AEK_SIMD |
1163 AArch64::AEK_FP16 | AArch64::AEK_RAS |
1164 AArch64::AEK_LSE | AArch64::AEK_RDM,
1165 "8.2-A")));
1166
1167 static constexpr unsigned NumAArch64CPUArchs = 48;
1168
1169 TEST(TargetParserTest, testAArch64CPUArchList) {
1170 SmallVector<StringRef, NumAArch64CPUArchs> List;
1171 AArch64::fillValidCPUArchList(List);
1172
1173 // No list exists for these in this test suite, so ensure all are
1174 // valid, and match the expected 'magic' count.
1175 EXPECT_EQ(List.size(), NumAArch64CPUArchs);
1176 for(StringRef CPU : List) {
1177 EXPECT_NE(AArch64::parseCPUArch(CPU), AArch64::ArchKind::INVALID);
1178 }
1179 }
1180
1181 bool testAArch64Arch(StringRef Arch, StringRef DefaultCPU, StringRef SubArch,
1182 unsigned ArchAttr) {
1183 AArch64::ArchKind AK = AArch64::parseArch(Arch);
1184 return (AK != AArch64::ArchKind::INVALID) &
1185 AArch64::getDefaultCPU(Arch).equals(DefaultCPU) &
1186 AArch64::getSubArch(AK).equals(SubArch) &
1187 (AArch64::getArchAttr(AK) == ArchAttr);
1188 }
1189
1190 TEST(TargetParserTest, testAArch64Arch) {
1191 EXPECT_TRUE(testAArch64Arch("armv8-a", "cortex-a53", "v8",
1192 ARMBuildAttrs::CPUArch::v8_A));
1193 EXPECT_TRUE(testAArch64Arch("armv8.1-a", "generic", "v8.1a",
1194 ARMBuildAttrs::CPUArch::v8_A));
1195 EXPECT_TRUE(testAArch64Arch("armv8.2-a", "generic", "v8.2a",
1196 ARMBuildAttrs::CPUArch::v8_A));
1197 EXPECT_TRUE(testAArch64Arch("armv8.3-a", "generic", "v8.3a",
1198 ARMBuildAttrs::CPUArch::v8_A));
1199 EXPECT_TRUE(testAArch64Arch("armv8.4-a", "generic", "v8.4a",
1200 ARMBuildAttrs::CPUArch::v8_A));
1201 EXPECT_TRUE(testAArch64Arch("armv8.5-a", "generic", "v8.5a",
1202 ARMBuildAttrs::CPUArch::v8_A));
1203 EXPECT_TRUE(testAArch64Arch("armv8.6-a", "generic", "v8.6a",
1204 ARMBuildAttrs::CPUArch::v8_A));
1205 EXPECT_TRUE(testAArch64Arch("armv8.7-a", "generic", "v8.7a",
1206 ARMBuildAttrs::CPUArch::v8_A));
1207 }
1208
1209 bool testAArch64Extension(StringRef CPUName, AArch64::ArchKind AK,
1210 StringRef ArchExt) {
1211 return AArch64::getDefaultExtensions(CPUName, AK) &
1212 AArch64::parseArchExt(ArchExt);
1213 }
1214
1215 TEST(TargetParserTest, testAArch64Extension) {
1216 EXPECT_FALSE(testAArch64Extension("cortex-a34",
1217 AArch64::ArchKind::INVALID, "ras"));
1218 EXPECT_FALSE(testAArch64Extension("cortex-a35",
1219 AArch64::ArchKind::INVALID, "ras"));
1220 EXPECT_FALSE(testAArch64Extension("cortex-a53",
1221 AArch64::ArchKind::INVALID, "ras"));
1222 EXPECT_TRUE(testAArch64Extension("cortex-a55",
1223 AArch64::ArchKind::INVALID, "ras"));
1224 EXPECT_TRUE(testAArch64Extension("cortex-a55",
1225 AArch64::ArchKind::INVALID, "fp16"));
1226 EXPECT_FALSE(testAArch64Extension("cortex-a55",
1227 AArch64::ArchKind::INVALID, "fp16fml"));
1228 EXPECT_TRUE(testAArch64Extension("cortex-a55",
1229 AArch64::ArchKind::INVALID, "dotprod"));
1230 EXPECT_FALSE(testAArch64Extension("cortex-a57",
1231 AArch64::ArchKind::INVALID, "ras"));
1232 EXPECT_FALSE(testAArch64Extension("cortex-a72",
1233 AArch64::ArchKind::INVALID, "ras"));
1234 EXPECT_FALSE(testAArch64Extension("cortex-a73",
1235 AArch64::ArchKind::INVALID, "ras"));
1236 EXPECT_TRUE(testAArch64Extension("cortex-a75",
1237 AArch64::ArchKind::INVALID, "ras"));
1238 EXPECT_TRUE(testAArch64Extension("cortex-a75",
1239 AArch64::ArchKind::INVALID, "fp16"));
1240 EXPECT_FALSE(testAArch64Extension("cortex-a75",
1241 AArch64::ArchKind::INVALID, "fp16fml"));
1242 EXPECT_TRUE(testAArch64Extension("cortex-a75",
1243 AArch64::ArchKind::INVALID, "dotprod"));
1244 EXPECT_TRUE(testAArch64Extension("cortex-r82",
1245 AArch64::ArchKind::INVALID, "ras"));
1246 EXPECT_TRUE(testAArch64Extension("cortex-r82",
1247 AArch64::ArchKind::INVALID, "fp16"));
1248 EXPECT_TRUE(testAArch64Extension("cortex-r82",
1249 AArch64::ArchKind::INVALID, "fp16fml"));
1250 EXPECT_TRUE(testAArch64Extension("cortex-r82",
1251 AArch64::ArchKind::INVALID, "dotprod"));
1252 EXPECT_TRUE(testAArch64Extension("cortex-r82",
1253 AArch64::ArchKind::INVALID, "lse"));
1254 EXPECT_FALSE(testAArch64Extension("cyclone",
1255 AArch64::ArchKind::INVALID, "ras"));
1256 EXPECT_FALSE(testAArch64Extension("exynos-m3",
1257 AArch64::ArchKind::INVALID, "ras"));
1258 EXPECT_TRUE(testAArch64Extension("exynos-m4",
1259 AArch64::ArchKind::INVALID, "dotprod"));
1260 EXPECT_TRUE(testAArch64Extension("exynos-m4",
1261 AArch64::ArchKind::INVALID, "fp16"));
1262 EXPECT_TRUE(testAArch64Extension("exynos-m4",
1263 AArch64::ArchKind::INVALID, "lse"));
1264 EXPECT_TRUE(testAArch64Extension("exynos-m4",
1265 AArch64::ArchKind::INVALID, "ras"));
1266 EXPECT_TRUE(testAArch64Extension("exynos-m4",
1267 AArch64::ArchKind::INVALID, "rdm"));
1268 EXPECT_TRUE(testAArch64Extension("exynos-m5",
1269 AArch64::ArchKind::INVALID, "dotprod"));
1270 EXPECT_TRUE(testAArch64Extension("exynos-m5",
1271 AArch64::ArchKind::INVALID, "fp16"));
1272 EXPECT_TRUE(testAArch64Extension("exynos-m5",
1273 AArch64::ArchKind::INVALID, "lse"));
1274 EXPECT_TRUE(testAArch64Extension("exynos-m5",
1275 AArch64::ArchKind::INVALID, "ras"));
1276 EXPECT_TRUE(testAArch64Extension("exynos-m5",
1277 AArch64::ArchKind::INVALID, "rdm"));
1278 EXPECT_TRUE(testAArch64Extension("falkor",
1279 AArch64::ArchKind::INVALID, "rdm"));
1280 EXPECT_FALSE(testAArch64Extension("kryo",
1281 AArch64::ArchKind::INVALID, "ras"));
1282 EXPECT_TRUE(testAArch64Extension("saphira",
1283 AArch64::ArchKind::INVALID, "crc"));
1284 EXPECT_TRUE(testAArch64Extension("saphira",
1285 AArch64::ArchKind::INVALID, "lse"));
1286 EXPECT_TRUE(testAArch64Extension("saphira",
1287 AArch64::ArchKind::INVALID, "rdm"));
1288 EXPECT_TRUE(testAArch64Extension("saphira",
1289 AArch64::ArchKind::INVALID, "ras"));
1290 EXPECT_TRUE(testAArch64Extension("saphira",
1291 AArch64::ArchKind::INVALID, "rcpc"));
1292 EXPECT_TRUE(testAArch64Extension("saphira",
1293 AArch64::ArchKind::INVALID, "profile"));
1294 EXPECT_FALSE(testAArch64Extension("saphira",
1295 AArch64::ArchKind::INVALID, "fp16"));
1296 EXPECT_FALSE(testAArch64Extension("thunderx2t99",
1297 AArch64::ArchKind::INVALID, "ras"));
1298 EXPECT_FALSE(testAArch64Extension("thunderx",
1299 AArch64::ArchKind::INVALID, "lse"));
1300 EXPECT_FALSE(testAArch64Extension("thunderxt81",
1301 AArch64::ArchKind::INVALID, "lse"));
1302 EXPECT_FALSE(testAArch64Extension("thunderxt83",
1303 AArch64::ArchKind::INVALID, "lse"));
1304 EXPECT_FALSE(testAArch64Extension("thunderxt88",
1305 AArch64::ArchKind::INVALID, "lse"));
1306 EXPECT_TRUE(testAArch64Extension("tsv110",
1307 AArch64::ArchKind::INVALID, "crypto"));
1308 EXPECT_FALSE(testAArch64Extension("tsv110",
1309 AArch64::ArchKind::INVALID, "sha3"));
1310 EXPECT_FALSE(testAArch64Extension("tsv110",
1311 AArch64::ArchKind::INVALID, "sm4"));
1312 EXPECT_TRUE(testAArch64Extension("tsv110",
1313 AArch64::ArchKind::INVALID, "ras"));
1314 EXPECT_TRUE(testAArch64Extension("tsv110",
1315 AArch64::ArchKind::INVALID, "profile"));
1316 EXPECT_TRUE(testAArch64Extension("tsv110",
1317 AArch64::ArchKind::INVALID, "fp16"));
1318 EXPECT_TRUE(testAArch64Extension("tsv110",
1319 AArch64::ArchKind::INVALID, "fp16fml"));
1320 EXPECT_TRUE(testAArch64Extension("tsv110",
1321 AArch64::ArchKind::INVALID, "dotprod"));
1322 EXPECT_TRUE(testAArch64Extension("a64fx",
1323 AArch64::ArchKind::INVALID, "fp16"));
1324 EXPECT_TRUE(testAArch64Extension("a64fx",
1325 AArch64::ArchKind::INVALID, "sve"));
1326 EXPECT_FALSE(testAArch64Extension("a64fx",
1327 AArch64::ArchKind::INVALID, "sve2"));
1328 EXPECT_TRUE(
1329 testAArch64Extension("carmel", AArch64::ArchKind::INVALID, "crypto"));
1330 EXPECT_TRUE(
1331 testAArch64Extension("carmel", AArch64::ArchKind::INVALID, "fp16"));
1332
1333 EXPECT_FALSE(testAArch64Extension(
1334 "generic", AArch64::ArchKind::ARMV8A, "ras"));
1335 EXPECT_FALSE(testAArch64Extension(
1336 "generic", AArch64::ArchKind::ARMV8_1A, "ras"));
1337 EXPECT_FALSE(testAArch64Extension(
1338 "generic", AArch64::ArchKind::ARMV8_2A, "profile"));
1339 EXPECT_FALSE(testAArch64Extension(
1340 "generic", AArch64::ArchKind::ARMV8_2A, "fp16"));
1341 EXPECT_FALSE(testAArch64Extension(
1342 "generic", AArch64::ArchKind::ARMV8_2A, "fp16fml"));
1343 EXPECT_FALSE(testAArch64Extension(
1344 "generic", AArch64::ArchKind::ARMV8_3A, "fp16"));
1345 EXPECT_FALSE(testAArch64Extension(
1346 "generic", AArch64::ArchKind::ARMV8_3A, "fp16fml"));
1347 EXPECT_FALSE(testAArch64Extension(
1348 "generic", AArch64::ArchKind::ARMV8_4A, "fp16"));
1349 EXPECT_FALSE(testAArch64Extension(
1350 "generic", AArch64::ArchKind::ARMV8_4A, "fp16fml"));
1351 }
1352
1353 TEST(TargetParserTest, AArch64ExtensionFeatures) {
1354 std::vector<uint64_t> Extensions = {
1355 AArch64::AEK_CRC, AArch64::AEK_CRYPTO,
1356 AArch64::AEK_FP, AArch64::AEK_SIMD,
1357 AArch64::AEK_FP16, AArch64::AEK_PROFILE,
1358 AArch64::AEK_RAS, AArch64::AEK_LSE,
1359 AArch64::AEK_RDM, AArch64::AEK_DOTPROD,
1360 AArch64::AEK_SVE, AArch64::AEK_SVE2,
1361 AArch64::AEK_SVE2AES, AArch64::AEK_SVE2SM4,
1362 AArch64::AEK_SVE2SHA3, AArch64::AEK_SVE2BITPERM,
1363 AArch64::AEK_RCPC, AArch64::AEK_FP16FML,
1364 AArch64::AEK_SME, AArch64::AEK_SMEF64,
1365 AArch64::AEK_SMEI64 };
1366
1367 std::vector<StringRef> Features;
1368
1369 uint64_t ExtVal = 0;
1370 for (auto Ext : Extensions)
1371 ExtVal |= Ext;
1372
1373 EXPECT_FALSE(AArch64::getExtensionFeatures(AArch64::AEK_INVALID, Features));
1374 EXPECT_TRUE(!Features.size());
1375
1376 AArch64::getExtensionFeatures(ExtVal, Features);
1377 EXPECT_TRUE(Extensions.size() == Features.size());
1378
1379 EXPECT_TRUE(llvm::is_contained(Features, "+crc"));
1380 EXPECT_TRUE(llvm::is_contained(Features, "+crypto"));
1381 EXPECT_TRUE(llvm::is_contained(Features, "+fp-armv8"));
1382 EXPECT_TRUE(llvm::is_contained(Features, "+neon"));
1383 EXPECT_TRUE(llvm::is_contained(Features, "+fullfp16"));
1384 EXPECT_TRUE(llvm::is_contained(Features, "+spe"));
1385 EXPECT_TRUE(llvm::is_contained(Features, "+ras"));
1386 EXPECT_TRUE(llvm::is_contained(Features, "+lse"));
1387 EXPECT_TRUE(llvm::is_contained(Features, "+rdm"));
1388 EXPECT_TRUE(llvm::is_contained(Features, "+dotprod"));
1389 EXPECT_TRUE(llvm::is_contained(Features, "+rcpc"));
1390 EXPECT_TRUE(llvm::is_contained(Features, "+fp16fml"));
1391 EXPECT_TRUE(llvm::is_contained(Features, "+sve"));
1392 EXPECT_TRUE(llvm::is_contained(Features, "+sve2"));
1393 EXPECT_TRUE(llvm::is_contained(Features, "+sve2-aes"));
1394 EXPECT_TRUE(llvm::is_contained(Features, "+sve2-sm4"));
1395 EXPECT_TRUE(llvm::is_contained(Features, "+sve2-sha3"));
1396 EXPECT_TRUE(llvm::is_contained(Features, "+sve2-bitperm"));
1397 EXPECT_TRUE(llvm::is_contained(Features, "+sme"));
1398 EXPECT_TRUE(llvm::is_contained(Features, "+sme-f64"));
1399 EXPECT_TRUE(llvm::is_contained(Features, "+sme-i64"));
1400 }
1401
1402 TEST(TargetParserTest, AArch64ArchFeatures) {
1403 std::vector<StringRef> Features;
1404
1405 for (auto AK : AArch64::ArchKinds)
1406 EXPECT_TRUE((AK == AArch64::ArchKind::INVALID)
1407 ? !AArch64::getArchFeatures(AK, Features)
1408 : AArch64::getArchFeatures(AK, Features));
1409 }
1410
1411 TEST(TargetParserTest, AArch64ArchExtFeature) {
1412 const char *ArchExt[][4] = {{"crc", "nocrc", "+crc", "-crc"},
1413 {"crypto", "nocrypto", "+crypto", "-crypto"},
1414 {"flagm", "noflagm", "+flagm", "-flagm"},
1415 {"fp", "nofp", "+fp-armv8", "-fp-armv8"},
1416 {"simd", "nosimd", "+neon", "-neon"},
1417 {"fp16", "nofp16", "+fullfp16", "-fullfp16"},
1418 {"fp16fml", "nofp16fml", "+fp16fml", "-fp16fml"},
1419 {"profile", "noprofile", "+spe", "-spe"},
1420 {"ras", "noras", "+ras", "-ras"},
1421 {"lse", "nolse", "+lse", "-lse"},
1422 {"rdm", "nordm", "+rdm", "-rdm"},
1423 {"sve", "nosve", "+sve", "-sve"},
1424 {"sve2", "nosve2", "+sve2", "-sve2"},
1425 {"sve2-aes", "nosve2-aes", "+sve2-aes",
1426 "-sve2-aes"},
1427 {"sve2-sm4", "nosve2-sm4", "+sve2-sm4",
1428 "-sve2-sm4"},
1429 {"sve2-sha3", "nosve2-sha3", "+sve2-sha3",
1430 "-sve2-sha3"},
1431 {"sve2-bitperm", "nosve2-bitperm",
1432 "+sve2-bitperm", "-sve2-bitperm"},
1433 {"dotprod", "nodotprod", "+dotprod", "-dotprod"},
1434 {"rcpc", "norcpc", "+rcpc", "-rcpc" },
1435 {"rng", "norng", "+rand", "-rand"},
1436 {"memtag", "nomemtag", "+mte", "-mte"},
1437 {"tme", "notme", "+tme", "-tme"},
1438 {"pauth", "nopauth", "+pauth", "-pauth"},
1439 {"ssbs", "nossbs", "+ssbs", "-ssbs"},
1440 {"sb", "nosb", "+sb", "-sb"},
1441 {"predres", "nopredres", "+predres", "-predres"},
1442 {"i8mm", "noi8mm", "+i8mm", "-i8mm"},
1443 {"f32mm", "nof32mm", "+f32mm", "-f32mm"},
1444 {"f64mm", "nof64mm", "+f64mm", "-f64mm"},
1445 {"sme", "nosme", "+sme", "-sme"},
1446 {"sme-f64", "nosme-f64", "+sme-f64", "-sme-f64"},
1447 {"sme-i64", "nosme-i64", "+sme-i64", "-sme-i64"},
1448 };
1449
1450 for (unsigned i = 0; i < array_lengthof(ArchExt); i++) {
1451 EXPECT_EQ(StringRef(ArchExt[i][2]),
1452 AArch64::getArchExtFeature(ArchExt[i][0]));
1453 EXPECT_EQ(StringRef(ArchExt[i][3]),
1454 AArch64::getArchExtFeature(ArchExt[i][1]));
1455 }
1456 }
1457
1458 } // namespace
LLVM monorepo