Gitiles
Code Review Sign In
gerrit-public.fairphone.software / toolchain / llvm-project / b1554311d3c38d10d064ccf11c6486a87a11ccce / . / llvm / unittests / Support / TargetParserTest.cpp
blob: a3d806f76fb514d84882328314dfc7949e9b3f95 [file] [log] [blame]
Saleem Abdulrasool11bf1ac2016-03-06 04:50:55 +0000[diff] [blame]1//===----------- TargetParser.cpp - Target Parser -------------------------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
Zijiao Mae56a53a2016-07-28 06:11:18 +0000[diff] [blame]10#include "llvm/ADT/STLExtras.h"
11#include "llvm/Support/ARMBuildAttributes.h"
Saleem Abdulrasool11bf1ac2016-03-06 04:50:55 +0000[diff] [blame]12#include "llvm/Support/TargetParser.h"
Zijiao Mae56a53a2016-07-28 06:11:18 +0000[diff] [blame]13#include "gtest/gtest.h"
14#include <string>
Saleem Abdulrasool11bf1ac2016-03-06 04:50:55 +0000[diff] [blame]15
16using namespace llvm;
17
18namespace {
Zijiao Mae56a53a2016-07-28 06:11:18 +0000[diff] [blame]19const char *ARMArch[] = {
Zijiao Ma639f84b2016-12-06 02:22:08 +0000[diff] [blame]20 "armv2", "armv2a", "armv3", "armv3m", "armv4",
21 "armv4t", "armv5", "armv5t", "armv5e", "armv5te",
22 "armv5tej", "armv6", "armv6j", "armv6k", "armv6hl",
23 "armv6t2", "armv6kz", "armv6z", "armv6zk", "armv6-m",
24 "armv6m", "armv6sm", "armv6s-m", "armv7-a", "armv7",
25 "armv7a", "armv7hl", "armv7l", "armv7-r", "armv7r",
26 "armv7-m", "armv7m", "armv7k", "armv7s", "armv7e-m",
27 "armv7em", "armv8-a", "armv8", "armv8a", "armv8.1-a",
28 "armv8.1a", "armv8.2-a", "armv8.2a", "armv8-r", "armv8r",
29 "armv8-m.base", "armv8m.base", "armv8-m.main", "armv8m.main", "iwmmxt",
30 "iwmmxt2", "xscale"};
Saleem Abdulrasool1ef925f2016-06-08 14:30:00 +0000[diff] [blame]31
Zijiao Ma639f84b2016-12-06 02:22:08 +0000[diff] [blame]32bool testARMCPU(StringRef CPUName, StringRef ExpectedArch,
33 StringRef ExpectedFPU, unsigned ExpectedFlags,
34 StringRef CPUAttr) {
35 unsigned ArchKind = ARM::parseCPUArch(CPUName);
36 bool pass = ARM::getArchName(ArchKind).equals(ExpectedArch);
37 unsigned FPUKind = ARM::getDefaultFPU(CPUName, ArchKind);
38 pass &= ARM::getFPUName(FPUKind).equals(ExpectedFPU);
39
40 unsigned ExtKind = ARM::getDefaultExtensions(CPUName, ArchKind);
41 if (ExtKind > 1 && (ExtKind & ARM::AEK_NONE))
42 pass &= ((ExtKind ^ ARM::AEK_NONE) == ExpectedFlags);
43 else
44 pass &= (ExtKind == ExpectedFlags);
45
46 pass &= ARM::getCPUAttr(ArchKind).equals(CPUAttr);
47
48 return pass;
Saleem Abdulrasool1ef925f2016-06-08 14:30:00 +0000[diff] [blame]49}
50
Zijiao Ma639f84b2016-12-06 02:22:08 +0000[diff] [blame]51TEST(TargetParserTest, testARMCPU) {
52 EXPECT_TRUE(testARMCPU("invalid", "invalid", "invalid",
53 ARM::AEK_NONE, ""));
54 EXPECT_TRUE(testARMCPU("generic", "invalid", "none",
55 ARM::AEK_NONE, ""));
56
57 EXPECT_TRUE(testARMCPU("arm2", "armv2", "none",
58 ARM::AEK_NONE, "2"));
59 EXPECT_TRUE(testARMCPU("arm3", "armv2a", "none",
60 ARM::AEK_NONE, "2A"));
61 EXPECT_TRUE(testARMCPU("arm6", "armv3", "none",
62 ARM::AEK_NONE, "3"));
63 EXPECT_TRUE(testARMCPU("arm7m", "armv3m", "none",
64 ARM::AEK_NONE, "3M"));
65 EXPECT_TRUE(testARMCPU("arm8", "armv4", "none",
66 ARM::AEK_NONE, "4"));
67 EXPECT_TRUE(testARMCPU("arm810", "armv4", "none",
68 ARM::AEK_NONE, "4"));
69 EXPECT_TRUE(testARMCPU("strongarm", "armv4", "none",
70 ARM::AEK_NONE, "4"));
71 EXPECT_TRUE(testARMCPU("strongarm110", "armv4", "none",
72 ARM::AEK_NONE, "4"));
73 EXPECT_TRUE(testARMCPU("strongarm1100", "armv4", "none",
74 ARM::AEK_NONE, "4"));
75 EXPECT_TRUE(testARMCPU("strongarm1110", "armv4", "none",
76 ARM::AEK_NONE, "4"));
77 EXPECT_TRUE(testARMCPU("arm7tdmi", "armv4t", "none",
78 ARM::AEK_NONE, "4T"));
79 EXPECT_TRUE(testARMCPU("arm7tdmi-s", "armv4t", "none",
80 ARM::AEK_NONE, "4T"));
81 EXPECT_TRUE(testARMCPU("arm710t", "armv4t", "none",
82 ARM::AEK_NONE, "4T"));
83 EXPECT_TRUE(testARMCPU("arm720t", "armv4t", "none",
84 ARM::AEK_NONE, "4T"));
85 EXPECT_TRUE(testARMCPU("arm9", "armv4t", "none",
86 ARM::AEK_NONE, "4T"));
87 EXPECT_TRUE(testARMCPU("arm9tdmi", "armv4t", "none",
88 ARM::AEK_NONE, "4T"));
89 EXPECT_TRUE(testARMCPU("arm920", "armv4t", "none",
90 ARM::AEK_NONE, "4T"));
91 EXPECT_TRUE(testARMCPU("arm920t", "armv4t", "none",
92 ARM::AEK_NONE, "4T"));
93 EXPECT_TRUE(testARMCPU("arm922t", "armv4t", "none",
94 ARM::AEK_NONE, "4T"));
95 EXPECT_TRUE(testARMCPU("arm9312", "armv4t", "none",
96 ARM::AEK_NONE, "4T"));
97 EXPECT_TRUE(testARMCPU("arm940t", "armv4t", "none",
98 ARM::AEK_NONE, "4T"));
99 EXPECT_TRUE(testARMCPU("ep9312", "armv4t", "none",
100 ARM::AEK_NONE, "4T"));
101 EXPECT_TRUE(testARMCPU("arm10tdmi", "armv5t", "none",
102 ARM::AEK_NONE, "5T"));
103 EXPECT_TRUE(testARMCPU("arm1020t", "armv5t", "none",
104 ARM::AEK_NONE, "5T"));
105 EXPECT_TRUE(testARMCPU("arm9e", "armv5te", "none",
106 ARM::AEK_DSP, "5TE"));
107 EXPECT_TRUE(testARMCPU("arm946e-s", "armv5te", "none",
108 ARM::AEK_DSP, "5TE"));
109 EXPECT_TRUE(testARMCPU("arm966e-s", "armv5te", "none",
110 ARM::AEK_DSP, "5TE"));
111 EXPECT_TRUE(testARMCPU("arm968e-s", "armv5te", "none",
112 ARM::AEK_DSP, "5TE"));
113 EXPECT_TRUE(testARMCPU("arm10e", "armv5te", "none",
114 ARM::AEK_DSP, "5TE"));
115 EXPECT_TRUE(testARMCPU("arm1020e", "armv5te", "none",
116 ARM::AEK_DSP, "5TE"));
117 EXPECT_TRUE(testARMCPU("arm1022e", "armv5te", "none",
118 ARM::AEK_DSP, "5TE"));
119 EXPECT_TRUE(testARMCPU("arm926ej-s", "armv5tej", "none",
120 ARM::AEK_DSP, "5TEJ"));
121 EXPECT_TRUE(testARMCPU("arm1136j-s", "armv6", "none",
122 ARM::AEK_DSP, "6"));
123 EXPECT_TRUE(testARMCPU("arm1136jf-s", "armv6", "vfpv2",
124 ARM::AEK_DSP, "6"));
125 EXPECT_TRUE(testARMCPU("arm1136jz-s", "armv6", "none",
126 ARM::AEK_DSP, "6"));
127 EXPECT_TRUE(testARMCPU("arm1176j-s", "armv6k", "none",
128 ARM::AEK_DSP, "6K"));
129 EXPECT_TRUE(testARMCPU("arm1176jz-s", "armv6kz", "none",
130 ARM::AEK_SEC | ARM::AEK_DSP, "6KZ"));
131 EXPECT_TRUE(testARMCPU("mpcore", "armv6k", "vfpv2",
132 ARM::AEK_DSP, "6K"));
133 EXPECT_TRUE(testARMCPU("mpcorenovfp", "armv6k", "none",
134 ARM::AEK_DSP, "6K"));
135 EXPECT_TRUE(testARMCPU("arm1176jzf-s", "armv6kz", "vfpv2",
136 ARM::AEK_SEC | ARM::AEK_DSP, "6KZ"));
137 EXPECT_TRUE(testARMCPU("arm1156t2-s", "armv6t2", "none",
138 ARM::AEK_DSP, "6T2"));
139 EXPECT_TRUE(testARMCPU("arm1156t2f-s", "armv6t2", "vfpv2",
140 ARM::AEK_DSP, "6T2"));
141 EXPECT_TRUE(testARMCPU("cortex-m0", "armv6-m", "none",
142 ARM::AEK_NONE, "6-M"));
143 EXPECT_TRUE(testARMCPU("cortex-m0plus", "armv6-m", "none",
144 ARM::AEK_NONE, "6-M"));
145 EXPECT_TRUE(testARMCPU("cortex-m1", "armv6-m", "none",
146 ARM::AEK_NONE, "6-M"));
147 EXPECT_TRUE(testARMCPU("sc000", "armv6-m", "none",
148 ARM::AEK_NONE, "6-M"));
149 EXPECT_TRUE(testARMCPU("cortex-a5", "armv7-a", "neon-vfpv4",
150 ARM::AEK_MP | ARM::AEK_SEC | ARM::AEK_DSP, "7-A"));
151 EXPECT_TRUE(testARMCPU("cortex-a7", "armv7-a", "neon-vfpv4",
152 ARM::AEK_HWDIV | ARM::AEK_HWDIVARM | ARM::AEK_MP |
153 ARM::AEK_SEC | ARM::AEK_VIRT | ARM::AEK_DSP,
154 "7-A"));
155 EXPECT_TRUE(testARMCPU("cortex-a8", "armv7-a", "neon",
156 ARM::AEK_SEC | ARM::AEK_DSP, "7-A"));
157 EXPECT_TRUE(testARMCPU("cortex-a9", "armv7-a", "neon-fp16",
158 ARM::AEK_MP | ARM::AEK_SEC | ARM::AEK_DSP, "7-A"));
159 EXPECT_TRUE(testARMCPU("cortex-a12", "armv7-a", "neon-vfpv4",
160 ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_VIRT |
161 ARM::AEK_HWDIVARM | ARM::AEK_HWDIV | ARM::AEK_DSP,
162 "7-A"));
163 EXPECT_TRUE(testARMCPU("cortex-a15", "armv7-a", "neon-vfpv4",
164 ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_VIRT |
165 ARM::AEK_HWDIVARM | ARM::AEK_HWDIV | ARM::AEK_DSP,
166 "7-A"));
167 EXPECT_TRUE(testARMCPU("cortex-a17", "armv7-a", "neon-vfpv4",
168 ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_VIRT |
169 ARM::AEK_HWDIVARM | ARM::AEK_HWDIV | ARM::AEK_DSP,
170 "7-A"));
171 EXPECT_TRUE(testARMCPU("krait", "armv7-a", "neon-vfpv4",
172 ARM::AEK_HWDIVARM | ARM::AEK_HWDIV | ARM::AEK_DSP,
173 "7-A"));
174 EXPECT_TRUE(testARMCPU("cortex-r4", "armv7-r", "none",
175 ARM::AEK_HWDIV | ARM::AEK_DSP, "7-R"));
176 EXPECT_TRUE(testARMCPU("cortex-r4f", "armv7-r", "vfpv3-d16",
177 ARM::AEK_HWDIV | ARM::AEK_DSP, "7-R"));
178 EXPECT_TRUE(testARMCPU("cortex-r5", "armv7-r", "vfpv3-d16",
179 ARM::AEK_MP | ARM::AEK_HWDIVARM | ARM::AEK_HWDIV |
180 ARM::AEK_DSP, "7-R"));
181 EXPECT_TRUE(testARMCPU("cortex-r7", "armv7-r", "vfpv3-d16-fp16",
182 ARM::AEK_MP | ARM::AEK_HWDIVARM | ARM::AEK_HWDIV |
183 ARM::AEK_DSP, "7-R"));
184 EXPECT_TRUE(testARMCPU("cortex-r8", "armv7-r", "vfpv3-d16-fp16",
185 ARM::AEK_MP | ARM::AEK_HWDIVARM | ARM::AEK_HWDIV |
186 ARM::AEK_DSP, "7-R"));
187 EXPECT_TRUE(testARMCPU("cortex-r52", "armv8-r", "neon-fp-armv8",
188 ARM::AEK_CRC | ARM::AEK_MP | ARM::AEK_VIRT |
189 ARM::AEK_HWDIVARM | ARM::AEK_HWDIV | ARM::AEK_DSP,
190 "8-R"));
191 EXPECT_TRUE(testARMCPU("sc300", "armv7-m", "none",
192 ARM::AEK_HWDIV, "7-M"));
193 EXPECT_TRUE(testARMCPU("cortex-m3", "armv7-m", "none",
194 ARM::AEK_HWDIV, "7-M"));
195 EXPECT_TRUE(testARMCPU("cortex-m4", "armv7e-m", "fpv4-sp-d16",
196 ARM::AEK_HWDIV | ARM::AEK_DSP, "7E-M"));
197 EXPECT_TRUE(testARMCPU("cortex-m7", "armv7e-m", "fpv5-d16",
198 ARM::AEK_HWDIV | ARM::AEK_DSP, "7E-M"));
199 EXPECT_TRUE(testARMCPU("cortex-a32", "armv8-a", "crypto-neon-fp-armv8",
200 ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
201 ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
202 ARM::AEK_HWDIV | ARM::AEK_DSP,
203 "8-A"));
204 EXPECT_TRUE(testARMCPU("cortex-a35", "armv8-a", "crypto-neon-fp-armv8",
205 ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
206 ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
207 ARM::AEK_HWDIV | ARM::AEK_DSP,
208 "8-A"));
209 EXPECT_TRUE(testARMCPU("cortex-a53", "armv8-a", "crypto-neon-fp-armv8",
210 ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
211 ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
212 ARM::AEK_HWDIV | ARM::AEK_DSP,
213 "8-A"));
214 EXPECT_TRUE(testARMCPU("cortex-a57", "armv8-a", "crypto-neon-fp-armv8",
215 ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
216 ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
217 ARM::AEK_HWDIV | ARM::AEK_DSP,
218 "8-A"));
219 EXPECT_TRUE(testARMCPU("cortex-a72", "armv8-a", "crypto-neon-fp-armv8",
220 ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
221 ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
222 ARM::AEK_HWDIV | ARM::AEK_DSP,
223 "8-A"));
224 EXPECT_TRUE(testARMCPU("cortex-a73", "armv8-a", "crypto-neon-fp-armv8",
225 ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
226 ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
227 ARM::AEK_HWDIV | ARM::AEK_DSP,
228 "8-A"));
229 EXPECT_TRUE(testARMCPU("cyclone", "armv8-a", "crypto-neon-fp-armv8",
230 ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
231 ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
232 ARM::AEK_HWDIV | ARM::AEK_DSP,
233 "8-A"));
234 EXPECT_TRUE(testARMCPU("exynos-m1", "armv8-a", "crypto-neon-fp-armv8",
235 ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
236 ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
237 ARM::AEK_HWDIV | ARM::AEK_DSP,
238 "8-A"));
239 EXPECT_TRUE(testARMCPU("exynos-m2", "armv8-a", "crypto-neon-fp-armv8",
240 ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
241 ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
242 ARM::AEK_HWDIV | ARM::AEK_DSP,
243 "8-A"));
Evandro Menezesaeec7802016-12-13 23:31:41 +0000[diff] [blame]244 EXPECT_TRUE(testARMCPU("exynos-m3", "armv8-a", "crypto-neon-fp-armv8",
245 ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
246 ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
247 ARM::AEK_HWDIV | ARM::AEK_DSP,
248 "8-A"));
Zijiao Ma639f84b2016-12-06 02:22:08 +0000[diff] [blame]249 EXPECT_TRUE(testARMCPU("iwmmxt", "iwmmxt", "none",
250 ARM::AEK_NONE, "iwmmxt"));
251 EXPECT_TRUE(testARMCPU("xscale", "xscale", "none",
252 ARM::AEK_NONE, "xscale"));
253 EXPECT_TRUE(testARMCPU("swift", "armv7s", "neon-vfpv4",
254 ARM::AEK_HWDIVARM | ARM::AEK_HWDIV | ARM::AEK_DSP,
255 "7-S"));
Zachary Turner67cb90b2016-08-05 16:45:07 +0000[diff] [blame]256}
257
Zijiao Ma639f84b2016-12-06 02:22:08 +0000[diff] [blame]258bool testARMArch(StringRef Arch, StringRef DefaultCPU, StringRef SubArch,
259 unsigned ArchAttr) {
260 unsigned ArchKind = ARM::parseArch(Arch);
261 return (ArchKind != ARM::AK_INVALID) &
262 ARM::getDefaultCPU(Arch).equals(DefaultCPU) &
263 ARM::getSubArch(ArchKind).equals(SubArch) &
264 (ARM::getArchAttr(ArchKind) == ArchAttr);
Saleem Abdulrasool11bf1ac2016-03-06 04:50:55 +0000[diff] [blame]265}
266
Zijiao Ma639f84b2016-12-06 02:22:08 +0000[diff] [blame]267TEST(TargetParserTest, testARMArch) {
268 EXPECT_TRUE(
269 testARMArch("armv2", "arm2", "v2",
270 ARMBuildAttrs::CPUArch::Pre_v4));
271 EXPECT_TRUE(
272 testARMArch("armv2a", "arm3", "v2a",
273 ARMBuildAttrs::CPUArch::Pre_v4));
274 EXPECT_TRUE(
275 testARMArch("armv3", "arm6", "v3",
276 ARMBuildAttrs::CPUArch::Pre_v4));
277 EXPECT_TRUE(
278 testARMArch("armv3m", "arm7m", "v3m",
279 ARMBuildAttrs::CPUArch::Pre_v4));
280 EXPECT_TRUE(
281 testARMArch("armv4", "strongarm", "v4",
282 ARMBuildAttrs::CPUArch::v4));
283 EXPECT_TRUE(
284 testARMArch("armv4t", "arm7tdmi", "v4t",
285 ARMBuildAttrs::CPUArch::v4T));
286 EXPECT_TRUE(
287 testARMArch("armv5t", "arm10tdmi", "v5",
288 ARMBuildAttrs::CPUArch::v5T));
289 EXPECT_TRUE(
290 testARMArch("armv5te", "arm1022e", "v5e",
291 ARMBuildAttrs::CPUArch::v5TE));
292 EXPECT_TRUE(
293 testARMArch("armv5tej", "arm926ej-s", "v5e",
294 ARMBuildAttrs::CPUArch::v5TEJ));
295 EXPECT_TRUE(
296 testARMArch("armv6", "arm1136jf-s", "v6",
297 ARMBuildAttrs::CPUArch::v6));
298 EXPECT_TRUE(
299 testARMArch("armv6k", "arm1176j-s", "v6k",
300 ARMBuildAttrs::CPUArch::v6K));
301 EXPECT_TRUE(
302 testARMArch("armv6t2", "arm1156t2-s", "v6t2",
303 ARMBuildAttrs::CPUArch::v6T2));
304 EXPECT_TRUE(
305 testARMArch("armv6kz", "arm1176jzf-s", "v6kz",
306 ARMBuildAttrs::CPUArch::v6KZ));
307 EXPECT_TRUE(
308 testARMArch("armv6-m", "cortex-m0", "v6m",
309 ARMBuildAttrs::CPUArch::v6_M));
310 EXPECT_TRUE(
311 testARMArch("armv7-a", "cortex-a8", "v7",
312 ARMBuildAttrs::CPUArch::v7));
313 EXPECT_TRUE(
314 testARMArch("armv7-r", "cortex-r4", "v7r",
315 ARMBuildAttrs::CPUArch::v7));
316 EXPECT_TRUE(
317 testARMArch("armv7-m", "cortex-m3", "v7m",
318 ARMBuildAttrs::CPUArch::v7));
319 EXPECT_TRUE(
320 testARMArch("armv7e-m", "cortex-m4", "v7em",
321 ARMBuildAttrs::CPUArch::v7E_M));
322 EXPECT_TRUE(
323 testARMArch("armv8-a", "cortex-a53", "v8",
324 ARMBuildAttrs::CPUArch::v8_A));
325 EXPECT_TRUE(
326 testARMArch("armv8.1-a", "generic", "v8.1a",
327 ARMBuildAttrs::CPUArch::v8_A));
328 EXPECT_TRUE(
329 testARMArch("armv8.2-a", "generic", "v8.2a",
330 ARMBuildAttrs::CPUArch::v8_A));
331 EXPECT_TRUE(
332 testARMArch("armv8-r", "cortex-r52", "v8r",
333 ARMBuildAttrs::CPUArch::v8_R));
334 EXPECT_TRUE(
335 testARMArch("armv8-m.base", "generic", "v8m.base",
336 ARMBuildAttrs::CPUArch::v8_M_Base));
337 EXPECT_TRUE(
338 testARMArch("armv8-m.main", "generic", "v8m.main",
339 ARMBuildAttrs::CPUArch::v8_M_Main));
340 EXPECT_TRUE(
341 testARMArch("iwmmxt", "iwmmxt", "",
342 ARMBuildAttrs::CPUArch::v5TE));
343 EXPECT_TRUE(
344 testARMArch("iwmmxt2", "generic", "",
345 ARMBuildAttrs::CPUArch::v5TE));
346 EXPECT_TRUE(
347 testARMArch("xscale", "xscale", "v5e",
348 ARMBuildAttrs::CPUArch::v5TE));
349 EXPECT_TRUE(
350 testARMArch("armv7s", "swift", "v7s",
351 ARMBuildAttrs::CPUArch::v7));
352 EXPECT_TRUE(
353 testARMArch("armv7k", "generic", "v7k",
354 ARMBuildAttrs::CPUArch::v7));
Saleem Abdulrasool11bf1ac2016-03-06 04:50:55 +0000[diff] [blame]355}
356
Zijiao Ma639f84b2016-12-06 02:22:08 +0000[diff] [blame]357bool testARMExtension(StringRef CPUName, unsigned ArchKind, StringRef ArchExt) {
358 return ARM::getDefaultExtensions(CPUName, ArchKind) &
359 ARM::parseArchExt(ArchExt);
Saleem Abdulrasool11bf1ac2016-03-06 04:50:55 +0000[diff] [blame]360}
361
Zijiao Ma639f84b2016-12-06 02:22:08 +0000[diff] [blame]362TEST(TargetParserTest, testARMExtension) {
363 EXPECT_FALSE(testARMExtension("arm2", 0, "thumb"));
364 EXPECT_FALSE(testARMExtension("arm3", 0, "thumb"));
365 EXPECT_FALSE(testARMExtension("arm6", 0, "thumb"));
366 EXPECT_FALSE(testARMExtension("arm7m", 0, "thumb"));
367 EXPECT_FALSE(testARMExtension("strongarm", 0, "dsp"));
368 EXPECT_FALSE(testARMExtension("arm7tdmi", 0, "dsp"));
369 EXPECT_FALSE(testARMExtension("arm10tdmi", 0, "simd"));
370 EXPECT_FALSE(testARMExtension("arm1022e", 0, "simd"));
371 EXPECT_FALSE(testARMExtension("arm926ej-s", 0, "simd"));
372 EXPECT_FALSE(testARMExtension("arm1136jf-s", 0, "crypto"));
373 EXPECT_FALSE(testARMExtension("arm1176j-s", 0, "crypto"));
374 EXPECT_FALSE(testARMExtension("arm1156t2-s", 0, "crypto"));
375 EXPECT_FALSE(testARMExtension("arm1176jzf-s", 0, "crypto"));
376 EXPECT_FALSE(testARMExtension("cortex-m0", 0, "crypto"));
377 EXPECT_FALSE(testARMExtension("cortex-a8", 0, "crypto"));
378 EXPECT_FALSE(testARMExtension("cortex-r4", 0, "crypto"));
379 EXPECT_FALSE(testARMExtension("cortex-m3", 0, "crypto"));
380 EXPECT_FALSE(testARMExtension("cortex-a53", 0, "ras"));
381 EXPECT_FALSE(testARMExtension("cortex-r52", 0, "ras"));
382 EXPECT_FALSE(testARMExtension("iwmmxt", 0, "crc"));
383 EXPECT_FALSE(testARMExtension("xscale", 0, "crc"));
384 EXPECT_FALSE(testARMExtension("swift", 0, "crc"));
385
386 EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV2, "thumb"));
387 EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV2A, "thumb"));
388 EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV3, "thumb"));
389 EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV3M, "thumb"));
390 EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV4, "dsp"));
391 EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV4T, "dsp"));
392 EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV5T, "simd"));
393 EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV5TE, "simd"));
394 EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV5TEJ, "simd"));
395 EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV6, "crypto"));
396 EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV6K, "crypto"));
397 EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV6T2, "crypto"));
398 EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV6KZ, "crypto"));
399 EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV6M, "crypto"));
400 EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV7A, "crypto"));
401 EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV7R, "crypto"));
402 EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV7M, "crypto"));
403 EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV7EM, "crypto"));
404 EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV8A, "ras"));
405 EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV8_1A, "ras"));
406 EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV8_2A, "spe"));
407 EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV8R, "ras"));
408 EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV8MBaseline, "crc"));
409 EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV8MMainline, "crc"));
410 EXPECT_FALSE(testARMExtension("generic", ARM::AK_IWMMXT, "crc"));
411 EXPECT_FALSE(testARMExtension("generic", ARM::AK_IWMMXT2, "crc"));
412 EXPECT_FALSE(testARMExtension("generic", ARM::AK_XSCALE, "crc"));
413 EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV7S, "crypto"));
414 EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV7K, "crypto"));
Saleem Abdulrasool11bf1ac2016-03-06 04:50:55 +0000[diff] [blame]415}
Saleem Abdulrasool1ef925f2016-06-08 14:30:00 +0000[diff] [blame]416
Zijiao Mae56a53a2016-07-28 06:11:18 +0000[diff] [blame]417TEST(TargetParserTest, ARMFPUVersion) {
418 for (ARM::FPUKind FK = static_cast<ARM::FPUKind>(0);
419 FK <= ARM::FPUKind::FK_LAST;
420 FK = static_cast<ARM::FPUKind>(static_cast<unsigned>(FK) + 1))
421 if (FK == ARM::FK_LAST)
Simon Pilgrim3080dbc2016-07-28 13:29:56 +0000[diff] [blame]422 EXPECT_EQ(0U, ARM::getFPUVersion(FK));
Zijiao Mae56a53a2016-07-28 06:11:18 +0000[diff] [blame]423 else
Simon Pilgrim3080dbc2016-07-28 13:29:56 +0000[diff] [blame]424 EXPECT_LE(0U, ARM::getFPUVersion(FK));
Zijiao Mae56a53a2016-07-28 06:11:18 +0000[diff] [blame]425}
426
427TEST(TargetParserTest, ARMFPUNeonSupportLevel) {
428 for (ARM::FPUKind FK = static_cast<ARM::FPUKind>(0);
429 FK <= ARM::FPUKind::FK_LAST;
430 FK = static_cast<ARM::FPUKind>(static_cast<unsigned>(FK) + 1))
431 if (FK == ARM::FK_LAST)
Simon Pilgrim3080dbc2016-07-28 13:29:56 +0000[diff] [blame]432 EXPECT_EQ(0U, ARM::getFPUNeonSupportLevel(FK));
Zijiao Mae56a53a2016-07-28 06:11:18 +0000[diff] [blame]433 else
Simon Pilgrim3080dbc2016-07-28 13:29:56 +0000[diff] [blame]434 EXPECT_LE(0U, ARM::getFPUNeonSupportLevel(FK));
Zijiao Mae56a53a2016-07-28 06:11:18 +0000[diff] [blame]435}
436
437TEST(TargetParserTest, ARMFPURestriction) {
438 for (ARM::FPUKind FK = static_cast<ARM::FPUKind>(0);
439 FK <= ARM::FPUKind::FK_LAST;
440 FK = static_cast<ARM::FPUKind>(static_cast<unsigned>(FK) + 1))
441 if (FK == ARM::FK_LAST)
Simon Pilgrim3080dbc2016-07-28 13:29:56 +0000[diff] [blame]442 EXPECT_EQ(0U, ARM::getFPURestriction(FK));
Zijiao Mae56a53a2016-07-28 06:11:18 +0000[diff] [blame]443 else
Simon Pilgrim3080dbc2016-07-28 13:29:56 +0000[diff] [blame]444 EXPECT_LE(0U, ARM::getFPURestriction(FK));
Zijiao Mae56a53a2016-07-28 06:11:18 +0000[diff] [blame]445}
446
Zijiao Mae56a53a2016-07-28 06:11:18 +0000[diff] [blame]447TEST(TargetParserTest, ARMExtensionFeatures) {
Mehdi Aminia0016ec2016-10-07 08:37:29 +0000[diff] [blame]448 std::vector<StringRef> Features;
Zijiao Mae56a53a2016-07-28 06:11:18 +0000[diff] [blame]449 unsigned Extensions = ARM::AEK_CRC | ARM::AEK_CRYPTO | ARM::AEK_DSP |
450 ARM::AEK_HWDIVARM | ARM::AEK_HWDIV | ARM::AEK_MP |
451 ARM::AEK_SEC | ARM::AEK_VIRT | ARM::AEK_RAS;
452
453 for (unsigned i = 0; i <= Extensions; i++)
454 EXPECT_TRUE(i == 0 ? !ARM::getExtensionFeatures(i, Features)
455 : ARM::getExtensionFeatures(i, Features));
456}
457
458TEST(TargetParserTest, ARMFPUFeatures) {
Mehdi Aminia0016ec2016-10-07 08:37:29 +0000[diff] [blame]459 std::vector<StringRef> Features;
Zijiao Mae56a53a2016-07-28 06:11:18 +0000[diff] [blame]460 for (ARM::FPUKind FK = static_cast<ARM::FPUKind>(0);
461 FK <= ARM::FPUKind::FK_LAST;
462 FK = static_cast<ARM::FPUKind>(static_cast<unsigned>(FK) + 1))
463 EXPECT_TRUE((FK == ARM::FK_INVALID || FK >= ARM::FK_LAST)
464 ? !ARM::getFPUFeatures(FK, Features)
465 : ARM::getFPUFeatures(FK, Features));
466}
467
Zijiao Mae56a53a2016-07-28 06:11:18 +0000[diff] [blame]468TEST(TargetParserTest, ARMArchExtFeature) {
469 const char *ArchExt[][4] = {{"crc", "nocrc", "+crc", "-crc"},
470 {"crypto", "nocrypto", "+crypto", "-crypto"},
471 {"dsp", "nodsp", "+dsp", "-dsp"},
472 {"fp", "nofp", nullptr, nullptr},
473 {"idiv", "noidiv", nullptr, nullptr},
474 {"mp", "nomp", nullptr, nullptr},
475 {"simd", "nosimd", nullptr, nullptr},
476 {"sec", "nosec", nullptr, nullptr},
477 {"virt", "novirt", nullptr, nullptr},
478 {"fp16", "nofp16", "+fullfp16", "-fullfp16"},
479 {"ras", "noras", "+ras", "-ras"},
480 {"os", "noos", nullptr, nullptr},
481 {"iwmmxt", "noiwmmxt", nullptr, nullptr},
482 {"iwmmxt2", "noiwmmxt2", nullptr, nullptr},
483 {"maverick", "maverick", nullptr, nullptr},
484 {"xscale", "noxscale", nullptr, nullptr}};
485
486 for (unsigned i = 0; i < array_lengthof(ArchExt); i++) {
Mehdi Aminia0016ec2016-10-07 08:37:29 +0000[diff] [blame]487 EXPECT_EQ(StringRef(ArchExt[i][2]), ARM::getArchExtFeature(ArchExt[i][0]));
488 EXPECT_EQ(StringRef(ArchExt[i][3]), ARM::getArchExtFeature(ArchExt[i][1]));
Zijiao Mae56a53a2016-07-28 06:11:18 +0000[diff] [blame]489 }
490}
491
Zijiao Mae56a53a2016-07-28 06:11:18 +0000[diff] [blame]492TEST(TargetParserTest, ARMparseHWDiv) {
493 const char *hwdiv[] = {"thumb", "arm", "arm,thumb", "thumb,arm"};
494
495 for (unsigned i = 0; i < array_lengthof(hwdiv); i++)
496 EXPECT_NE(ARM::AEK_INVALID, ARM::parseHWDiv((StringRef)hwdiv[i]));
497}
498
Zijiao Mae56a53a2016-07-28 06:11:18 +0000[diff] [blame]499TEST(TargetParserTest, ARMparseArchEndianAndISA) {
500 const char *Arch[] = {
501 "v2", "v2a", "v3", "v3m", "v4", "v4t", "v5", "v5t",
502 "v5e", "v5te", "v5tej", "v6", "v6j", "v6k", "v6hl", "v6t2",
503 "v6kz", "v6z", "v6zk", "v6-m", "v6m", "v6sm", "v6s-m", "v7-a",
504 "v7", "v7a", "v7hl", "v7l", "v7-r", "v7r", "v7-m", "v7m",
505 "v7k", "v7s", "v7e-m", "v7em", "v8-a", "v8", "v8a", "v8.1-a",
Javed Absarfb4b6e82016-10-07 12:06:40 +0000[diff] [blame]506 "v8.1a", "v8.2-a", "v8.2a", "v8-r"};
Zijiao Mae56a53a2016-07-28 06:11:18 +0000[diff] [blame]507
508 for (unsigned i = 0; i < array_lengthof(Arch); i++) {
509 std::string arm_1 = "armeb" + (std::string)(Arch[i]);
510 std::string arm_2 = "arm" + (std::string)(Arch[i]) + "eb";
511 std::string arm_3 = "arm" + (std::string)(Arch[i]);
512 std::string thumb_1 = "thumbeb" + (std::string)(Arch[i]);
513 std::string thumb_2 = "thumb" + (std::string)(Arch[i]) + "eb";
514 std::string thumb_3 = "thumb" + (std::string)(Arch[i]);
515
516 EXPECT_EQ(ARM::EK_BIG, ARM::parseArchEndian(arm_1));
517 EXPECT_EQ(ARM::EK_BIG, ARM::parseArchEndian(arm_2));
518 EXPECT_EQ(ARM::EK_LITTLE, ARM::parseArchEndian(arm_3));
519
520 EXPECT_EQ(ARM::IK_ARM, ARM::parseArchISA(arm_1));
521 EXPECT_EQ(ARM::IK_ARM, ARM::parseArchISA(arm_2));
522 EXPECT_EQ(ARM::IK_ARM, ARM::parseArchISA(arm_3));
523 if (i >= 4) {
524 EXPECT_EQ(ARM::EK_BIG, ARM::parseArchEndian(thumb_1));
525 EXPECT_EQ(ARM::EK_BIG, ARM::parseArchEndian(thumb_2));
526 EXPECT_EQ(ARM::EK_LITTLE, ARM::parseArchEndian(thumb_3));
527
528 EXPECT_EQ(ARM::IK_THUMB, ARM::parseArchISA(thumb_1));
529 EXPECT_EQ(ARM::IK_THUMB, ARM::parseArchISA(thumb_2));
530 EXPECT_EQ(ARM::IK_THUMB, ARM::parseArchISA(thumb_3));
531 }
532 }
533
534 EXPECT_EQ(ARM::EK_LITTLE, ARM::parseArchEndian("aarch64"));
535 EXPECT_EQ(ARM::EK_BIG, ARM::parseArchEndian("aarch64_be"));
536
537 EXPECT_EQ(ARM::IK_AARCH64, ARM::parseArchISA("aarch64"));
538 EXPECT_EQ(ARM::IK_AARCH64, ARM::parseArchISA("aarch64_be"));
539 EXPECT_EQ(ARM::IK_AARCH64, ARM::parseArchISA("arm64"));
540 EXPECT_EQ(ARM::IK_AARCH64, ARM::parseArchISA("arm64_be"));
541}
542
543TEST(TargetParserTest, ARMparseArchProfile) {
544 for (unsigned i = 0; i < array_lengthof(ARMArch); i++) {
545 switch (ARM::parseArch(ARMArch[i])) {
546 case ARM::AK_ARMV6M:
547 case ARM::AK_ARMV7M:
548 case ARM::AK_ARMV7EM:
549 case ARM::AK_ARMV8MMainline:
550 case ARM::AK_ARMV8MBaseline:
551 EXPECT_EQ(ARM::PK_M, ARM::parseArchProfile(ARMArch[i]));
552 continue;
553 case ARM::AK_ARMV7R:
Zijiao Ma639f84b2016-12-06 02:22:08 +0000[diff] [blame]554 case ARM::AK_ARMV8R:
Zijiao Mae56a53a2016-07-28 06:11:18 +0000[diff] [blame]555 EXPECT_EQ(ARM::PK_R, ARM::parseArchProfile(ARMArch[i]));
556 continue;
557 case ARM::AK_ARMV7A:
558 case ARM::AK_ARMV7K:
559 case ARM::AK_ARMV8A:
560 case ARM::AK_ARMV8_1A:
561 case ARM::AK_ARMV8_2A:
562 EXPECT_EQ(ARM::PK_A, ARM::parseArchProfile(ARMArch[i]));
563 continue;
564 }
565 EXPECT_EQ(ARM::PK_INVALID, ARM::parseArchProfile(ARMArch[i]));
566 }
567}
568
569TEST(TargetParserTest, ARMparseArchVersion) {
570 for (unsigned i = 0; i < array_lengthof(ARMArch); i++)
571 if (((std::string)ARMArch[i]).substr(0, 4) == "armv")
David Blaikiefd5a7f12016-07-28 21:42:12 +0000[diff] [blame]572 EXPECT_EQ((ARMArch[i][4] - 48u), ARM::parseArchVersion(ARMArch[i]));
Zijiao Mae56a53a2016-07-28 06:11:18 +0000[diff] [blame]573 else
David Blaikiefd5a7f12016-07-28 21:42:12 +0000[diff] [blame]574 EXPECT_EQ(5u, ARM::parseArchVersion(ARMArch[i]));
Zijiao Mae56a53a2016-07-28 06:11:18 +0000[diff] [blame]575}
576
Zijiao Ma639f84b2016-12-06 02:22:08 +0000[diff] [blame]577bool testAArch64CPU(StringRef CPUName, StringRef ExpectedArch,
578 StringRef ExpectedFPU, unsigned ExpectedFlags,
579 StringRef CPUAttr) {
580 unsigned ArchKind = AArch64::parseCPUArch(CPUName);
581 bool pass = AArch64::getArchName(ArchKind).equals(ExpectedArch);
582 unsigned FPUKind = AArch64::getDefaultFPU(CPUName, ArchKind);
583 pass &= AArch64::getFPUName(FPUKind).equals(ExpectedFPU);
Zijiao Mae56a53a2016-07-28 06:11:18 +0000[diff] [blame]584
Zijiao Ma639f84b2016-12-06 02:22:08 +0000[diff] [blame]585 unsigned ExtKind = AArch64::getDefaultExtensions(CPUName, ArchKind);
586 if (ExtKind > 1 && (ExtKind & AArch64::AEK_NONE))
587 pass &= ((ExtKind ^ AArch64::AEK_NONE) == ExpectedFlags);
588 else
589 pass &= (ExtKind == ExpectedFlags);
590
591 pass &= AArch64::getCPUAttr(ArchKind).equals(CPUAttr);
592
593 return pass;
Zijiao Mae56a53a2016-07-28 06:11:18 +0000[diff] [blame]594}
595
Zijiao Ma639f84b2016-12-06 02:22:08 +0000[diff] [blame]596TEST(TargetParserTest, testAArch64CPU) {
597 EXPECT_TRUE(testAArch64CPU(
598 "invalid", "invalid", "invalid",
599 AArch64::AEK_INVALID, ""));
600 EXPECT_TRUE(testAArch64CPU(
601 "generic", "invalid", "none",
602 AArch64::AEK_NONE, ""));
Zijiao Mae56a53a2016-07-28 06:11:18 +0000[diff] [blame]603
Zijiao Ma639f84b2016-12-06 02:22:08 +0000[diff] [blame]604 EXPECT_TRUE(testAArch64CPU(
605 "cortex-a35", "armv8-a", "crypto-neon-fp-armv8",
606 AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_SIMD, "8-A"));
607 EXPECT_TRUE(testAArch64CPU(
608 "cortex-a53", "armv8-a", "crypto-neon-fp-armv8",
609 AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_SIMD, "8-A"));
610 EXPECT_TRUE(testAArch64CPU(
611 "cortex-a57", "armv8-a", "crypto-neon-fp-armv8",
612 AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_SIMD, "8-A"));
613 EXPECT_TRUE(testAArch64CPU(
614 "cortex-a72", "armv8-a", "crypto-neon-fp-armv8",
615 AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_SIMD, "8-A"));
616 EXPECT_TRUE(testAArch64CPU(
617 "cortex-a73", "armv8-a", "crypto-neon-fp-armv8",
618 AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_SIMD, "8-A"));
619 EXPECT_TRUE(testAArch64CPU(
620 "cyclone", "armv8-a", "crypto-neon-fp-armv8",
621 AArch64::AEK_CRYPTO | AArch64::AEK_SIMD, "8-A"));
622 EXPECT_TRUE(testAArch64CPU(
623 "exynos-m1", "armv8-a", "crypto-neon-fp-armv8",
624 AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_SIMD, "8-A"));
625 EXPECT_TRUE(testAArch64CPU(
626 "exynos-m2", "armv8-a", "crypto-neon-fp-armv8",
627 AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_SIMD, "8-A"));
628 EXPECT_TRUE(testAArch64CPU(
Evandro Menezesaeec7802016-12-13 23:31:41 +0000[diff] [blame]629 "exynos-m3", "armv8-a", "crypto-neon-fp-armv8",
630 AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_SIMD, "8-A"));
631 EXPECT_TRUE(testAArch64CPU(
Zijiao Ma639f84b2016-12-06 02:22:08 +0000[diff] [blame]632 "falkor", "armv8-a", "crypto-neon-fp-armv8",
633 AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_SIMD, "8-A"));
634 EXPECT_TRUE(testAArch64CPU(
635 "kryo", "armv8-a", "crypto-neon-fp-armv8",
636 AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_SIMD, "8-A"));
637 EXPECT_TRUE(testAArch64CPU(
638 "vulcan", "armv8.1-a", "crypto-neon-fp-armv8",
639 AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_SIMD, "8.1-A"));
640}
641
642bool testAArch64Arch(StringRef Arch, StringRef DefaultCPU, StringRef SubArch,
643 unsigned ArchAttr) {
644 unsigned ArchKind = AArch64::parseArch(Arch);
645 return (ArchKind != static_cast<unsigned>(AArch64::ArchKind::AK_INVALID)) &
646 AArch64::getDefaultCPU(Arch).equals(DefaultCPU) &
647 AArch64::getSubArch(ArchKind).equals(SubArch) &
648 (AArch64::getArchAttr(ArchKind) == ArchAttr);
649}
650
651TEST(TargetParserTest, testAArch64Arch) {
652 EXPECT_TRUE(testAArch64Arch("armv8-a", "cortex-a53", "v8",
653 ARMBuildAttrs::CPUArch::v8_A));
654 EXPECT_TRUE(testAArch64Arch("armv8.1-a", "generic", "v8.1a",
655 ARMBuildAttrs::CPUArch::v8_A));
656 EXPECT_TRUE(testAArch64Arch("armv8.2-a", "generic", "v8.2a",
657 ARMBuildAttrs::CPUArch::v8_A));
658}
659
660bool testAArch64Extension(StringRef CPUName, unsigned ArchKind,
661 StringRef ArchExt) {
662 return AArch64::getDefaultExtensions(CPUName, ArchKind) &
663 AArch64::parseArchExt(ArchExt);
664}
665
666TEST(TargetParserTest, testAArch64Extension) {
667 EXPECT_FALSE(testAArch64Extension("cortex-a35", 0, "ras"));
668 EXPECT_FALSE(testAArch64Extension("cortex-a53", 0, "ras"));
669 EXPECT_FALSE(testAArch64Extension("cortex-a57", 0, "ras"));
670 EXPECT_FALSE(testAArch64Extension("cortex-a72", 0, "ras"));
671 EXPECT_FALSE(testAArch64Extension("cortex-a73", 0, "ras"));
672 EXPECT_FALSE(testAArch64Extension("cyclone", 0, "ras"));
673 EXPECT_FALSE(testAArch64Extension("exynos-m1", 0, "ras"));
674 EXPECT_FALSE(testAArch64Extension("kryo", 0, "ras"));
675 EXPECT_FALSE(testAArch64Extension("vulcan", 0, "ras"));
676
677 EXPECT_FALSE(testAArch64Extension(
678 "generic", static_cast<unsigned>(AArch64::ArchKind::AK_ARMV8A), "ras"));
679 EXPECT_FALSE(testAArch64Extension(
680 "generic", static_cast<unsigned>(AArch64::ArchKind::AK_ARMV8_1A), "ras"));
681 EXPECT_FALSE(testAArch64Extension(
682 "generic", static_cast<unsigned>(AArch64::ArchKind::AK_ARMV8_2A), "spe"));
Zijiao Mae56a53a2016-07-28 06:11:18 +0000[diff] [blame]683}
684
685TEST(TargetParserTest, AArch64ExtensionFeatures) {
Mehdi Aminia0016ec2016-10-07 08:37:29 +0000[diff] [blame]686 std::vector<StringRef> Features;
Zijiao Mae56a53a2016-07-28 06:11:18 +0000[diff] [blame]687 unsigned Extensions = AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
688 AArch64::AEK_FP | AArch64::AEK_SIMD |
689 AArch64::AEK_FP16 | AArch64::AEK_PROFILE |
690 AArch64::AEK_RAS;
691
692 for (unsigned i = 0; i <= Extensions; i++)
693 EXPECT_TRUE(i == 0 ? !AArch64::getExtensionFeatures(i, Features)
694 : AArch64::getExtensionFeatures(i, Features));
695}
696
697TEST(TargetParserTest, AArch64ArchFeatures) {
Mehdi Aminia0016ec2016-10-07 08:37:29 +0000[diff] [blame]698 std::vector<StringRef> Features;
Zijiao Mae56a53a2016-07-28 06:11:18 +0000[diff] [blame]699
700 for (unsigned AK = 0; AK < static_cast<unsigned>(AArch64::ArchKind::AK_LAST);
701 AK++)
702 EXPECT_TRUE((AK == static_cast<unsigned>(AArch64::ArchKind::AK_INVALID) ||
703 AK == static_cast<unsigned>(AArch64::ArchKind::AK_LAST))
704 ? !AArch64::getArchFeatures(AK, Features)
705 : AArch64::getArchFeatures(AK, Features));
706}
707
Zijiao Mae56a53a2016-07-28 06:11:18 +0000[diff] [blame]708TEST(TargetParserTest, AArch64ArchExtFeature) {
709 const char *ArchExt[][4] = {{"crc", "nocrc", "+crc", "-crc"},
710 {"crypto", "nocrypto", "+crypto", "-crypto"},
711 {"fp", "nofp", "+fp-armv8", "-fp-armv8"},
712 {"simd", "nosimd", "+neon", "-neon"},
713 {"fp16", "nofp16", "+fullfp16", "-fullfp16"},
714 {"profile", "noprofile", "+spe", "-spe"},
715 {"ras", "noras", "+ras", "-ras"}};
716
717 for (unsigned i = 0; i < array_lengthof(ArchExt); i++) {
Zijiao Ma639f84b2016-12-06 02:22:08 +0000[diff] [blame]718 EXPECT_EQ(StringRef(ArchExt[i][2]),
719 AArch64::getArchExtFeature(ArchExt[i][0]));
720 EXPECT_EQ(StringRef(ArchExt[i][3]),
721 AArch64::getArchExtFeature(ArchExt[i][1]));
Zijiao Mae56a53a2016-07-28 06:11:18 +0000[diff] [blame]722 }
723}
Zijiao Mae56a53a2016-07-28 06:11:18 +0000[diff] [blame]724}