1 | //===----------- Triple.cpp - Triple unit tests ---------------------------===// |
2 | // |
3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
4 | // See https://llvm.org/LICENSE.txt for license information. |
5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
6 | // |
7 | //===----------------------------------------------------------------------===// |
8 | |
9 | #include "llvm/TargetParser/Triple.h" |
10 | #include "llvm/Support/VersionTuple.h" |
11 | #include "gtest/gtest.h" |
12 | |
13 | using namespace llvm; |
14 | |
15 | namespace { |
16 | |
17 | TEST(TripleTest, BasicParsing) { |
18 | Triple T; |
19 | |
20 | T = Triple("" ); |
21 | EXPECT_EQ("" , T.getArchName().str()); |
22 | EXPECT_EQ("" , T.getVendorName().str()); |
23 | EXPECT_EQ("" , T.getOSName().str()); |
24 | EXPECT_EQ("" , T.getEnvironmentName().str()); |
25 | |
26 | T = Triple("-" ); |
27 | EXPECT_EQ("" , T.getArchName().str()); |
28 | EXPECT_EQ("" , T.getVendorName().str()); |
29 | EXPECT_EQ("" , T.getOSName().str()); |
30 | EXPECT_EQ("" , T.getEnvironmentName().str()); |
31 | |
32 | T = Triple("--" ); |
33 | EXPECT_EQ("" , T.getArchName().str()); |
34 | EXPECT_EQ("" , T.getVendorName().str()); |
35 | EXPECT_EQ("" , T.getOSName().str()); |
36 | EXPECT_EQ("" , T.getEnvironmentName().str()); |
37 | |
38 | T = Triple("---" ); |
39 | EXPECT_EQ("" , T.getArchName().str()); |
40 | EXPECT_EQ("" , T.getVendorName().str()); |
41 | EXPECT_EQ("" , T.getOSName().str()); |
42 | EXPECT_EQ("" , T.getEnvironmentName().str()); |
43 | |
44 | T = Triple("----" ); |
45 | EXPECT_EQ("" , T.getArchName().str()); |
46 | EXPECT_EQ("" , T.getVendorName().str()); |
47 | EXPECT_EQ("" , T.getOSName().str()); |
48 | EXPECT_EQ("-" , T.getEnvironmentName().str()); |
49 | |
50 | T = Triple("a" ); |
51 | EXPECT_EQ("a" , T.getArchName().str()); |
52 | EXPECT_EQ("" , T.getVendorName().str()); |
53 | EXPECT_EQ("" , T.getOSName().str()); |
54 | EXPECT_EQ("" , T.getEnvironmentName().str()); |
55 | |
56 | T = Triple("a-b" ); |
57 | EXPECT_EQ("a" , T.getArchName().str()); |
58 | EXPECT_EQ("b" , T.getVendorName().str()); |
59 | EXPECT_EQ("" , T.getOSName().str()); |
60 | EXPECT_EQ("" , T.getEnvironmentName().str()); |
61 | |
62 | T = Triple("a-b-c" ); |
63 | EXPECT_EQ("a" , T.getArchName().str()); |
64 | EXPECT_EQ("b" , T.getVendorName().str()); |
65 | EXPECT_EQ("c" , T.getOSName().str()); |
66 | EXPECT_EQ("" , T.getEnvironmentName().str()); |
67 | |
68 | T = Triple("a-b-c-d" ); |
69 | EXPECT_EQ("a" , T.getArchName().str()); |
70 | EXPECT_EQ("b" , T.getVendorName().str()); |
71 | EXPECT_EQ("c" , T.getOSName().str()); |
72 | EXPECT_EQ("d" , T.getEnvironmentName().str()); |
73 | } |
74 | |
75 | TEST(TripleTest, ParsedIDs) { |
76 | Triple T; |
77 | |
78 | T = Triple("i386-apple-darwin" ); |
79 | EXPECT_EQ(Triple::x86, T.getArch()); |
80 | EXPECT_EQ(Triple::Apple, T.getVendor()); |
81 | EXPECT_EQ(Triple::Darwin, T.getOS()); |
82 | EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment()); |
83 | |
84 | T = Triple("i386-pc-elfiamcu" ); |
85 | EXPECT_EQ(Triple::x86, T.getArch()); |
86 | EXPECT_EQ(Triple::PC, T.getVendor()); |
87 | EXPECT_EQ(Triple::ELFIAMCU, T.getOS()); |
88 | EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment()); |
89 | |
90 | T = Triple("i386-pc-hurd-gnu" ); |
91 | EXPECT_EQ(Triple::x86, T.getArch()); |
92 | EXPECT_EQ(Triple::PC, T.getVendor()); |
93 | EXPECT_EQ(Triple::Hurd, T.getOS()); |
94 | EXPECT_EQ(Triple::GNU, T.getEnvironment()); |
95 | |
96 | T = Triple("x86_64-pc-linux-gnu" ); |
97 | EXPECT_EQ(Triple::x86_64, T.getArch()); |
98 | EXPECT_EQ(Triple::PC, T.getVendor()); |
99 | EXPECT_EQ(Triple::Linux, T.getOS()); |
100 | EXPECT_EQ(Triple::GNU, T.getEnvironment()); |
101 | |
102 | T = Triple("x86_64-pc-linux-musl" ); |
103 | EXPECT_EQ(Triple::x86_64, T.getArch()); |
104 | EXPECT_EQ(Triple::PC, T.getVendor()); |
105 | EXPECT_EQ(Triple::Linux, T.getOS()); |
106 | EXPECT_EQ(Triple::Musl, T.getEnvironment()); |
107 | |
108 | T = Triple("x86_64-pc-linux-muslx32" ); |
109 | EXPECT_EQ(Triple::x86_64, T.getArch()); |
110 | EXPECT_EQ(Triple::PC, T.getVendor()); |
111 | EXPECT_EQ(Triple::Linux, T.getOS()); |
112 | EXPECT_EQ(Triple::MuslX32, T.getEnvironment()); |
113 | |
114 | T = Triple("x86_64-pc-hurd-gnu" ); |
115 | EXPECT_EQ(Triple::x86_64, T.getArch()); |
116 | EXPECT_EQ(Triple::PC, T.getVendor()); |
117 | EXPECT_EQ(Triple::Hurd, T.getOS()); |
118 | EXPECT_EQ(Triple::GNU, T.getEnvironment()); |
119 | |
120 | T = Triple("arm-unknown-linux-android16" ); |
121 | EXPECT_EQ(Triple::arm, T.getArch()); |
122 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
123 | EXPECT_EQ(Triple::Linux, T.getOS()); |
124 | EXPECT_EQ(Triple::Android, T.getEnvironment()); |
125 | |
126 | T = Triple("aarch64-unknown-linux-android21" ); |
127 | EXPECT_EQ(Triple::aarch64, T.getArch()); |
128 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
129 | EXPECT_EQ(Triple::Linux, T.getOS()); |
130 | EXPECT_EQ(Triple::Android, T.getEnvironment()); |
131 | |
132 | // PS4 has two spellings for the vendor. |
133 | T = Triple("x86_64-scei-ps4" ); |
134 | EXPECT_EQ(Triple::x86_64, T.getArch()); |
135 | EXPECT_EQ(Triple::SCEI, T.getVendor()); |
136 | EXPECT_EQ(Triple::PS4, T.getOS()); |
137 | |
138 | T = Triple("x86_64-sie-ps4" ); |
139 | EXPECT_EQ(Triple::x86_64, T.getArch()); |
140 | EXPECT_EQ(Triple::SCEI, T.getVendor()); |
141 | EXPECT_EQ(Triple::PS4, T.getOS()); |
142 | |
143 | T = Triple("x86_64-sie-ps5" ); |
144 | EXPECT_EQ(Triple::x86_64, T.getArch()); |
145 | EXPECT_EQ(Triple::SCEI, T.getVendor()); |
146 | EXPECT_EQ(Triple::PS5, T.getOS()); |
147 | |
148 | T = Triple("powerpc-ibm-aix" ); |
149 | EXPECT_EQ(Triple::ppc, T.getArch()); |
150 | EXPECT_EQ(Triple::IBM, T.getVendor()); |
151 | EXPECT_EQ(Triple::AIX, T.getOS()); |
152 | EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment()); |
153 | |
154 | T = Triple("powerpc64-ibm-aix" ); |
155 | EXPECT_EQ(Triple::ppc64, T.getArch()); |
156 | EXPECT_EQ(Triple::IBM, T.getVendor()); |
157 | EXPECT_EQ(Triple::AIX, T.getOS()); |
158 | EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment()); |
159 | |
160 | T = Triple("powerpc-dunno-notsure" ); |
161 | EXPECT_EQ(Triple::ppc, T.getArch()); |
162 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
163 | EXPECT_EQ(Triple::UnknownOS, T.getOS()); |
164 | EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment()); |
165 | |
166 | T = Triple("powerpcspe-unknown-freebsd" ); |
167 | EXPECT_EQ(Triple::ppc, T.getArch()); |
168 | EXPECT_EQ(Triple::PPCSubArch_spe, T.getSubArch()); |
169 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
170 | EXPECT_EQ(Triple::FreeBSD, T.getOS()); |
171 | EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment()); |
172 | |
173 | T = Triple("s390x-ibm-zos" ); |
174 | EXPECT_EQ(Triple::systemz, T.getArch()); |
175 | EXPECT_EQ(Triple::IBM, T.getVendor()); |
176 | EXPECT_EQ(Triple::ZOS, T.getOS()); |
177 | EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment()); |
178 | |
179 | T = Triple("systemz-ibm-zos" ); |
180 | EXPECT_EQ(Triple::systemz, T.getArch()); |
181 | EXPECT_EQ(Triple::IBM, T.getVendor()); |
182 | EXPECT_EQ(Triple::ZOS, T.getOS()); |
183 | EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment()); |
184 | |
185 | T = Triple("arm-none-none-eabi" ); |
186 | EXPECT_EQ(Triple::arm, T.getArch()); |
187 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
188 | EXPECT_EQ(Triple::UnknownOS, T.getOS()); |
189 | EXPECT_EQ(Triple::EABI, T.getEnvironment()); |
190 | |
191 | T = Triple("arm-none-linux-musleabi" ); |
192 | EXPECT_EQ(Triple::arm, T.getArch()); |
193 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
194 | EXPECT_EQ(Triple::Linux, T.getOS()); |
195 | EXPECT_EQ(Triple::MuslEABI, T.getEnvironment()); |
196 | |
197 | T = Triple("armv6hl-none-linux-gnueabi" ); |
198 | EXPECT_EQ(Triple::arm, T.getArch()); |
199 | EXPECT_EQ(Triple::Linux, T.getOS()); |
200 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
201 | EXPECT_EQ(Triple::GNUEABI, T.getEnvironment()); |
202 | |
203 | T = Triple("armv7hl-none-linux-gnueabi" ); |
204 | EXPECT_EQ(Triple::arm, T.getArch()); |
205 | EXPECT_EQ(Triple::Linux, T.getOS()); |
206 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
207 | EXPECT_EQ(Triple::GNUEABI, T.getEnvironment()); |
208 | |
209 | T = Triple("amdil-unknown-unknown" ); |
210 | EXPECT_EQ(Triple::amdil, T.getArch()); |
211 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
212 | EXPECT_EQ(Triple::UnknownOS, T.getOS()); |
213 | |
214 | T = Triple("amdil64-unknown-unknown" ); |
215 | EXPECT_EQ(Triple::amdil64, T.getArch()); |
216 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
217 | EXPECT_EQ(Triple::UnknownOS, T.getOS()); |
218 | |
219 | T = Triple("hsail-unknown-unknown" ); |
220 | EXPECT_EQ(Triple::hsail, T.getArch()); |
221 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
222 | EXPECT_EQ(Triple::UnknownOS, T.getOS()); |
223 | |
224 | T = Triple("hsail64-unknown-unknown" ); |
225 | EXPECT_EQ(Triple::hsail64, T.getArch()); |
226 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
227 | EXPECT_EQ(Triple::UnknownOS, T.getOS()); |
228 | |
229 | T = Triple("sparcel-unknown-unknown" ); |
230 | EXPECT_EQ(Triple::sparcel, T.getArch()); |
231 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
232 | EXPECT_EQ(Triple::UnknownOS, T.getOS()); |
233 | |
234 | T = Triple("spir-unknown-unknown" ); |
235 | EXPECT_EQ(Triple::spir, T.getArch()); |
236 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
237 | EXPECT_EQ(Triple::UnknownOS, T.getOS()); |
238 | |
239 | T = Triple("spir64-unknown-unknown" ); |
240 | EXPECT_EQ(Triple::spir64, T.getArch()); |
241 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
242 | EXPECT_EQ(Triple::UnknownOS, T.getOS()); |
243 | |
244 | T = Triple("spirv32-unknown-unknown" ); |
245 | EXPECT_EQ(Triple::spirv32, T.getArch()); |
246 | EXPECT_EQ(Triple::NoSubArch, T.getSubArch()); |
247 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
248 | EXPECT_EQ(Triple::UnknownOS, T.getOS()); |
249 | |
250 | T = Triple("spirv32v1.0-unknown-unknown" ); |
251 | EXPECT_EQ(Triple::spirv32, T.getArch()); |
252 | EXPECT_EQ(Triple::SPIRVSubArch_v10, T.getSubArch()); |
253 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
254 | EXPECT_EQ(Triple::UnknownOS, T.getOS()); |
255 | |
256 | T = Triple("spirv32v1.1-unknown-unknown" ); |
257 | EXPECT_EQ(Triple::spirv32, T.getArch()); |
258 | EXPECT_EQ(Triple::SPIRVSubArch_v11, T.getSubArch()); |
259 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
260 | EXPECT_EQ(Triple::UnknownOS, T.getOS()); |
261 | |
262 | T = Triple("spirv32v1.2-unknown-unknown" ); |
263 | EXPECT_EQ(Triple::spirv32, T.getArch()); |
264 | EXPECT_EQ(Triple::SPIRVSubArch_v12, T.getSubArch()); |
265 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
266 | EXPECT_EQ(Triple::UnknownOS, T.getOS()); |
267 | |
268 | T = Triple("spirv32v1.3-unknown-unknown" ); |
269 | EXPECT_EQ(Triple::spirv32, T.getArch()); |
270 | EXPECT_EQ(Triple::SPIRVSubArch_v13, T.getSubArch()); |
271 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
272 | EXPECT_EQ(Triple::UnknownOS, T.getOS()); |
273 | |
274 | T = Triple("spirv32v1.4-unknown-unknown" ); |
275 | EXPECT_EQ(Triple::spirv32, T.getArch()); |
276 | EXPECT_EQ(Triple::SPIRVSubArch_v14, T.getSubArch()); |
277 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
278 | EXPECT_EQ(Triple::UnknownOS, T.getOS()); |
279 | |
280 | T = Triple("spirv32v1.5-unknown-unknown" ); |
281 | EXPECT_EQ(Triple::spirv32, T.getArch()); |
282 | EXPECT_EQ(Triple::SPIRVSubArch_v15, T.getSubArch()); |
283 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
284 | EXPECT_EQ(Triple::UnknownOS, T.getOS()); |
285 | |
286 | T = Triple("spirv64-unknown-unknown" ); |
287 | EXPECT_EQ(Triple::spirv64, T.getArch()); |
288 | EXPECT_EQ(Triple::NoSubArch, T.getSubArch()); |
289 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
290 | EXPECT_EQ(Triple::UnknownOS, T.getOS()); |
291 | |
292 | T = Triple("spirv64v1.0-unknown-unknown" ); |
293 | EXPECT_EQ(Triple::spirv64, T.getArch()); |
294 | EXPECT_EQ(Triple::SPIRVSubArch_v10, T.getSubArch()); |
295 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
296 | EXPECT_EQ(Triple::UnknownOS, T.getOS()); |
297 | |
298 | T = Triple("spirv64v1.1-unknown-unknown" ); |
299 | EXPECT_EQ(Triple::spirv64, T.getArch()); |
300 | EXPECT_EQ(Triple::SPIRVSubArch_v11, T.getSubArch()); |
301 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
302 | EXPECT_EQ(Triple::UnknownOS, T.getOS()); |
303 | |
304 | T = Triple("spirv64v1.2-unknown-unknown" ); |
305 | EXPECT_EQ(Triple::spirv64, T.getArch()); |
306 | EXPECT_EQ(Triple::SPIRVSubArch_v12, T.getSubArch()); |
307 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
308 | EXPECT_EQ(Triple::UnknownOS, T.getOS()); |
309 | |
310 | T = Triple("spirv64v1.3-unknown-unknown" ); |
311 | EXPECT_EQ(Triple::spirv64, T.getArch()); |
312 | EXPECT_EQ(Triple::SPIRVSubArch_v13, T.getSubArch()); |
313 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
314 | EXPECT_EQ(Triple::UnknownOS, T.getOS()); |
315 | |
316 | T = Triple("spirv64v1.4-unknown-unknown" ); |
317 | EXPECT_EQ(Triple::spirv64, T.getArch()); |
318 | EXPECT_EQ(Triple::SPIRVSubArch_v14, T.getSubArch()); |
319 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
320 | EXPECT_EQ(Triple::UnknownOS, T.getOS()); |
321 | |
322 | T = Triple("spirv64v1.5-unknown-unknown" ); |
323 | EXPECT_EQ(Triple::spirv64, T.getArch()); |
324 | EXPECT_EQ(Triple::SPIRVSubArch_v15, T.getSubArch()); |
325 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
326 | EXPECT_EQ(Triple::UnknownOS, T.getOS()); |
327 | |
328 | T = Triple("spirv-unknown-vulkan-pixel" ); |
329 | EXPECT_EQ(Triple::spirv, T.getArch()); |
330 | EXPECT_EQ(Triple::NoSubArch, T.getSubArch()); |
331 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
332 | EXPECT_EQ(Triple::Vulkan, T.getOS()); |
333 | EXPECT_EQ(VersionTuple(1, 2), T.getVulkanVersion()); |
334 | EXPECT_EQ(Triple::Pixel, T.getEnvironment()); |
335 | |
336 | T = Triple("spirv-unknown-vulkan-vertex" ); |
337 | EXPECT_EQ(Triple::spirv, T.getArch()); |
338 | EXPECT_EQ(Triple::NoSubArch, T.getSubArch()); |
339 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
340 | EXPECT_EQ(Triple::Vulkan, T.getOS()); |
341 | EXPECT_EQ(VersionTuple(1, 2), T.getVulkanVersion()); |
342 | EXPECT_EQ(Triple::Vertex, T.getEnvironment()); |
343 | |
344 | T = Triple("spirv-unknown-vulkan-geometry" ); |
345 | EXPECT_EQ(Triple::spirv, T.getArch()); |
346 | EXPECT_EQ(Triple::NoSubArch, T.getSubArch()); |
347 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
348 | EXPECT_EQ(Triple::Vulkan, T.getOS()); |
349 | EXPECT_EQ(VersionTuple(1, 2), T.getVulkanVersion()); |
350 | EXPECT_EQ(Triple::Geometry, T.getEnvironment()); |
351 | |
352 | T = Triple("spirv-unknown-vulkan-library" ); |
353 | EXPECT_EQ(Triple::spirv, T.getArch()); |
354 | EXPECT_EQ(Triple::NoSubArch, T.getSubArch()); |
355 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
356 | EXPECT_EQ(Triple::Vulkan, T.getOS()); |
357 | EXPECT_EQ(VersionTuple(1, 2), T.getVulkanVersion()); |
358 | EXPECT_EQ(Triple::Library, T.getEnvironment()); |
359 | |
360 | T = Triple("spirv-unknown-vulkan-raygeneration" ); |
361 | EXPECT_EQ(Triple::spirv, T.getArch()); |
362 | EXPECT_EQ(Triple::NoSubArch, T.getSubArch()); |
363 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
364 | EXPECT_EQ(Triple::Vulkan, T.getOS()); |
365 | EXPECT_EQ(VersionTuple(1, 2), T.getVulkanVersion()); |
366 | EXPECT_EQ(Triple::RayGeneration, T.getEnvironment()); |
367 | |
368 | T = Triple("spirv-unknown-vulkan-intersection" ); |
369 | EXPECT_EQ(Triple::spirv, T.getArch()); |
370 | EXPECT_EQ(Triple::NoSubArch, T.getSubArch()); |
371 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
372 | EXPECT_EQ(Triple::Vulkan, T.getOS()); |
373 | EXPECT_EQ(VersionTuple(1, 2), T.getVulkanVersion()); |
374 | EXPECT_EQ(Triple::Intersection, T.getEnvironment()); |
375 | |
376 | T = Triple("spirv-unknown-vulkan-anyhit" ); |
377 | EXPECT_EQ(Triple::spirv, T.getArch()); |
378 | EXPECT_EQ(Triple::NoSubArch, T.getSubArch()); |
379 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
380 | EXPECT_EQ(Triple::Vulkan, T.getOS()); |
381 | EXPECT_EQ(VersionTuple(1, 2), T.getVulkanVersion()); |
382 | EXPECT_EQ(Triple::AnyHit, T.getEnvironment()); |
383 | |
384 | T = Triple("spirv-unknown-vulkan-closesthit" ); |
385 | EXPECT_EQ(Triple::spirv, T.getArch()); |
386 | EXPECT_EQ(Triple::NoSubArch, T.getSubArch()); |
387 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
388 | EXPECT_EQ(Triple::Vulkan, T.getOS()); |
389 | EXPECT_EQ(VersionTuple(1, 2), T.getVulkanVersion()); |
390 | EXPECT_EQ(Triple::ClosestHit, T.getEnvironment()); |
391 | |
392 | T = Triple("spirv-unknown-vulkan-miss" ); |
393 | EXPECT_EQ(Triple::spirv, T.getArch()); |
394 | EXPECT_EQ(Triple::NoSubArch, T.getSubArch()); |
395 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
396 | EXPECT_EQ(Triple::Vulkan, T.getOS()); |
397 | EXPECT_EQ(VersionTuple(1, 2), T.getVulkanVersion()); |
398 | EXPECT_EQ(Triple::Miss, T.getEnvironment()); |
399 | |
400 | T = Triple("spirv-unknown-vulkan-callable" ); |
401 | EXPECT_EQ(Triple::spirv, T.getArch()); |
402 | EXPECT_EQ(Triple::NoSubArch, T.getSubArch()); |
403 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
404 | EXPECT_EQ(Triple::Vulkan, T.getOS()); |
405 | EXPECT_EQ(VersionTuple(1, 2), T.getVulkanVersion()); |
406 | EXPECT_EQ(Triple::Callable, T.getEnvironment()); |
407 | |
408 | T = Triple("spirv-unknown-vulkan-mesh" ); |
409 | EXPECT_EQ(Triple::spirv, T.getArch()); |
410 | EXPECT_EQ(Triple::NoSubArch, T.getSubArch()); |
411 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
412 | EXPECT_EQ(Triple::Vulkan, T.getOS()); |
413 | EXPECT_EQ(VersionTuple(1, 2), T.getVulkanVersion()); |
414 | EXPECT_EQ(Triple::Mesh, T.getEnvironment()); |
415 | |
416 | T = Triple("spirv-unknown-vulkan-amplification" ); |
417 | EXPECT_EQ(Triple::spirv, T.getArch()); |
418 | EXPECT_EQ(Triple::NoSubArch, T.getSubArch()); |
419 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
420 | EXPECT_EQ(Triple::Vulkan, T.getOS()); |
421 | EXPECT_EQ(VersionTuple(1, 2), T.getVulkanVersion()); |
422 | EXPECT_EQ(Triple::Amplification, T.getEnvironment()); |
423 | |
424 | T = Triple("spirv1.5-unknown-vulkan1.2-compute" ); |
425 | EXPECT_EQ(Triple::spirv, T.getArch()); |
426 | EXPECT_EQ(Triple::SPIRVSubArch_v15, T.getSubArch()); |
427 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
428 | EXPECT_EQ(Triple::Vulkan, T.getOS()); |
429 | EXPECT_EQ(VersionTuple(1, 2), T.getVulkanVersion()); |
430 | EXPECT_EQ(Triple::Compute, T.getEnvironment()); |
431 | |
432 | T = Triple("spirv1.6-unknown-vulkan1.3-compute" ); |
433 | EXPECT_EQ(Triple::spirv, T.getArch()); |
434 | EXPECT_EQ(Triple::SPIRVSubArch_v16, T.getSubArch()); |
435 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
436 | EXPECT_EQ(Triple::Vulkan, T.getOS()); |
437 | EXPECT_EQ(VersionTuple(1, 3), T.getVulkanVersion()); |
438 | EXPECT_EQ(Triple::Compute, T.getEnvironment()); |
439 | |
440 | T = Triple("x86_64-unknown-fuchsia" ); |
441 | EXPECT_EQ(Triple::x86_64, T.getArch()); |
442 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
443 | EXPECT_EQ(Triple::Fuchsia, T.getOS()); |
444 | EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment()); |
445 | |
446 | T = Triple("x86_64-unknown-hermit" ); |
447 | EXPECT_EQ(Triple::x86_64, T.getArch()); |
448 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
449 | EXPECT_EQ(Triple::HermitCore, T.getOS()); |
450 | EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment()); |
451 | |
452 | T = Triple("x86_64-unknown-uefi" ); |
453 | EXPECT_EQ(Triple::x86_64, T.getArch()); |
454 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
455 | EXPECT_EQ(Triple::UEFI, T.getOS()); |
456 | EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment()); |
457 | EXPECT_EQ(Triple::COFF, T.getObjectFormat()); |
458 | |
459 | T = Triple("wasm32-unknown-unknown" ); |
460 | EXPECT_EQ(Triple::wasm32, T.getArch()); |
461 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
462 | EXPECT_EQ(Triple::UnknownOS, T.getOS()); |
463 | EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment()); |
464 | |
465 | T = Triple("wasm32-unknown-wasi" ); |
466 | EXPECT_EQ(Triple::wasm32, T.getArch()); |
467 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
468 | EXPECT_EQ(Triple::WASI, T.getOS()); |
469 | EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment()); |
470 | |
471 | T = Triple("wasm64-unknown-unknown" ); |
472 | EXPECT_EQ(Triple::wasm64, T.getArch()); |
473 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
474 | EXPECT_EQ(Triple::UnknownOS, T.getOS()); |
475 | EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment()); |
476 | |
477 | T = Triple("wasm64-unknown-wasi" ); |
478 | EXPECT_EQ(Triple::wasm64, T.getArch()); |
479 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
480 | EXPECT_EQ(Triple::WASI, T.getOS()); |
481 | EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment()); |
482 | |
483 | T = Triple("avr-unknown-unknown" ); |
484 | EXPECT_EQ(Triple::avr, T.getArch()); |
485 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
486 | EXPECT_EQ(Triple::UnknownOS, T.getOS()); |
487 | EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment()); |
488 | |
489 | T = Triple("avr" ); |
490 | EXPECT_EQ(Triple::avr, T.getArch()); |
491 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
492 | EXPECT_EQ(Triple::UnknownOS, T.getOS()); |
493 | EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment()); |
494 | |
495 | T = Triple("lanai-unknown-unknown" ); |
496 | EXPECT_EQ(Triple::lanai, T.getArch()); |
497 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
498 | EXPECT_EQ(Triple::UnknownOS, T.getOS()); |
499 | EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment()); |
500 | |
501 | T = Triple("lanai" ); |
502 | EXPECT_EQ(Triple::lanai, T.getArch()); |
503 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
504 | EXPECT_EQ(Triple::UnknownOS, T.getOS()); |
505 | EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment()); |
506 | |
507 | T = Triple("amdgcn-mesa-mesa3d" ); |
508 | EXPECT_EQ(Triple::amdgcn, T.getArch()); |
509 | EXPECT_EQ(Triple::Mesa, T.getVendor()); |
510 | EXPECT_EQ(Triple::Mesa3D, T.getOS()); |
511 | EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment()); |
512 | |
513 | T = Triple("amdgcn-amd-amdhsa" ); |
514 | EXPECT_EQ(Triple::amdgcn, T.getArch()); |
515 | EXPECT_EQ(Triple::AMD, T.getVendor()); |
516 | EXPECT_EQ(Triple::AMDHSA, T.getOS()); |
517 | EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment()); |
518 | |
519 | T = Triple("amdgcn-amd-amdpal" ); |
520 | EXPECT_EQ(Triple::amdgcn, T.getArch()); |
521 | EXPECT_EQ(Triple::AMD, T.getVendor()); |
522 | EXPECT_EQ(Triple::AMDPAL, T.getOS()); |
523 | EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment()); |
524 | |
525 | T = Triple("ve-unknown-linux" ); |
526 | EXPECT_EQ(Triple::ve, T.getArch()); |
527 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
528 | EXPECT_EQ(Triple::Linux, T.getOS()); |
529 | EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment()); |
530 | |
531 | T = Triple("csky-unknown-unknown" ); |
532 | EXPECT_EQ(Triple::csky, T.getArch()); |
533 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
534 | EXPECT_EQ(Triple::UnknownOS, T.getOS()); |
535 | EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment()); |
536 | |
537 | T = Triple("csky-unknown-linux" ); |
538 | EXPECT_EQ(Triple::csky, T.getArch()); |
539 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
540 | EXPECT_EQ(Triple::Linux, T.getOS()); |
541 | EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment()); |
542 | |
543 | T = Triple("loongarch32-unknown-unknown" ); |
544 | EXPECT_EQ(Triple::loongarch32, T.getArch()); |
545 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
546 | EXPECT_EQ(Triple::UnknownOS, T.getOS()); |
547 | EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment()); |
548 | |
549 | T = Triple("loongarch32-unknown-linux-gnu" ); |
550 | EXPECT_EQ(Triple::loongarch32, T.getArch()); |
551 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
552 | EXPECT_EQ(Triple::Linux, T.getOS()); |
553 | EXPECT_EQ(Triple::GNU, T.getEnvironment()); |
554 | |
555 | T = Triple("loongarch32-unknown-linux-gnuf32" ); |
556 | EXPECT_EQ(Triple::loongarch32, T.getArch()); |
557 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
558 | EXPECT_EQ(Triple::Linux, T.getOS()); |
559 | EXPECT_EQ(Triple::GNUF32, T.getEnvironment()); |
560 | |
561 | T = Triple("loongarch32-unknown-linux-gnuf64" ); |
562 | EXPECT_EQ(Triple::loongarch32, T.getArch()); |
563 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
564 | EXPECT_EQ(Triple::Linux, T.getOS()); |
565 | EXPECT_EQ(Triple::GNUF64, T.getEnvironment()); |
566 | |
567 | T = Triple("loongarch32-unknown-linux-gnusf" ); |
568 | EXPECT_EQ(Triple::loongarch32, T.getArch()); |
569 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
570 | EXPECT_EQ(Triple::Linux, T.getOS()); |
571 | EXPECT_EQ(Triple::GNUSF, T.getEnvironment()); |
572 | |
573 | T = Triple("loongarch32-unknown-linux-musl" ); |
574 | EXPECT_EQ(Triple::loongarch32, T.getArch()); |
575 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
576 | EXPECT_EQ(Triple::Linux, T.getOS()); |
577 | EXPECT_EQ(Triple::Musl, T.getEnvironment()); |
578 | |
579 | T = Triple("loongarch64-unknown-linux" ); |
580 | EXPECT_EQ(Triple::loongarch64, T.getArch()); |
581 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
582 | EXPECT_EQ(Triple::Linux, T.getOS()); |
583 | EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment()); |
584 | |
585 | T = Triple("loongarch64-unknown-linux-gnu" ); |
586 | EXPECT_EQ(Triple::loongarch64, T.getArch()); |
587 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
588 | EXPECT_EQ(Triple::Linux, T.getOS()); |
589 | EXPECT_EQ(Triple::GNU, T.getEnvironment()); |
590 | |
591 | T = Triple("loongarch64-unknown-linux-gnuf32" ); |
592 | EXPECT_EQ(Triple::loongarch64, T.getArch()); |
593 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
594 | EXPECT_EQ(Triple::Linux, T.getOS()); |
595 | EXPECT_EQ(Triple::GNUF32, T.getEnvironment()); |
596 | |
597 | T = Triple("loongarch64-unknown-linux-gnuf64" ); |
598 | EXPECT_EQ(Triple::loongarch64, T.getArch()); |
599 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
600 | EXPECT_EQ(Triple::Linux, T.getOS()); |
601 | EXPECT_EQ(Triple::GNUF64, T.getEnvironment()); |
602 | |
603 | T = Triple("loongarch64-unknown-linux-gnusf" ); |
604 | EXPECT_EQ(Triple::loongarch64, T.getArch()); |
605 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
606 | EXPECT_EQ(Triple::Linux, T.getOS()); |
607 | EXPECT_EQ(Triple::GNUSF, T.getEnvironment()); |
608 | |
609 | T = Triple("loongarch64-unknown-linux-musl" ); |
610 | EXPECT_EQ(Triple::loongarch64, T.getArch()); |
611 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
612 | EXPECT_EQ(Triple::Linux, T.getOS()); |
613 | EXPECT_EQ(Triple::Musl, T.getEnvironment()); |
614 | |
615 | T = Triple("riscv32-unknown-unknown" ); |
616 | EXPECT_EQ(Triple::riscv32, T.getArch()); |
617 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
618 | EXPECT_EQ(Triple::UnknownOS, T.getOS()); |
619 | EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment()); |
620 | |
621 | T = Triple("riscv64-unknown-linux" ); |
622 | EXPECT_EQ(Triple::riscv64, T.getArch()); |
623 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
624 | EXPECT_EQ(Triple::Linux, T.getOS()); |
625 | EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment()); |
626 | |
627 | T = Triple("riscv64-unknown-freebsd" ); |
628 | EXPECT_EQ(Triple::riscv64, T.getArch()); |
629 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
630 | EXPECT_EQ(Triple::FreeBSD, T.getOS()); |
631 | EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment()); |
632 | |
633 | T = Triple("riscv64-suse-linux" ); |
634 | EXPECT_EQ(Triple::riscv64, T.getArch()); |
635 | EXPECT_EQ(Triple::SUSE, T.getVendor()); |
636 | EXPECT_EQ(Triple::Linux, T.getOS()); |
637 | EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment()); |
638 | |
639 | T = Triple("armv7hl-suse-linux-gnueabi" ); |
640 | EXPECT_EQ(Triple::arm, T.getArch()); |
641 | EXPECT_EQ(Triple::SUSE, T.getVendor()); |
642 | EXPECT_EQ(Triple::Linux, T.getOS()); |
643 | EXPECT_EQ(Triple::GNUEABI, T.getEnvironment()); |
644 | |
645 | T = Triple("i586-pc-haiku" ); |
646 | EXPECT_EQ(Triple::x86, T.getArch()); |
647 | EXPECT_EQ(Triple::PC, T.getVendor()); |
648 | EXPECT_EQ(Triple::Haiku, T.getOS()); |
649 | EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment()); |
650 | |
651 | T = Triple("x86_64-unknown-haiku" ); |
652 | EXPECT_EQ(Triple::x86_64, T.getArch()); |
653 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
654 | EXPECT_EQ(Triple::Haiku, T.getOS()); |
655 | EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment()); |
656 | |
657 | T = Triple("mips-mti-linux-gnu" ); |
658 | EXPECT_EQ(Triple::mips, T.getArch()); |
659 | EXPECT_EQ(Triple::MipsTechnologies, T.getVendor()); |
660 | EXPECT_EQ(Triple::Linux, T.getOS()); |
661 | EXPECT_EQ(Triple::GNU, T.getEnvironment()); |
662 | |
663 | T = Triple("mipsel-img-linux-gnu" ); |
664 | EXPECT_EQ(Triple::mipsel, T.getArch()); |
665 | EXPECT_EQ(Triple::ImaginationTechnologies, T.getVendor()); |
666 | EXPECT_EQ(Triple::Linux, T.getOS()); |
667 | EXPECT_EQ(Triple::GNU, T.getEnvironment()); |
668 | |
669 | T = Triple("mips64-mti-linux-gnu" ); |
670 | EXPECT_EQ(Triple::mips64, T.getArch()); |
671 | EXPECT_EQ(Triple::MipsTechnologies, T.getVendor()); |
672 | EXPECT_EQ(Triple::Linux, T.getOS()); |
673 | EXPECT_EQ(Triple::GNU, T.getEnvironment()); |
674 | |
675 | T = Triple("mips64el-img-linux-gnu" ); |
676 | EXPECT_EQ(Triple::mips64el, T.getArch()); |
677 | EXPECT_EQ(Triple::ImaginationTechnologies, T.getVendor()); |
678 | EXPECT_EQ(Triple::Linux, T.getOS()); |
679 | EXPECT_EQ(Triple::GNU, T.getEnvironment()); |
680 | |
681 | T = Triple("mips64el-img-linux-gnuabin32" ); |
682 | EXPECT_EQ(Triple::mips64el, T.getArch()); |
683 | EXPECT_EQ(Triple::ImaginationTechnologies, T.getVendor()); |
684 | EXPECT_EQ(Triple::Linux, T.getOS()); |
685 | EXPECT_EQ(Triple::GNUABIN32, T.getEnvironment()); |
686 | |
687 | T = Triple("mips64el-unknown-linux-gnuabi64" ); |
688 | EXPECT_EQ(Triple::mips64el, T.getArch()); |
689 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
690 | EXPECT_EQ(Triple::Linux, T.getOS()); |
691 | EXPECT_EQ(Triple::GNUABI64, T.getEnvironment()); |
692 | EXPECT_EQ(Triple::NoSubArch, T.getSubArch()); |
693 | T = Triple("mips64el" ); |
694 | EXPECT_EQ(Triple::mips64el, T.getArch()); |
695 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
696 | EXPECT_EQ(Triple::GNUABI64, T.getEnvironment()); |
697 | EXPECT_EQ(Triple::NoSubArch, T.getSubArch()); |
698 | |
699 | T = Triple("mips64-unknown-linux-gnuabi64" ); |
700 | EXPECT_EQ(Triple::mips64, T.getArch()); |
701 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
702 | EXPECT_EQ(Triple::Linux, T.getOS()); |
703 | EXPECT_EQ(Triple::GNUABI64, T.getEnvironment()); |
704 | EXPECT_EQ(Triple::NoSubArch, T.getSubArch()); |
705 | T = Triple("mips64" ); |
706 | EXPECT_EQ(Triple::mips64, T.getArch()); |
707 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
708 | EXPECT_EQ(Triple::GNUABI64, T.getEnvironment()); |
709 | EXPECT_EQ(Triple::NoSubArch, T.getSubArch()); |
710 | |
711 | T = Triple("mipsisa64r6el-unknown-linux-gnuabi64" ); |
712 | EXPECT_EQ(Triple::mips64el, T.getArch()); |
713 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
714 | EXPECT_EQ(Triple::Linux, T.getOS()); |
715 | EXPECT_EQ(Triple::GNUABI64, T.getEnvironment()); |
716 | EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch()); |
717 | T = Triple("mips64r6el" ); |
718 | EXPECT_EQ(Triple::mips64el, T.getArch()); |
719 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
720 | EXPECT_EQ(Triple::GNUABI64, T.getEnvironment()); |
721 | EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch()); |
722 | T = Triple("mipsisa64r6el" ); |
723 | EXPECT_EQ(Triple::mips64el, T.getArch()); |
724 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
725 | EXPECT_EQ(Triple::GNUABI64, T.getEnvironment()); |
726 | EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch()); |
727 | |
728 | T = Triple("mipsisa64r6-unknown-linux-gnuabi64" ); |
729 | EXPECT_EQ(Triple::mips64, T.getArch()); |
730 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
731 | EXPECT_EQ(Triple::Linux, T.getOS()); |
732 | EXPECT_EQ(Triple::GNUABI64, T.getEnvironment()); |
733 | EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch()); |
734 | T = Triple("mips64r6" ); |
735 | EXPECT_EQ(Triple::mips64, T.getArch()); |
736 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
737 | EXPECT_EQ(Triple::GNUABI64, T.getEnvironment()); |
738 | EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch()); |
739 | T = Triple("mipsisa64r6" ); |
740 | EXPECT_EQ(Triple::mips64, T.getArch()); |
741 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
742 | EXPECT_EQ(Triple::GNUABI64, T.getEnvironment()); |
743 | EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch()); |
744 | |
745 | T = Triple("mips64el-unknown-linux-gnuabin32" ); |
746 | EXPECT_EQ(Triple::mips64el, T.getArch()); |
747 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
748 | EXPECT_EQ(Triple::Linux, T.getOS()); |
749 | EXPECT_EQ(Triple::GNUABIN32, T.getEnvironment()); |
750 | EXPECT_EQ(Triple::NoSubArch, T.getSubArch()); |
751 | T = Triple("mipsn32el" ); |
752 | EXPECT_EQ(Triple::mips64el, T.getArch()); |
753 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
754 | EXPECT_EQ(Triple::GNUABIN32, T.getEnvironment()); |
755 | EXPECT_EQ(Triple::NoSubArch, T.getSubArch()); |
756 | |
757 | T = Triple("mips64-unknown-linux-gnuabin32" ); |
758 | EXPECT_EQ(Triple::mips64, T.getArch()); |
759 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
760 | EXPECT_EQ(Triple::Linux, T.getOS()); |
761 | EXPECT_EQ(Triple::GNUABIN32, T.getEnvironment()); |
762 | EXPECT_EQ(Triple::NoSubArch, T.getSubArch()); |
763 | T = Triple("mipsn32" ); |
764 | EXPECT_EQ(Triple::mips64, T.getArch()); |
765 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
766 | EXPECT_EQ(Triple::GNUABIN32, T.getEnvironment()); |
767 | EXPECT_EQ(Triple::NoSubArch, T.getSubArch()); |
768 | |
769 | T = Triple("mipsisa64r6el-unknown-linux-gnuabin32" ); |
770 | EXPECT_EQ(Triple::mips64el, T.getArch()); |
771 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
772 | EXPECT_EQ(Triple::Linux, T.getOS()); |
773 | EXPECT_EQ(Triple::GNUABIN32, T.getEnvironment()); |
774 | EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch()); |
775 | T = Triple("mipsn32r6el" ); |
776 | EXPECT_EQ(Triple::mips64el, T.getArch()); |
777 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
778 | EXPECT_EQ(Triple::GNUABIN32, T.getEnvironment()); |
779 | EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch()); |
780 | |
781 | T = Triple("mipsisa64r6-unknown-linux-gnuabin32" ); |
782 | EXPECT_EQ(Triple::mips64, T.getArch()); |
783 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
784 | EXPECT_EQ(Triple::Linux, T.getOS()); |
785 | EXPECT_EQ(Triple::GNUABIN32, T.getEnvironment()); |
786 | EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch()); |
787 | T = Triple("mipsn32r6" ); |
788 | EXPECT_EQ(Triple::mips64, T.getArch()); |
789 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
790 | EXPECT_EQ(Triple::GNUABIN32, T.getEnvironment()); |
791 | EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch()); |
792 | |
793 | T = Triple("mipsel-unknown-linux-gnu" ); |
794 | EXPECT_EQ(Triple::mipsel, T.getArch()); |
795 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
796 | EXPECT_EQ(Triple::Linux, T.getOS()); |
797 | EXPECT_EQ(Triple::GNU, T.getEnvironment()); |
798 | EXPECT_EQ(Triple::NoSubArch, T.getSubArch()); |
799 | T = Triple("mipsel" ); |
800 | EXPECT_EQ(Triple::mipsel, T.getArch()); |
801 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
802 | EXPECT_EQ(Triple::GNU, T.getEnvironment()); |
803 | EXPECT_EQ(Triple::NoSubArch, T.getSubArch()); |
804 | |
805 | T = Triple("mips-unknown-linux-gnu" ); |
806 | EXPECT_EQ(Triple::mips, T.getArch()); |
807 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
808 | EXPECT_EQ(Triple::Linux, T.getOS()); |
809 | EXPECT_EQ(Triple::GNU, T.getEnvironment()); |
810 | EXPECT_EQ(Triple::NoSubArch, T.getSubArch()); |
811 | T = Triple("mips" ); |
812 | EXPECT_EQ(Triple::mips, T.getArch()); |
813 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
814 | EXPECT_EQ(Triple::GNU, T.getEnvironment()); |
815 | EXPECT_EQ(Triple::NoSubArch, T.getSubArch()); |
816 | |
817 | T = Triple("mipsisa32r6el-unknown-linux-gnu" ); |
818 | EXPECT_EQ(Triple::mipsel, T.getArch()); |
819 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
820 | EXPECT_EQ(Triple::Linux, T.getOS()); |
821 | EXPECT_EQ(Triple::GNU, T.getEnvironment()); |
822 | EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch()); |
823 | T = Triple("mipsr6el" ); |
824 | EXPECT_EQ(Triple::mipsel, T.getArch()); |
825 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
826 | EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch()); |
827 | T = Triple("mipsisa32r6el" ); |
828 | EXPECT_EQ(Triple::mipsel, T.getArch()); |
829 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
830 | EXPECT_EQ(Triple::GNU, T.getEnvironment()); |
831 | EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch()); |
832 | |
833 | T = Triple("mipsisa32r6-unknown-linux-gnu" ); |
834 | EXPECT_EQ(Triple::mips, T.getArch()); |
835 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
836 | EXPECT_EQ(Triple::Linux, T.getOS()); |
837 | EXPECT_EQ(Triple::GNU, T.getEnvironment()); |
838 | EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch()); |
839 | T = Triple("mipsr6" ); |
840 | EXPECT_EQ(Triple::mips, T.getArch()); |
841 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
842 | EXPECT_EQ(Triple::GNU, T.getEnvironment()); |
843 | EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch()); |
844 | T = Triple("mipsisa32r6" ); |
845 | EXPECT_EQ(Triple::mips, T.getArch()); |
846 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
847 | EXPECT_EQ(Triple::GNU, T.getEnvironment()); |
848 | EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch()); |
849 | |
850 | T = Triple("arm-oe-linux-gnueabi" ); |
851 | EXPECT_EQ(Triple::arm, T.getArch()); |
852 | EXPECT_EQ(Triple::OpenEmbedded, T.getVendor()); |
853 | EXPECT_EQ(Triple::Linux, T.getOS()); |
854 | EXPECT_EQ(Triple::GNUEABI, T.getEnvironment()); |
855 | |
856 | T = Triple("aarch64-oe-linux" ); |
857 | EXPECT_EQ(Triple::aarch64, T.getArch()); |
858 | EXPECT_EQ(Triple::OpenEmbedded, T.getVendor()); |
859 | EXPECT_EQ(Triple::Linux, T.getOS()); |
860 | EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment()); |
861 | EXPECT_TRUE(T.isArch64Bit()); |
862 | |
863 | T = Triple("arm64_32-apple-ios" ); |
864 | EXPECT_EQ(Triple::aarch64_32, T.getArch()); |
865 | EXPECT_EQ(Triple::IOS, T.getOS()); |
866 | EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment()); |
867 | EXPECT_TRUE(T.isArch32Bit()); |
868 | |
869 | T = Triple("dxil-unknown-shadermodel-pixel" ); |
870 | EXPECT_EQ(Triple::dxil, T.getArch()); |
871 | EXPECT_EQ(Triple::NoSubArch, T.getSubArch()); |
872 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
873 | EXPECT_EQ(Triple::ShaderModel, T.getOS()); |
874 | EXPECT_EQ(Triple::Pixel, T.getEnvironment()); |
875 | EXPECT_FALSE(T.supportsCOMDAT()); |
876 | |
877 | T = Triple("dxil-unknown-shadermodel-vertex" ); |
878 | EXPECT_EQ(Triple::dxil, T.getArch()); |
879 | EXPECT_EQ(Triple::NoSubArch, T.getSubArch()); |
880 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
881 | EXPECT_EQ(Triple::ShaderModel, T.getOS()); |
882 | EXPECT_EQ(Triple::Vertex, T.getEnvironment()); |
883 | EXPECT_FALSE(T.supportsCOMDAT()); |
884 | |
885 | T = Triple("dxil-unknown-shadermodel-geometry" ); |
886 | EXPECT_EQ(Triple::dxil, T.getArch()); |
887 | EXPECT_EQ(Triple::NoSubArch, T.getSubArch()); |
888 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
889 | EXPECT_EQ(Triple::ShaderModel, T.getOS()); |
890 | EXPECT_EQ(Triple::Geometry, T.getEnvironment()); |
891 | EXPECT_FALSE(T.supportsCOMDAT()); |
892 | |
893 | T = Triple("dxil-unknown-shadermodel-hull" ); |
894 | EXPECT_EQ(Triple::dxil, T.getArch()); |
895 | EXPECT_EQ(Triple::NoSubArch, T.getSubArch()); |
896 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
897 | EXPECT_EQ(Triple::ShaderModel, T.getOS()); |
898 | EXPECT_EQ(Triple::Hull, T.getEnvironment()); |
899 | EXPECT_FALSE(T.supportsCOMDAT()); |
900 | |
901 | T = Triple("dxil-unknown-shadermodel-domain" ); |
902 | EXPECT_EQ(Triple::dxil, T.getArch()); |
903 | EXPECT_EQ(Triple::NoSubArch, T.getSubArch()); |
904 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
905 | EXPECT_EQ(Triple::ShaderModel, T.getOS()); |
906 | EXPECT_EQ(Triple::Domain, T.getEnvironment()); |
907 | EXPECT_FALSE(T.supportsCOMDAT()); |
908 | |
909 | T = Triple("dxil-unknown-shadermodel-compute" ); |
910 | EXPECT_EQ(Triple::dxil, T.getArch()); |
911 | EXPECT_EQ(Triple::NoSubArch, T.getSubArch()); |
912 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
913 | EXPECT_EQ(Triple::ShaderModel, T.getOS()); |
914 | EXPECT_EQ(Triple::Compute, T.getEnvironment()); |
915 | EXPECT_FALSE(T.supportsCOMDAT()); |
916 | |
917 | T = Triple("dxil-unknown-shadermodel-library" ); |
918 | EXPECT_EQ(Triple::dxil, T.getArch()); |
919 | EXPECT_EQ(Triple::NoSubArch, T.getSubArch()); |
920 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
921 | EXPECT_EQ(Triple::ShaderModel, T.getOS()); |
922 | EXPECT_EQ(Triple::Library, T.getEnvironment()); |
923 | EXPECT_FALSE(T.supportsCOMDAT()); |
924 | |
925 | T = Triple("dxil-unknown-shadermodel-raygeneration" ); |
926 | EXPECT_EQ(Triple::dxil, T.getArch()); |
927 | EXPECT_EQ(Triple::NoSubArch, T.getSubArch()); |
928 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
929 | EXPECT_EQ(Triple::ShaderModel, T.getOS()); |
930 | EXPECT_EQ(Triple::RayGeneration, T.getEnvironment()); |
931 | EXPECT_FALSE(T.supportsCOMDAT()); |
932 | |
933 | T = Triple("dxil-unknown-shadermodel-intersection" ); |
934 | EXPECT_EQ(Triple::dxil, T.getArch()); |
935 | EXPECT_EQ(Triple::NoSubArch, T.getSubArch()); |
936 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
937 | EXPECT_EQ(Triple::ShaderModel, T.getOS()); |
938 | EXPECT_EQ(Triple::Intersection, T.getEnvironment()); |
939 | EXPECT_FALSE(T.supportsCOMDAT()); |
940 | |
941 | T = Triple("dxil-unknown-shadermodel-anyhit" ); |
942 | EXPECT_EQ(Triple::dxil, T.getArch()); |
943 | EXPECT_EQ(Triple::NoSubArch, T.getSubArch()); |
944 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
945 | EXPECT_EQ(Triple::ShaderModel, T.getOS()); |
946 | EXPECT_EQ(Triple::AnyHit, T.getEnvironment()); |
947 | EXPECT_FALSE(T.supportsCOMDAT()); |
948 | |
949 | T = Triple("dxil-unknown-shadermodel-closesthit" ); |
950 | EXPECT_EQ(Triple::dxil, T.getArch()); |
951 | EXPECT_EQ(Triple::NoSubArch, T.getSubArch()); |
952 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
953 | EXPECT_EQ(Triple::ShaderModel, T.getOS()); |
954 | EXPECT_EQ(Triple::ClosestHit, T.getEnvironment()); |
955 | EXPECT_FALSE(T.supportsCOMDAT()); |
956 | |
957 | T = Triple("dxil-unknown-shadermodel-miss" ); |
958 | EXPECT_EQ(Triple::dxil, T.getArch()); |
959 | EXPECT_EQ(Triple::NoSubArch, T.getSubArch()); |
960 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
961 | EXPECT_EQ(Triple::ShaderModel, T.getOS()); |
962 | EXPECT_EQ(Triple::Miss, T.getEnvironment()); |
963 | EXPECT_FALSE(T.supportsCOMDAT()); |
964 | |
965 | T = Triple("dxil-unknown-shadermodel-callable" ); |
966 | EXPECT_EQ(Triple::dxil, T.getArch()); |
967 | EXPECT_EQ(Triple::NoSubArch, T.getSubArch()); |
968 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
969 | EXPECT_EQ(Triple::ShaderModel, T.getOS()); |
970 | EXPECT_EQ(Triple::Callable, T.getEnvironment()); |
971 | EXPECT_FALSE(T.supportsCOMDAT()); |
972 | |
973 | T = Triple("dxil-unknown-shadermodel-mesh" ); |
974 | EXPECT_EQ(Triple::dxil, T.getArch()); |
975 | EXPECT_EQ(Triple::NoSubArch, T.getSubArch()); |
976 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
977 | EXPECT_EQ(Triple::ShaderModel, T.getOS()); |
978 | EXPECT_EQ(Triple::Mesh, T.getEnvironment()); |
979 | EXPECT_FALSE(T.supportsCOMDAT()); |
980 | |
981 | T = Triple("dxil-unknown-shadermodel-amplification" ); |
982 | EXPECT_EQ(Triple::dxil, T.getArch()); |
983 | EXPECT_EQ(Triple::NoSubArch, T.getSubArch()); |
984 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
985 | EXPECT_EQ(Triple::ShaderModel, T.getOS()); |
986 | EXPECT_EQ(Triple::Amplification, T.getEnvironment()); |
987 | EXPECT_FALSE(T.supportsCOMDAT()); |
988 | |
989 | T = Triple("dxilv1.0-unknown-unknown" ); |
990 | EXPECT_EQ(Triple::dxil, T.getArch()); |
991 | EXPECT_EQ(Triple::DXILSubArch_v1_0, T.getSubArch()); |
992 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
993 | EXPECT_EQ(Triple::UnknownOS, T.getOS()); |
994 | |
995 | T = Triple("dxilv1.1-unknown-unknown" ); |
996 | EXPECT_EQ(Triple::dxil, T.getArch()); |
997 | EXPECT_EQ(Triple::DXILSubArch_v1_1, T.getSubArch()); |
998 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
999 | EXPECT_EQ(Triple::UnknownOS, T.getOS()); |
1000 | |
1001 | T = Triple("dxilv1.2-unknown-unknown" ); |
1002 | EXPECT_EQ(Triple::dxil, T.getArch()); |
1003 | EXPECT_EQ(Triple::DXILSubArch_v1_2, T.getSubArch()); |
1004 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
1005 | EXPECT_EQ(Triple::UnknownOS, T.getOS()); |
1006 | |
1007 | T = Triple("dxilv1.3-unknown-unknown" ); |
1008 | EXPECT_EQ(Triple::dxil, T.getArch()); |
1009 | EXPECT_EQ(Triple::DXILSubArch_v1_3, T.getSubArch()); |
1010 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
1011 | EXPECT_EQ(Triple::UnknownOS, T.getOS()); |
1012 | |
1013 | T = Triple("dxilv1.4-unknown-unknown" ); |
1014 | EXPECT_EQ(Triple::dxil, T.getArch()); |
1015 | EXPECT_EQ(Triple::DXILSubArch_v1_4, T.getSubArch()); |
1016 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
1017 | EXPECT_EQ(Triple::UnknownOS, T.getOS()); |
1018 | |
1019 | T = Triple("dxilv1.5-unknown-unknown" ); |
1020 | EXPECT_EQ(Triple::dxil, T.getArch()); |
1021 | EXPECT_EQ(Triple::DXILSubArch_v1_5, T.getSubArch()); |
1022 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
1023 | EXPECT_EQ(Triple::UnknownOS, T.getOS()); |
1024 | |
1025 | T = Triple("dxilv1.6-unknown-unknown" ); |
1026 | EXPECT_EQ(Triple::dxil, T.getArch()); |
1027 | EXPECT_EQ(Triple::DXILSubArch_v1_6, T.getSubArch()); |
1028 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
1029 | EXPECT_EQ(Triple::UnknownOS, T.getOS()); |
1030 | |
1031 | T = Triple("dxilv1.7-unknown-unknown" ); |
1032 | EXPECT_EQ(Triple::dxil, T.getArch()); |
1033 | EXPECT_EQ(Triple::DXILSubArch_v1_7, T.getSubArch()); |
1034 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
1035 | EXPECT_EQ(Triple::UnknownOS, T.getOS()); |
1036 | |
1037 | T = Triple("dxilv1.8-unknown-unknown" ); |
1038 | EXPECT_EQ(Triple::dxil, T.getArch()); |
1039 | EXPECT_EQ(Triple::DXILSubArch_v1_8, T.getSubArch()); |
1040 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
1041 | EXPECT_EQ(Triple::UnknownOS, T.getOS()); |
1042 | |
1043 | // Check specification of unknown SubArch results in |
1044 | // unknown architecture. |
1045 | T = Triple("dxilv1.999-unknown-unknown" ); |
1046 | EXPECT_EQ(Triple::UnknownArch, T.getArch()); |
1047 | EXPECT_EQ(Triple::NoSubArch, T.getSubArch()); |
1048 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
1049 | EXPECT_EQ(Triple::UnknownOS, T.getOS()); |
1050 | |
1051 | T = Triple("dxil-unknown-unknown" ); |
1052 | EXPECT_EQ(Triple::dxil, T.getArch()); |
1053 | EXPECT_EQ(Triple::NoSubArch, T.getSubArch()); |
1054 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
1055 | EXPECT_EQ(Triple::UnknownOS, T.getOS()); |
1056 | |
1057 | T = Triple("xtensa" ); |
1058 | EXPECT_EQ(Triple::xtensa, T.getArch()); |
1059 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
1060 | EXPECT_EQ(Triple::UnknownOS, T.getOS()); |
1061 | EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment()); |
1062 | |
1063 | T = Triple("xtensa-unknown-unknown" ); |
1064 | EXPECT_EQ(Triple::xtensa, T.getArch()); |
1065 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
1066 | EXPECT_EQ(Triple::UnknownOS, T.getOS()); |
1067 | EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment()); |
1068 | |
1069 | T = Triple("arm-unknown-linux-ohos" ); |
1070 | EXPECT_EQ(Triple::arm, T.getArch()); |
1071 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
1072 | EXPECT_EQ(Triple::Linux, T.getOS()); |
1073 | EXPECT_EQ(Triple::OpenHOS, T.getEnvironment()); |
1074 | |
1075 | T = Triple("arm-unknown-liteos" ); |
1076 | EXPECT_EQ(Triple::arm, T.getArch()); |
1077 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
1078 | EXPECT_EQ(Triple::LiteOS, T.getOS()); |
1079 | EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment()); |
1080 | |
1081 | T = Triple("x86_64-pc-serenity" ); |
1082 | EXPECT_EQ(Triple::x86_64, T.getArch()); |
1083 | EXPECT_EQ(Triple::PC, T.getVendor()); |
1084 | EXPECT_EQ(Triple::Serenity, T.getOS()); |
1085 | EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment()); |
1086 | |
1087 | T = Triple("aarch64-pc-serenity" ); |
1088 | EXPECT_EQ(Triple::aarch64, T.getArch()); |
1089 | EXPECT_EQ(Triple::PC, T.getVendor()); |
1090 | EXPECT_EQ(Triple::Serenity, T.getOS()); |
1091 | EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment()); |
1092 | |
1093 | T = Triple("huh" ); |
1094 | EXPECT_EQ(Triple::UnknownArch, T.getArch()); |
1095 | } |
1096 | |
1097 | static std::string Join(StringRef A, StringRef B, StringRef C) { |
1098 | std::string Str = std::string(A); |
1099 | Str += '-'; |
1100 | Str += B; |
1101 | Str += '-'; |
1102 | Str += C; |
1103 | return Str; |
1104 | } |
1105 | |
1106 | static std::string Join(StringRef A, StringRef B, StringRef C, StringRef D) { |
1107 | std::string Str = std::string(A); |
1108 | Str += '-'; |
1109 | Str += B; |
1110 | Str += '-'; |
1111 | Str += C; |
1112 | Str += '-'; |
1113 | Str += D; |
1114 | return Str; |
1115 | } |
1116 | |
1117 | TEST(TripleTest, Normalization) { |
1118 | |
1119 | EXPECT_EQ("unknown" , Triple::normalize("" )); |
1120 | EXPECT_EQ("unknown-unknown" , Triple::normalize("-" )); |
1121 | EXPECT_EQ("unknown-unknown-unknown" , Triple::normalize("--" )); |
1122 | EXPECT_EQ("unknown-unknown-unknown-unknown" , Triple::normalize("---" )); |
1123 | EXPECT_EQ("unknown-unknown-unknown-unknown-unknown" , |
1124 | Triple::normalize("----" )); |
1125 | |
1126 | EXPECT_EQ("a" , Triple::normalize("a" )); |
1127 | EXPECT_EQ("a-b" , Triple::normalize("a-b" )); |
1128 | EXPECT_EQ("a-b-c" , Triple::normalize("a-b-c" )); |
1129 | EXPECT_EQ("a-b-c-d" , Triple::normalize("a-b-c-d" )); |
1130 | |
1131 | EXPECT_EQ("i386-b-c" , Triple::normalize("i386-b-c" )); |
1132 | EXPECT_EQ("i386-a-c" , Triple::normalize("a-i386-c" )); |
1133 | EXPECT_EQ("i386-a-b" , Triple::normalize("a-b-i386" )); |
1134 | EXPECT_EQ("i386-a-b-c" , Triple::normalize("a-b-c-i386" )); |
1135 | |
1136 | EXPECT_EQ("a-pc-c" , Triple::normalize("a-pc-c" )); |
1137 | EXPECT_EQ("unknown-pc-b-c" , Triple::normalize("pc-b-c" )); |
1138 | EXPECT_EQ("a-pc-b" , Triple::normalize("a-b-pc" )); |
1139 | EXPECT_EQ("a-pc-b-c" , Triple::normalize("a-b-c-pc" )); |
1140 | |
1141 | EXPECT_EQ("a-b-linux" , Triple::normalize("a-b-linux" )); |
1142 | EXPECT_EQ("unknown-unknown-linux-b-c" , Triple::normalize("linux-b-c" )); |
1143 | EXPECT_EQ("a-unknown-linux-c" , Triple::normalize("a-linux-c" )); |
1144 | |
1145 | EXPECT_EQ("i386-pc-a" , Triple::normalize("a-pc-i386" )); |
1146 | EXPECT_EQ("i386-pc-unknown" , Triple::normalize("-pc-i386" )); |
1147 | EXPECT_EQ("unknown-pc-linux-c" , Triple::normalize("linux-pc-c" )); |
1148 | EXPECT_EQ("unknown-pc-linux" , Triple::normalize("linux-pc-" )); |
1149 | |
1150 | EXPECT_EQ("i386" , Triple::normalize("i386" )); |
1151 | EXPECT_EQ("unknown-pc" , Triple::normalize("pc" )); |
1152 | EXPECT_EQ("unknown-unknown-linux" , Triple::normalize("linux" )); |
1153 | |
1154 | EXPECT_EQ("x86_64-unknown-linux-gnu" , Triple::normalize("x86_64-gnu-linux" )); |
1155 | |
1156 | // Check that normalizing a permutated set of valid components returns a |
1157 | // triple with the unpermuted components. |
1158 | // |
1159 | // We don't check every possible combination. For the set of architectures A, |
1160 | // vendors V, operating systems O, and environments E, that would require |A| |
1161 | // * |V| * |O| * |E| * 4! tests. Instead we check every option for any given |
1162 | // slot and make sure it gets normalized to the correct position from every |
1163 | // permutation. This should cover the core logic while being a tractable |
1164 | // number of tests at (|A| + |V| + |O| + |E|) * 4!. |
1165 | auto FirstArchType = Triple::ArchType(Triple::UnknownArch + 1); |
1166 | auto FirstVendorType = Triple::VendorType(Triple::UnknownVendor + 1); |
1167 | auto FirstOSType = Triple::OSType(Triple::UnknownOS + 1); |
1168 | auto FirstEnvType = Triple::EnvironmentType(Triple::UnknownEnvironment + 1); |
1169 | StringRef InitialC[] = {Triple::getArchTypeName(Kind: FirstArchType), |
1170 | Triple::getVendorTypeName(Kind: FirstVendorType), |
1171 | Triple::getOSTypeName(Kind: FirstOSType), |
1172 | Triple::getEnvironmentTypeName(Kind: FirstEnvType)}; |
1173 | for (int Arch = FirstArchType; Arch <= Triple::LastArchType; ++Arch) { |
1174 | StringRef C[] = {InitialC[0], InitialC[1], InitialC[2], InitialC[3]}; |
1175 | C[0] = Triple::getArchTypeName(Kind: Triple::ArchType(Arch)); |
1176 | std::string E = Join(A: C[0], B: C[1], C: C[2]); |
1177 | int I[] = {0, 1, 2}; |
1178 | do { |
1179 | EXPECT_EQ(E, Triple::normalize(Join(C[I[0]], C[I[1]], C[I[2]]))); |
1180 | } while (std::next_permutation(first: std::begin(arr&: I), last: std::end(arr&: I))); |
1181 | std::string F = Join(A: C[0], B: C[1], C: C[2], D: C[3]); |
1182 | int J[] = {0, 1, 2, 3}; |
1183 | do { |
1184 | EXPECT_EQ(F, Triple::normalize(Join(C[J[0]], C[J[1]], C[J[2]], C[J[3]]))); |
1185 | } while (std::next_permutation(first: std::begin(arr&: J), last: std::end(arr&: J))); |
1186 | } |
1187 | for (int Vendor = FirstVendorType; Vendor <= Triple::LastVendorType; |
1188 | ++Vendor) { |
1189 | StringRef C[] = {InitialC[0], InitialC[1], InitialC[2], InitialC[3]}; |
1190 | C[1] = Triple::getVendorTypeName(Kind: Triple::VendorType(Vendor)); |
1191 | std::string E = Join(A: C[0], B: C[1], C: C[2]); |
1192 | int I[] = {0, 1, 2}; |
1193 | do { |
1194 | EXPECT_EQ(E, Triple::normalize(Join(C[I[0]], C[I[1]], C[I[2]]))); |
1195 | } while (std::next_permutation(first: std::begin(arr&: I), last: std::end(arr&: I))); |
1196 | std::string F = Join(A: C[0], B: C[1], C: C[2], D: C[3]); |
1197 | int J[] = {0, 1, 2, 3}; |
1198 | do { |
1199 | EXPECT_EQ(F, Triple::normalize(Join(C[J[0]], C[J[1]], C[J[2]], C[J[3]]))); |
1200 | } while (std::next_permutation(first: std::begin(arr&: J), last: std::end(arr&: J))); |
1201 | } |
1202 | for (int OS = FirstOSType; OS <= Triple::LastOSType; ++OS) { |
1203 | if (OS == Triple::Win32) |
1204 | continue; |
1205 | StringRef C[] = {InitialC[0], InitialC[1], InitialC[2], InitialC[3]}; |
1206 | C[2] = Triple::getOSTypeName(Kind: Triple::OSType(OS)); |
1207 | std::string E = Join(A: C[0], B: C[1], C: C[2]); |
1208 | int I[] = {0, 1, 2}; |
1209 | do { |
1210 | EXPECT_EQ(E, Triple::normalize(Join(C[I[0]], C[I[1]], C[I[2]]))); |
1211 | } while (std::next_permutation(first: std::begin(arr&: I), last: std::end(arr&: I))); |
1212 | std::string F = Join(A: C[0], B: C[1], C: C[2], D: C[3]); |
1213 | int J[] = {0, 1, 2, 3}; |
1214 | do { |
1215 | EXPECT_EQ(F, Triple::normalize(Join(C[J[0]], C[J[1]], C[J[2]], C[J[3]]))); |
1216 | } while (std::next_permutation(first: std::begin(arr&: J), last: std::end(arr&: J))); |
1217 | } |
1218 | for (int Env = FirstEnvType; Env <= Triple::LastEnvironmentType; ++Env) { |
1219 | StringRef C[] = {InitialC[0], InitialC[1], InitialC[2], InitialC[3]}; |
1220 | C[3] = Triple::getEnvironmentTypeName(Kind: Triple::EnvironmentType(Env)); |
1221 | std::string F = Join(A: C[0], B: C[1], C: C[2], D: C[3]); |
1222 | int J[] = {0, 1, 2, 3}; |
1223 | do { |
1224 | EXPECT_EQ(F, Triple::normalize(Join(C[J[0]], C[J[1]], C[J[2]], C[J[3]]))); |
1225 | } while (std::next_permutation(first: std::begin(arr&: J), last: std::end(arr&: J))); |
1226 | } |
1227 | |
1228 | // Various real-world funky triples. The value returned by GCC's config.sub |
1229 | // is given in the comment. |
1230 | EXPECT_EQ("i386-unknown-windows-gnu" , |
1231 | Triple::normalize("i386-mingw32" )); // i386-pc-mingw32 |
1232 | EXPECT_EQ("x86_64-unknown-linux-gnu" , |
1233 | Triple::normalize("x86_64-linux-gnu" )); // x86_64-pc-linux-gnu |
1234 | EXPECT_EQ("i486-unknown-linux-gnu" , |
1235 | Triple::normalize("i486-linux-gnu" )); // i486-pc-linux-gnu |
1236 | EXPECT_EQ("i386-redhat-linux" , |
1237 | Triple::normalize("i386-redhat-linux" )); // i386-redhat-linux-gnu |
1238 | EXPECT_EQ("i686-unknown-linux" , |
1239 | Triple::normalize("i686-linux" )); // i686-pc-linux-gnu |
1240 | EXPECT_EQ("arm-none-unknown-eabi" , |
1241 | Triple::normalize("arm-none-eabi" )); // arm-none-eabi |
1242 | EXPECT_EQ("ve-unknown-linux" , |
1243 | Triple::normalize("ve-linux" )); // ve-linux |
1244 | EXPECT_EQ("wasm32-unknown-wasi" , |
1245 | Triple::normalize("wasm32-wasi" )); // wasm32-unknown-wasi |
1246 | EXPECT_EQ("wasm64-unknown-wasi" , |
1247 | Triple::normalize("wasm64-wasi" )); // wasm64-unknown-wasi |
1248 | } |
1249 | |
1250 | TEST(TripleTest, MutateName) { |
1251 | Triple T; |
1252 | EXPECT_EQ(Triple::UnknownArch, T.getArch()); |
1253 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
1254 | EXPECT_EQ(Triple::UnknownOS, T.getOS()); |
1255 | EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment()); |
1256 | |
1257 | T.setArchName("i386" ); |
1258 | EXPECT_EQ(Triple::x86, T.getArch()); |
1259 | EXPECT_EQ("i386--" , T.getTriple()); |
1260 | |
1261 | T.setVendorName("pc" ); |
1262 | EXPECT_EQ(Triple::x86, T.getArch()); |
1263 | EXPECT_EQ(Triple::PC, T.getVendor()); |
1264 | EXPECT_EQ("i386-pc-" , T.getTriple()); |
1265 | |
1266 | T.setOSName("linux" ); |
1267 | EXPECT_EQ(Triple::x86, T.getArch()); |
1268 | EXPECT_EQ(Triple::PC, T.getVendor()); |
1269 | EXPECT_EQ(Triple::Linux, T.getOS()); |
1270 | EXPECT_EQ("i386-pc-linux" , T.getTriple()); |
1271 | |
1272 | T.setEnvironmentName("gnu" ); |
1273 | EXPECT_EQ(Triple::x86, T.getArch()); |
1274 | EXPECT_EQ(Triple::PC, T.getVendor()); |
1275 | EXPECT_EQ(Triple::Linux, T.getOS()); |
1276 | EXPECT_EQ("i386-pc-linux-gnu" , T.getTriple()); |
1277 | |
1278 | T.setOSName("freebsd" ); |
1279 | EXPECT_EQ(Triple::x86, T.getArch()); |
1280 | EXPECT_EQ(Triple::PC, T.getVendor()); |
1281 | EXPECT_EQ(Triple::FreeBSD, T.getOS()); |
1282 | EXPECT_EQ("i386-pc-freebsd-gnu" , T.getTriple()); |
1283 | |
1284 | T.setOSAndEnvironmentName("darwin" ); |
1285 | EXPECT_EQ(Triple::x86, T.getArch()); |
1286 | EXPECT_EQ(Triple::PC, T.getVendor()); |
1287 | EXPECT_EQ(Triple::Darwin, T.getOS()); |
1288 | EXPECT_EQ("i386-pc-darwin" , T.getTriple()); |
1289 | } |
1290 | |
1291 | TEST(TripleTest, BitWidthChecks) { |
1292 | Triple T; |
1293 | EXPECT_FALSE(T.isArch16Bit()); |
1294 | EXPECT_FALSE(T.isArch32Bit()); |
1295 | EXPECT_FALSE(T.isArch64Bit()); |
1296 | EXPECT_EQ(T.getArchPointerBitWidth(), 0U); |
1297 | |
1298 | T.setArch(Kind: Triple::arm); |
1299 | EXPECT_FALSE(T.isArch16Bit()); |
1300 | EXPECT_TRUE(T.isArch32Bit()); |
1301 | EXPECT_FALSE(T.isArch64Bit()); |
1302 | EXPECT_EQ(T.getArchPointerBitWidth(), 32U); |
1303 | |
1304 | T.setArch(Kind: Triple::hexagon); |
1305 | EXPECT_FALSE(T.isArch16Bit()); |
1306 | EXPECT_TRUE(T.isArch32Bit()); |
1307 | EXPECT_FALSE(T.isArch64Bit()); |
1308 | EXPECT_EQ(T.getArchPointerBitWidth(), 32U); |
1309 | |
1310 | T.setArch(Kind: Triple::mips); |
1311 | EXPECT_FALSE(T.isArch16Bit()); |
1312 | EXPECT_TRUE(T.isArch32Bit()); |
1313 | EXPECT_FALSE(T.isArch64Bit()); |
1314 | EXPECT_EQ(T.getArchPointerBitWidth(), 32U); |
1315 | |
1316 | T.setArch(Kind: Triple::mips64); |
1317 | EXPECT_FALSE(T.isArch16Bit()); |
1318 | EXPECT_FALSE(T.isArch32Bit()); |
1319 | EXPECT_TRUE(T.isArch64Bit()); |
1320 | EXPECT_EQ(T.getArchPointerBitWidth(), 64U); |
1321 | |
1322 | T.setArch(Kind: Triple::msp430); |
1323 | EXPECT_TRUE(T.isArch16Bit()); |
1324 | EXPECT_FALSE(T.isArch32Bit()); |
1325 | EXPECT_FALSE(T.isArch64Bit()); |
1326 | EXPECT_EQ(T.getArchPointerBitWidth(), 16U); |
1327 | |
1328 | T.setArch(Kind: Triple::ppc); |
1329 | EXPECT_FALSE(T.isArch16Bit()); |
1330 | EXPECT_TRUE(T.isArch32Bit()); |
1331 | EXPECT_FALSE(T.isArch64Bit()); |
1332 | EXPECT_EQ(T.getArchPointerBitWidth(), 32U); |
1333 | |
1334 | T.setArch(Kind: Triple::ppc64); |
1335 | EXPECT_FALSE(T.isArch16Bit()); |
1336 | EXPECT_FALSE(T.isArch32Bit()); |
1337 | EXPECT_TRUE(T.isArch64Bit()); |
1338 | EXPECT_EQ(T.getArchPointerBitWidth(), 64U); |
1339 | |
1340 | T.setArch(Kind: Triple::x86); |
1341 | EXPECT_FALSE(T.isArch16Bit()); |
1342 | EXPECT_TRUE(T.isArch32Bit()); |
1343 | EXPECT_FALSE(T.isArch64Bit()); |
1344 | EXPECT_EQ(T.getArchPointerBitWidth(), 32U); |
1345 | |
1346 | T.setArch(Kind: Triple::x86_64); |
1347 | EXPECT_FALSE(T.isArch16Bit()); |
1348 | EXPECT_FALSE(T.isArch32Bit()); |
1349 | EXPECT_TRUE(T.isArch64Bit()); |
1350 | EXPECT_EQ(T.getArchPointerBitWidth(), 64U); |
1351 | |
1352 | T.setArch(Kind: Triple::amdil); |
1353 | EXPECT_FALSE(T.isArch16Bit()); |
1354 | EXPECT_TRUE(T.isArch32Bit()); |
1355 | EXPECT_FALSE(T.isArch64Bit()); |
1356 | EXPECT_EQ(T.getArchPointerBitWidth(), 32U); |
1357 | |
1358 | T.setArch(Kind: Triple::amdil64); |
1359 | EXPECT_FALSE(T.isArch16Bit()); |
1360 | EXPECT_FALSE(T.isArch32Bit()); |
1361 | EXPECT_TRUE(T.isArch64Bit()); |
1362 | EXPECT_EQ(T.getArchPointerBitWidth(), 64U); |
1363 | |
1364 | T.setArch(Kind: Triple::hsail); |
1365 | EXPECT_FALSE(T.isArch16Bit()); |
1366 | EXPECT_TRUE(T.isArch32Bit()); |
1367 | EXPECT_FALSE(T.isArch64Bit()); |
1368 | EXPECT_EQ(T.getArchPointerBitWidth(), 32U); |
1369 | |
1370 | T.setArch(Kind: Triple::hsail64); |
1371 | EXPECT_FALSE(T.isArch16Bit()); |
1372 | EXPECT_FALSE(T.isArch32Bit()); |
1373 | EXPECT_TRUE(T.isArch64Bit()); |
1374 | EXPECT_EQ(T.getArchPointerBitWidth(), 64U); |
1375 | |
1376 | T.setArch(Kind: Triple::spir); |
1377 | EXPECT_FALSE(T.isArch16Bit()); |
1378 | EXPECT_TRUE(T.isArch32Bit()); |
1379 | EXPECT_FALSE(T.isArch64Bit()); |
1380 | EXPECT_EQ(T.getArchPointerBitWidth(), 32U); |
1381 | |
1382 | T.setArch(Kind: Triple::spir64); |
1383 | EXPECT_FALSE(T.isArch16Bit()); |
1384 | EXPECT_FALSE(T.isArch32Bit()); |
1385 | EXPECT_TRUE(T.isArch64Bit()); |
1386 | EXPECT_EQ(T.getArchPointerBitWidth(), 64U); |
1387 | |
1388 | T.setArch(Kind: Triple::spirv); |
1389 | EXPECT_FALSE(T.isArch16Bit()); |
1390 | EXPECT_FALSE(T.isArch32Bit()); |
1391 | EXPECT_TRUE(T.isArch64Bit()); |
1392 | EXPECT_TRUE(T.isSPIRV()); |
1393 | |
1394 | T.setArch(Kind: Triple::spirv32); |
1395 | EXPECT_FALSE(T.isArch16Bit()); |
1396 | EXPECT_TRUE(T.isArch32Bit()); |
1397 | EXPECT_FALSE(T.isArch64Bit()); |
1398 | EXPECT_TRUE(T.isSPIRV()); |
1399 | |
1400 | T.setArch(Kind: Triple::spirv64); |
1401 | EXPECT_FALSE(T.isArch16Bit()); |
1402 | EXPECT_FALSE(T.isArch32Bit()); |
1403 | EXPECT_TRUE(T.isArch64Bit()); |
1404 | EXPECT_TRUE(T.isSPIRV()); |
1405 | |
1406 | T.setArch(Kind: Triple::sparc); |
1407 | EXPECT_FALSE(T.isArch16Bit()); |
1408 | EXPECT_TRUE(T.isArch32Bit()); |
1409 | EXPECT_FALSE(T.isArch64Bit()); |
1410 | |
1411 | T.setArch(Kind: Triple::sparcel); |
1412 | EXPECT_FALSE(T.isArch16Bit()); |
1413 | EXPECT_TRUE(T.isArch32Bit()); |
1414 | EXPECT_FALSE(T.isArch64Bit()); |
1415 | |
1416 | T.setArch(Kind: Triple::sparcv9); |
1417 | EXPECT_FALSE(T.isArch16Bit()); |
1418 | EXPECT_FALSE(T.isArch32Bit()); |
1419 | EXPECT_TRUE(T.isArch64Bit()); |
1420 | |
1421 | T.setArch(Kind: Triple::wasm32); |
1422 | EXPECT_FALSE(T.isArch16Bit()); |
1423 | EXPECT_TRUE(T.isArch32Bit()); |
1424 | EXPECT_FALSE(T.isArch64Bit()); |
1425 | |
1426 | T.setArch(Kind: Triple::wasm64); |
1427 | EXPECT_FALSE(T.isArch16Bit()); |
1428 | EXPECT_FALSE(T.isArch32Bit()); |
1429 | EXPECT_TRUE(T.isArch64Bit()); |
1430 | |
1431 | T.setArch(Kind: Triple::avr); |
1432 | EXPECT_TRUE(T.isArch16Bit()); |
1433 | EXPECT_FALSE(T.isArch32Bit()); |
1434 | EXPECT_FALSE(T.isArch64Bit()); |
1435 | |
1436 | T.setArch(Kind: Triple::lanai); |
1437 | EXPECT_FALSE(T.isArch16Bit()); |
1438 | EXPECT_TRUE(T.isArch32Bit()); |
1439 | EXPECT_FALSE(T.isArch64Bit()); |
1440 | |
1441 | T.setArch(Kind: Triple::riscv32); |
1442 | EXPECT_FALSE(T.isArch16Bit()); |
1443 | EXPECT_TRUE(T.isArch32Bit()); |
1444 | EXPECT_FALSE(T.isArch64Bit()); |
1445 | EXPECT_TRUE(T.isRISCV()); |
1446 | |
1447 | T.setArch(Kind: Triple::riscv64); |
1448 | EXPECT_FALSE(T.isArch16Bit()); |
1449 | EXPECT_FALSE(T.isArch32Bit()); |
1450 | EXPECT_TRUE(T.isArch64Bit()); |
1451 | EXPECT_TRUE(T.isRISCV()); |
1452 | |
1453 | T.setArch(Kind: Triple::csky); |
1454 | EXPECT_FALSE(T.isArch16Bit()); |
1455 | EXPECT_TRUE(T.isArch32Bit()); |
1456 | EXPECT_FALSE(T.isArch64Bit()); |
1457 | EXPECT_TRUE(T.isCSKY()); |
1458 | |
1459 | T.setArch(Kind: Triple::loongarch32); |
1460 | EXPECT_FALSE(T.isArch16Bit()); |
1461 | EXPECT_TRUE(T.isArch32Bit()); |
1462 | EXPECT_FALSE(T.isArch64Bit()); |
1463 | EXPECT_TRUE(T.isLoongArch()); |
1464 | EXPECT_TRUE(T.isLoongArch32()); |
1465 | |
1466 | T.setArch(Kind: Triple::loongarch64); |
1467 | EXPECT_FALSE(T.isArch16Bit()); |
1468 | EXPECT_FALSE(T.isArch32Bit()); |
1469 | EXPECT_TRUE(T.isArch64Bit()); |
1470 | EXPECT_TRUE(T.isLoongArch()); |
1471 | EXPECT_TRUE(T.isLoongArch64()); |
1472 | |
1473 | T.setArch(Kind: Triple::dxil); |
1474 | EXPECT_FALSE(T.isArch16Bit()); |
1475 | EXPECT_TRUE(T.isArch32Bit()); |
1476 | EXPECT_FALSE(T.isArch64Bit()); |
1477 | EXPECT_TRUE(T.isDXIL()); |
1478 | |
1479 | T.setArch(Kind: Triple::xtensa); |
1480 | EXPECT_FALSE(T.isArch16Bit()); |
1481 | EXPECT_TRUE(T.isArch32Bit()); |
1482 | EXPECT_FALSE(T.isArch64Bit()); |
1483 | } |
1484 | |
1485 | TEST(TripleTest, BitWidthArchVariants) { |
1486 | Triple T; |
1487 | EXPECT_EQ(Triple::UnknownArch, T.get32BitArchVariant().getArch()); |
1488 | EXPECT_EQ(Triple::UnknownArch, T.get64BitArchVariant().getArch()); |
1489 | |
1490 | T.setArch(Kind: Triple::UnknownArch); |
1491 | EXPECT_EQ(Triple::UnknownArch, T.get32BitArchVariant().getArch()); |
1492 | EXPECT_EQ(Triple::UnknownArch, T.get64BitArchVariant().getArch()); |
1493 | |
1494 | T.setArch(Kind: Triple::mips); |
1495 | EXPECT_EQ(Triple::mips, T.get32BitArchVariant().getArch()); |
1496 | EXPECT_EQ(Triple::NoSubArch, T.get32BitArchVariant().getSubArch()); |
1497 | EXPECT_EQ(Triple::mips64, T.get64BitArchVariant().getArch()); |
1498 | EXPECT_EQ(Triple::NoSubArch, T.get64BitArchVariant().getSubArch()); |
1499 | |
1500 | T.setArch(Kind: Triple::mips, SubArch: Triple::MipsSubArch_r6); |
1501 | EXPECT_EQ(Triple::mips, T.get32BitArchVariant().getArch()); |
1502 | EXPECT_EQ(Triple::MipsSubArch_r6, T.get32BitArchVariant().getSubArch()); |
1503 | EXPECT_EQ(Triple::mips64, T.get64BitArchVariant().getArch()); |
1504 | EXPECT_EQ(Triple::MipsSubArch_r6, T.get64BitArchVariant().getSubArch()); |
1505 | |
1506 | T.setArch(Kind: Triple::mipsel); |
1507 | EXPECT_EQ(Triple::mipsel, T.get32BitArchVariant().getArch()); |
1508 | EXPECT_EQ(Triple::NoSubArch, T.get32BitArchVariant().getSubArch()); |
1509 | EXPECT_EQ(Triple::mips64el, T.get64BitArchVariant().getArch()); |
1510 | EXPECT_EQ(Triple::NoSubArch, T.get64BitArchVariant().getSubArch()); |
1511 | |
1512 | T.setArch(Kind: Triple::mipsel, SubArch: Triple::MipsSubArch_r6); |
1513 | EXPECT_EQ(Triple::mipsel, T.get32BitArchVariant().getArch()); |
1514 | EXPECT_EQ(Triple::MipsSubArch_r6, T.get32BitArchVariant().getSubArch()); |
1515 | EXPECT_EQ(Triple::mips64el, T.get64BitArchVariant().getArch()); |
1516 | EXPECT_EQ(Triple::MipsSubArch_r6, T.get64BitArchVariant().getSubArch()); |
1517 | |
1518 | T.setArch(Kind: Triple::ppc); |
1519 | EXPECT_EQ(Triple::ppc, T.get32BitArchVariant().getArch()); |
1520 | EXPECT_EQ(Triple::ppc64, T.get64BitArchVariant().getArch()); |
1521 | |
1522 | T.setArch(Kind: Triple::nvptx); |
1523 | EXPECT_EQ(Triple::nvptx, T.get32BitArchVariant().getArch()); |
1524 | EXPECT_EQ(Triple::nvptx64, T.get64BitArchVariant().getArch()); |
1525 | |
1526 | T.setArch(Kind: Triple::sparc); |
1527 | EXPECT_EQ(Triple::sparc, T.get32BitArchVariant().getArch()); |
1528 | EXPECT_EQ(Triple::sparcv9, T.get64BitArchVariant().getArch()); |
1529 | |
1530 | T.setArch(Kind: Triple::x86); |
1531 | EXPECT_EQ(Triple::x86, T.get32BitArchVariant().getArch()); |
1532 | EXPECT_EQ(Triple::x86_64, T.get64BitArchVariant().getArch()); |
1533 | |
1534 | T.setArch(Kind: Triple::mips64); |
1535 | EXPECT_EQ(Triple::mips, T.get32BitArchVariant().getArch()); |
1536 | EXPECT_EQ(Triple::NoSubArch, T.get32BitArchVariant().getSubArch()); |
1537 | EXPECT_EQ(Triple::mips64, T.get64BitArchVariant().getArch()); |
1538 | EXPECT_EQ(Triple::NoSubArch, T.get64BitArchVariant().getSubArch()); |
1539 | |
1540 | T.setArch(Kind: Triple::mips64, SubArch: Triple::MipsSubArch_r6); |
1541 | EXPECT_EQ(Triple::mips, T.get32BitArchVariant().getArch()); |
1542 | EXPECT_EQ(Triple::MipsSubArch_r6, T.get32BitArchVariant().getSubArch()); |
1543 | EXPECT_EQ(Triple::mips64, T.get64BitArchVariant().getArch()); |
1544 | EXPECT_EQ(Triple::MipsSubArch_r6, T.get64BitArchVariant().getSubArch()); |
1545 | |
1546 | T.setArch(Kind: Triple::mips64el); |
1547 | EXPECT_EQ(Triple::mipsel, T.get32BitArchVariant().getArch()); |
1548 | EXPECT_EQ(Triple::NoSubArch, T.get32BitArchVariant().getSubArch()); |
1549 | EXPECT_EQ(Triple::mips64el, T.get64BitArchVariant().getArch()); |
1550 | EXPECT_EQ(Triple::NoSubArch, T.get64BitArchVariant().getSubArch()); |
1551 | |
1552 | T.setArch(Kind: Triple::mips64el, SubArch: Triple::MipsSubArch_r6); |
1553 | EXPECT_EQ(Triple::mipsel, T.get32BitArchVariant().getArch()); |
1554 | EXPECT_EQ(Triple::MipsSubArch_r6, T.get32BitArchVariant().getSubArch()); |
1555 | EXPECT_EQ(Triple::mips64el, T.get64BitArchVariant().getArch()); |
1556 | EXPECT_EQ(Triple::MipsSubArch_r6, T.get64BitArchVariant().getSubArch()); |
1557 | |
1558 | T.setArch(Kind: Triple::ppc64); |
1559 | EXPECT_EQ(Triple::ppc, T.get32BitArchVariant().getArch()); |
1560 | EXPECT_EQ(Triple::ppc64, T.get64BitArchVariant().getArch()); |
1561 | |
1562 | T.setArch(Kind: Triple::nvptx64); |
1563 | EXPECT_EQ(Triple::nvptx, T.get32BitArchVariant().getArch()); |
1564 | EXPECT_EQ(Triple::nvptx64, T.get64BitArchVariant().getArch()); |
1565 | |
1566 | T.setArch(Kind: Triple::sparcv9); |
1567 | EXPECT_EQ(Triple::sparc, T.get32BitArchVariant().getArch()); |
1568 | EXPECT_EQ(Triple::sparcv9, T.get64BitArchVariant().getArch()); |
1569 | |
1570 | T.setArch(Kind: Triple::x86_64); |
1571 | EXPECT_EQ(Triple::x86, T.get32BitArchVariant().getArch()); |
1572 | EXPECT_EQ(Triple::x86_64, T.get64BitArchVariant().getArch()); |
1573 | |
1574 | T.setArch(Kind: Triple::amdil); |
1575 | EXPECT_EQ(Triple::amdil, T.get32BitArchVariant().getArch()); |
1576 | EXPECT_EQ(Triple::amdil64, T.get64BitArchVariant().getArch()); |
1577 | |
1578 | T.setArch(Kind: Triple::amdil64); |
1579 | EXPECT_EQ(Triple::amdil, T.get32BitArchVariant().getArch()); |
1580 | EXPECT_EQ(Triple::amdil64, T.get64BitArchVariant().getArch()); |
1581 | |
1582 | T.setArch(Kind: Triple::hsail); |
1583 | EXPECT_EQ(Triple::hsail, T.get32BitArchVariant().getArch()); |
1584 | EXPECT_EQ(Triple::hsail64, T.get64BitArchVariant().getArch()); |
1585 | |
1586 | T.setArch(Kind: Triple::hsail64); |
1587 | EXPECT_EQ(Triple::hsail, T.get32BitArchVariant().getArch()); |
1588 | EXPECT_EQ(Triple::hsail64, T.get64BitArchVariant().getArch()); |
1589 | |
1590 | T.setArch(Kind: Triple::spir); |
1591 | EXPECT_EQ(Triple::spir, T.get32BitArchVariant().getArch()); |
1592 | EXPECT_EQ(Triple::spir64, T.get64BitArchVariant().getArch()); |
1593 | |
1594 | T.setArch(Kind: Triple::spir64); |
1595 | EXPECT_EQ(Triple::spir, T.get32BitArchVariant().getArch()); |
1596 | EXPECT_EQ(Triple::spir64, T.get64BitArchVariant().getArch()); |
1597 | |
1598 | T.setArch(Kind: Triple::spirv); |
1599 | EXPECT_EQ(Triple::spirv32, T.get32BitArchVariant().getArch()); |
1600 | EXPECT_EQ(Triple::spirv64, T.get64BitArchVariant().getArch()); |
1601 | |
1602 | T.setArch(Kind: Triple::spirv32); |
1603 | EXPECT_EQ(Triple::spirv32, T.get32BitArchVariant().getArch()); |
1604 | EXPECT_EQ(Triple::spirv64, T.get64BitArchVariant().getArch()); |
1605 | |
1606 | T.setArch(Kind: Triple::spirv64); |
1607 | EXPECT_EQ(Triple::spirv32, T.get32BitArchVariant().getArch()); |
1608 | EXPECT_EQ(Triple::spirv64, T.get64BitArchVariant().getArch()); |
1609 | |
1610 | T.setArch(Kind: Triple::wasm32); |
1611 | EXPECT_EQ(Triple::wasm32, T.get32BitArchVariant().getArch()); |
1612 | EXPECT_EQ(Triple::wasm64, T.get64BitArchVariant().getArch()); |
1613 | |
1614 | T.setArch(Kind: Triple::wasm64); |
1615 | EXPECT_EQ(Triple::wasm32, T.get32BitArchVariant().getArch()); |
1616 | EXPECT_EQ(Triple::wasm64, T.get64BitArchVariant().getArch()); |
1617 | |
1618 | T.setArch(Kind: Triple::riscv32); |
1619 | EXPECT_EQ(Triple::riscv32, T.get32BitArchVariant().getArch()); |
1620 | EXPECT_EQ(Triple::riscv64, T.get64BitArchVariant().getArch()); |
1621 | |
1622 | T.setArch(Kind: Triple::riscv64); |
1623 | EXPECT_EQ(Triple::riscv32, T.get32BitArchVariant().getArch()); |
1624 | EXPECT_EQ(Triple::riscv64, T.get64BitArchVariant().getArch()); |
1625 | |
1626 | T.setArch(Kind: Triple::csky); |
1627 | EXPECT_EQ(Triple::csky, T.get32BitArchVariant().getArch()); |
1628 | EXPECT_EQ(Triple::UnknownArch, T.get64BitArchVariant().getArch()); |
1629 | |
1630 | T.setArch(Kind: Triple::loongarch32); |
1631 | EXPECT_EQ(Triple::loongarch32, T.get32BitArchVariant().getArch()); |
1632 | EXPECT_EQ(Triple::loongarch64, T.get64BitArchVariant().getArch()); |
1633 | |
1634 | T.setArch(Kind: Triple::loongarch64); |
1635 | EXPECT_EQ(Triple::loongarch32, T.get32BitArchVariant().getArch()); |
1636 | EXPECT_EQ(Triple::loongarch64, T.get64BitArchVariant().getArch()); |
1637 | |
1638 | T.setArch(Kind: Triple::thumbeb); |
1639 | EXPECT_EQ(Triple::thumbeb, T.get32BitArchVariant().getArch()); |
1640 | EXPECT_EQ(Triple::aarch64_be, T.get64BitArchVariant().getArch()); |
1641 | |
1642 | T.setArch(Kind: Triple::thumb); |
1643 | EXPECT_EQ(Triple::thumb, T.get32BitArchVariant().getArch()); |
1644 | EXPECT_EQ(Triple::aarch64, T.get64BitArchVariant().getArch()); |
1645 | |
1646 | T.setArch(Kind: Triple::aarch64); |
1647 | EXPECT_EQ(Triple::arm, T.get32BitArchVariant().getArch()); |
1648 | EXPECT_EQ(Triple::aarch64, T.get64BitArchVariant().getArch()); |
1649 | |
1650 | T.setArch(Kind: Triple::aarch64_be); |
1651 | EXPECT_EQ(Triple::armeb, T.get32BitArchVariant().getArch()); |
1652 | EXPECT_EQ(Triple::aarch64_be, T.get64BitArchVariant().getArch()); |
1653 | |
1654 | T.setArch(Kind: Triple::renderscript32); |
1655 | EXPECT_EQ(Triple::renderscript32, T.get32BitArchVariant().getArch()); |
1656 | EXPECT_EQ(Triple::renderscript64, T.get64BitArchVariant().getArch()); |
1657 | |
1658 | T.setArch(Kind: Triple::renderscript64); |
1659 | EXPECT_EQ(Triple::renderscript32, T.get32BitArchVariant().getArch()); |
1660 | EXPECT_EQ(Triple::renderscript64, T.get64BitArchVariant().getArch()); |
1661 | |
1662 | T.setArch(Kind: Triple::armeb); |
1663 | EXPECT_EQ(Triple::armeb, T.get32BitArchVariant().getArch()); |
1664 | EXPECT_EQ(Triple::aarch64_be, T.get64BitArchVariant().getArch()); |
1665 | |
1666 | T.setArch(Kind: Triple::arm); |
1667 | EXPECT_EQ(Triple::arm, T.get32BitArchVariant().getArch()); |
1668 | EXPECT_EQ(Triple::aarch64, T.get64BitArchVariant().getArch()); |
1669 | |
1670 | T.setArch(Kind: Triple::systemz); |
1671 | EXPECT_EQ(Triple::UnknownArch, T.get32BitArchVariant().getArch()); |
1672 | EXPECT_EQ(Triple::systemz, T.get64BitArchVariant().getArch()); |
1673 | |
1674 | T.setArch(Kind: Triple::xcore); |
1675 | EXPECT_EQ(Triple::xcore, T.get32BitArchVariant().getArch()); |
1676 | EXPECT_EQ(Triple::UnknownArch, T.get64BitArchVariant().getArch()); |
1677 | |
1678 | T.setArch(Kind: Triple::dxil); |
1679 | EXPECT_EQ(Triple::dxil, T.get32BitArchVariant().getArch()); |
1680 | EXPECT_EQ(Triple::UnknownArch, T.get64BitArchVariant().getArch()); |
1681 | |
1682 | T.setArch(Kind: Triple::xtensa); |
1683 | EXPECT_EQ(Triple::xtensa, T.get32BitArchVariant().getArch()); |
1684 | EXPECT_EQ(Triple::UnknownArch, T.get64BitArchVariant().getArch()); |
1685 | } |
1686 | |
1687 | TEST(TripleTest, EndianArchVariants) { |
1688 | Triple T; |
1689 | EXPECT_EQ(Triple::UnknownArch, T.getBigEndianArchVariant().getArch()); |
1690 | EXPECT_EQ(Triple::UnknownArch, T.getLittleEndianArchVariant().getArch()); |
1691 | |
1692 | T.setArch(Kind: Triple::UnknownArch); |
1693 | EXPECT_EQ(Triple::UnknownArch, T.getBigEndianArchVariant().getArch()); |
1694 | EXPECT_EQ(Triple::UnknownArch, T.getLittleEndianArchVariant().getArch()); |
1695 | |
1696 | T.setArch(Kind: Triple::aarch64_be); |
1697 | EXPECT_EQ(Triple::aarch64_be, T.getBigEndianArchVariant().getArch()); |
1698 | EXPECT_EQ(Triple::aarch64, T.getLittleEndianArchVariant().getArch()); |
1699 | |
1700 | T.setArch(Kind: Triple::aarch64); |
1701 | EXPECT_EQ(Triple::aarch64_be, T.getBigEndianArchVariant().getArch()); |
1702 | EXPECT_EQ(Triple::aarch64, T.getLittleEndianArchVariant().getArch()); |
1703 | |
1704 | T.setArch(Kind: Triple::armeb); |
1705 | EXPECT_EQ(Triple::armeb, T.getBigEndianArchVariant().getArch()); |
1706 | EXPECT_EQ(Triple::UnknownArch, T.getLittleEndianArchVariant().getArch()); |
1707 | |
1708 | T.setArch(Kind: Triple::arm); |
1709 | EXPECT_EQ(Triple::UnknownArch, T.getBigEndianArchVariant().getArch()); |
1710 | EXPECT_EQ(Triple::arm, T.getLittleEndianArchVariant().getArch()); |
1711 | T = Triple("arm" ); |
1712 | EXPECT_TRUE(T.isLittleEndian()); |
1713 | T = Triple("thumb" ); |
1714 | EXPECT_TRUE(T.isLittleEndian()); |
1715 | T = Triple("armeb" ); |
1716 | EXPECT_FALSE(T.isLittleEndian()); |
1717 | T = Triple("thumbeb" ); |
1718 | EXPECT_FALSE(T.isLittleEndian()); |
1719 | |
1720 | T.setArch(Kind: Triple::bpfeb); |
1721 | EXPECT_EQ(Triple::bpfeb, T.getBigEndianArchVariant().getArch()); |
1722 | EXPECT_EQ(Triple::bpfel, T.getLittleEndianArchVariant().getArch()); |
1723 | |
1724 | T.setArch(Kind: Triple::bpfel); |
1725 | EXPECT_EQ(Triple::bpfeb, T.getBigEndianArchVariant().getArch()); |
1726 | EXPECT_EQ(Triple::bpfel, T.getLittleEndianArchVariant().getArch()); |
1727 | |
1728 | T.setArch(Kind: Triple::mips64); |
1729 | EXPECT_EQ(Triple::mips64, T.getBigEndianArchVariant().getArch()); |
1730 | EXPECT_EQ(Triple::NoSubArch, T.getBigEndianArchVariant().getSubArch()); |
1731 | EXPECT_EQ(Triple::mips64el, T.getLittleEndianArchVariant().getArch()); |
1732 | EXPECT_EQ(Triple::NoSubArch, T.getLittleEndianArchVariant().getSubArch()); |
1733 | |
1734 | T.setArch(Kind: Triple::mips64, SubArch: Triple::MipsSubArch_r6); |
1735 | EXPECT_EQ(Triple::mips64, T.getBigEndianArchVariant().getArch()); |
1736 | EXPECT_EQ(Triple::MipsSubArch_r6, T.getBigEndianArchVariant().getSubArch()); |
1737 | EXPECT_EQ(Triple::mips64el, T.getLittleEndianArchVariant().getArch()); |
1738 | EXPECT_EQ(Triple::MipsSubArch_r6, |
1739 | T.getLittleEndianArchVariant().getSubArch()); |
1740 | |
1741 | T.setArch(Kind: Triple::mips64el); |
1742 | EXPECT_EQ(Triple::mips64, T.getBigEndianArchVariant().getArch()); |
1743 | EXPECT_EQ(Triple::NoSubArch, T.getBigEndianArchVariant().getSubArch()); |
1744 | EXPECT_EQ(Triple::mips64el, T.getLittleEndianArchVariant().getArch()); |
1745 | EXPECT_EQ(Triple::NoSubArch, T.getLittleEndianArchVariant().getSubArch()); |
1746 | |
1747 | T.setArch(Kind: Triple::mips64el, SubArch: Triple::MipsSubArch_r6); |
1748 | EXPECT_EQ(Triple::mips64, T.getBigEndianArchVariant().getArch()); |
1749 | EXPECT_EQ(Triple::MipsSubArch_r6, T.getBigEndianArchVariant().getSubArch()); |
1750 | EXPECT_EQ(Triple::mips64el, T.getLittleEndianArchVariant().getArch()); |
1751 | EXPECT_EQ(Triple::MipsSubArch_r6, |
1752 | T.getLittleEndianArchVariant().getSubArch()); |
1753 | |
1754 | T.setArch(Kind: Triple::mips); |
1755 | EXPECT_EQ(Triple::mips, T.getBigEndianArchVariant().getArch()); |
1756 | EXPECT_EQ(Triple::NoSubArch, T.getBigEndianArchVariant().getSubArch()); |
1757 | EXPECT_EQ(Triple::mipsel, T.getLittleEndianArchVariant().getArch()); |
1758 | EXPECT_EQ(Triple::NoSubArch, T.getLittleEndianArchVariant().getSubArch()); |
1759 | |
1760 | T.setArch(Kind: Triple::mips, SubArch: Triple::MipsSubArch_r6); |
1761 | EXPECT_EQ(Triple::mips, T.getBigEndianArchVariant().getArch()); |
1762 | EXPECT_EQ(Triple::MipsSubArch_r6, T.getBigEndianArchVariant().getSubArch()); |
1763 | EXPECT_EQ(Triple::mipsel, T.getLittleEndianArchVariant().getArch()); |
1764 | EXPECT_EQ(Triple::MipsSubArch_r6, |
1765 | T.getLittleEndianArchVariant().getSubArch()); |
1766 | |
1767 | T.setArch(Kind: Triple::mipsel); |
1768 | EXPECT_EQ(Triple::mips, T.getBigEndianArchVariant().getArch()); |
1769 | EXPECT_EQ(Triple::NoSubArch, T.getBigEndianArchVariant().getSubArch()); |
1770 | EXPECT_EQ(Triple::mipsel, T.getLittleEndianArchVariant().getArch()); |
1771 | EXPECT_EQ(Triple::NoSubArch, T.getLittleEndianArchVariant().getSubArch()); |
1772 | |
1773 | T.setArch(Kind: Triple::mipsel, SubArch: Triple::MipsSubArch_r6); |
1774 | EXPECT_EQ(Triple::mips, T.getBigEndianArchVariant().getArch()); |
1775 | EXPECT_EQ(Triple::MipsSubArch_r6, T.getBigEndianArchVariant().getSubArch()); |
1776 | EXPECT_EQ(Triple::mipsel, T.getLittleEndianArchVariant().getArch()); |
1777 | EXPECT_EQ(Triple::MipsSubArch_r6, |
1778 | T.getLittleEndianArchVariant().getSubArch()); |
1779 | |
1780 | T.setArch(Kind: Triple::ppc); |
1781 | EXPECT_EQ(Triple::ppc, T.getBigEndianArchVariant().getArch()); |
1782 | EXPECT_EQ(Triple::ppcle, T.getLittleEndianArchVariant().getArch()); |
1783 | |
1784 | T.setArch(Kind: Triple::ppc64); |
1785 | EXPECT_EQ(Triple::ppc64, T.getBigEndianArchVariant().getArch()); |
1786 | EXPECT_EQ(Triple::ppc64le, T.getLittleEndianArchVariant().getArch()); |
1787 | |
1788 | T.setArch(Kind: Triple::ppc64le); |
1789 | EXPECT_EQ(Triple::ppc64, T.getBigEndianArchVariant().getArch()); |
1790 | EXPECT_EQ(Triple::ppc64le, T.getLittleEndianArchVariant().getArch()); |
1791 | |
1792 | T.setArch(Kind: Triple::sparc); |
1793 | EXPECT_EQ(Triple::sparc, T.getBigEndianArchVariant().getArch()); |
1794 | EXPECT_EQ(Triple::sparcel, T.getLittleEndianArchVariant().getArch()); |
1795 | |
1796 | T.setArch(Kind: Triple::sparcel); |
1797 | EXPECT_EQ(Triple::sparc, T.getBigEndianArchVariant().getArch()); |
1798 | EXPECT_EQ(Triple::sparcel, T.getLittleEndianArchVariant().getArch()); |
1799 | |
1800 | T.setArch(Kind: Triple::thumb); |
1801 | EXPECT_EQ(Triple::UnknownArch, T.getBigEndianArchVariant().getArch()); |
1802 | EXPECT_EQ(Triple::thumb, T.getLittleEndianArchVariant().getArch()); |
1803 | |
1804 | T.setArch(Kind: Triple::thumbeb); |
1805 | EXPECT_EQ(Triple::thumbeb, T.getBigEndianArchVariant().getArch()); |
1806 | EXPECT_EQ(Triple::UnknownArch, T.getLittleEndianArchVariant().getArch()); |
1807 | |
1808 | T.setArch(Kind: Triple::lanai); |
1809 | EXPECT_EQ(Triple::lanai, T.getBigEndianArchVariant().getArch()); |
1810 | EXPECT_EQ(Triple::UnknownArch, T.getLittleEndianArchVariant().getArch()); |
1811 | |
1812 | T.setArch(Kind: Triple::tcele); |
1813 | EXPECT_EQ(Triple::tce, T.getBigEndianArchVariant().getArch()); |
1814 | EXPECT_EQ(Triple::tcele, T.getLittleEndianArchVariant().getArch()); |
1815 | |
1816 | T.setArch(Kind: Triple::tce); |
1817 | EXPECT_EQ(Triple::tce, T.getBigEndianArchVariant().getArch()); |
1818 | EXPECT_EQ(Triple::tcele, T.getLittleEndianArchVariant().getArch()); |
1819 | |
1820 | T.setArch(Kind: Triple::csky); |
1821 | EXPECT_EQ(Triple::UnknownArch, T.getBigEndianArchVariant().getArch()); |
1822 | EXPECT_EQ(Triple::csky, T.getLittleEndianArchVariant().getArch()); |
1823 | |
1824 | T.setArch(Kind: Triple::loongarch32); |
1825 | EXPECT_TRUE(T.isLittleEndian()); |
1826 | EXPECT_EQ(Triple::UnknownArch, T.getBigEndianArchVariant().getArch()); |
1827 | EXPECT_EQ(Triple::loongarch32, T.getLittleEndianArchVariant().getArch()); |
1828 | |
1829 | T.setArch(Kind: Triple::loongarch64); |
1830 | EXPECT_TRUE(T.isLittleEndian()); |
1831 | EXPECT_EQ(Triple::UnknownArch, T.getBigEndianArchVariant().getArch()); |
1832 | EXPECT_EQ(Triple::loongarch64, T.getLittleEndianArchVariant().getArch()); |
1833 | |
1834 | T.setArch(Kind: Triple::dxil); |
1835 | EXPECT_TRUE(T.isLittleEndian()); |
1836 | EXPECT_EQ(Triple::UnknownArch, T.getBigEndianArchVariant().getArch()); |
1837 | EXPECT_EQ(Triple::dxil, T.getLittleEndianArchVariant().getArch()); |
1838 | } |
1839 | |
1840 | TEST(TripleTest, XROS) { |
1841 | Triple T; |
1842 | VersionTuple Version; |
1843 | |
1844 | T = Triple("arm64-apple-xros" ); |
1845 | EXPECT_TRUE(T.isXROS()); |
1846 | EXPECT_TRUE(T.isOSDarwin()); |
1847 | EXPECT_FALSE(T.isiOS()); |
1848 | EXPECT_FALSE(T.isMacOSX()); |
1849 | EXPECT_FALSE(T.isSimulatorEnvironment()); |
1850 | EXPECT_EQ(T.getOSName(), "xros" ); |
1851 | Version = T.getOSVersion(); |
1852 | EXPECT_EQ(VersionTuple(0), Version); |
1853 | |
1854 | T = Triple("arm64-apple-visionos1.2" ); |
1855 | EXPECT_TRUE(T.isXROS()); |
1856 | EXPECT_TRUE(T.isOSDarwin()); |
1857 | EXPECT_FALSE(T.isiOS()); |
1858 | EXPECT_FALSE(T.isMacOSX()); |
1859 | EXPECT_FALSE(T.isSimulatorEnvironment()); |
1860 | EXPECT_EQ(T.getOSName(), "visionos1.2" ); |
1861 | Version = T.getOSVersion(); |
1862 | EXPECT_EQ(VersionTuple(1, 2), Version); |
1863 | |
1864 | T = Triple("arm64-apple-xros1-simulator" ); |
1865 | EXPECT_TRUE(T.isXROS()); |
1866 | EXPECT_TRUE(T.isOSDarwin()); |
1867 | EXPECT_FALSE(T.isiOS()); |
1868 | EXPECT_FALSE(T.isMacOSX()); |
1869 | EXPECT_TRUE(T.isSimulatorEnvironment()); |
1870 | Version = T.getOSVersion(); |
1871 | EXPECT_EQ(VersionTuple(1), Version); |
1872 | Version = T.getiOSVersion(); |
1873 | EXPECT_EQ(VersionTuple(17), Version); |
1874 | } |
1875 | |
1876 | TEST(TripleTest, getOSVersion) { |
1877 | Triple T; |
1878 | VersionTuple Version; |
1879 | |
1880 | T = Triple("i386-apple-darwin9" ); |
1881 | EXPECT_TRUE(T.isMacOSX()); |
1882 | EXPECT_FALSE(T.isiOS()); |
1883 | EXPECT_FALSE(T.isArch16Bit()); |
1884 | EXPECT_TRUE(T.isArch32Bit()); |
1885 | EXPECT_FALSE(T.isArch64Bit()); |
1886 | T.getMacOSXVersion(Version); |
1887 | EXPECT_EQ(VersionTuple(10, 5), Version); |
1888 | Version = T.getiOSVersion(); |
1889 | EXPECT_EQ(VersionTuple(5), Version); |
1890 | |
1891 | T = Triple("x86_64-apple-darwin9" ); |
1892 | EXPECT_TRUE(T.isMacOSX()); |
1893 | EXPECT_FALSE(T.isiOS()); |
1894 | EXPECT_FALSE(T.isArch16Bit()); |
1895 | EXPECT_FALSE(T.isArch32Bit()); |
1896 | EXPECT_TRUE(T.isArch64Bit()); |
1897 | T.getMacOSXVersion(Version); |
1898 | EXPECT_EQ(VersionTuple(10, 5), Version); |
1899 | Version = T.getiOSVersion(); |
1900 | EXPECT_EQ(VersionTuple(5), Version); |
1901 | |
1902 | T = Triple("x86_64-apple-macosx" ); |
1903 | EXPECT_TRUE(T.isMacOSX()); |
1904 | EXPECT_FALSE(T.isiOS()); |
1905 | EXPECT_FALSE(T.isArch16Bit()); |
1906 | EXPECT_FALSE(T.isArch32Bit()); |
1907 | EXPECT_TRUE(T.isArch64Bit()); |
1908 | T.getMacOSXVersion(Version); |
1909 | EXPECT_EQ(VersionTuple(10, 4), Version); |
1910 | Version = T.getiOSVersion(); |
1911 | EXPECT_EQ(VersionTuple(5), Version); |
1912 | |
1913 | T = Triple("x86_64-apple-macosx10.7" ); |
1914 | EXPECT_TRUE(T.isMacOSX()); |
1915 | EXPECT_FALSE(T.isiOS()); |
1916 | EXPECT_FALSE(T.isArch16Bit()); |
1917 | EXPECT_FALSE(T.isArch32Bit()); |
1918 | EXPECT_TRUE(T.isArch64Bit()); |
1919 | T.getMacOSXVersion(Version); |
1920 | EXPECT_EQ(VersionTuple(10, 7), Version); |
1921 | Version = T.getiOSVersion(); |
1922 | EXPECT_EQ(VersionTuple(5), Version); |
1923 | |
1924 | T = Triple("x86_64-apple-macos11.0" ); |
1925 | EXPECT_TRUE(T.isMacOSX()); |
1926 | EXPECT_FALSE(T.isiOS()); |
1927 | EXPECT_FALSE(T.isArch16Bit()); |
1928 | EXPECT_FALSE(T.isArch32Bit()); |
1929 | EXPECT_TRUE(T.isArch64Bit()); |
1930 | T.getMacOSXVersion(Version); |
1931 | EXPECT_EQ(VersionTuple(11, 0), Version); |
1932 | |
1933 | T = Triple("arm64-apple-macosx11.5.8" ); |
1934 | EXPECT_TRUE(T.isMacOSX()); |
1935 | EXPECT_FALSE(T.isiOS()); |
1936 | EXPECT_FALSE(T.isArch16Bit()); |
1937 | EXPECT_FALSE(T.isArch32Bit()); |
1938 | EXPECT_TRUE(T.isArch64Bit()); |
1939 | T.getMacOSXVersion(Version); |
1940 | EXPECT_EQ(VersionTuple(11, 5, 8), Version); |
1941 | |
1942 | // 10.16 forms a valid triple, even though it's not |
1943 | // a version of a macOS. |
1944 | T = Triple("x86_64-apple-macos10.16" ); |
1945 | EXPECT_TRUE(T.isMacOSX()); |
1946 | T.getMacOSXVersion(Version); |
1947 | EXPECT_EQ(VersionTuple(10, 16), Version); |
1948 | |
1949 | T = Triple("x86_64-apple-darwin20" ); |
1950 | EXPECT_TRUE(T.isMacOSX()); |
1951 | T.getMacOSXVersion(Version); |
1952 | EXPECT_EQ(VersionTuple(11), Version); |
1953 | |
1954 | // For darwin triples on macOS 11, only compare the major version. |
1955 | T = Triple("x86_64-apple-darwin20.2" ); |
1956 | EXPECT_TRUE(T.isMacOSX()); |
1957 | T.getMacOSXVersion(Version); |
1958 | EXPECT_EQ(VersionTuple(11), Version); |
1959 | |
1960 | T = Triple("armv7-apple-ios" ); |
1961 | EXPECT_FALSE(T.isMacOSX()); |
1962 | EXPECT_TRUE(T.isiOS()); |
1963 | EXPECT_FALSE(T.isArch16Bit()); |
1964 | EXPECT_TRUE(T.isArch32Bit()); |
1965 | EXPECT_FALSE(T.isArch64Bit()); |
1966 | T.getMacOSXVersion(Version); |
1967 | EXPECT_EQ(VersionTuple(10, 4), Version); |
1968 | Version = T.getiOSVersion(); |
1969 | EXPECT_EQ(VersionTuple(5), Version); |
1970 | |
1971 | T = Triple("armv7-apple-ios7.0" ); |
1972 | EXPECT_FALSE(T.isMacOSX()); |
1973 | EXPECT_TRUE(T.isiOS()); |
1974 | EXPECT_FALSE(T.isArch16Bit()); |
1975 | EXPECT_TRUE(T.isArch32Bit()); |
1976 | EXPECT_FALSE(T.isArch64Bit()); |
1977 | T.getMacOSXVersion(Version); |
1978 | EXPECT_EQ(VersionTuple(10, 4), Version); |
1979 | Version = T.getiOSVersion(); |
1980 | EXPECT_EQ(VersionTuple(7, 0), Version); |
1981 | EXPECT_FALSE(T.isSimulatorEnvironment()); |
1982 | |
1983 | T = Triple("x86_64-apple-ios10.3-simulator" ); |
1984 | EXPECT_TRUE(T.isiOS()); |
1985 | Version = T.getiOSVersion(); |
1986 | EXPECT_EQ(VersionTuple(10, 3), Version); |
1987 | EXPECT_TRUE(T.isSimulatorEnvironment()); |
1988 | EXPECT_FALSE(T.isMacCatalystEnvironment()); |
1989 | |
1990 | T = Triple("x86_64-apple-ios13.0-macabi" ); |
1991 | EXPECT_TRUE(T.isiOS()); |
1992 | Version = T.getiOSVersion(); |
1993 | EXPECT_EQ(VersionTuple(13, 0), Version); |
1994 | EXPECT_TRUE(T.getEnvironment() == Triple::MacABI); |
1995 | EXPECT_TRUE(T.isMacCatalystEnvironment()); |
1996 | EXPECT_FALSE(T.isSimulatorEnvironment()); |
1997 | |
1998 | T = Triple("x86_64-apple-driverkit20.1.0" ); |
1999 | EXPECT_TRUE(T.isDriverKit()); |
2000 | EXPECT_TRUE(T.isOSDarwin()); |
2001 | EXPECT_FALSE(T.isMacOSX()); |
2002 | EXPECT_FALSE(T.isiOS()); |
2003 | Version = T.getDriverKitVersion(); |
2004 | EXPECT_EQ(VersionTuple(20, 1), Version); |
2005 | |
2006 | T = Triple("x86_64-apple-driverkit20" ); |
2007 | Version = T.getDriverKitVersion(); |
2008 | EXPECT_EQ(VersionTuple(20, 0), Version); |
2009 | |
2010 | // DriverKit version should default to 19.0. |
2011 | T = Triple("x86_64-apple-driverkit" ); |
2012 | Version = T.getDriverKitVersion(); |
2013 | EXPECT_EQ(VersionTuple(19, 0), Version); |
2014 | |
2015 | T = Triple("dxil-unknown-shadermodel6.6-pixel" ); |
2016 | EXPECT_EQ(Triple::dxil, T.getArch()); |
2017 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
2018 | EXPECT_EQ(Triple::ShaderModel, T.getOS()); |
2019 | Version = T.getOSVersion(); |
2020 | EXPECT_EQ(VersionTuple(6, 6), Version); |
2021 | EXPECT_EQ(Triple::Pixel, T.getEnvironment()); |
2022 | |
2023 | T = Triple("dxil-unknown-shadermodel6.0-pixel" ); |
2024 | EXPECT_EQ(Triple::dxil, T.getArch()); |
2025 | EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); |
2026 | EXPECT_EQ(Triple::ShaderModel, T.getOS()); |
2027 | Version = T.getOSVersion(); |
2028 | EXPECT_EQ(VersionTuple(6, 0), Version); |
2029 | EXPECT_EQ(Triple::Pixel, T.getEnvironment()); |
2030 | } |
2031 | |
2032 | TEST(TripleTest, getEnvironmentVersion) { |
2033 | Triple T; |
2034 | VersionTuple Version; |
2035 | |
2036 | T = Triple("arm-unknown-linux-android16" ); |
2037 | EXPECT_TRUE(T.isAndroid()); |
2038 | Version = T.getEnvironmentVersion(); |
2039 | EXPECT_EQ(VersionTuple(16), Version); |
2040 | EXPECT_EQ(Triple::Android, T.getEnvironment()); |
2041 | |
2042 | T = Triple("aarch64-unknown-linux-android21" ); |
2043 | EXPECT_TRUE(T.isAndroid()); |
2044 | Version = T.getEnvironmentVersion(); |
2045 | EXPECT_EQ(VersionTuple(21), Version); |
2046 | EXPECT_EQ(Triple::Android, T.getEnvironment()); |
2047 | } |
2048 | |
2049 | TEST(TripleTest, isMacOSVersionLT) { |
2050 | Triple T = Triple("x86_64-apple-macos11" ); |
2051 | EXPECT_TRUE(T.isMacOSXVersionLT(11, 1, 0)); |
2052 | EXPECT_FALSE(T.isMacOSXVersionLT(10, 15, 0)); |
2053 | |
2054 | T = Triple("x86_64-apple-darwin20" ); |
2055 | EXPECT_TRUE(T.isMacOSXVersionLT(11, 1, 0)); |
2056 | EXPECT_FALSE(T.isMacOSXVersionLT(11, 0, 0)); |
2057 | EXPECT_FALSE(T.isMacOSXVersionLT(10, 15, 0)); |
2058 | } |
2059 | |
2060 | TEST(TripleTest, CanonicalizeOSVersion) { |
2061 | EXPECT_EQ(VersionTuple(10, 15, 4), |
2062 | Triple::getCanonicalVersionForOS(Triple::MacOSX, |
2063 | VersionTuple(10, 15, 4))); |
2064 | EXPECT_EQ(VersionTuple(11, 0), Triple::getCanonicalVersionForOS( |
2065 | Triple::MacOSX, VersionTuple(10, 16))); |
2066 | EXPECT_EQ(VersionTuple(20), |
2067 | Triple::getCanonicalVersionForOS(Triple::Darwin, VersionTuple(20))); |
2068 | } |
2069 | |
2070 | TEST(TripleTest, FileFormat) { |
2071 | EXPECT_EQ(Triple::ELF, Triple("i686-unknown-linux-gnu" ).getObjectFormat()); |
2072 | EXPECT_EQ(Triple::ELF, Triple("i686-unknown-freebsd" ).getObjectFormat()); |
2073 | EXPECT_EQ(Triple::ELF, Triple("i686-unknown-netbsd" ).getObjectFormat()); |
2074 | EXPECT_EQ(Triple::ELF, Triple("i686--win32-elf" ).getObjectFormat()); |
2075 | EXPECT_EQ(Triple::ELF, Triple("i686---elf" ).getObjectFormat()); |
2076 | |
2077 | EXPECT_EQ(Triple::MachO, Triple("i686-apple-macosx" ).getObjectFormat()); |
2078 | EXPECT_EQ(Triple::MachO, Triple("i686-apple-ios" ).getObjectFormat()); |
2079 | EXPECT_EQ(Triple::MachO, Triple("i686---macho" ).getObjectFormat()); |
2080 | EXPECT_EQ(Triple::MachO, Triple("powerpc-apple-macosx" ).getObjectFormat()); |
2081 | |
2082 | EXPECT_EQ(Triple::COFF, Triple("i686--win32" ).getObjectFormat()); |
2083 | |
2084 | EXPECT_EQ(Triple::ELF, Triple("i686-pc-windows-msvc-elf" ).getObjectFormat()); |
2085 | EXPECT_EQ(Triple::ELF, Triple("i686-pc-cygwin-elf" ).getObjectFormat()); |
2086 | |
2087 | EXPECT_EQ(Triple::ELF, Triple("systemz-ibm-linux" ).getObjectFormat()); |
2088 | EXPECT_EQ(Triple::ELF, Triple("systemz-ibm-unknown" ).getObjectFormat()); |
2089 | |
2090 | EXPECT_EQ(Triple::GOFF, Triple("s390x-ibm-zos" ).getObjectFormat()); |
2091 | EXPECT_EQ(Triple::GOFF, Triple("systemz-ibm-zos" ).getObjectFormat()); |
2092 | EXPECT_EQ(Triple::GOFF, Triple("s390x-ibm-zos-goff" ).getObjectFormat()); |
2093 | EXPECT_EQ(Triple::GOFF, Triple("s390x-unknown-zos-goff" ).getObjectFormat()); |
2094 | EXPECT_EQ(Triple::GOFF, Triple("s390x---goff" ).getObjectFormat()); |
2095 | |
2096 | EXPECT_EQ(Triple::Wasm, Triple("wasm32-unknown-unknown" ).getObjectFormat()); |
2097 | EXPECT_EQ(Triple::Wasm, Triple("wasm64-unknown-unknown" ).getObjectFormat()); |
2098 | EXPECT_EQ(Triple::Wasm, Triple("wasm32-wasi" ).getObjectFormat()); |
2099 | EXPECT_EQ(Triple::Wasm, Triple("wasm64-wasi" ).getObjectFormat()); |
2100 | EXPECT_EQ(Triple::Wasm, Triple("wasm32-unknown-wasi" ).getObjectFormat()); |
2101 | EXPECT_EQ(Triple::Wasm, Triple("wasm64-unknown-wasi" ).getObjectFormat()); |
2102 | |
2103 | EXPECT_EQ(Triple::Wasm, |
2104 | Triple("wasm32-unknown-unknown-wasm" ).getObjectFormat()); |
2105 | EXPECT_EQ(Triple::Wasm, |
2106 | Triple("wasm64-unknown-unknown-wasm" ).getObjectFormat()); |
2107 | EXPECT_EQ(Triple::Wasm, |
2108 | Triple("wasm32-wasi-wasm" ).getObjectFormat()); |
2109 | EXPECT_EQ(Triple::Wasm, |
2110 | Triple("wasm64-wasi-wasm" ).getObjectFormat()); |
2111 | EXPECT_EQ(Triple::Wasm, |
2112 | Triple("wasm32-unknown-wasi-wasm" ).getObjectFormat()); |
2113 | EXPECT_EQ(Triple::Wasm, |
2114 | Triple("wasm64-unknown-wasi-wasm" ).getObjectFormat()); |
2115 | |
2116 | EXPECT_EQ(Triple::XCOFF, Triple("powerpc-ibm-aix" ).getObjectFormat()); |
2117 | EXPECT_EQ(Triple::XCOFF, Triple("powerpc64-ibm-aix" ).getObjectFormat()); |
2118 | EXPECT_EQ(Triple::XCOFF, Triple("powerpc---xcoff" ).getObjectFormat()); |
2119 | EXPECT_EQ(Triple::XCOFF, Triple("powerpc64---xcoff" ).getObjectFormat()); |
2120 | |
2121 | EXPECT_EQ(Triple::ELF, Triple("csky-unknown-unknown" ).getObjectFormat()); |
2122 | EXPECT_EQ(Triple::ELF, Triple("csky-unknown-linux" ).getObjectFormat()); |
2123 | |
2124 | EXPECT_EQ(Triple::SPIRV, Triple("spirv-unknown-unknown" ).getObjectFormat()); |
2125 | EXPECT_EQ(Triple::SPIRV, Triple("spirv32-unknown-unknown" ).getObjectFormat()); |
2126 | EXPECT_EQ(Triple::SPIRV, Triple("spirv64-unknown-unknown" ).getObjectFormat()); |
2127 | |
2128 | EXPECT_EQ(Triple::ELF, |
2129 | Triple("loongarch32-unknown-unknown" ).getObjectFormat()); |
2130 | EXPECT_EQ(Triple::ELF, Triple("loongarch64-unknown-linux" ).getObjectFormat()); |
2131 | |
2132 | Triple MSVCNormalized(Triple::normalize(Str: "i686-pc-windows-msvc-elf" )); |
2133 | EXPECT_EQ(Triple::ELF, MSVCNormalized.getObjectFormat()); |
2134 | |
2135 | Triple GNUWindowsNormalized(Triple::normalize(Str: "i686-pc-windows-gnu-elf" )); |
2136 | EXPECT_EQ(Triple::ELF, GNUWindowsNormalized.getObjectFormat()); |
2137 | |
2138 | Triple CygnusNormalised(Triple::normalize(Str: "i686-pc-windows-cygnus-elf" )); |
2139 | EXPECT_EQ(Triple::ELF, CygnusNormalised.getObjectFormat()); |
2140 | |
2141 | Triple CygwinNormalized(Triple::normalize(Str: "i686-pc-cygwin-elf" )); |
2142 | EXPECT_EQ(Triple::ELF, CygwinNormalized.getObjectFormat()); |
2143 | |
2144 | EXPECT_EQ(Triple::DXContainer, |
2145 | Triple("dxil-unknown-shadermodel" ).getObjectFormat()); |
2146 | |
2147 | Triple T = Triple("" ); |
2148 | T.setObjectFormat(Triple::ELF); |
2149 | EXPECT_EQ(Triple::ELF, T.getObjectFormat()); |
2150 | EXPECT_EQ("elf" , Triple::getObjectFormatTypeName(T.getObjectFormat())); |
2151 | |
2152 | T.setObjectFormat(Triple::MachO); |
2153 | EXPECT_EQ(Triple::MachO, T.getObjectFormat()); |
2154 | EXPECT_EQ("macho" , Triple::getObjectFormatTypeName(T.getObjectFormat())); |
2155 | |
2156 | T.setObjectFormat(Triple::XCOFF); |
2157 | EXPECT_EQ(Triple::XCOFF, T.getObjectFormat()); |
2158 | EXPECT_EQ("xcoff" , Triple::getObjectFormatTypeName(T.getObjectFormat())); |
2159 | |
2160 | T.setObjectFormat(Triple::GOFF); |
2161 | EXPECT_EQ(Triple::GOFF, T.getObjectFormat()); |
2162 | EXPECT_EQ("goff" , Triple::getObjectFormatTypeName(T.getObjectFormat())); |
2163 | |
2164 | T.setObjectFormat(Triple::SPIRV); |
2165 | EXPECT_EQ(Triple::SPIRV, T.getObjectFormat()); |
2166 | EXPECT_EQ("spirv" , Triple::getObjectFormatTypeName(T.getObjectFormat())); |
2167 | |
2168 | EXPECT_EQ(Triple::ELF, Triple("amdgcn-apple-macosx" ).getObjectFormat()); |
2169 | EXPECT_EQ(Triple::ELF, Triple("r600-apple-macosx" ).getObjectFormat()); |
2170 | EXPECT_EQ(Triple::SPIRV, Triple("spirv-apple-macosx" ).getObjectFormat()); |
2171 | EXPECT_EQ(Triple::SPIRV, Triple("spirv32-apple-macosx" ).getObjectFormat()); |
2172 | EXPECT_EQ(Triple::SPIRV, Triple("spirv64-apple-macosx" ).getObjectFormat()); |
2173 | EXPECT_EQ(Triple::DXContainer, Triple("dxil-apple-macosx" ).getObjectFormat()); |
2174 | } |
2175 | |
2176 | TEST(TripleTest, NormalizeWindows) { |
2177 | EXPECT_EQ("i686-pc-windows-msvc" , Triple::normalize("i686-pc-win32" )); |
2178 | EXPECT_EQ("i686-unknown-windows-msvc" , Triple::normalize("i686-win32" )); |
2179 | EXPECT_EQ("i686-pc-windows-gnu" , Triple::normalize("i686-pc-mingw32" )); |
2180 | EXPECT_EQ("i686-unknown-windows-gnu" , Triple::normalize("i686-mingw32" )); |
2181 | EXPECT_EQ("i686-pc-windows-gnu" , Triple::normalize("i686-pc-mingw32-w64" )); |
2182 | EXPECT_EQ("i686-unknown-windows-gnu" , Triple::normalize("i686-mingw32-w64" )); |
2183 | EXPECT_EQ("i686-pc-windows-cygnus" , Triple::normalize("i686-pc-cygwin" )); |
2184 | EXPECT_EQ("i686-unknown-windows-cygnus" , Triple::normalize("i686-cygwin" )); |
2185 | |
2186 | EXPECT_EQ("x86_64-pc-windows-msvc" , Triple::normalize("x86_64-pc-win32" )); |
2187 | EXPECT_EQ("x86_64-unknown-windows-msvc" , Triple::normalize("x86_64-win32" )); |
2188 | EXPECT_EQ("x86_64-pc-windows-gnu" , Triple::normalize("x86_64-pc-mingw32" )); |
2189 | EXPECT_EQ("x86_64-unknown-windows-gnu" , Triple::normalize("x86_64-mingw32" )); |
2190 | EXPECT_EQ("x86_64-pc-windows-gnu" , |
2191 | Triple::normalize("x86_64-pc-mingw32-w64" )); |
2192 | EXPECT_EQ("x86_64-unknown-windows-gnu" , |
2193 | Triple::normalize("x86_64-mingw32-w64" )); |
2194 | |
2195 | EXPECT_EQ("i686-pc-windows-elf" , Triple::normalize("i686-pc-win32-elf" )); |
2196 | EXPECT_EQ("i686-unknown-windows-elf" , Triple::normalize("i686-win32-elf" )); |
2197 | EXPECT_EQ("i686-pc-windows-macho" , Triple::normalize("i686-pc-win32-macho" )); |
2198 | EXPECT_EQ("i686-unknown-windows-macho" , |
2199 | Triple::normalize("i686-win32-macho" )); |
2200 | |
2201 | EXPECT_EQ("x86_64-pc-windows-elf" , Triple::normalize("x86_64-pc-win32-elf" )); |
2202 | EXPECT_EQ("x86_64-unknown-windows-elf" , |
2203 | Triple::normalize("x86_64-win32-elf" )); |
2204 | EXPECT_EQ("x86_64-pc-windows-macho" , |
2205 | Triple::normalize("x86_64-pc-win32-macho" )); |
2206 | EXPECT_EQ("x86_64-unknown-windows-macho" , |
2207 | Triple::normalize("x86_64-win32-macho" )); |
2208 | |
2209 | EXPECT_EQ("i686-pc-windows-cygnus" , |
2210 | Triple::normalize("i686-pc-windows-cygnus" )); |
2211 | EXPECT_EQ("i686-pc-windows-gnu" , Triple::normalize("i686-pc-windows-gnu" )); |
2212 | EXPECT_EQ("i686-pc-windows-itanium" , |
2213 | Triple::normalize("i686-pc-windows-itanium" )); |
2214 | EXPECT_EQ("i686-pc-windows-msvc" , Triple::normalize("i686-pc-windows-msvc" )); |
2215 | |
2216 | EXPECT_EQ("i686-pc-windows-elf" , |
2217 | Triple::normalize("i686-pc-windows-elf-elf" )); |
2218 | |
2219 | EXPECT_TRUE(Triple("x86_64-pc-win32" ).isWindowsMSVCEnvironment()); |
2220 | } |
2221 | |
2222 | TEST(TripleTest, NormalizeAndroid) { |
2223 | EXPECT_EQ("arm-unknown-linux-android16" , |
2224 | Triple::normalize("arm-linux-androideabi16" )); |
2225 | EXPECT_EQ("armv7a-unknown-linux-android" , |
2226 | Triple::normalize("armv7a-linux-androideabi" )); |
2227 | EXPECT_EQ("aarch64-unknown-linux-android21" , |
2228 | Triple::normalize("aarch64-linux-android21" )); |
2229 | } |
2230 | |
2231 | TEST(TripleTest, NormalizeARM) { |
2232 | EXPECT_EQ("armv6-unknown-netbsd-eabi" , |
2233 | Triple::normalize("armv6-netbsd-eabi" )); |
2234 | EXPECT_EQ("armv7-unknown-netbsd-eabi" , |
2235 | Triple::normalize("armv7-netbsd-eabi" )); |
2236 | EXPECT_EQ("armv6eb-unknown-netbsd-eabi" , |
2237 | Triple::normalize("armv6eb-netbsd-eabi" )); |
2238 | EXPECT_EQ("armv7eb-unknown-netbsd-eabi" , |
2239 | Triple::normalize("armv7eb-netbsd-eabi" )); |
2240 | EXPECT_EQ("armv6-unknown-netbsd-eabihf" , |
2241 | Triple::normalize("armv6-netbsd-eabihf" )); |
2242 | EXPECT_EQ("armv7-unknown-netbsd-eabihf" , |
2243 | Triple::normalize("armv7-netbsd-eabihf" )); |
2244 | EXPECT_EQ("armv6eb-unknown-netbsd-eabihf" , |
2245 | Triple::normalize("armv6eb-netbsd-eabihf" )); |
2246 | EXPECT_EQ("armv7eb-unknown-netbsd-eabihf" , |
2247 | Triple::normalize("armv7eb-netbsd-eabihf" )); |
2248 | |
2249 | EXPECT_EQ("armv7-suse-linux-gnueabihf" , |
2250 | Triple::normalize("armv7-suse-linux-gnueabi" )); |
2251 | |
2252 | Triple T; |
2253 | T = Triple("armv6--netbsd-eabi" ); |
2254 | EXPECT_EQ(Triple::arm, T.getArch()); |
2255 | T = Triple("armv6eb--netbsd-eabi" ); |
2256 | EXPECT_EQ(Triple::armeb, T.getArch()); |
2257 | T = Triple("armv7-suse-linux-gnueabihf" ); |
2258 | EXPECT_EQ(Triple::GNUEABIHF, T.getEnvironment()); |
2259 | } |
2260 | |
2261 | TEST(TripleTest, ParseARMArch) { |
2262 | // ARM |
2263 | { |
2264 | Triple T = Triple("arm" ); |
2265 | EXPECT_EQ(Triple::arm, T.getArch()); |
2266 | } |
2267 | { |
2268 | Triple T = Triple("armeb" ); |
2269 | EXPECT_EQ(Triple::armeb, T.getArch()); |
2270 | } |
2271 | // THUMB |
2272 | { |
2273 | Triple T = Triple("thumb" ); |
2274 | EXPECT_EQ(Triple::thumb, T.getArch()); |
2275 | } |
2276 | { |
2277 | Triple T = Triple("thumbeb" ); |
2278 | EXPECT_EQ(Triple::thumbeb, T.getArch()); |
2279 | } |
2280 | // AARCH64 |
2281 | { |
2282 | Triple T = Triple("arm64" ); |
2283 | EXPECT_EQ(Triple::aarch64, T.getArch()); |
2284 | } |
2285 | { |
2286 | Triple T = Triple("arm64_32" ); |
2287 | EXPECT_EQ(Triple::aarch64_32, T.getArch()); |
2288 | } |
2289 | { |
2290 | Triple T = Triple("aarch64" ); |
2291 | EXPECT_EQ(Triple::aarch64, T.getArch()); |
2292 | } |
2293 | { |
2294 | Triple T = Triple("aarch64_be" ); |
2295 | EXPECT_EQ(Triple::aarch64_be, T.getArch()); |
2296 | } |
2297 | { |
2298 | Triple T = Triple("arm64e" ); |
2299 | EXPECT_EQ(Triple::aarch64, T.getArch()); |
2300 | EXPECT_EQ(Triple::AArch64SubArch_arm64e, T.getSubArch()); |
2301 | } |
2302 | { |
2303 | Triple T = Triple("arm64ec" ); |
2304 | EXPECT_EQ(Triple::aarch64, T.getArch()); |
2305 | EXPECT_EQ(Triple::AArch64SubArch_arm64ec, T.getSubArch()); |
2306 | } |
2307 | { |
2308 | Triple T; |
2309 | T.setArch(Kind: Triple::aarch64, SubArch: Triple::AArch64SubArch_arm64ec); |
2310 | EXPECT_EQ("arm64ec" , T.getArchName()); |
2311 | } |
2312 | } |
2313 | |
2314 | TEST(TripleTest, isArmT32) { |
2315 | // Not isArmT32 |
2316 | { |
2317 | Triple T = Triple("thumbv6m" ); |
2318 | EXPECT_FALSE(T.isArmT32()); |
2319 | } |
2320 | { |
2321 | Triple T = Triple("armv8m.base" ); |
2322 | EXPECT_FALSE(T.isArmT32()); |
2323 | } |
2324 | { |
2325 | Triple T = Triple("armv7s" ); |
2326 | EXPECT_FALSE(T.isArmT32()); |
2327 | } |
2328 | { |
2329 | Triple T = Triple("armv7k" ); |
2330 | EXPECT_FALSE(T.isArmT32()); |
2331 | } |
2332 | { |
2333 | Triple T = Triple("armv7ve" ); |
2334 | EXPECT_FALSE(T.isArmT32()); |
2335 | } |
2336 | { |
2337 | Triple T = Triple("armv6" ); |
2338 | EXPECT_FALSE(T.isArmT32()); |
2339 | } |
2340 | { |
2341 | Triple T = Triple("armv6m" ); |
2342 | EXPECT_FALSE(T.isArmT32()); |
2343 | } |
2344 | { |
2345 | Triple T = Triple("armv6k" ); |
2346 | EXPECT_FALSE(T.isArmT32()); |
2347 | } |
2348 | { |
2349 | Triple T = Triple("armv6t2" ); |
2350 | EXPECT_FALSE(T.isArmT32()); |
2351 | } |
2352 | { |
2353 | Triple T = Triple("armv5" ); |
2354 | EXPECT_FALSE(T.isArmT32()); |
2355 | } |
2356 | { |
2357 | Triple T = Triple("armv5te" ); |
2358 | EXPECT_FALSE(T.isArmT32()); |
2359 | } |
2360 | { |
2361 | Triple T = Triple("armv4t" ); |
2362 | EXPECT_FALSE(T.isArmT32()); |
2363 | } |
2364 | |
2365 | // isArmT32 |
2366 | { |
2367 | Triple T = Triple("arm" ); |
2368 | EXPECT_TRUE(T.isArmT32()); |
2369 | } |
2370 | { |
2371 | Triple T = Triple("armv7m" ); |
2372 | EXPECT_TRUE(T.isArmT32()); |
2373 | } |
2374 | { |
2375 | Triple T = Triple("armv7em" ); |
2376 | EXPECT_TRUE(T.isArmT32()); |
2377 | } |
2378 | { |
2379 | Triple T = Triple("armv8m.main" ); |
2380 | EXPECT_TRUE(T.isArmT32()); |
2381 | } |
2382 | { |
2383 | Triple T = Triple("armv8.1m.main" ); |
2384 | EXPECT_TRUE(T.isArmT32()); |
2385 | } |
2386 | } |
2387 | |
2388 | TEST(TripleTest, isArmMClass) { |
2389 | // not M-class |
2390 | { |
2391 | Triple T = Triple("armv7s" ); |
2392 | EXPECT_FALSE(T.isArmMClass()); |
2393 | } |
2394 | { |
2395 | Triple T = Triple("armv7k" ); |
2396 | EXPECT_FALSE(T.isArmMClass()); |
2397 | } |
2398 | { |
2399 | Triple T = Triple("armv7ve" ); |
2400 | EXPECT_FALSE(T.isArmMClass()); |
2401 | } |
2402 | { |
2403 | Triple T = Triple("armv6" ); |
2404 | EXPECT_FALSE(T.isArmMClass()); |
2405 | } |
2406 | { |
2407 | Triple T = Triple("armv6k" ); |
2408 | EXPECT_FALSE(T.isArmMClass()); |
2409 | } |
2410 | { |
2411 | Triple T = Triple("armv6t2" ); |
2412 | EXPECT_FALSE(T.isArmMClass()); |
2413 | } |
2414 | { |
2415 | Triple T = Triple("armv5" ); |
2416 | EXPECT_FALSE(T.isArmMClass()); |
2417 | } |
2418 | { |
2419 | Triple T = Triple("armv5te" ); |
2420 | EXPECT_FALSE(T.isArmMClass()); |
2421 | } |
2422 | { |
2423 | Triple T = Triple("armv4t" ); |
2424 | EXPECT_FALSE(T.isArmMClass()); |
2425 | } |
2426 | { |
2427 | Triple T = Triple("arm" ); |
2428 | EXPECT_FALSE(T.isArmMClass()); |
2429 | } |
2430 | |
2431 | // is M-class |
2432 | { |
2433 | Triple T = Triple("armv6m" ); |
2434 | EXPECT_TRUE(T.isArmMClass()); |
2435 | } |
2436 | { |
2437 | Triple T = Triple("armv7m" ); |
2438 | EXPECT_TRUE(T.isArmMClass()); |
2439 | } |
2440 | { |
2441 | Triple T = Triple("armv7em" ); |
2442 | EXPECT_TRUE(T.isArmMClass()); |
2443 | } |
2444 | { |
2445 | Triple T = Triple("armv8m.base" ); |
2446 | EXPECT_TRUE(T.isArmMClass()); |
2447 | } |
2448 | { |
2449 | Triple T = Triple("armv8m.main" ); |
2450 | EXPECT_TRUE(T.isArmMClass()); |
2451 | } |
2452 | { |
2453 | Triple T = Triple("armv8.1m.main" ); |
2454 | EXPECT_TRUE(T.isArmMClass()); |
2455 | } |
2456 | } |
2457 | } // end anonymous namespace |
2458 | |