Gitiles
Code Review Sign In
gerrit-public.fairphone.software / toolchain / llvm-project / 74c265e537fb5cca31edaaa3e4197f2bee1d3a60 / . / llvm / unittests / Support / TargetParserTest.cpp
blob: c84313a87472c81ac49b42cb0ea89ddc3571336c [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"));
244 EXPECT_TRUE(testARMCPU("iwmmxt", "iwmmxt", "none",
245 ARM::AEK_NONE, "iwmmxt"));
246 EXPECT_TRUE(testARMCPU("xscale", "xscale", "none",
247 ARM::AEK_NONE, "xscale"));
248 EXPECT_TRUE(testARMCPU("swift", "armv7s", "neon-vfpv4",
249 ARM::AEK_HWDIVARM | ARM::AEK_HWDIV | ARM::AEK_DSP,
250 "7-S"));
Zachary Turner67cb90b2016-08-05 16:45:07 +0000[diff] [blame]251}
252
Zijiao Ma639f84b2016-12-06 02:22:08 +0000[diff] [blame]253bool testARMArch(StringRef Arch, StringRef DefaultCPU, StringRef SubArch,
254 unsigned ArchAttr) {
255 unsigned ArchKind = ARM::parseArch(Arch);
256 return (ArchKind != ARM::AK_INVALID) &
257 ARM::getDefaultCPU(Arch).equals(DefaultCPU) &
258 ARM::getSubArch(ArchKind).equals(SubArch) &
259 (ARM::getArchAttr(ArchKind) == ArchAttr);
Saleem Abdulrasool11bf1ac2016-03-06 04:50:55 +0000[diff] [blame]260}
261
Zijiao Ma639f84b2016-12-06 02:22:08 +0000[diff] [blame]262TEST(TargetParserTest, testARMArch) {
263 EXPECT_TRUE(
264 testARMArch("armv2", "arm2", "v2",
265 ARMBuildAttrs::CPUArch::Pre_v4));
266 EXPECT_TRUE(
267 testARMArch("armv2a", "arm3", "v2a",
268 ARMBuildAttrs::CPUArch::Pre_v4));
269 EXPECT_TRUE(
270 testARMArch("armv3", "arm6", "v3",
271 ARMBuildAttrs::CPUArch::Pre_v4));
272 EXPECT_TRUE(
273 testARMArch("armv3m", "arm7m", "v3m",
274 ARMBuildAttrs::CPUArch::Pre_v4));
275 EXPECT_TRUE(
276 testARMArch("armv4", "strongarm", "v4",
277 ARMBuildAttrs::CPUArch::v4));
278 EXPECT_TRUE(
279 testARMArch("armv4t", "arm7tdmi", "v4t",
280 ARMBuildAttrs::CPUArch::v4T));
281 EXPECT_TRUE(
282 testARMArch("armv5t", "arm10tdmi", "v5",
283 ARMBuildAttrs::CPUArch::v5T));
284 EXPECT_TRUE(
285 testARMArch("armv5te", "arm1022e", "v5e",
286 ARMBuildAttrs::CPUArch::v5TE));
287 EXPECT_TRUE(
288 testARMArch("armv5tej", "arm926ej-s", "v5e",
289 ARMBuildAttrs::CPUArch::v5TEJ));
290 EXPECT_TRUE(
291 testARMArch("armv6", "arm1136jf-s", "v6",
292 ARMBuildAttrs::CPUArch::v6));
293 EXPECT_TRUE(
294 testARMArch("armv6k", "arm1176j-s", "v6k",
295 ARMBuildAttrs::CPUArch::v6K));
296 EXPECT_TRUE(
297 testARMArch("armv6t2", "arm1156t2-s", "v6t2",
298 ARMBuildAttrs::CPUArch::v6T2));
299 EXPECT_TRUE(
300 testARMArch("armv6kz", "arm1176jzf-s", "v6kz",
301 ARMBuildAttrs::CPUArch::v6KZ));
302 EXPECT_TRUE(
303 testARMArch("armv6-m", "cortex-m0", "v6m",
304 ARMBuildAttrs::CPUArch::v6_M));
305 EXPECT_TRUE(
306 testARMArch("armv7-a", "cortex-a8", "v7",
307 ARMBuildAttrs::CPUArch::v7));
308 EXPECT_TRUE(
309 testARMArch("armv7-r", "cortex-r4", "v7r",
310 ARMBuildAttrs::CPUArch::v7));
311 EXPECT_TRUE(
312 testARMArch("armv7-m", "cortex-m3", "v7m",
313 ARMBuildAttrs::CPUArch::v7));
314 EXPECT_TRUE(
315 testARMArch("armv7e-m", "cortex-m4", "v7em",
316 ARMBuildAttrs::CPUArch::v7E_M));
317 EXPECT_TRUE(
318 testARMArch("armv8-a", "cortex-a53", "v8",
319 ARMBuildAttrs::CPUArch::v8_A));
320 EXPECT_TRUE(
321 testARMArch("armv8.1-a", "generic", "v8.1a",
322 ARMBuildAttrs::CPUArch::v8_A));
323 EXPECT_TRUE(
324 testARMArch("armv8.2-a", "generic", "v8.2a",
325 ARMBuildAttrs::CPUArch::v8_A));
326 EXPECT_TRUE(
327 testARMArch("armv8-r", "cortex-r52", "v8r",
328 ARMBuildAttrs::CPUArch::v8_R));
329 EXPECT_TRUE(
330 testARMArch("armv8-m.base", "generic", "v8m.base",
331 ARMBuildAttrs::CPUArch::v8_M_Base));
332 EXPECT_TRUE(
333 testARMArch("armv8-m.main", "generic", "v8m.main",
334 ARMBuildAttrs::CPUArch::v8_M_Main));
335 EXPECT_TRUE(
336 testARMArch("iwmmxt", "iwmmxt", "",
337 ARMBuildAttrs::CPUArch::v5TE));
338 EXPECT_TRUE(
339 testARMArch("iwmmxt2", "generic", "",
340 ARMBuildAttrs::CPUArch::v5TE));
341 EXPECT_TRUE(
342 testARMArch("xscale", "xscale", "v5e",
343 ARMBuildAttrs::CPUArch::v5TE));
344 EXPECT_TRUE(
345 testARMArch("armv7s", "swift", "v7s",
346 ARMBuildAttrs::CPUArch::v7));
347 EXPECT_TRUE(
348 testARMArch("armv7k", "generic", "v7k",
349 ARMBuildAttrs::CPUArch::v7));
Saleem Abdulrasool11bf1ac2016-03-06 04:50:55 +0000[diff] [blame]350}
351
Zijiao Ma639f84b2016-12-06 02:22:08 +0000[diff] [blame]352bool testARMExtension(StringRef CPUName, unsigned ArchKind, StringRef ArchExt) {
353 return ARM::getDefaultExtensions(CPUName, ArchKind) &
354 ARM::parseArchExt(ArchExt);
Saleem Abdulrasool11bf1ac2016-03-06 04:50:55 +0000[diff] [blame]355}
356
Zijiao Ma639f84b2016-12-06 02:22:08 +0000[diff] [blame]357TEST(TargetParserTest, testARMExtension) {
358 EXPECT_FALSE(testARMExtension("arm2", 0, "thumb"));
359 EXPECT_FALSE(testARMExtension("arm3", 0, "thumb"));
360 EXPECT_FALSE(testARMExtension("arm6", 0, "thumb"));
361 EXPECT_FALSE(testARMExtension("arm7m", 0, "thumb"));
362 EXPECT_FALSE(testARMExtension("strongarm", 0, "dsp"));
363 EXPECT_FALSE(testARMExtension("arm7tdmi", 0, "dsp"));
364 EXPECT_FALSE(testARMExtension("arm10tdmi", 0, "simd"));
365 EXPECT_FALSE(testARMExtension("arm1022e", 0, "simd"));
366 EXPECT_FALSE(testARMExtension("arm926ej-s", 0, "simd"));
367 EXPECT_FALSE(testARMExtension("arm1136jf-s", 0, "crypto"));
368 EXPECT_FALSE(testARMExtension("arm1176j-s", 0, "crypto"));
369 EXPECT_FALSE(testARMExtension("arm1156t2-s", 0, "crypto"));
370 EXPECT_FALSE(testARMExtension("arm1176jzf-s", 0, "crypto"));
371 EXPECT_FALSE(testARMExtension("cortex-m0", 0, "crypto"));
372 EXPECT_FALSE(testARMExtension("cortex-a8", 0, "crypto"));
373 EXPECT_FALSE(testARMExtension("cortex-r4", 0, "crypto"));
374 EXPECT_FALSE(testARMExtension("cortex-m3", 0, "crypto"));
375 EXPECT_FALSE(testARMExtension("cortex-a53", 0, "ras"));
376 EXPECT_FALSE(testARMExtension("cortex-r52", 0, "ras"));
377 EXPECT_FALSE(testARMExtension("iwmmxt", 0, "crc"));
378 EXPECT_FALSE(testARMExtension("xscale", 0, "crc"));
379 EXPECT_FALSE(testARMExtension("swift", 0, "crc"));
380
381 EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV2, "thumb"));
382 EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV2A, "thumb"));
383 EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV3, "thumb"));
384 EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV3M, "thumb"));
385 EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV4, "dsp"));
386 EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV4T, "dsp"));
387 EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV5T, "simd"));
388 EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV5TE, "simd"));
389 EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV5TEJ, "simd"));
390 EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV6, "crypto"));
391 EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV6K, "crypto"));
392 EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV6T2, "crypto"));
393 EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV6KZ, "crypto"));
394 EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV6M, "crypto"));
395 EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV7A, "crypto"));
396 EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV7R, "crypto"));
397 EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV7M, "crypto"));
398 EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV7EM, "crypto"));
399 EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV8A, "ras"));
400 EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV8_1A, "ras"));
401 EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV8_2A, "spe"));
402 EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV8R, "ras"));
403 EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV8MBaseline, "crc"));
404 EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV8MMainline, "crc"));
405 EXPECT_FALSE(testARMExtension("generic", ARM::AK_IWMMXT, "crc"));
406 EXPECT_FALSE(testARMExtension("generic", ARM::AK_IWMMXT2, "crc"));
407 EXPECT_FALSE(testARMExtension("generic", ARM::AK_XSCALE, "crc"));
408 EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV7S, "crypto"));
409 EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV7K, "crypto"));
Saleem Abdulrasool11bf1ac2016-03-06 04:50:55 +0000[diff] [blame]410}
Saleem Abdulrasool1ef925f2016-06-08 14:30:00 +0000[diff] [blame]411
Zijiao Mae56a53a2016-07-28 06:11:18 +0000[diff] [blame]412TEST(TargetParserTest, ARMFPUVersion) {
413 for (ARM::FPUKind FK = static_cast<ARM::FPUKind>(0);
414 FK <= ARM::FPUKind::FK_LAST;
415 FK = static_cast<ARM::FPUKind>(static_cast<unsigned>(FK) + 1))
416 if (FK == ARM::FK_LAST)
Simon Pilgrim3080dbc2016-07-28 13:29:56 +0000[diff] [blame]417 EXPECT_EQ(0U, ARM::getFPUVersion(FK));
Zijiao Mae56a53a2016-07-28 06:11:18 +0000[diff] [blame]418 else
Simon Pilgrim3080dbc2016-07-28 13:29:56 +0000[diff] [blame]419 EXPECT_LE(0U, ARM::getFPUVersion(FK));
Zijiao Mae56a53a2016-07-28 06:11:18 +0000[diff] [blame]420}
421
422TEST(TargetParserTest, ARMFPUNeonSupportLevel) {
423 for (ARM::FPUKind FK = static_cast<ARM::FPUKind>(0);
424 FK <= ARM::FPUKind::FK_LAST;
425 FK = static_cast<ARM::FPUKind>(static_cast<unsigned>(FK) + 1))
426 if (FK == ARM::FK_LAST)
Simon Pilgrim3080dbc2016-07-28 13:29:56 +0000[diff] [blame]427 EXPECT_EQ(0U, ARM::getFPUNeonSupportLevel(FK));
Zijiao Mae56a53a2016-07-28 06:11:18 +0000[diff] [blame]428 else
Simon Pilgrim3080dbc2016-07-28 13:29:56 +0000[diff] [blame]429 EXPECT_LE(0U, ARM::getFPUNeonSupportLevel(FK));
Zijiao Mae56a53a2016-07-28 06:11:18 +0000[diff] [blame]430}
431
432TEST(TargetParserTest, ARMFPURestriction) {
433 for (ARM::FPUKind FK = static_cast<ARM::FPUKind>(0);
434 FK <= ARM::FPUKind::FK_LAST;
435 FK = static_cast<ARM::FPUKind>(static_cast<unsigned>(FK) + 1))
436 if (FK == ARM::FK_LAST)
Simon Pilgrim3080dbc2016-07-28 13:29:56 +0000[diff] [blame]437 EXPECT_EQ(0U, ARM::getFPURestriction(FK));
Zijiao Mae56a53a2016-07-28 06:11:18 +0000[diff] [blame]438 else
Simon Pilgrim3080dbc2016-07-28 13:29:56 +0000[diff] [blame]439 EXPECT_LE(0U, ARM::getFPURestriction(FK));
Zijiao Mae56a53a2016-07-28 06:11:18 +0000[diff] [blame]440}
441
Zijiao Mae56a53a2016-07-28 06:11:18 +0000[diff] [blame]442TEST(TargetParserTest, ARMExtensionFeatures) {
Mehdi Aminia0016ec2016-10-07 08:37:29 +0000[diff] [blame]443 std::vector<StringRef> Features;
Zijiao Mae56a53a2016-07-28 06:11:18 +0000[diff] [blame]444 unsigned Extensions = ARM::AEK_CRC | ARM::AEK_CRYPTO | ARM::AEK_DSP |
445 ARM::AEK_HWDIVARM | ARM::AEK_HWDIV | ARM::AEK_MP |
446 ARM::AEK_SEC | ARM::AEK_VIRT | ARM::AEK_RAS;
447
448 for (unsigned i = 0; i <= Extensions; i++)
449 EXPECT_TRUE(i == 0 ? !ARM::getExtensionFeatures(i, Features)
450 : ARM::getExtensionFeatures(i, Features));
451}
452
453TEST(TargetParserTest, ARMFPUFeatures) {
Mehdi Aminia0016ec2016-10-07 08:37:29 +0000[diff] [blame]454 std::vector<StringRef> Features;
Zijiao Mae56a53a2016-07-28 06:11:18 +0000[diff] [blame]455 for (ARM::FPUKind FK = static_cast<ARM::FPUKind>(0);
456 FK <= ARM::FPUKind::FK_LAST;
457 FK = static_cast<ARM::FPUKind>(static_cast<unsigned>(FK) + 1))
458 EXPECT_TRUE((FK == ARM::FK_INVALID || FK >= ARM::FK_LAST)
459 ? !ARM::getFPUFeatures(FK, Features)
460 : ARM::getFPUFeatures(FK, Features));
461}
462
Zijiao Mae56a53a2016-07-28 06:11:18 +0000[diff] [blame]463TEST(TargetParserTest, ARMArchExtFeature) {
464 const char *ArchExt[][4] = {{"crc", "nocrc", "+crc", "-crc"},
465 {"crypto", "nocrypto", "+crypto", "-crypto"},
466 {"dsp", "nodsp", "+dsp", "-dsp"},
467 {"fp", "nofp", nullptr, nullptr},
468 {"idiv", "noidiv", nullptr, nullptr},
469 {"mp", "nomp", nullptr, nullptr},
470 {"simd", "nosimd", nullptr, nullptr},
471 {"sec", "nosec", nullptr, nullptr},
472 {"virt", "novirt", nullptr, nullptr},
473 {"fp16", "nofp16", "+fullfp16", "-fullfp16"},
474 {"ras", "noras", "+ras", "-ras"},
475 {"os", "noos", nullptr, nullptr},
476 {"iwmmxt", "noiwmmxt", nullptr, nullptr},
477 {"iwmmxt2", "noiwmmxt2", nullptr, nullptr},
478 {"maverick", "maverick", nullptr, nullptr},
479 {"xscale", "noxscale", nullptr, nullptr}};
480
481 for (unsigned i = 0; i < array_lengthof(ArchExt); i++) {
Mehdi Aminia0016ec2016-10-07 08:37:29 +0000[diff] [blame]482 EXPECT_EQ(StringRef(ArchExt[i][2]), ARM::getArchExtFeature(ArchExt[i][0]));
483 EXPECT_EQ(StringRef(ArchExt[i][3]), ARM::getArchExtFeature(ArchExt[i][1]));
Zijiao Mae56a53a2016-07-28 06:11:18 +0000[diff] [blame]484 }
485}
486
Zijiao Mae56a53a2016-07-28 06:11:18 +0000[diff] [blame]487TEST(TargetParserTest, ARMparseHWDiv) {
488 const char *hwdiv[] = {"thumb", "arm", "arm,thumb", "thumb,arm"};
489
490 for (unsigned i = 0; i < array_lengthof(hwdiv); i++)
491 EXPECT_NE(ARM::AEK_INVALID, ARM::parseHWDiv((StringRef)hwdiv[i]));
492}
493
Zijiao Mae56a53a2016-07-28 06:11:18 +0000[diff] [blame]494TEST(TargetParserTest, ARMparseArchEndianAndISA) {
495 const char *Arch[] = {
496 "v2", "v2a", "v3", "v3m", "v4", "v4t", "v5", "v5t",
497 "v5e", "v5te", "v5tej", "v6", "v6j", "v6k", "v6hl", "v6t2",
498 "v6kz", "v6z", "v6zk", "v6-m", "v6m", "v6sm", "v6s-m", "v7-a",
499 "v7", "v7a", "v7hl", "v7l", "v7-r", "v7r", "v7-m", "v7m",
500 "v7k", "v7s", "v7e-m", "v7em", "v8-a", "v8", "v8a", "v8.1-a",
Javed Absarfb4b6e82016-10-07 12:06:40 +0000[diff] [blame]501 "v8.1a", "v8.2-a", "v8.2a", "v8-r"};
Zijiao Mae56a53a2016-07-28 06:11:18 +0000[diff] [blame]502
503 for (unsigned i = 0; i < array_lengthof(Arch); i++) {
504 std::string arm_1 = "armeb" + (std::string)(Arch[i]);
505 std::string arm_2 = "arm" + (std::string)(Arch[i]) + "eb";
506 std::string arm_3 = "arm" + (std::string)(Arch[i]);
507 std::string thumb_1 = "thumbeb" + (std::string)(Arch[i]);
508 std::string thumb_2 = "thumb" + (std::string)(Arch[i]) + "eb";
509 std::string thumb_3 = "thumb" + (std::string)(Arch[i]);
510
511 EXPECT_EQ(ARM::EK_BIG, ARM::parseArchEndian(arm_1));
512 EXPECT_EQ(ARM::EK_BIG, ARM::parseArchEndian(arm_2));
513 EXPECT_EQ(ARM::EK_LITTLE, ARM::parseArchEndian(arm_3));
514
515 EXPECT_EQ(ARM::IK_ARM, ARM::parseArchISA(arm_1));
516 EXPECT_EQ(ARM::IK_ARM, ARM::parseArchISA(arm_2));
517 EXPECT_EQ(ARM::IK_ARM, ARM::parseArchISA(arm_3));
518 if (i >= 4) {
519 EXPECT_EQ(ARM::EK_BIG, ARM::parseArchEndian(thumb_1));
520 EXPECT_EQ(ARM::EK_BIG, ARM::parseArchEndian(thumb_2));
521 EXPECT_EQ(ARM::EK_LITTLE, ARM::parseArchEndian(thumb_3));
522
523 EXPECT_EQ(ARM::IK_THUMB, ARM::parseArchISA(thumb_1));
524 EXPECT_EQ(ARM::IK_THUMB, ARM::parseArchISA(thumb_2));
525 EXPECT_EQ(ARM::IK_THUMB, ARM::parseArchISA(thumb_3));
526 }
527 }
528
529 EXPECT_EQ(ARM::EK_LITTLE, ARM::parseArchEndian("aarch64"));
530 EXPECT_EQ(ARM::EK_BIG, ARM::parseArchEndian("aarch64_be"));
531
532 EXPECT_EQ(ARM::IK_AARCH64, ARM::parseArchISA("aarch64"));
533 EXPECT_EQ(ARM::IK_AARCH64, ARM::parseArchISA("aarch64_be"));
534 EXPECT_EQ(ARM::IK_AARCH64, ARM::parseArchISA("arm64"));
535 EXPECT_EQ(ARM::IK_AARCH64, ARM::parseArchISA("arm64_be"));
536}
537
538TEST(TargetParserTest, ARMparseArchProfile) {
539 for (unsigned i = 0; i < array_lengthof(ARMArch); i++) {
540 switch (ARM::parseArch(ARMArch[i])) {
541 case ARM::AK_ARMV6M:
542 case ARM::AK_ARMV7M:
543 case ARM::AK_ARMV7EM:
544 case ARM::AK_ARMV8MMainline:
545 case ARM::AK_ARMV8MBaseline:
546 EXPECT_EQ(ARM::PK_M, ARM::parseArchProfile(ARMArch[i]));
547 continue;
548 case ARM::AK_ARMV7R:
Zijiao Ma639f84b2016-12-06 02:22:08 +0000[diff] [blame]549 case ARM::AK_ARMV8R:
Zijiao Mae56a53a2016-07-28 06:11:18 +0000[diff] [blame]550 EXPECT_EQ(ARM::PK_R, ARM::parseArchProfile(ARMArch[i]));
551 continue;
552 case ARM::AK_ARMV7A:
553 case ARM::AK_ARMV7K:
554 case ARM::AK_ARMV8A:
555 case ARM::AK_ARMV8_1A:
556 case ARM::AK_ARMV8_2A:
557 EXPECT_EQ(ARM::PK_A, ARM::parseArchProfile(ARMArch[i]));
558 continue;
559 }
560 EXPECT_EQ(ARM::PK_INVALID, ARM::parseArchProfile(ARMArch[i]));
561 }
562}
563
564TEST(TargetParserTest, ARMparseArchVersion) {
565 for (unsigned i = 0; i < array_lengthof(ARMArch); i++)
566 if (((std::string)ARMArch[i]).substr(0, 4) == "armv")
David Blaikiefd5a7f12016-07-28 21:42:12 +0000[diff] [blame]567 EXPECT_EQ((ARMArch[i][4] - 48u), ARM::parseArchVersion(ARMArch[i]));
Zijiao Mae56a53a2016-07-28 06:11:18 +0000[diff] [blame]568 else
David Blaikiefd5a7f12016-07-28 21:42:12 +0000[diff] [blame]569 EXPECT_EQ(5u, ARM::parseArchVersion(ARMArch[i]));
Zijiao Mae56a53a2016-07-28 06:11:18 +0000[diff] [blame]570}
571
Zijiao Ma639f84b2016-12-06 02:22:08 +0000[diff] [blame]572bool testAArch64CPU(StringRef CPUName, StringRef ExpectedArch,
573 StringRef ExpectedFPU, unsigned ExpectedFlags,
574 StringRef CPUAttr) {
575 unsigned ArchKind = AArch64::parseCPUArch(CPUName);
576 bool pass = AArch64::getArchName(ArchKind).equals(ExpectedArch);
577 unsigned FPUKind = AArch64::getDefaultFPU(CPUName, ArchKind);
578 pass &= AArch64::getFPUName(FPUKind).equals(ExpectedFPU);
Zijiao Mae56a53a2016-07-28 06:11:18 +0000[diff] [blame]579
Zijiao Ma639f84b2016-12-06 02:22:08 +0000[diff] [blame]580 unsigned ExtKind = AArch64::getDefaultExtensions(CPUName, ArchKind);
581 if (ExtKind > 1 && (ExtKind & AArch64::AEK_NONE))
582 pass &= ((ExtKind ^ AArch64::AEK_NONE) == ExpectedFlags);
583 else
584 pass &= (ExtKind == ExpectedFlags);
585
586 pass &= AArch64::getCPUAttr(ArchKind).equals(CPUAttr);
587
588 return pass;
Zijiao Mae56a53a2016-07-28 06:11:18 +0000[diff] [blame]589}
590
Zijiao Ma639f84b2016-12-06 02:22:08 +0000[diff] [blame]591TEST(TargetParserTest, testAArch64CPU) {
592 EXPECT_TRUE(testAArch64CPU(
593 "invalid", "invalid", "invalid",
594 AArch64::AEK_INVALID, ""));
595 EXPECT_TRUE(testAArch64CPU(
596 "generic", "invalid", "none",
597 AArch64::AEK_NONE, ""));
Zijiao Mae56a53a2016-07-28 06:11:18 +0000[diff] [blame]598
Zijiao Ma639f84b2016-12-06 02:22:08 +0000[diff] [blame]599 EXPECT_TRUE(testAArch64CPU(
600 "cortex-a35", "armv8-a", "crypto-neon-fp-armv8",
601 AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_SIMD, "8-A"));
602 EXPECT_TRUE(testAArch64CPU(
603 "cortex-a53", "armv8-a", "crypto-neon-fp-armv8",
604 AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_SIMD, "8-A"));
605 EXPECT_TRUE(testAArch64CPU(
606 "cortex-a57", "armv8-a", "crypto-neon-fp-armv8",
607 AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_SIMD, "8-A"));
608 EXPECT_TRUE(testAArch64CPU(
609 "cortex-a72", "armv8-a", "crypto-neon-fp-armv8",
610 AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_SIMD, "8-A"));
611 EXPECT_TRUE(testAArch64CPU(
612 "cortex-a73", "armv8-a", "crypto-neon-fp-armv8",
613 AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_SIMD, "8-A"));
614 EXPECT_TRUE(testAArch64CPU(
615 "cyclone", "armv8-a", "crypto-neon-fp-armv8",
616 AArch64::AEK_CRYPTO | AArch64::AEK_SIMD, "8-A"));
617 EXPECT_TRUE(testAArch64CPU(
618 "exynos-m1", "armv8-a", "crypto-neon-fp-armv8",
619 AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_SIMD, "8-A"));
620 EXPECT_TRUE(testAArch64CPU(
621 "exynos-m2", "armv8-a", "crypto-neon-fp-armv8",
622 AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_SIMD, "8-A"));
623 EXPECT_TRUE(testAArch64CPU(
624 "falkor", "armv8-a", "crypto-neon-fp-armv8",
625 AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_SIMD, "8-A"));
626 EXPECT_TRUE(testAArch64CPU(
627 "kryo", "armv8-a", "crypto-neon-fp-armv8",
628 AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_SIMD, "8-A"));
629 EXPECT_TRUE(testAArch64CPU(
630 "vulcan", "armv8.1-a", "crypto-neon-fp-armv8",
631 AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_SIMD, "8.1-A"));
632}
633
634bool testAArch64Arch(StringRef Arch, StringRef DefaultCPU, StringRef SubArch,
635 unsigned ArchAttr) {
636 unsigned ArchKind = AArch64::parseArch(Arch);
637 return (ArchKind != static_cast<unsigned>(AArch64::ArchKind::AK_INVALID)) &
638 AArch64::getDefaultCPU(Arch).equals(DefaultCPU) &
639 AArch64::getSubArch(ArchKind).equals(SubArch) &
640 (AArch64::getArchAttr(ArchKind) == ArchAttr);
641}
642
643TEST(TargetParserTest, testAArch64Arch) {
644 EXPECT_TRUE(testAArch64Arch("armv8-a", "cortex-a53", "v8",
645 ARMBuildAttrs::CPUArch::v8_A));
646 EXPECT_TRUE(testAArch64Arch("armv8.1-a", "generic", "v8.1a",
647 ARMBuildAttrs::CPUArch::v8_A));
648 EXPECT_TRUE(testAArch64Arch("armv8.2-a", "generic", "v8.2a",
649 ARMBuildAttrs::CPUArch::v8_A));
650}
651
652bool testAArch64Extension(StringRef CPUName, unsigned ArchKind,
653 StringRef ArchExt) {
654 return AArch64::getDefaultExtensions(CPUName, ArchKind) &
655 AArch64::parseArchExt(ArchExt);
656}
657
658TEST(TargetParserTest, testAArch64Extension) {
659 EXPECT_FALSE(testAArch64Extension("cortex-a35", 0, "ras"));
660 EXPECT_FALSE(testAArch64Extension("cortex-a53", 0, "ras"));
661 EXPECT_FALSE(testAArch64Extension("cortex-a57", 0, "ras"));
662 EXPECT_FALSE(testAArch64Extension("cortex-a72", 0, "ras"));
663 EXPECT_FALSE(testAArch64Extension("cortex-a73", 0, "ras"));
664 EXPECT_FALSE(testAArch64Extension("cyclone", 0, "ras"));
665 EXPECT_FALSE(testAArch64Extension("exynos-m1", 0, "ras"));
666 EXPECT_FALSE(testAArch64Extension("kryo", 0, "ras"));
667 EXPECT_FALSE(testAArch64Extension("vulcan", 0, "ras"));
668
669 EXPECT_FALSE(testAArch64Extension(
670 "generic", static_cast<unsigned>(AArch64::ArchKind::AK_ARMV8A), "ras"));
671 EXPECT_FALSE(testAArch64Extension(
672 "generic", static_cast<unsigned>(AArch64::ArchKind::AK_ARMV8_1A), "ras"));
673 EXPECT_FALSE(testAArch64Extension(
674 "generic", static_cast<unsigned>(AArch64::ArchKind::AK_ARMV8_2A), "spe"));
Zijiao Mae56a53a2016-07-28 06:11:18 +0000[diff] [blame]675}
676
677TEST(TargetParserTest, AArch64ExtensionFeatures) {
Mehdi Aminia0016ec2016-10-07 08:37:29 +0000[diff] [blame]678 std::vector<StringRef> Features;
Zijiao Mae56a53a2016-07-28 06:11:18 +0000[diff] [blame]679 unsigned Extensions = AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
680 AArch64::AEK_FP | AArch64::AEK_SIMD |
681 AArch64::AEK_FP16 | AArch64::AEK_PROFILE |
682 AArch64::AEK_RAS;
683
684 for (unsigned i = 0; i <= Extensions; i++)
685 EXPECT_TRUE(i == 0 ? !AArch64::getExtensionFeatures(i, Features)
686 : AArch64::getExtensionFeatures(i, Features));
687}
688
689TEST(TargetParserTest, AArch64ArchFeatures) {
Mehdi Aminia0016ec2016-10-07 08:37:29 +0000[diff] [blame]690 std::vector<StringRef> Features;
Zijiao Mae56a53a2016-07-28 06:11:18 +0000[diff] [blame]691
692 for (unsigned AK = 0; AK < static_cast<unsigned>(AArch64::ArchKind::AK_LAST);
693 AK++)
694 EXPECT_TRUE((AK == static_cast<unsigned>(AArch64::ArchKind::AK_INVALID) ||
695 AK == static_cast<unsigned>(AArch64::ArchKind::AK_LAST))
696 ? !AArch64::getArchFeatures(AK, Features)
697 : AArch64::getArchFeatures(AK, Features));
698}
699
Zijiao Mae56a53a2016-07-28 06:11:18 +0000[diff] [blame]700TEST(TargetParserTest, AArch64ArchExtFeature) {
701 const char *ArchExt[][4] = {{"crc", "nocrc", "+crc", "-crc"},
702 {"crypto", "nocrypto", "+crypto", "-crypto"},
703 {"fp", "nofp", "+fp-armv8", "-fp-armv8"},
704 {"simd", "nosimd", "+neon", "-neon"},
705 {"fp16", "nofp16", "+fullfp16", "-fullfp16"},
706 {"profile", "noprofile", "+spe", "-spe"},
707 {"ras", "noras", "+ras", "-ras"}};
708
709 for (unsigned i = 0; i < array_lengthof(ArchExt); i++) {
Zijiao Ma639f84b2016-12-06 02:22:08 +0000[diff] [blame]710 EXPECT_EQ(StringRef(ArchExt[i][2]),
711 AArch64::getArchExtFeature(ArchExt[i][0]));
712 EXPECT_EQ(StringRef(ArchExt[i][3]),
713 AArch64::getArchExtFeature(ArchExt[i][1]));
Zijiao Mae56a53a2016-07-28 06:11:18 +0000[diff] [blame]714 }
715}
Zijiao Mae56a53a2016-07-28 06:11:18 +0000[diff] [blame]716}