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