Debian Codegraph @

llvm-project/llvm/unittests/TargetParser/TripleTest.cpp

raw
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-contiki-unknown");
91 EXPECT_EQ(Triple::x86, T.getArch());
92 EXPECT_EQ(Triple::PC, T.getVendor());
93 EXPECT_EQ(Triple::Contiki, T.getOS());
94 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
95
96 T = Triple("i386-pc-hurd-gnu");
97 EXPECT_EQ(Triple::x86, T.getArch());
98 EXPECT_EQ(Triple::PC, T.getVendor());
99 EXPECT_EQ(Triple::Hurd, T.getOS());
100 EXPECT_EQ(Triple::GNU, T.getEnvironment());
101
102 T = Triple("x86_64-pc-linux-gnu");
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::GNU, T.getEnvironment());
107
108 T = Triple("x86_64-pc-linux-musl");
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::Musl, T.getEnvironment());
113
114 T = Triple("x86_64-pc-linux-muslx32");
115 EXPECT_EQ(Triple::x86_64, T.getArch());
116 EXPECT_EQ(Triple::PC, T.getVendor());
117 EXPECT_EQ(Triple::Linux, T.getOS());
118 EXPECT_EQ(Triple::MuslX32, 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("x86_64-unknown-ananas");
329 EXPECT_EQ(Triple::x86_64, T.getArch());
330 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
331 EXPECT_EQ(Triple::Ananas, T.getOS());
332 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
333
334 T = Triple("x86_64-unknown-cloudabi");
335 EXPECT_EQ(Triple::x86_64, T.getArch());
336 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
337 EXPECT_EQ(Triple::CloudABI, T.getOS());
338 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
339
340 T = Triple("x86_64-unknown-fuchsia");
341 EXPECT_EQ(Triple::x86_64, T.getArch());
342 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
343 EXPECT_EQ(Triple::Fuchsia, T.getOS());
344 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
345
346 T = Triple("x86_64-unknown-hermit");
347 EXPECT_EQ(Triple::x86_64, T.getArch());
348 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
349 EXPECT_EQ(Triple::HermitCore, T.getOS());
350 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
351
352 T = Triple("wasm32-unknown-unknown");
353 EXPECT_EQ(Triple::wasm32, T.getArch());
354 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
355 EXPECT_EQ(Triple::UnknownOS, T.getOS());
356 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
357
358 T = Triple("wasm32-unknown-wasi");
359 EXPECT_EQ(Triple::wasm32, T.getArch());
360 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
361 EXPECT_EQ(Triple::WASI, T.getOS());
362 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
363
364 T = Triple("wasm64-unknown-unknown");
365 EXPECT_EQ(Triple::wasm64, T.getArch());
366 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
367 EXPECT_EQ(Triple::UnknownOS, T.getOS());
368 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
369
370 T = Triple("wasm64-unknown-wasi");
371 EXPECT_EQ(Triple::wasm64, T.getArch());
372 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
373 EXPECT_EQ(Triple::WASI, T.getOS());
374 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
375
376 T = Triple("avr-unknown-unknown");
377 EXPECT_EQ(Triple::avr, T.getArch());
378 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
379 EXPECT_EQ(Triple::UnknownOS, T.getOS());
380 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
381
382 T = Triple("avr");
383 EXPECT_EQ(Triple::avr, T.getArch());
384 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
385 EXPECT_EQ(Triple::UnknownOS, T.getOS());
386 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
387
388 T = Triple("lanai-unknown-unknown");
389 EXPECT_EQ(Triple::lanai, T.getArch());
390 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
391 EXPECT_EQ(Triple::UnknownOS, T.getOS());
392 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
393
394 T = Triple("lanai");
395 EXPECT_EQ(Triple::lanai, T.getArch());
396 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
397 EXPECT_EQ(Triple::UnknownOS, T.getOS());
398 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
399
400 T = Triple("amdgcn-mesa-mesa3d");
401 EXPECT_EQ(Triple::amdgcn, T.getArch());
402 EXPECT_EQ(Triple::Mesa, T.getVendor());
403 EXPECT_EQ(Triple::Mesa3D, T.getOS());
404 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
405
406 T = Triple("amdgcn-amd-amdhsa");
407 EXPECT_EQ(Triple::amdgcn, T.getArch());
408 EXPECT_EQ(Triple::AMD, T.getVendor());
409 EXPECT_EQ(Triple::AMDHSA, T.getOS());
410 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
411
412 T = Triple("amdgcn-amd-amdpal");
413 EXPECT_EQ(Triple::amdgcn, T.getArch());
414 EXPECT_EQ(Triple::AMD, T.getVendor());
415 EXPECT_EQ(Triple::AMDPAL, T.getOS());
416 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
417
418 T = Triple("ve-unknown-linux");
419 EXPECT_EQ(Triple::ve, T.getArch());
420 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
421 EXPECT_EQ(Triple::Linux, T.getOS());
422 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
423
424 T = Triple("csky-unknown-unknown");
425 EXPECT_EQ(Triple::csky, T.getArch());
426 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
427 EXPECT_EQ(Triple::UnknownOS, T.getOS());
428 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
429
430 T = Triple("csky-unknown-linux");
431 EXPECT_EQ(Triple::csky, T.getArch());
432 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
433 EXPECT_EQ(Triple::Linux, T.getOS());
434 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
435
436 T = Triple("loongarch32-unknown-unknown");
437 EXPECT_EQ(Triple::loongarch32, T.getArch());
438 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
439 EXPECT_EQ(Triple::UnknownOS, T.getOS());
440 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
441
442 T = Triple("loongarch32-unknown-linux-gnu");
443 EXPECT_EQ(Triple::loongarch32, T.getArch());
444 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
445 EXPECT_EQ(Triple::Linux, T.getOS());
446 EXPECT_EQ(Triple::GNU, T.getEnvironment());
447
448 T = Triple("loongarch32-unknown-linux-gnuf32");
449 EXPECT_EQ(Triple::loongarch32, T.getArch());
450 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
451 EXPECT_EQ(Triple::Linux, T.getOS());
452 EXPECT_EQ(Triple::GNUF32, T.getEnvironment());
453
454 T = Triple("loongarch32-unknown-linux-gnuf64");
455 EXPECT_EQ(Triple::loongarch32, T.getArch());
456 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
457 EXPECT_EQ(Triple::Linux, T.getOS());
458 EXPECT_EQ(Triple::GNUF64, T.getEnvironment());
459
460 T = Triple("loongarch32-unknown-linux-gnusf");
461 EXPECT_EQ(Triple::loongarch32, T.getArch());
462 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
463 EXPECT_EQ(Triple::Linux, T.getOS());
464 EXPECT_EQ(Triple::GNUSF, T.getEnvironment());
465
466 T = Triple("loongarch32-unknown-linux-musl");
467 EXPECT_EQ(Triple::loongarch32, T.getArch());
468 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
469 EXPECT_EQ(Triple::Linux, T.getOS());
470 EXPECT_EQ(Triple::Musl, T.getEnvironment());
471
472 T = Triple("loongarch64-unknown-linux");
473 EXPECT_EQ(Triple::loongarch64, T.getArch());
474 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
475 EXPECT_EQ(Triple::Linux, T.getOS());
476 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
477
478 T = Triple("loongarch64-unknown-linux-gnu");
479 EXPECT_EQ(Triple::loongarch64, T.getArch());
480 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
481 EXPECT_EQ(Triple::Linux, T.getOS());
482 EXPECT_EQ(Triple::GNU, T.getEnvironment());
483
484 T = Triple("loongarch64-unknown-linux-gnuf32");
485 EXPECT_EQ(Triple::loongarch64, T.getArch());
486 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
487 EXPECT_EQ(Triple::Linux, T.getOS());
488 EXPECT_EQ(Triple::GNUF32, T.getEnvironment());
489
490 T = Triple("loongarch64-unknown-linux-gnuf64");
491 EXPECT_EQ(Triple::loongarch64, T.getArch());
492 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
493 EXPECT_EQ(Triple::Linux, T.getOS());
494 EXPECT_EQ(Triple::GNUF64, T.getEnvironment());
495
496 T = Triple("loongarch64-unknown-linux-gnusf");
497 EXPECT_EQ(Triple::loongarch64, T.getArch());
498 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
499 EXPECT_EQ(Triple::Linux, T.getOS());
500 EXPECT_EQ(Triple::GNUSF, T.getEnvironment());
501
502 T = Triple("loongarch64-unknown-linux-musl");
503 EXPECT_EQ(Triple::loongarch64, T.getArch());
504 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
505 EXPECT_EQ(Triple::Linux, T.getOS());
506 EXPECT_EQ(Triple::Musl, T.getEnvironment());
507
508 T = Triple("riscv32-unknown-unknown");
509 EXPECT_EQ(Triple::riscv32, T.getArch());
510 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
511 EXPECT_EQ(Triple::UnknownOS, T.getOS());
512 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
513
514 T = Triple("riscv64-unknown-linux");
515 EXPECT_EQ(Triple::riscv64, T.getArch());
516 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
517 EXPECT_EQ(Triple::Linux, T.getOS());
518 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
519
520 T = Triple("riscv64-unknown-freebsd");
521 EXPECT_EQ(Triple::riscv64, T.getArch());
522 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
523 EXPECT_EQ(Triple::FreeBSD, T.getOS());
524 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
525
526 T = Triple("riscv64-suse-linux");
527 EXPECT_EQ(Triple::riscv64, T.getArch());
528 EXPECT_EQ(Triple::SUSE, T.getVendor());
529 EXPECT_EQ(Triple::Linux, T.getOS());
530 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
531
532 T = Triple("armv7hl-suse-linux-gnueabi");
533 EXPECT_EQ(Triple::arm, T.getArch());
534 EXPECT_EQ(Triple::SUSE, T.getVendor());
535 EXPECT_EQ(Triple::Linux, T.getOS());
536 EXPECT_EQ(Triple::GNUEABI, T.getEnvironment());
537
538 T = Triple("i586-pc-haiku");
539 EXPECT_EQ(Triple::x86, T.getArch());
540 EXPECT_EQ(Triple::PC, T.getVendor());
541 EXPECT_EQ(Triple::Haiku, T.getOS());
542 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
543
544 T = Triple("x86_64-unknown-haiku");
545 EXPECT_EQ(Triple::x86_64, T.getArch());
546 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
547 EXPECT_EQ(Triple::Haiku, T.getOS());
548 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
549
550 T = Triple("mips-mti-linux-gnu");
551 EXPECT_EQ(Triple::mips, T.getArch());
552 EXPECT_EQ(Triple::MipsTechnologies, T.getVendor());
553 EXPECT_EQ(Triple::Linux, T.getOS());
554 EXPECT_EQ(Triple::GNU, T.getEnvironment());
555
556 T = Triple("mipsel-img-linux-gnu");
557 EXPECT_EQ(Triple::mipsel, T.getArch());
558 EXPECT_EQ(Triple::ImaginationTechnologies, T.getVendor());
559 EXPECT_EQ(Triple::Linux, T.getOS());
560 EXPECT_EQ(Triple::GNU, T.getEnvironment());
561
562 T = Triple("mips64-mti-linux-gnu");
563 EXPECT_EQ(Triple::mips64, T.getArch());
564 EXPECT_EQ(Triple::MipsTechnologies, T.getVendor());
565 EXPECT_EQ(Triple::Linux, T.getOS());
566 EXPECT_EQ(Triple::GNU, T.getEnvironment());
567
568 T = Triple("mips64el-img-linux-gnu");
569 EXPECT_EQ(Triple::mips64el, T.getArch());
570 EXPECT_EQ(Triple::ImaginationTechnologies, T.getVendor());
571 EXPECT_EQ(Triple::Linux, T.getOS());
572 EXPECT_EQ(Triple::GNU, T.getEnvironment());
573
574 T = Triple("mips64el-img-linux-gnuabin32");
575 EXPECT_EQ(Triple::mips64el, T.getArch());
576 EXPECT_EQ(Triple::ImaginationTechnologies, T.getVendor());
577 EXPECT_EQ(Triple::Linux, T.getOS());
578 EXPECT_EQ(Triple::GNUABIN32, T.getEnvironment());
579
580 T = Triple("mips64el-unknown-linux-gnuabi64");
581 EXPECT_EQ(Triple::mips64el, T.getArch());
582 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
583 EXPECT_EQ(Triple::Linux, T.getOS());
584 EXPECT_EQ(Triple::GNUABI64, T.getEnvironment());
585 EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
586 T = Triple("mips64el");
587 EXPECT_EQ(Triple::mips64el, T.getArch());
588 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
589 EXPECT_EQ(Triple::GNUABI64, T.getEnvironment());
590 EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
591
592 T = Triple("mips64-unknown-linux-gnuabi64");
593 EXPECT_EQ(Triple::mips64, T.getArch());
594 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
595 EXPECT_EQ(Triple::Linux, T.getOS());
596 EXPECT_EQ(Triple::GNUABI64, T.getEnvironment());
597 EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
598 T = Triple("mips64");
599 EXPECT_EQ(Triple::mips64, T.getArch());
600 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
601 EXPECT_EQ(Triple::GNUABI64, T.getEnvironment());
602 EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
603
604 T = Triple("mipsisa64r6el-unknown-linux-gnuabi64");
605 EXPECT_EQ(Triple::mips64el, T.getArch());
606 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
607 EXPECT_EQ(Triple::Linux, T.getOS());
608 EXPECT_EQ(Triple::GNUABI64, T.getEnvironment());
609 EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch());
610 T = Triple("mips64r6el");
611 EXPECT_EQ(Triple::mips64el, T.getArch());
612 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
613 EXPECT_EQ(Triple::GNUABI64, T.getEnvironment());
614 EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch());
615 T = Triple("mipsisa64r6el");
616 EXPECT_EQ(Triple::mips64el, T.getArch());
617 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
618 EXPECT_EQ(Triple::GNUABI64, T.getEnvironment());
619 EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch());
620
621 T = Triple("mipsisa64r6-unknown-linux-gnuabi64");
622 EXPECT_EQ(Triple::mips64, T.getArch());
623 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
624 EXPECT_EQ(Triple::Linux, T.getOS());
625 EXPECT_EQ(Triple::GNUABI64, T.getEnvironment());
626 EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch());
627 T = Triple("mips64r6");
628 EXPECT_EQ(Triple::mips64, T.getArch());
629 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
630 EXPECT_EQ(Triple::GNUABI64, T.getEnvironment());
631 EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch());
632 T = Triple("mipsisa64r6");
633 EXPECT_EQ(Triple::mips64, T.getArch());
634 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
635 EXPECT_EQ(Triple::GNUABI64, T.getEnvironment());
636 EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch());
637
638 T = Triple("mips64el-unknown-linux-gnuabin32");
639 EXPECT_EQ(Triple::mips64el, T.getArch());
640 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
641 EXPECT_EQ(Triple::Linux, T.getOS());
642 EXPECT_EQ(Triple::GNUABIN32, T.getEnvironment());
643 EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
644 T = Triple("mipsn32el");
645 EXPECT_EQ(Triple::mips64el, T.getArch());
646 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
647 EXPECT_EQ(Triple::GNUABIN32, T.getEnvironment());
648 EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
649
650 T = Triple("mips64-unknown-linux-gnuabin32");
651 EXPECT_EQ(Triple::mips64, T.getArch());
652 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
653 EXPECT_EQ(Triple::Linux, T.getOS());
654 EXPECT_EQ(Triple::GNUABIN32, T.getEnvironment());
655 EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
656 T = Triple("mipsn32");
657 EXPECT_EQ(Triple::mips64, T.getArch());
658 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
659 EXPECT_EQ(Triple::GNUABIN32, T.getEnvironment());
660 EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
661
662 T = Triple("mipsisa64r6el-unknown-linux-gnuabin32");
663 EXPECT_EQ(Triple::mips64el, T.getArch());
664 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
665 EXPECT_EQ(Triple::Linux, T.getOS());
666 EXPECT_EQ(Triple::GNUABIN32, T.getEnvironment());
667 EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch());
668 T = Triple("mipsn32r6el");
669 EXPECT_EQ(Triple::mips64el, T.getArch());
670 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
671 EXPECT_EQ(Triple::GNUABIN32, T.getEnvironment());
672 EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch());
673
674 T = Triple("mipsisa64r6-unknown-linux-gnuabin32");
675 EXPECT_EQ(Triple::mips64, T.getArch());
676 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
677 EXPECT_EQ(Triple::Linux, T.getOS());
678 EXPECT_EQ(Triple::GNUABIN32, T.getEnvironment());
679 EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch());
680 T = Triple("mipsn32r6");
681 EXPECT_EQ(Triple::mips64, T.getArch());
682 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
683 EXPECT_EQ(Triple::GNUABIN32, T.getEnvironment());
684 EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch());
685
686 T = Triple("mipsel-unknown-linux-gnu");
687 EXPECT_EQ(Triple::mipsel, T.getArch());
688 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
689 EXPECT_EQ(Triple::Linux, T.getOS());
690 EXPECT_EQ(Triple::GNU, T.getEnvironment());
691 EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
692 T = Triple("mipsel");
693 EXPECT_EQ(Triple::mipsel, T.getArch());
694 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
695 EXPECT_EQ(Triple::GNU, T.getEnvironment());
696 EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
697
698 T = Triple("mips-unknown-linux-gnu");
699 EXPECT_EQ(Triple::mips, T.getArch());
700 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
701 EXPECT_EQ(Triple::Linux, T.getOS());
702 EXPECT_EQ(Triple::GNU, T.getEnvironment());
703 EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
704 T = Triple("mips");
705 EXPECT_EQ(Triple::mips, T.getArch());
706 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
707 EXPECT_EQ(Triple::GNU, T.getEnvironment());
708 EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
709
710 T = Triple("mipsisa32r6el-unknown-linux-gnu");
711 EXPECT_EQ(Triple::mipsel, T.getArch());
712 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
713 EXPECT_EQ(Triple::Linux, T.getOS());
714 EXPECT_EQ(Triple::GNU, T.getEnvironment());
715 EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch());
716 T = Triple("mipsr6el");
717 EXPECT_EQ(Triple::mipsel, T.getArch());
718 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
719 EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch());
720 T = Triple("mipsisa32r6el");
721 EXPECT_EQ(Triple::mipsel, T.getArch());
722 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
723 EXPECT_EQ(Triple::GNU, T.getEnvironment());
724 EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch());
725
726 T = Triple("mipsisa32r6-unknown-linux-gnu");
727 EXPECT_EQ(Triple::mips, T.getArch());
728 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
729 EXPECT_EQ(Triple::Linux, T.getOS());
730 EXPECT_EQ(Triple::GNU, T.getEnvironment());
731 EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch());
732 T = Triple("mipsr6");
733 EXPECT_EQ(Triple::mips, T.getArch());
734 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
735 EXPECT_EQ(Triple::GNU, T.getEnvironment());
736 EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch());
737 T = Triple("mipsisa32r6");
738 EXPECT_EQ(Triple::mips, T.getArch());
739 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
740 EXPECT_EQ(Triple::GNU, T.getEnvironment());
741 EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch());
742
743 T = Triple("arm-oe-linux-gnueabi");
744 EXPECT_EQ(Triple::arm, T.getArch());
745 EXPECT_EQ(Triple::OpenEmbedded, T.getVendor());
746 EXPECT_EQ(Triple::Linux, T.getOS());
747 EXPECT_EQ(Triple::GNUEABI, T.getEnvironment());
748
749 T = Triple("aarch64-oe-linux");
750 EXPECT_EQ(Triple::aarch64, T.getArch());
751 EXPECT_EQ(Triple::OpenEmbedded, T.getVendor());
752 EXPECT_EQ(Triple::Linux, T.getOS());
753 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
754 EXPECT_TRUE(T.isArch64Bit());
755
756 T = Triple("arm64_32-apple-ios");
757 EXPECT_EQ(Triple::aarch64_32, T.getArch());
758 EXPECT_EQ(Triple::IOS, T.getOS());
759 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
760 EXPECT_TRUE(T.isArch32Bit());
761
762 T = Triple("dxil-unknown-shadermodel-pixel");
763 EXPECT_EQ(Triple::dxil, T.getArch());
764 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
765 EXPECT_EQ(Triple::ShaderModel, T.getOS());
766 EXPECT_EQ(Triple::Pixel, T.getEnvironment());
767 EXPECT_FALSE(T.supportsCOMDAT());
768
769 T = Triple("dxil-unknown-shadermodel-vertex");
770 EXPECT_EQ(Triple::dxil, T.getArch());
771 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
772 EXPECT_EQ(Triple::ShaderModel, T.getOS());
773 EXPECT_EQ(Triple::Vertex, T.getEnvironment());
774 EXPECT_FALSE(T.supportsCOMDAT());
775
776 T = Triple("dxil-unknown-shadermodel-geometry");
777 EXPECT_EQ(Triple::dxil, T.getArch());
778 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
779 EXPECT_EQ(Triple::ShaderModel, T.getOS());
780 EXPECT_EQ(Triple::Geometry, T.getEnvironment());
781 EXPECT_FALSE(T.supportsCOMDAT());
782
783 T = Triple("dxil-unknown-shadermodel-hull");
784 EXPECT_EQ(Triple::dxil, T.getArch());
785 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
786 EXPECT_EQ(Triple::ShaderModel, T.getOS());
787 EXPECT_EQ(Triple::Hull, T.getEnvironment());
788 EXPECT_FALSE(T.supportsCOMDAT());
789
790 T = Triple("dxil-unknown-shadermodel-domain");
791 EXPECT_EQ(Triple::dxil, T.getArch());
792 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
793 EXPECT_EQ(Triple::ShaderModel, T.getOS());
794 EXPECT_EQ(Triple::Domain, T.getEnvironment());
795 EXPECT_FALSE(T.supportsCOMDAT());
796
797 T = Triple("dxil-unknown-shadermodel-compute");
798 EXPECT_EQ(Triple::dxil, T.getArch());
799 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
800 EXPECT_EQ(Triple::ShaderModel, T.getOS());
801 EXPECT_EQ(Triple::Compute, T.getEnvironment());
802 EXPECT_FALSE(T.supportsCOMDAT());
803
804 T = Triple("dxil-unknown-shadermodel-library");
805 EXPECT_EQ(Triple::dxil, T.getArch());
806 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
807 EXPECT_EQ(Triple::ShaderModel, T.getOS());
808 EXPECT_EQ(Triple::Library, T.getEnvironment());
809 EXPECT_FALSE(T.supportsCOMDAT());
810
811 T = Triple("dxil-unknown-shadermodel-raygeneration");
812 EXPECT_EQ(Triple::dxil, T.getArch());
813 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
814 EXPECT_EQ(Triple::ShaderModel, T.getOS());
815 EXPECT_EQ(Triple::RayGeneration, T.getEnvironment());
816 EXPECT_FALSE(T.supportsCOMDAT());
817
818 T = Triple("dxil-unknown-shadermodel-intersection");
819 EXPECT_EQ(Triple::dxil, T.getArch());
820 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
821 EXPECT_EQ(Triple::ShaderModel, T.getOS());
822 EXPECT_EQ(Triple::Intersection, T.getEnvironment());
823 EXPECT_FALSE(T.supportsCOMDAT());
824
825 T = Triple("dxil-unknown-shadermodel-anyhit");
826 EXPECT_EQ(Triple::dxil, T.getArch());
827 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
828 EXPECT_EQ(Triple::ShaderModel, T.getOS());
829 EXPECT_EQ(Triple::AnyHit, T.getEnvironment());
830 EXPECT_FALSE(T.supportsCOMDAT());
831
832 T = Triple("dxil-unknown-shadermodel-closesthit");
833 EXPECT_EQ(Triple::dxil, T.getArch());
834 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
835 EXPECT_EQ(Triple::ShaderModel, T.getOS());
836 EXPECT_EQ(Triple::ClosestHit, T.getEnvironment());
837 EXPECT_FALSE(T.supportsCOMDAT());
838
839 T = Triple("dxil-unknown-shadermodel-miss");
840 EXPECT_EQ(Triple::dxil, T.getArch());
841 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
842 EXPECT_EQ(Triple::ShaderModel, T.getOS());
843 EXPECT_EQ(Triple::Miss, T.getEnvironment());
844 EXPECT_FALSE(T.supportsCOMDAT());
845
846 T = Triple("dxil-unknown-shadermodel-callable");
847 EXPECT_EQ(Triple::dxil, T.getArch());
848 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
849 EXPECT_EQ(Triple::ShaderModel, T.getOS());
850 EXPECT_EQ(Triple::Callable, T.getEnvironment());
851 EXPECT_FALSE(T.supportsCOMDAT());
852
853 T = Triple("dxil-unknown-shadermodel-mesh");
854 EXPECT_EQ(Triple::dxil, T.getArch());
855 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
856 EXPECT_EQ(Triple::ShaderModel, T.getOS());
857 EXPECT_EQ(Triple::Mesh, T.getEnvironment());
858 EXPECT_FALSE(T.supportsCOMDAT());
859
860 T = Triple("dxil-unknown-shadermodel-amplification");
861 EXPECT_EQ(Triple::dxil, T.getArch());
862 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
863 EXPECT_EQ(Triple::ShaderModel, T.getOS());
864 EXPECT_EQ(Triple::Amplification, T.getEnvironment());
865 EXPECT_FALSE(T.supportsCOMDAT());
866
867 T = Triple("xtensa");
868 EXPECT_EQ(Triple::xtensa, T.getArch());
869 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
870 EXPECT_EQ(Triple::UnknownOS, T.getOS());
871 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
872
873 T = Triple("xtensa-unknown-unknown");
874 EXPECT_EQ(Triple::xtensa, T.getArch());
875 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
876 EXPECT_EQ(Triple::UnknownOS, T.getOS());
877 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
878
879 T = Triple("huh");
880 EXPECT_EQ(Triple::UnknownArch, T.getArch());
881 }
882
883 static std::string Join(StringRef A, StringRef B, StringRef C) {
884 std::string Str = std::string(A);
885 Str += '-';
886 Str += B;
887 Str += '-';
888 Str += C;
889 return Str;
890 }
891
892 static std::string Join(StringRef A, StringRef B, StringRef C, StringRef D) {
893 std::string Str = std::string(A);
894 Str += '-';
895 Str += B;
896 Str += '-';
897 Str += C;
898 Str += '-';
899 Str += D;
900 return Str;
901 }
902
903 TEST(TripleTest, Normalization) {
904
905 EXPECT_EQ("unknown", Triple::normalize(""));
906 EXPECT_EQ("unknown-unknown", Triple::normalize("-"));
907 EXPECT_EQ("unknown-unknown-unknown", Triple::normalize("--"));
908 EXPECT_EQ("unknown-unknown-unknown-unknown", Triple::normalize("---"));
909 EXPECT_EQ("unknown-unknown-unknown-unknown-unknown",
910 Triple::normalize("----"));
911
912 EXPECT_EQ("a", Triple::normalize("a"));
913 EXPECT_EQ("a-b", Triple::normalize("a-b"));
914 EXPECT_EQ("a-b-c", Triple::normalize("a-b-c"));
915 EXPECT_EQ("a-b-c-d", Triple::normalize("a-b-c-d"));
916
917 EXPECT_EQ("i386-b-c", Triple::normalize("i386-b-c"));
918 EXPECT_EQ("i386-a-c", Triple::normalize("a-i386-c"));
919 EXPECT_EQ("i386-a-b", Triple::normalize("a-b-i386"));
920 EXPECT_EQ("i386-a-b-c", Triple::normalize("a-b-c-i386"));
921
922 EXPECT_EQ("a-pc-c", Triple::normalize("a-pc-c"));
923 EXPECT_EQ("unknown-pc-b-c", Triple::normalize("pc-b-c"));
924 EXPECT_EQ("a-pc-b", Triple::normalize("a-b-pc"));
925 EXPECT_EQ("a-pc-b-c", Triple::normalize("a-b-c-pc"));
926
927 EXPECT_EQ("a-b-linux", Triple::normalize("a-b-linux"));
928 EXPECT_EQ("unknown-unknown-linux-b-c", Triple::normalize("linux-b-c"));
929 EXPECT_EQ("a-unknown-linux-c", Triple::normalize("a-linux-c"));
930
931 EXPECT_EQ("i386-pc-a", Triple::normalize("a-pc-i386"));
932 EXPECT_EQ("i386-pc-unknown", Triple::normalize("-pc-i386"));
933 EXPECT_EQ("unknown-pc-linux-c", Triple::normalize("linux-pc-c"));
934 EXPECT_EQ("unknown-pc-linux", Triple::normalize("linux-pc-"));
935
936 EXPECT_EQ("i386", Triple::normalize("i386"));
937 EXPECT_EQ("unknown-pc", Triple::normalize("pc"));
938 EXPECT_EQ("unknown-unknown-linux", Triple::normalize("linux"));
939
940 EXPECT_EQ("x86_64-unknown-linux-gnu", Triple::normalize("x86_64-gnu-linux"));
941
942 // Check that normalizing a permutated set of valid components returns a
943 // triple with the unpermuted components.
944 //
945 // We don't check every possible combination. For the set of architectures A,
946 // vendors V, operating systems O, and environments E, that would require |A|
947 // * |V| * |O| * |E| * 4! tests. Instead we check every option for any given
948 // slot and make sure it gets normalized to the correct position from every
949 // permutation. This should cover the core logic while being a tractable
950 // number of tests at (|A| + |V| + |O| + |E|) * 4!.
951 auto FirstArchType = Triple::ArchType(Triple::UnknownArch + 1);
952 auto FirstVendorType = Triple::VendorType(Triple::UnknownVendor + 1);
953 auto FirstOSType = Triple::OSType(Triple::UnknownOS + 1);
954 auto FirstEnvType = Triple::EnvironmentType(Triple::UnknownEnvironment + 1);
955 StringRef InitialC[] = {Triple::getArchTypeName(FirstArchType),
956 Triple::getVendorTypeName(FirstVendorType),
957 Triple::getOSTypeName(FirstOSType),
958 Triple::getEnvironmentTypeName(FirstEnvType)};
959 for (int Arch = FirstArchType; Arch <= Triple::LastArchType; ++Arch) {
960 StringRef C[] = {InitialC[0], InitialC[1], InitialC[2], InitialC[3]};
961 C[0] = Triple::getArchTypeName(Triple::ArchType(Arch));
962 std::string E = Join(C[0], C[1], C[2]);
963 int I[] = {0, 1, 2};
964 do {
965 EXPECT_EQ(E, Triple::normalize(Join(C[I[0]], C[I[1]], C[I[2]])));
966 } while (std::next_permutation(std::begin(I), std::end(I)));
967 std::string F = Join(C[0], C[1], C[2], C[3]);
968 int J[] = {0, 1, 2, 3};
969 do {
970 EXPECT_EQ(F, Triple::normalize(Join(C[J[0]], C[J[1]], C[J[2]], C[J[3]])));
971 } while (std::next_permutation(std::begin(J), std::end(J)));
972 }
973 for (int Vendor = FirstVendorType; Vendor <= Triple::LastVendorType;
974 ++Vendor) {
975 StringRef C[] = {InitialC[0], InitialC[1], InitialC[2], InitialC[3]};
976 C[1] = Triple::getVendorTypeName(Triple::VendorType(Vendor));
977 std::string E = Join(C[0], C[1], C[2]);
978 int I[] = {0, 1, 2};
979 do {
980 EXPECT_EQ(E, Triple::normalize(Join(C[I[0]], C[I[1]], C[I[2]])));
981 } while (std::next_permutation(std::begin(I), std::end(I)));
982 std::string F = Join(C[0], C[1], C[2], C[3]);
983 int J[] = {0, 1, 2, 3};
984 do {
985 EXPECT_EQ(F, Triple::normalize(Join(C[J[0]], C[J[1]], C[J[2]], C[J[3]])));
986 } while (std::next_permutation(std::begin(J), std::end(J)));
987 }
988 for (int OS = FirstOSType; OS <= Triple::LastOSType; ++OS) {
989 if (OS == Triple::Win32)
990 continue;
991 StringRef C[] = {InitialC[0], InitialC[1], InitialC[2], InitialC[3]};
992 C[2] = Triple::getOSTypeName(Triple::OSType(OS));
993 std::string E = Join(C[0], C[1], C[2]);
994 int I[] = {0, 1, 2};
995 do {
996 EXPECT_EQ(E, Triple::normalize(Join(C[I[0]], C[I[1]], C[I[2]])));
997 } while (std::next_permutation(std::begin(I), std::end(I)));
998 std::string F = Join(C[0], C[1], C[2], C[3]);
999 int J[] = {0, 1, 2, 3};
1000 do {
1001 EXPECT_EQ(F, Triple::normalize(Join(C[J[0]], C[J[1]], C[J[2]], C[J[3]])));
1002 } while (std::next_permutation(std::begin(J), std::end(J)));
1003 }
1004 for (int Env = FirstEnvType; Env <= Triple::LastEnvironmentType; ++Env) {
1005 StringRef C[] = {InitialC[0], InitialC[1], InitialC[2], InitialC[3]};
1006 C[3] = Triple::getEnvironmentTypeName(Triple::EnvironmentType(Env));
1007 std::string F = Join(C[0], C[1], C[2], C[3]);
1008 int J[] = {0, 1, 2, 3};
1009 do {
1010 EXPECT_EQ(F, Triple::normalize(Join(C[J[0]], C[J[1]], C[J[2]], C[J[3]])));
1011 } while (std::next_permutation(std::begin(J), std::end(J)));
1012 }
1013
1014 // Various real-world funky triples. The value returned by GCC's config.sub
1015 // is given in the comment.
1016 EXPECT_EQ("i386-unknown-windows-gnu",
1017 Triple::normalize("i386-mingw32")); // i386-pc-mingw32
1018 EXPECT_EQ("x86_64-unknown-linux-gnu",
1019 Triple::normalize("x86_64-linux-gnu")); // x86_64-pc-linux-gnu
1020 EXPECT_EQ("i486-unknown-linux-gnu",
1021 Triple::normalize("i486-linux-gnu")); // i486-pc-linux-gnu
1022 EXPECT_EQ("i386-redhat-linux",
1023 Triple::normalize("i386-redhat-linux")); // i386-redhat-linux-gnu
1024 EXPECT_EQ("i686-unknown-linux",
1025 Triple::normalize("i686-linux")); // i686-pc-linux-gnu
1026 EXPECT_EQ("arm-none-unknown-eabi",
1027 Triple::normalize("arm-none-eabi")); // arm-none-eabi
1028 EXPECT_EQ("ve-unknown-linux",
1029 Triple::normalize("ve-linux")); // ve-linux
1030 EXPECT_EQ("wasm32-unknown-wasi",
1031 Triple::normalize("wasm32-wasi")); // wasm32-unknown-wasi
1032 EXPECT_EQ("wasm64-unknown-wasi",
1033 Triple::normalize("wasm64-wasi")); // wasm64-unknown-wasi
1034 }
1035
1036 TEST(TripleTest, MutateName) {
1037 Triple T;
1038 EXPECT_EQ(Triple::UnknownArch, T.getArch());
1039 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
1040 EXPECT_EQ(Triple::UnknownOS, T.getOS());
1041 EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
1042
1043 T.setArchName("i386");
1044 EXPECT_EQ(Triple::x86, T.getArch());
1045 EXPECT_EQ("i386--", T.getTriple());
1046
1047 T.setVendorName("pc");
1048 EXPECT_EQ(Triple::x86, T.getArch());
1049 EXPECT_EQ(Triple::PC, T.getVendor());
1050 EXPECT_EQ("i386-pc-", T.getTriple());
1051
1052 T.setOSName("linux");
1053 EXPECT_EQ(Triple::x86, T.getArch());
1054 EXPECT_EQ(Triple::PC, T.getVendor());
1055 EXPECT_EQ(Triple::Linux, T.getOS());
1056 EXPECT_EQ("i386-pc-linux", T.getTriple());
1057
1058 T.setEnvironmentName("gnu");
1059 EXPECT_EQ(Triple::x86, T.getArch());
1060 EXPECT_EQ(Triple::PC, T.getVendor());
1061 EXPECT_EQ(Triple::Linux, T.getOS());
1062 EXPECT_EQ("i386-pc-linux-gnu", T.getTriple());
1063
1064 T.setOSName("freebsd");
1065 EXPECT_EQ(Triple::x86, T.getArch());
1066 EXPECT_EQ(Triple::PC, T.getVendor());
1067 EXPECT_EQ(Triple::FreeBSD, T.getOS());
1068 EXPECT_EQ("i386-pc-freebsd-gnu", T.getTriple());
1069
1070 T.setOSAndEnvironmentName("darwin");
1071 EXPECT_EQ(Triple::x86, T.getArch());
1072 EXPECT_EQ(Triple::PC, T.getVendor());
1073 EXPECT_EQ(Triple::Darwin, T.getOS());
1074 EXPECT_EQ("i386-pc-darwin", T.getTriple());
1075 }
1076
1077 TEST(TripleTest, BitWidthPredicates) {
1078 Triple T;
1079 EXPECT_FALSE(T.isArch16Bit());
1080 EXPECT_FALSE(T.isArch32Bit());
1081 EXPECT_FALSE(T.isArch64Bit());
1082
1083 T.setArch(Triple::arm);
1084 EXPECT_FALSE(T.isArch16Bit());
1085 EXPECT_TRUE(T.isArch32Bit());
1086 EXPECT_FALSE(T.isArch64Bit());
1087
1088 T.setArch(Triple::hexagon);
1089 EXPECT_FALSE(T.isArch16Bit());
1090 EXPECT_TRUE(T.isArch32Bit());
1091 EXPECT_FALSE(T.isArch64Bit());
1092
1093 T.setArch(Triple::mips);
1094 EXPECT_FALSE(T.isArch16Bit());
1095 EXPECT_TRUE(T.isArch32Bit());
1096 EXPECT_FALSE(T.isArch64Bit());
1097
1098 T.setArch(Triple::mips64);
1099 EXPECT_FALSE(T.isArch16Bit());
1100 EXPECT_FALSE(T.isArch32Bit());
1101 EXPECT_TRUE(T.isArch64Bit());
1102
1103 T.setArch(Triple::msp430);
1104 EXPECT_TRUE(T.isArch16Bit());
1105 EXPECT_FALSE(T.isArch32Bit());
1106 EXPECT_FALSE(T.isArch64Bit());
1107
1108 T.setArch(Triple::ppc);
1109 EXPECT_FALSE(T.isArch16Bit());
1110 EXPECT_TRUE(T.isArch32Bit());
1111 EXPECT_FALSE(T.isArch64Bit());
1112
1113 T.setArch(Triple::ppc64);
1114 EXPECT_FALSE(T.isArch16Bit());
1115 EXPECT_FALSE(T.isArch32Bit());
1116 EXPECT_TRUE(T.isArch64Bit());
1117
1118 T.setArch(Triple::x86);
1119 EXPECT_FALSE(T.isArch16Bit());
1120 EXPECT_TRUE(T.isArch32Bit());
1121 EXPECT_FALSE(T.isArch64Bit());
1122
1123 T.setArch(Triple::x86_64);
1124 EXPECT_FALSE(T.isArch16Bit());
1125 EXPECT_FALSE(T.isArch32Bit());
1126 EXPECT_TRUE(T.isArch64Bit());
1127
1128 T.setArch(Triple::amdil);
1129 EXPECT_FALSE(T.isArch16Bit());
1130 EXPECT_TRUE(T.isArch32Bit());
1131 EXPECT_FALSE(T.isArch64Bit());
1132
1133 T.setArch(Triple::amdil64);
1134 EXPECT_FALSE(T.isArch16Bit());
1135 EXPECT_FALSE(T.isArch32Bit());
1136 EXPECT_TRUE(T.isArch64Bit());
1137
1138 T.setArch(Triple::hsail);
1139 EXPECT_FALSE(T.isArch16Bit());
1140 EXPECT_TRUE(T.isArch32Bit());
1141 EXPECT_FALSE(T.isArch64Bit());
1142
1143 T.setArch(Triple::hsail64);
1144 EXPECT_FALSE(T.isArch16Bit());
1145 EXPECT_FALSE(T.isArch32Bit());
1146 EXPECT_TRUE(T.isArch64Bit());
1147
1148 T.setArch(Triple::spir);
1149 EXPECT_FALSE(T.isArch16Bit());
1150 EXPECT_TRUE(T.isArch32Bit());
1151 EXPECT_FALSE(T.isArch64Bit());
1152
1153 T.setArch(Triple::spir64);
1154 EXPECT_FALSE(T.isArch16Bit());
1155 EXPECT_FALSE(T.isArch32Bit());
1156 EXPECT_TRUE(T.isArch64Bit());
1157
1158 T.setArch(Triple::spirv32);
1159 EXPECT_FALSE(T.isArch16Bit());
1160 EXPECT_TRUE(T.isArch32Bit());
1161 EXPECT_FALSE(T.isArch64Bit());
1162 EXPECT_TRUE(T.isSPIRV());
1163
1164 T.setArch(Triple::spirv64);
1165 EXPECT_FALSE(T.isArch16Bit());
1166 EXPECT_FALSE(T.isArch32Bit());
1167 EXPECT_TRUE(T.isArch64Bit());
1168 EXPECT_TRUE(T.isSPIRV());
1169
1170 T.setArch(Triple::sparc);
1171 EXPECT_FALSE(T.isArch16Bit());
1172 EXPECT_TRUE(T.isArch32Bit());
1173 EXPECT_FALSE(T.isArch64Bit());
1174
1175 T.setArch(Triple::sparcel);
1176 EXPECT_FALSE(T.isArch16Bit());
1177 EXPECT_TRUE(T.isArch32Bit());
1178 EXPECT_FALSE(T.isArch64Bit());
1179
1180 T.setArch(Triple::sparcv9);
1181 EXPECT_FALSE(T.isArch16Bit());
1182 EXPECT_FALSE(T.isArch32Bit());
1183 EXPECT_TRUE(T.isArch64Bit());
1184
1185 T.setArch(Triple::wasm32);
1186 EXPECT_FALSE(T.isArch16Bit());
1187 EXPECT_TRUE(T.isArch32Bit());
1188 EXPECT_FALSE(T.isArch64Bit());
1189
1190 T.setArch(Triple::wasm64);
1191 EXPECT_FALSE(T.isArch16Bit());
1192 EXPECT_FALSE(T.isArch32Bit());
1193 EXPECT_TRUE(T.isArch64Bit());
1194
1195 T.setArch(Triple::avr);
1196 EXPECT_TRUE(T.isArch16Bit());
1197 EXPECT_FALSE(T.isArch32Bit());
1198 EXPECT_FALSE(T.isArch64Bit());
1199
1200 T.setArch(Triple::lanai);
1201 EXPECT_FALSE(T.isArch16Bit());
1202 EXPECT_TRUE(T.isArch32Bit());
1203 EXPECT_FALSE(T.isArch64Bit());
1204
1205 T.setArch(Triple::riscv32);
1206 EXPECT_FALSE(T.isArch16Bit());
1207 EXPECT_TRUE(T.isArch32Bit());
1208 EXPECT_FALSE(T.isArch64Bit());
1209 EXPECT_TRUE(T.isRISCV());
1210
1211 T.setArch(Triple::riscv64);
1212 EXPECT_FALSE(T.isArch16Bit());
1213 EXPECT_FALSE(T.isArch32Bit());
1214 EXPECT_TRUE(T.isArch64Bit());
1215 EXPECT_TRUE(T.isRISCV());
1216
1217 T.setArch(Triple::csky);
1218 EXPECT_FALSE(T.isArch16Bit());
1219 EXPECT_TRUE(T.isArch32Bit());
1220 EXPECT_FALSE(T.isArch64Bit());
1221 EXPECT_TRUE(T.isCSKY());
1222
1223 T.setArch(Triple::loongarch32);
1224 EXPECT_FALSE(T.isArch16Bit());
1225 EXPECT_TRUE(T.isArch32Bit());
1226 EXPECT_FALSE(T.isArch64Bit());
1227 EXPECT_TRUE(T.isLoongArch());
1228
1229 T.setArch(Triple::loongarch64);
1230 EXPECT_FALSE(T.isArch16Bit());
1231 EXPECT_FALSE(T.isArch32Bit());
1232 EXPECT_TRUE(T.isArch64Bit());
1233 EXPECT_TRUE(T.isLoongArch());
1234
1235 T.setArch(Triple::dxil);
1236 EXPECT_FALSE(T.isArch16Bit());
1237 EXPECT_TRUE(T.isArch32Bit());
1238 EXPECT_FALSE(T.isArch64Bit());
1239 EXPECT_TRUE(T.isDXIL());
1240
1241 T.setArch(Triple::xtensa);
1242 EXPECT_FALSE(T.isArch16Bit());
1243 EXPECT_TRUE(T.isArch32Bit());
1244 EXPECT_FALSE(T.isArch64Bit());
1245 }
1246
1247 TEST(TripleTest, BitWidthArchVariants) {
1248 Triple T;
1249 EXPECT_EQ(Triple::UnknownArch, T.get32BitArchVariant().getArch());
1250 EXPECT_EQ(Triple::UnknownArch, T.get64BitArchVariant().getArch());
1251
1252 T.setArch(Triple::UnknownArch);
1253 EXPECT_EQ(Triple::UnknownArch, T.get32BitArchVariant().getArch());
1254 EXPECT_EQ(Triple::UnknownArch, T.get64BitArchVariant().getArch());
1255
1256 T.setArch(Triple::mips);
1257 EXPECT_EQ(Triple::mips, T.get32BitArchVariant().getArch());
1258 EXPECT_EQ(Triple::NoSubArch, T.get32BitArchVariant().getSubArch());
1259 EXPECT_EQ(Triple::mips64, T.get64BitArchVariant().getArch());
1260 EXPECT_EQ(Triple::NoSubArch, T.get64BitArchVariant().getSubArch());
1261
1262 T.setArch(Triple::mips, Triple::MipsSubArch_r6);
1263 EXPECT_EQ(Triple::mips, T.get32BitArchVariant().getArch());
1264 EXPECT_EQ(Triple::MipsSubArch_r6, T.get32BitArchVariant().getSubArch());
1265 EXPECT_EQ(Triple::mips64, T.get64BitArchVariant().getArch());
1266 EXPECT_EQ(Triple::MipsSubArch_r6, T.get64BitArchVariant().getSubArch());
1267
1268 T.setArch(Triple::mipsel);
1269 EXPECT_EQ(Triple::mipsel, T.get32BitArchVariant().getArch());
1270 EXPECT_EQ(Triple::NoSubArch, T.get32BitArchVariant().getSubArch());
1271 EXPECT_EQ(Triple::mips64el, T.get64BitArchVariant().getArch());
1272 EXPECT_EQ(Triple::NoSubArch, T.get64BitArchVariant().getSubArch());
1273
1274 T.setArch(Triple::mipsel, Triple::MipsSubArch_r6);
1275 EXPECT_EQ(Triple::mipsel, T.get32BitArchVariant().getArch());
1276 EXPECT_EQ(Triple::MipsSubArch_r6, T.get32BitArchVariant().getSubArch());
1277 EXPECT_EQ(Triple::mips64el, T.get64BitArchVariant().getArch());
1278 EXPECT_EQ(Triple::MipsSubArch_r6, T.get64BitArchVariant().getSubArch());
1279
1280 T.setArch(Triple::ppc);
1281 EXPECT_EQ(Triple::ppc, T.get32BitArchVariant().getArch());
1282 EXPECT_EQ(Triple::ppc64, T.get64BitArchVariant().getArch());
1283
1284 T.setArch(Triple::nvptx);
1285 EXPECT_EQ(Triple::nvptx, T.get32BitArchVariant().getArch());
1286 EXPECT_EQ(Triple::nvptx64, T.get64BitArchVariant().getArch());
1287
1288 T.setArch(Triple::sparc);
1289 EXPECT_EQ(Triple::sparc, T.get32BitArchVariant().getArch());
1290 EXPECT_EQ(Triple::sparcv9, T.get64BitArchVariant().getArch());
1291
1292 T.setArch(Triple::x86);
1293 EXPECT_EQ(Triple::x86, T.get32BitArchVariant().getArch());
1294 EXPECT_EQ(Triple::x86_64, T.get64BitArchVariant().getArch());
1295
1296 T.setArch(Triple::mips64);
1297 EXPECT_EQ(Triple::mips, T.get32BitArchVariant().getArch());
1298 EXPECT_EQ(Triple::NoSubArch, T.get32BitArchVariant().getSubArch());
1299 EXPECT_EQ(Triple::mips64, T.get64BitArchVariant().getArch());
1300 EXPECT_EQ(Triple::NoSubArch, T.get64BitArchVariant().getSubArch());
1301
1302 T.setArch(Triple::mips64, Triple::MipsSubArch_r6);
1303 EXPECT_EQ(Triple::mips, T.get32BitArchVariant().getArch());
1304 EXPECT_EQ(Triple::MipsSubArch_r6, T.get32BitArchVariant().getSubArch());
1305 EXPECT_EQ(Triple::mips64, T.get64BitArchVariant().getArch());
1306 EXPECT_EQ(Triple::MipsSubArch_r6, T.get64BitArchVariant().getSubArch());
1307
1308 T.setArch(Triple::mips64el);
1309 EXPECT_EQ(Triple::mipsel, T.get32BitArchVariant().getArch());
1310 EXPECT_EQ(Triple::NoSubArch, T.get32BitArchVariant().getSubArch());
1311 EXPECT_EQ(Triple::mips64el, T.get64BitArchVariant().getArch());
1312 EXPECT_EQ(Triple::NoSubArch, T.get64BitArchVariant().getSubArch());
1313
1314 T.setArch(Triple::mips64el, Triple::MipsSubArch_r6);
1315 EXPECT_EQ(Triple::mipsel, T.get32BitArchVariant().getArch());
1316 EXPECT_EQ(Triple::MipsSubArch_r6, T.get32BitArchVariant().getSubArch());
1317 EXPECT_EQ(Triple::mips64el, T.get64BitArchVariant().getArch());
1318 EXPECT_EQ(Triple::MipsSubArch_r6, T.get64BitArchVariant().getSubArch());
1319
1320 T.setArch(Triple::ppc64);
1321 EXPECT_EQ(Triple::ppc, T.get32BitArchVariant().getArch());
1322 EXPECT_EQ(Triple::ppc64, T.get64BitArchVariant().getArch());
1323
1324 T.setArch(Triple::nvptx64);
1325 EXPECT_EQ(Triple::nvptx, T.get32BitArchVariant().getArch());
1326 EXPECT_EQ(Triple::nvptx64, T.get64BitArchVariant().getArch());
1327
1328 T.setArch(Triple::sparcv9);
1329 EXPECT_EQ(Triple::sparc, T.get32BitArchVariant().getArch());
1330 EXPECT_EQ(Triple::sparcv9, T.get64BitArchVariant().getArch());
1331
1332 T.setArch(Triple::x86_64);
1333 EXPECT_EQ(Triple::x86, T.get32BitArchVariant().getArch());
1334 EXPECT_EQ(Triple::x86_64, T.get64BitArchVariant().getArch());
1335
1336 T.setArch(Triple::amdil);
1337 EXPECT_EQ(Triple::amdil, T.get32BitArchVariant().getArch());
1338 EXPECT_EQ(Triple::amdil64, T.get64BitArchVariant().getArch());
1339
1340 T.setArch(Triple::amdil64);
1341 EXPECT_EQ(Triple::amdil, T.get32BitArchVariant().getArch());
1342 EXPECT_EQ(Triple::amdil64, T.get64BitArchVariant().getArch());
1343
1344 T.setArch(Triple::hsail);
1345 EXPECT_EQ(Triple::hsail, T.get32BitArchVariant().getArch());
1346 EXPECT_EQ(Triple::hsail64, T.get64BitArchVariant().getArch());
1347
1348 T.setArch(Triple::hsail64);
1349 EXPECT_EQ(Triple::hsail, T.get32BitArchVariant().getArch());
1350 EXPECT_EQ(Triple::hsail64, T.get64BitArchVariant().getArch());
1351
1352 T.setArch(Triple::spir);
1353 EXPECT_EQ(Triple::spir, T.get32BitArchVariant().getArch());
1354 EXPECT_EQ(Triple::spir64, T.get64BitArchVariant().getArch());
1355
1356 T.setArch(Triple::spir64);
1357 EXPECT_EQ(Triple::spir, T.get32BitArchVariant().getArch());
1358 EXPECT_EQ(Triple::spir64, T.get64BitArchVariant().getArch());
1359
1360 T.setArch(Triple::spirv32);
1361 EXPECT_EQ(Triple::spirv32, T.get32BitArchVariant().getArch());
1362 EXPECT_EQ(Triple::spirv64, T.get64BitArchVariant().getArch());
1363
1364 T.setArch(Triple::spirv64);
1365 EXPECT_EQ(Triple::spirv32, T.get32BitArchVariant().getArch());
1366 EXPECT_EQ(Triple::spirv64, T.get64BitArchVariant().getArch());
1367
1368 T.setArch(Triple::wasm32);
1369 EXPECT_EQ(Triple::wasm32, T.get32BitArchVariant().getArch());
1370 EXPECT_EQ(Triple::wasm64, T.get64BitArchVariant().getArch());
1371
1372 T.setArch(Triple::wasm64);
1373 EXPECT_EQ(Triple::wasm32, T.get32BitArchVariant().getArch());
1374 EXPECT_EQ(Triple::wasm64, T.get64BitArchVariant().getArch());
1375
1376 T.setArch(Triple::riscv32);
1377 EXPECT_EQ(Triple::riscv32, T.get32BitArchVariant().getArch());
1378 EXPECT_EQ(Triple::riscv64, T.get64BitArchVariant().getArch());
1379
1380 T.setArch(Triple::riscv64);
1381 EXPECT_EQ(Triple::riscv32, T.get32BitArchVariant().getArch());
1382 EXPECT_EQ(Triple::riscv64, T.get64BitArchVariant().getArch());
1383
1384 T.setArch(Triple::csky);
1385 EXPECT_EQ(Triple::csky, T.get32BitArchVariant().getArch());
1386 EXPECT_EQ(Triple::UnknownArch, T.get64BitArchVariant().getArch());
1387
1388 T.setArch(Triple::loongarch32);
1389 EXPECT_EQ(Triple::loongarch32, T.get32BitArchVariant().getArch());
1390 EXPECT_EQ(Triple::loongarch64, T.get64BitArchVariant().getArch());
1391
1392 T.setArch(Triple::loongarch64);
1393 EXPECT_EQ(Triple::loongarch32, T.get32BitArchVariant().getArch());
1394 EXPECT_EQ(Triple::loongarch64, T.get64BitArchVariant().getArch());
1395
1396 T.setArch(Triple::thumbeb);
1397 EXPECT_EQ(Triple::thumbeb, T.get32BitArchVariant().getArch());
1398 EXPECT_EQ(Triple::aarch64_be, T.get64BitArchVariant().getArch());
1399
1400 T.setArch(Triple::thumb);
1401 EXPECT_EQ(Triple::thumb, T.get32BitArchVariant().getArch());
1402 EXPECT_EQ(Triple::aarch64, T.get64BitArchVariant().getArch());
1403
1404 T.setArch(Triple::aarch64);
1405 EXPECT_EQ(Triple::arm, T.get32BitArchVariant().getArch());
1406 EXPECT_EQ(Triple::aarch64, T.get64BitArchVariant().getArch());
1407
1408 T.setArch(Triple::aarch64_be);
1409 EXPECT_EQ(Triple::armeb, T.get32BitArchVariant().getArch());
1410 EXPECT_EQ(Triple::aarch64_be, T.get64BitArchVariant().getArch());
1411
1412 T.setArch(Triple::renderscript32);
1413 EXPECT_EQ(Triple::renderscript32, T.get32BitArchVariant().getArch());
1414 EXPECT_EQ(Triple::renderscript64, T.get64BitArchVariant().getArch());
1415
1416 T.setArch(Triple::renderscript64);
1417 EXPECT_EQ(Triple::renderscript32, T.get32BitArchVariant().getArch());
1418 EXPECT_EQ(Triple::renderscript64, T.get64BitArchVariant().getArch());
1419
1420 T.setArch(Triple::armeb);
1421 EXPECT_EQ(Triple::armeb, T.get32BitArchVariant().getArch());
1422 EXPECT_EQ(Triple::aarch64_be, T.get64BitArchVariant().getArch());
1423
1424 T.setArch(Triple::arm);
1425 EXPECT_EQ(Triple::arm, T.get32BitArchVariant().getArch());
1426 EXPECT_EQ(Triple::aarch64, T.get64BitArchVariant().getArch());
1427
1428 T.setArch(Triple::systemz);
1429 EXPECT_EQ(Triple::UnknownArch, T.get32BitArchVariant().getArch());
1430 EXPECT_EQ(Triple::systemz, T.get64BitArchVariant().getArch());
1431
1432 T.setArch(Triple::xcore);
1433 EXPECT_EQ(Triple::xcore, T.get32BitArchVariant().getArch());
1434 EXPECT_EQ(Triple::UnknownArch, T.get64BitArchVariant().getArch());
1435
1436 T.setArch(Triple::dxil);
1437 EXPECT_EQ(Triple::dxil, T.get32BitArchVariant().getArch());
1438 EXPECT_EQ(Triple::UnknownArch, T.get64BitArchVariant().getArch());
1439
1440 T.setArch(Triple::xtensa);
1441 EXPECT_EQ(Triple::xtensa, T.get32BitArchVariant().getArch());
1442 EXPECT_EQ(Triple::UnknownArch, T.get64BitArchVariant().getArch());
1443 }
1444
1445 TEST(TripleTest, EndianArchVariants) {
1446 Triple T;
1447 EXPECT_EQ(Triple::UnknownArch, T.getBigEndianArchVariant().getArch());
1448 EXPECT_EQ(Triple::UnknownArch, T.getLittleEndianArchVariant().getArch());
1449
1450 T.setArch(Triple::UnknownArch);
1451 EXPECT_EQ(Triple::UnknownArch, T.getBigEndianArchVariant().getArch());
1452 EXPECT_EQ(Triple::UnknownArch, T.getLittleEndianArchVariant().getArch());
1453
1454 T.setArch(Triple::aarch64_be);
1455 EXPECT_EQ(Triple::aarch64_be, T.getBigEndianArchVariant().getArch());
1456 EXPECT_EQ(Triple::aarch64, T.getLittleEndianArchVariant().getArch());
1457
1458 T.setArch(Triple::aarch64);
1459 EXPECT_EQ(Triple::aarch64_be, T.getBigEndianArchVariant().getArch());
1460 EXPECT_EQ(Triple::aarch64, T.getLittleEndianArchVariant().getArch());
1461
1462 T.setArch(Triple::armeb);
1463 EXPECT_EQ(Triple::armeb, T.getBigEndianArchVariant().getArch());
1464 EXPECT_EQ(Triple::UnknownArch, T.getLittleEndianArchVariant().getArch());
1465
1466 T.setArch(Triple::arm);
1467 EXPECT_EQ(Triple::UnknownArch, T.getBigEndianArchVariant().getArch());
1468 EXPECT_EQ(Triple::arm, T.getLittleEndianArchVariant().getArch());
1469 T = Triple("arm");
1470 EXPECT_TRUE(T.isLittleEndian());
1471 T = Triple("thumb");
1472 EXPECT_TRUE(T.isLittleEndian());
1473 T = Triple("armeb");
1474 EXPECT_FALSE(T.isLittleEndian());
1475 T = Triple("thumbeb");
1476 EXPECT_FALSE(T.isLittleEndian());
1477
1478 T.setArch(Triple::bpfeb);
1479 EXPECT_EQ(Triple::bpfeb, T.getBigEndianArchVariant().getArch());
1480 EXPECT_EQ(Triple::bpfel, T.getLittleEndianArchVariant().getArch());
1481
1482 T.setArch(Triple::bpfel);
1483 EXPECT_EQ(Triple::bpfeb, T.getBigEndianArchVariant().getArch());
1484 EXPECT_EQ(Triple::bpfel, T.getLittleEndianArchVariant().getArch());
1485
1486 T.setArch(Triple::mips64);
1487 EXPECT_EQ(Triple::mips64, T.getBigEndianArchVariant().getArch());
1488 EXPECT_EQ(Triple::NoSubArch, T.getBigEndianArchVariant().getSubArch());
1489 EXPECT_EQ(Triple::mips64el, T.getLittleEndianArchVariant().getArch());
1490 EXPECT_EQ(Triple::NoSubArch, T.getLittleEndianArchVariant().getSubArch());
1491
1492 T.setArch(Triple::mips64, Triple::MipsSubArch_r6);
1493 EXPECT_EQ(Triple::mips64, T.getBigEndianArchVariant().getArch());
1494 EXPECT_EQ(Triple::MipsSubArch_r6, T.getBigEndianArchVariant().getSubArch());
1495 EXPECT_EQ(Triple::mips64el, T.getLittleEndianArchVariant().getArch());
1496 EXPECT_EQ(Triple::MipsSubArch_r6,
1497 T.getLittleEndianArchVariant().getSubArch());
1498
1499 T.setArch(Triple::mips64el);
1500 EXPECT_EQ(Triple::mips64, T.getBigEndianArchVariant().getArch());
1501 EXPECT_EQ(Triple::NoSubArch, T.getBigEndianArchVariant().getSubArch());
1502 EXPECT_EQ(Triple::mips64el, T.getLittleEndianArchVariant().getArch());
1503 EXPECT_EQ(Triple::NoSubArch, T.getLittleEndianArchVariant().getSubArch());
1504
1505 T.setArch(Triple::mips64el, Triple::MipsSubArch_r6);
1506 EXPECT_EQ(Triple::mips64, T.getBigEndianArchVariant().getArch());
1507 EXPECT_EQ(Triple::MipsSubArch_r6, T.getBigEndianArchVariant().getSubArch());
1508 EXPECT_EQ(Triple::mips64el, T.getLittleEndianArchVariant().getArch());
1509 EXPECT_EQ(Triple::MipsSubArch_r6,
1510 T.getLittleEndianArchVariant().getSubArch());
1511
1512 T.setArch(Triple::mips);
1513 EXPECT_EQ(Triple::mips, T.getBigEndianArchVariant().getArch());
1514 EXPECT_EQ(Triple::NoSubArch, T.getBigEndianArchVariant().getSubArch());
1515 EXPECT_EQ(Triple::mipsel, T.getLittleEndianArchVariant().getArch());
1516 EXPECT_EQ(Triple::NoSubArch, T.getLittleEndianArchVariant().getSubArch());
1517
1518 T.setArch(Triple::mips, Triple::MipsSubArch_r6);
1519 EXPECT_EQ(Triple::mips, T.getBigEndianArchVariant().getArch());
1520 EXPECT_EQ(Triple::MipsSubArch_r6, T.getBigEndianArchVariant().getSubArch());
1521 EXPECT_EQ(Triple::mipsel, T.getLittleEndianArchVariant().getArch());
1522 EXPECT_EQ(Triple::MipsSubArch_r6,
1523 T.getLittleEndianArchVariant().getSubArch());
1524
1525 T.setArch(Triple::mipsel);
1526 EXPECT_EQ(Triple::mips, T.getBigEndianArchVariant().getArch());
1527 EXPECT_EQ(Triple::NoSubArch, T.getBigEndianArchVariant().getSubArch());
1528 EXPECT_EQ(Triple::mipsel, T.getLittleEndianArchVariant().getArch());
1529 EXPECT_EQ(Triple::NoSubArch, T.getLittleEndianArchVariant().getSubArch());
1530
1531 T.setArch(Triple::mipsel, Triple::MipsSubArch_r6);
1532 EXPECT_EQ(Triple::mips, T.getBigEndianArchVariant().getArch());
1533 EXPECT_EQ(Triple::MipsSubArch_r6, T.getBigEndianArchVariant().getSubArch());
1534 EXPECT_EQ(Triple::mipsel, T.getLittleEndianArchVariant().getArch());
1535 EXPECT_EQ(Triple::MipsSubArch_r6,
1536 T.getLittleEndianArchVariant().getSubArch());
1537
1538 T.setArch(Triple::ppc);
1539 EXPECT_EQ(Triple::ppc, T.getBigEndianArchVariant().getArch());
1540 EXPECT_EQ(Triple::ppcle, T.getLittleEndianArchVariant().getArch());
1541
1542 T.setArch(Triple::ppc64);
1543 EXPECT_EQ(Triple::ppc64, T.getBigEndianArchVariant().getArch());
1544 EXPECT_EQ(Triple::ppc64le, T.getLittleEndianArchVariant().getArch());
1545
1546 T.setArch(Triple::ppc64le);
1547 EXPECT_EQ(Triple::ppc64, T.getBigEndianArchVariant().getArch());
1548 EXPECT_EQ(Triple::ppc64le, T.getLittleEndianArchVariant().getArch());
1549
1550 T.setArch(Triple::sparc);
1551 EXPECT_EQ(Triple::sparc, T.getBigEndianArchVariant().getArch());
1552 EXPECT_EQ(Triple::sparcel, T.getLittleEndianArchVariant().getArch());
1553
1554 T.setArch(Triple::sparcel);
1555 EXPECT_EQ(Triple::sparc, T.getBigEndianArchVariant().getArch());
1556 EXPECT_EQ(Triple::sparcel, T.getLittleEndianArchVariant().getArch());
1557
1558 T.setArch(Triple::thumb);
1559 EXPECT_EQ(Triple::UnknownArch, T.getBigEndianArchVariant().getArch());
1560 EXPECT_EQ(Triple::thumb, T.getLittleEndianArchVariant().getArch());
1561
1562 T.setArch(Triple::thumbeb);
1563 EXPECT_EQ(Triple::thumbeb, T.getBigEndianArchVariant().getArch());
1564 EXPECT_EQ(Triple::UnknownArch, T.getLittleEndianArchVariant().getArch());
1565
1566 T.setArch(Triple::lanai);
1567 EXPECT_EQ(Triple::lanai, T.getBigEndianArchVariant().getArch());
1568 EXPECT_EQ(Triple::UnknownArch, T.getLittleEndianArchVariant().getArch());
1569
1570 T.setArch(Triple::tcele);
1571 EXPECT_EQ(Triple::tce, T.getBigEndianArchVariant().getArch());
1572 EXPECT_EQ(Triple::tcele, T.getLittleEndianArchVariant().getArch());
1573
1574 T.setArch(Triple::tce);
1575 EXPECT_EQ(Triple::tce, T.getBigEndianArchVariant().getArch());
1576 EXPECT_EQ(Triple::tcele, T.getLittleEndianArchVariant().getArch());
1577
1578 T.setArch(Triple::csky);
1579 EXPECT_EQ(Triple::UnknownArch, T.getBigEndianArchVariant().getArch());
1580 EXPECT_EQ(Triple::csky, T.getLittleEndianArchVariant().getArch());
1581
1582 T.setArch(Triple::loongarch32);
1583 EXPECT_TRUE(T.isLittleEndian());
1584 EXPECT_EQ(Triple::UnknownArch, T.getBigEndianArchVariant().getArch());
1585 EXPECT_EQ(Triple::loongarch32, T.getLittleEndianArchVariant().getArch());
1586
1587 T.setArch(Triple::loongarch64);
1588 EXPECT_TRUE(T.isLittleEndian());
1589 EXPECT_EQ(Triple::UnknownArch, T.getBigEndianArchVariant().getArch());
1590 EXPECT_EQ(Triple::loongarch64, T.getLittleEndianArchVariant().getArch());
1591
1592 T.setArch(Triple::dxil);
1593 EXPECT_TRUE(T.isLittleEndian());
1594 EXPECT_EQ(Triple::UnknownArch, T.getBigEndianArchVariant().getArch());
1595 EXPECT_EQ(Triple::dxil, T.getLittleEndianArchVariant().getArch());
1596 }
1597
1598 TEST(TripleTest, getOSVersion) {
1599 Triple T;
1600 VersionTuple Version;
1601
1602 T = Triple("i386-apple-darwin9");
1603 EXPECT_TRUE(T.isMacOSX());
1604 EXPECT_FALSE(T.isiOS());
1605 EXPECT_FALSE(T.isArch16Bit());
1606 EXPECT_TRUE(T.isArch32Bit());
1607 EXPECT_FALSE(T.isArch64Bit());
1608 T.getMacOSXVersion(Version);
1609 EXPECT_EQ(VersionTuple(10, 5), Version);
1610 Version = T.getiOSVersion();
1611 EXPECT_EQ(VersionTuple(5), Version);
1612
1613 T = Triple("x86_64-apple-darwin9");
1614 EXPECT_TRUE(T.isMacOSX());
1615 EXPECT_FALSE(T.isiOS());
1616 EXPECT_FALSE(T.isArch16Bit());
1617 EXPECT_FALSE(T.isArch32Bit());
1618 EXPECT_TRUE(T.isArch64Bit());
1619 T.getMacOSXVersion(Version);
1620 EXPECT_EQ(VersionTuple(10, 5), Version);
1621 Version = T.getiOSVersion();
1622 EXPECT_EQ(VersionTuple(5), Version);
1623
1624 T = Triple("x86_64-apple-macosx");
1625 EXPECT_TRUE(T.isMacOSX());
1626 EXPECT_FALSE(T.isiOS());
1627 EXPECT_FALSE(T.isArch16Bit());
1628 EXPECT_FALSE(T.isArch32Bit());
1629 EXPECT_TRUE(T.isArch64Bit());
1630 T.getMacOSXVersion(Version);
1631 EXPECT_EQ(VersionTuple(10, 4), Version);
1632 Version = T.getiOSVersion();
1633 EXPECT_EQ(VersionTuple(5), Version);
1634
1635 T = Triple("x86_64-apple-macosx10.7");
1636 EXPECT_TRUE(T.isMacOSX());
1637 EXPECT_FALSE(T.isiOS());
1638 EXPECT_FALSE(T.isArch16Bit());
1639 EXPECT_FALSE(T.isArch32Bit());
1640 EXPECT_TRUE(T.isArch64Bit());
1641 T.getMacOSXVersion(Version);
1642 EXPECT_EQ(VersionTuple(10, 7), Version);
1643 Version = T.getiOSVersion();
1644 EXPECT_EQ(VersionTuple(5), Version);
1645
1646 T = Triple("x86_64-apple-macos11.0");
1647 EXPECT_TRUE(T.isMacOSX());
1648 EXPECT_FALSE(T.isiOS());
1649 EXPECT_FALSE(T.isArch16Bit());
1650 EXPECT_FALSE(T.isArch32Bit());
1651 EXPECT_TRUE(T.isArch64Bit());
1652 T.getMacOSXVersion(Version);
1653 EXPECT_EQ(VersionTuple(11, 0), Version);
1654
1655 T = Triple("arm64-apple-macosx11.5.8");
1656 EXPECT_TRUE(T.isMacOSX());
1657 EXPECT_FALSE(T.isiOS());
1658 EXPECT_FALSE(T.isArch16Bit());
1659 EXPECT_FALSE(T.isArch32Bit());
1660 EXPECT_TRUE(T.isArch64Bit());
1661 T.getMacOSXVersion(Version);
1662 EXPECT_EQ(VersionTuple(11, 5, 8), Version);
1663
1664 // 10.16 forms a valid triple, even though it's not
1665 // a version of a macOS.
1666 T = Triple("x86_64-apple-macos10.16");
1667 EXPECT_TRUE(T.isMacOSX());
1668 T.getMacOSXVersion(Version);
1669 EXPECT_EQ(VersionTuple(10, 16), Version);
1670
1671 T = Triple("x86_64-apple-darwin20");
1672 EXPECT_TRUE(T.isMacOSX());
1673 T.getMacOSXVersion(Version);
1674 EXPECT_EQ(VersionTuple(11), Version);
1675
1676 // For darwin triples on macOS 11, only compare the major version.
1677 T = Triple("x86_64-apple-darwin20.2");
1678 EXPECT_TRUE(T.isMacOSX());
1679 T.getMacOSXVersion(Version);
1680 EXPECT_EQ(VersionTuple(11), Version);
1681
1682 T = Triple("armv7-apple-ios");
1683 EXPECT_FALSE(T.isMacOSX());
1684 EXPECT_TRUE(T.isiOS());
1685 EXPECT_FALSE(T.isArch16Bit());
1686 EXPECT_TRUE(T.isArch32Bit());
1687 EXPECT_FALSE(T.isArch64Bit());
1688 T.getMacOSXVersion(Version);
1689 EXPECT_EQ(VersionTuple(10, 4), Version);
1690 Version = T.getiOSVersion();
1691 EXPECT_EQ(VersionTuple(5), Version);
1692
1693 T = Triple("armv7-apple-ios7.0");
1694 EXPECT_FALSE(T.isMacOSX());
1695 EXPECT_TRUE(T.isiOS());
1696 EXPECT_FALSE(T.isArch16Bit());
1697 EXPECT_TRUE(T.isArch32Bit());
1698 EXPECT_FALSE(T.isArch64Bit());
1699 T.getMacOSXVersion(Version);
1700 EXPECT_EQ(VersionTuple(10, 4), Version);
1701 Version = T.getiOSVersion();
1702 EXPECT_EQ(VersionTuple(7, 0), Version);
1703 EXPECT_FALSE(T.isSimulatorEnvironment());
1704
1705 T = Triple("x86_64-apple-ios10.3-simulator");
1706 EXPECT_TRUE(T.isiOS());
1707 Version = T.getiOSVersion();
1708 EXPECT_EQ(VersionTuple(10, 3), Version);
1709 EXPECT_TRUE(T.isSimulatorEnvironment());
1710 EXPECT_FALSE(T.isMacCatalystEnvironment());
1711
1712 T = Triple("x86_64-apple-ios13.0-macabi");
1713 EXPECT_TRUE(T.isiOS());
1714 Version = T.getiOSVersion();
1715 EXPECT_EQ(VersionTuple(13, 0), Version);
1716 EXPECT_TRUE(T.getEnvironment() == Triple::MacABI);
1717 EXPECT_TRUE(T.isMacCatalystEnvironment());
1718 EXPECT_FALSE(T.isSimulatorEnvironment());
1719
1720 T = Triple("x86_64-apple-driverkit20.1.0");
1721 EXPECT_TRUE(T.isDriverKit());
1722 EXPECT_TRUE(T.isOSDarwin());
1723 EXPECT_FALSE(T.isMacOSX());
1724 EXPECT_FALSE(T.isiOS());
1725 Version = T.getDriverKitVersion();
1726 EXPECT_EQ(VersionTuple(20, 1), Version);
1727
1728 T = Triple("x86_64-apple-driverkit20");
1729 Version = T.getDriverKitVersion();
1730 EXPECT_EQ(VersionTuple(20, 0), Version);
1731
1732 // DriverKit version should default to 19.0.
1733 T = Triple("x86_64-apple-driverkit");
1734 Version = T.getDriverKitVersion();
1735 EXPECT_EQ(VersionTuple(19, 0), Version);
1736
1737 T = Triple("dxil-unknown-shadermodel6.6-pixel");
1738 EXPECT_EQ(Triple::dxil, T.getArch());
1739 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
1740 EXPECT_EQ(Triple::ShaderModel, T.getOS());
1741 Version = T.getOSVersion();
1742 EXPECT_EQ(VersionTuple(6, 6), Version);
1743 EXPECT_EQ(Triple::Pixel, T.getEnvironment());
1744
1745 T = Triple("dxil-unknown-shadermodel6.0-pixel");
1746 EXPECT_EQ(Triple::dxil, T.getArch());
1747 EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
1748 EXPECT_EQ(Triple::ShaderModel, T.getOS());
1749 Version = T.getOSVersion();
1750 EXPECT_EQ(VersionTuple(6, 0), Version);
1751 EXPECT_EQ(Triple::Pixel, T.getEnvironment());
1752 }
1753
1754 TEST(TripleTest, getEnvironmentVersion) {
1755 Triple T;
1756 VersionTuple Version;
1757
1758 T = Triple("arm-unknown-linux-android16");
1759 EXPECT_TRUE(T.isAndroid());
1760 Version = T.getEnvironmentVersion();
1761 EXPECT_EQ(VersionTuple(16), Version);
1762 EXPECT_EQ(Triple::Android, T.getEnvironment());
1763
1764 T = Triple("aarch64-unknown-linux-android21");
1765 EXPECT_TRUE(T.isAndroid());
1766 Version = T.getEnvironmentVersion();
1767 EXPECT_EQ(VersionTuple(21), Version);
1768 EXPECT_EQ(Triple::Android, T.getEnvironment());
1769 }
1770
1771 TEST(TripleTest, isMacOSVersionLT) {
1772 Triple T = Triple("x86_64-apple-macos11");
1773 EXPECT_TRUE(T.isMacOSXVersionLT(11, 1, 0));
1774 EXPECT_FALSE(T.isMacOSXVersionLT(10, 15, 0));
1775
1776 T = Triple("x86_64-apple-darwin20");
1777 EXPECT_TRUE(T.isMacOSXVersionLT(11, 1, 0));
1778 EXPECT_FALSE(T.isMacOSXVersionLT(11, 0, 0));
1779 EXPECT_FALSE(T.isMacOSXVersionLT(10, 15, 0));
1780 }
1781
1782 TEST(TripleTest, CanonicalizeOSVersion) {
1783 EXPECT_EQ(VersionTuple(10, 15, 4),
1784 Triple::getCanonicalVersionForOS(Triple::MacOSX,
1785 VersionTuple(10, 15, 4)));
1786 EXPECT_EQ(VersionTuple(11, 0), Triple::getCanonicalVersionForOS(
1787 Triple::MacOSX, VersionTuple(10, 16)));
1788 EXPECT_EQ(VersionTuple(20),
1789 Triple::getCanonicalVersionForOS(Triple::Darwin, VersionTuple(20)));
1790 }
1791
1792 TEST(TripleTest, FileFormat) {
1793 EXPECT_EQ(Triple::ELF, Triple("i686-unknown-linux-gnu").getObjectFormat());
1794 EXPECT_EQ(Triple::ELF, Triple("i686-unknown-freebsd").getObjectFormat());
1795 EXPECT_EQ(Triple::ELF, Triple("i686-unknown-netbsd").getObjectFormat());
1796 EXPECT_EQ(Triple::ELF, Triple("i686--win32-elf").getObjectFormat());
1797 EXPECT_EQ(Triple::ELF, Triple("i686---elf").getObjectFormat());
1798
1799 EXPECT_EQ(Triple::MachO, Triple("i686-apple-macosx").getObjectFormat());
1800 EXPECT_EQ(Triple::MachO, Triple("i686-apple-ios").getObjectFormat());
1801 EXPECT_EQ(Triple::MachO, Triple("i686---macho").getObjectFormat());
1802
1803 EXPECT_EQ(Triple::COFF, Triple("i686--win32").getObjectFormat());
1804
1805 EXPECT_EQ(Triple::ELF, Triple("i686-pc-windows-msvc-elf").getObjectFormat());
1806 EXPECT_EQ(Triple::ELF, Triple("i686-pc-cygwin-elf").getObjectFormat());
1807
1808 EXPECT_EQ(Triple::ELF, Triple("systemz-ibm-linux").getObjectFormat());
1809 EXPECT_EQ(Triple::ELF, Triple("systemz-ibm-unknown").getObjectFormat());
1810
1811 EXPECT_EQ(Triple::GOFF, Triple("s390x-ibm-zos").getObjectFormat());
1812 EXPECT_EQ(Triple::GOFF, Triple("systemz-ibm-zos").getObjectFormat());
1813 EXPECT_EQ(Triple::GOFF, Triple("s390x-ibm-zos-goff").getObjectFormat());
1814 EXPECT_EQ(Triple::GOFF, Triple("s390x-unknown-zos-goff").getObjectFormat());
1815 EXPECT_EQ(Triple::GOFF, Triple("s390x---goff").getObjectFormat());
1816
1817 EXPECT_EQ(Triple::Wasm, Triple("wasm32-unknown-unknown").getObjectFormat());
1818 EXPECT_EQ(Triple::Wasm, Triple("wasm64-unknown-unknown").getObjectFormat());
1819 EXPECT_EQ(Triple::Wasm, Triple("wasm32-wasi").getObjectFormat());
1820 EXPECT_EQ(Triple::Wasm, Triple("wasm64-wasi").getObjectFormat());
1821 EXPECT_EQ(Triple::Wasm, Triple("wasm32-unknown-wasi").getObjectFormat());
1822 EXPECT_EQ(Triple::Wasm, Triple("wasm64-unknown-wasi").getObjectFormat());
1823
1824 EXPECT_EQ(Triple::Wasm,
1825 Triple("wasm32-unknown-unknown-wasm").getObjectFormat());
1826 EXPECT_EQ(Triple::Wasm,
1827 Triple("wasm64-unknown-unknown-wasm").getObjectFormat());
1828 EXPECT_EQ(Triple::Wasm,
1829 Triple("wasm32-wasi-wasm").getObjectFormat());
1830 EXPECT_EQ(Triple::Wasm,
1831 Triple("wasm64-wasi-wasm").getObjectFormat());
1832 EXPECT_EQ(Triple::Wasm,
1833 Triple("wasm32-unknown-wasi-wasm").getObjectFormat());
1834 EXPECT_EQ(Triple::Wasm,
1835 Triple("wasm64-unknown-wasi-wasm").getObjectFormat());
1836
1837 EXPECT_EQ(Triple::XCOFF, Triple("powerpc-ibm-aix").getObjectFormat());
1838 EXPECT_EQ(Triple::XCOFF, Triple("powerpc64-ibm-aix").getObjectFormat());
1839 EXPECT_EQ(Triple::XCOFF, Triple("powerpc---xcoff").getObjectFormat());
1840 EXPECT_EQ(Triple::XCOFF, Triple("powerpc64---xcoff").getObjectFormat());
1841
1842 EXPECT_EQ(Triple::ELF, Triple("csky-unknown-unknown").getObjectFormat());
1843 EXPECT_EQ(Triple::ELF, Triple("csky-unknown-linux").getObjectFormat());
1844
1845 EXPECT_EQ(Triple::SPIRV, Triple("spirv32-unknown-unknown").getObjectFormat());
1846 EXPECT_EQ(Triple::SPIRV, Triple("spirv64-unknown-unknown").getObjectFormat());
1847
1848 EXPECT_EQ(Triple::ELF,
1849 Triple("loongarch32-unknown-unknown").getObjectFormat());
1850 EXPECT_EQ(Triple::ELF, Triple("loongarch64-unknown-linux").getObjectFormat());
1851
1852 Triple MSVCNormalized(Triple::normalize("i686-pc-windows-msvc-elf"));
1853 EXPECT_EQ(Triple::ELF, MSVCNormalized.getObjectFormat());
1854
1855 Triple GNUWindowsNormalized(Triple::normalize("i686-pc-windows-gnu-elf"));
1856 EXPECT_EQ(Triple::ELF, GNUWindowsNormalized.getObjectFormat());
1857
1858 Triple CygnusNormalised(Triple::normalize("i686-pc-windows-cygnus-elf"));
1859 EXPECT_EQ(Triple::ELF, CygnusNormalised.getObjectFormat());
1860
1861 Triple CygwinNormalized(Triple::normalize("i686-pc-cygwin-elf"));
1862 EXPECT_EQ(Triple::ELF, CygwinNormalized.getObjectFormat());
1863
1864 EXPECT_EQ(Triple::DXContainer,
1865 Triple("dxil-unknown-shadermodel").getObjectFormat());
1866
1867 Triple T = Triple("");
1868 T.setObjectFormat(Triple::ELF);
1869 EXPECT_EQ(Triple::ELF, T.getObjectFormat());
1870
1871 T.setObjectFormat(Triple::MachO);
1872 EXPECT_EQ(Triple::MachO, T.getObjectFormat());
1873
1874 T.setObjectFormat(Triple::XCOFF);
1875 EXPECT_EQ(Triple::XCOFF, T.getObjectFormat());
1876
1877 T.setObjectFormat(Triple::GOFF);
1878 EXPECT_EQ(Triple::GOFF, T.getObjectFormat());
1879
1880 T.setObjectFormat(Triple::SPIRV);
1881 EXPECT_EQ(Triple::SPIRV, T.getObjectFormat());
1882 }
1883
1884 TEST(TripleTest, NormalizeWindows) {
1885 EXPECT_EQ("i686-pc-windows-msvc", Triple::normalize("i686-pc-win32"));
1886 EXPECT_EQ("i686-unknown-windows-msvc", Triple::normalize("i686-win32"));
1887 EXPECT_EQ("i686-pc-windows-gnu", Triple::normalize("i686-pc-mingw32"));
1888 EXPECT_EQ("i686-unknown-windows-gnu", Triple::normalize("i686-mingw32"));
1889 EXPECT_EQ("i686-pc-windows-gnu", Triple::normalize("i686-pc-mingw32-w64"));
1890 EXPECT_EQ("i686-unknown-windows-gnu", Triple::normalize("i686-mingw32-w64"));
1891 EXPECT_EQ("i686-pc-windows-cygnus", Triple::normalize("i686-pc-cygwin"));
1892 EXPECT_EQ("i686-unknown-windows-cygnus", Triple::normalize("i686-cygwin"));
1893
1894 EXPECT_EQ("x86_64-pc-windows-msvc", Triple::normalize("x86_64-pc-win32"));
1895 EXPECT_EQ("x86_64-unknown-windows-msvc", Triple::normalize("x86_64-win32"));
1896 EXPECT_EQ("x86_64-pc-windows-gnu", Triple::normalize("x86_64-pc-mingw32"));
1897 EXPECT_EQ("x86_64-unknown-windows-gnu", Triple::normalize("x86_64-mingw32"));
1898 EXPECT_EQ("x86_64-pc-windows-gnu",
1899 Triple::normalize("x86_64-pc-mingw32-w64"));
1900 EXPECT_EQ("x86_64-unknown-windows-gnu",
1901 Triple::normalize("x86_64-mingw32-w64"));
1902
1903 EXPECT_EQ("i686-pc-windows-elf", Triple::normalize("i686-pc-win32-elf"));
1904 EXPECT_EQ("i686-unknown-windows-elf", Triple::normalize("i686-win32-elf"));
1905 EXPECT_EQ("i686-pc-windows-macho", Triple::normalize("i686-pc-win32-macho"));
1906 EXPECT_EQ("i686-unknown-windows-macho",
1907 Triple::normalize("i686-win32-macho"));
1908
1909 EXPECT_EQ("x86_64-pc-windows-elf", Triple::normalize("x86_64-pc-win32-elf"));
1910 EXPECT_EQ("x86_64-unknown-windows-elf",
1911 Triple::normalize("x86_64-win32-elf"));
1912 EXPECT_EQ("x86_64-pc-windows-macho",
1913 Triple::normalize("x86_64-pc-win32-macho"));
1914 EXPECT_EQ("x86_64-unknown-windows-macho",
1915 Triple::normalize("x86_64-win32-macho"));
1916
1917 EXPECT_EQ("i686-pc-windows-cygnus",
1918 Triple::normalize("i686-pc-windows-cygnus"));
1919 EXPECT_EQ("i686-pc-windows-gnu", Triple::normalize("i686-pc-windows-gnu"));
1920 EXPECT_EQ("i686-pc-windows-itanium",
1921 Triple::normalize("i686-pc-windows-itanium"));
1922 EXPECT_EQ("i686-pc-windows-msvc", Triple::normalize("i686-pc-windows-msvc"));
1923
1924 EXPECT_EQ("i686-pc-windows-elf",
1925 Triple::normalize("i686-pc-windows-elf-elf"));
1926
1927 EXPECT_TRUE(Triple("x86_64-pc-win32").isWindowsMSVCEnvironment());
1928 }
1929
1930 TEST(TripleTest, NormalizeAndroid) {
1931 EXPECT_EQ("arm-unknown-linux-android16",
1932 Triple::normalize("arm-linux-androideabi16"));
1933 EXPECT_EQ("armv7a-unknown-linux-android",
1934 Triple::normalize("armv7a-linux-androideabi"));
1935 EXPECT_EQ("aarch64-unknown-linux-android21",
1936 Triple::normalize("aarch64-linux-android21"));
1937 }
1938
1939 TEST(TripleTest, NormalizeARM) {
1940 EXPECT_EQ("armv6-unknown-netbsd-eabi",
1941 Triple::normalize("armv6-netbsd-eabi"));
1942 EXPECT_EQ("armv7-unknown-netbsd-eabi",
1943 Triple::normalize("armv7-netbsd-eabi"));
1944 EXPECT_EQ("armv6eb-unknown-netbsd-eabi",
1945 Triple::normalize("armv6eb-netbsd-eabi"));
1946 EXPECT_EQ("armv7eb-unknown-netbsd-eabi",
1947 Triple::normalize("armv7eb-netbsd-eabi"));
1948 EXPECT_EQ("armv6-unknown-netbsd-eabihf",
1949 Triple::normalize("armv6-netbsd-eabihf"));
1950 EXPECT_EQ("armv7-unknown-netbsd-eabihf",
1951 Triple::normalize("armv7-netbsd-eabihf"));
1952 EXPECT_EQ("armv6eb-unknown-netbsd-eabihf",
1953 Triple::normalize("armv6eb-netbsd-eabihf"));
1954 EXPECT_EQ("armv7eb-unknown-netbsd-eabihf",
1955 Triple::normalize("armv7eb-netbsd-eabihf"));
1956
1957 EXPECT_EQ("armv7-suse-linux-gnueabihf",
1958 Triple::normalize("armv7-suse-linux-gnueabi"));
1959
1960 Triple T;
1961 T = Triple("armv6--netbsd-eabi");
1962 EXPECT_EQ(Triple::arm, T.getArch());
1963 T = Triple("armv6eb--netbsd-eabi");
1964 EXPECT_EQ(Triple::armeb, T.getArch());
1965 T = Triple("armv7-suse-linux-gnueabihf");
1966 EXPECT_EQ(Triple::GNUEABIHF, T.getEnvironment());
1967 }
1968
1969 TEST(TripleTest, ParseARMArch) {
1970 // ARM
1971 {
1972 Triple T = Triple("arm");
1973 EXPECT_EQ(Triple::arm, T.getArch());
1974 }
1975 {
1976 Triple T = Triple("armeb");
1977 EXPECT_EQ(Triple::armeb, T.getArch());
1978 }
1979 // THUMB
1980 {
1981 Triple T = Triple("thumb");
1982 EXPECT_EQ(Triple::thumb, T.getArch());
1983 }
1984 {
1985 Triple T = Triple("thumbeb");
1986 EXPECT_EQ(Triple::thumbeb, T.getArch());
1987 }
1988 // AARCH64
1989 {
1990 Triple T = Triple("arm64");
1991 EXPECT_EQ(Triple::aarch64, T.getArch());
1992 }
1993 {
1994 Triple T = Triple("arm64_32");
1995 EXPECT_EQ(Triple::aarch64_32, T.getArch());
1996 }
1997 {
1998 Triple T = Triple("aarch64");
1999 EXPECT_EQ(Triple::aarch64, T.getArch());
2000 }
2001 {
2002 Triple T = Triple("aarch64_be");
2003 EXPECT_EQ(Triple::aarch64_be, T.getArch());
2004 }
2005 {
2006 Triple T = Triple("arm64e");
2007 EXPECT_EQ(Triple::aarch64, T.getArch());
2008 EXPECT_EQ(Triple::AArch64SubArch_arm64e, T.getSubArch());
2009 }
2010 {
2011 Triple T = Triple("arm64ec");
2012 EXPECT_EQ(Triple::aarch64, T.getArch());
2013 EXPECT_EQ(Triple::AArch64SubArch_arm64ec, T.getSubArch());
2014 }
2015 {
2016 Triple T;
2017 T.setArch(Triple::aarch64, Triple::AArch64SubArch_arm64ec);
2018 EXPECT_EQ("arm64ec", T.getArchName());
2019 }
2020 }
2021
2022 TEST(TripleTest, isArmT32) {
2023 // Not isArmT32
2024 {
2025 Triple T = Triple("thumbv6m");
2026 EXPECT_FALSE(T.isArmT32());
2027 }
2028 {
2029 Triple T = Triple("armv8m.base");
2030 EXPECT_FALSE(T.isArmT32());
2031 }
2032 {
2033 Triple T = Triple("armv7s");
2034 EXPECT_FALSE(T.isArmT32());
2035 }
2036 {
2037 Triple T = Triple("armv7k");
2038 EXPECT_FALSE(T.isArmT32());
2039 }
2040 {
2041 Triple T = Triple("armv7ve");
2042 EXPECT_FALSE(T.isArmT32());
2043 }
2044 {
2045 Triple T = Triple("armv6");
2046 EXPECT_FALSE(T.isArmT32());
2047 }
2048 {
2049 Triple T = Triple("armv6m");
2050 EXPECT_FALSE(T.isArmT32());
2051 }
2052 {
2053 Triple T = Triple("armv6k");
2054 EXPECT_FALSE(T.isArmT32());
2055 }
2056 {
2057 Triple T = Triple("armv6t2");
2058 EXPECT_FALSE(T.isArmT32());
2059 }
2060 {
2061 Triple T = Triple("armv5");
2062 EXPECT_FALSE(T.isArmT32());
2063 }
2064 {
2065 Triple T = Triple("armv5te");
2066 EXPECT_FALSE(T.isArmT32());
2067 }
2068 {
2069 Triple T = Triple("armv4t");
2070 EXPECT_FALSE(T.isArmT32());
2071 }
2072
2073 // isArmT32
2074 {
2075 Triple T = Triple("arm");
2076 EXPECT_TRUE(T.isArmT32());
2077 }
2078 {
2079 Triple T = Triple("armv7m");
2080 EXPECT_TRUE(T.isArmT32());
2081 }
2082 {
2083 Triple T = Triple("armv7em");
2084 EXPECT_TRUE(T.isArmT32());
2085 }
2086 {
2087 Triple T = Triple("armv8m.main");
2088 EXPECT_TRUE(T.isArmT32());
2089 }
2090 {
2091 Triple T = Triple("armv8.1m.main");
2092 EXPECT_TRUE(T.isArmT32());
2093 }
2094 }
2095
2096 TEST(TripleTest, isArmMClass) {
2097 // not M-class
2098 {
2099 Triple T = Triple("armv7s");
2100 EXPECT_FALSE(T.isArmMClass());
2101 }
2102 {
2103 Triple T = Triple("armv7k");
2104 EXPECT_FALSE(T.isArmMClass());
2105 }
2106 {
2107 Triple T = Triple("armv7ve");
2108 EXPECT_FALSE(T.isArmMClass());
2109 }
2110 {
2111 Triple T = Triple("armv6");
2112 EXPECT_FALSE(T.isArmMClass());
2113 }
2114 {
2115 Triple T = Triple("armv6k");
2116 EXPECT_FALSE(T.isArmMClass());
2117 }
2118 {
2119 Triple T = Triple("armv6t2");
2120 EXPECT_FALSE(T.isArmMClass());
2121 }
2122 {
2123 Triple T = Triple("armv5");
2124 EXPECT_FALSE(T.isArmMClass());
2125 }
2126 {
2127 Triple T = Triple("armv5te");
2128 EXPECT_FALSE(T.isArmMClass());
2129 }
2130 {
2131 Triple T = Triple("armv4t");
2132 EXPECT_FALSE(T.isArmMClass());
2133 }
2134 {
2135 Triple T = Triple("arm");
2136 EXPECT_FALSE(T.isArmMClass());
2137 }
2138
2139 // is M-class
2140 {
2141 Triple T = Triple("armv6m");
2142 EXPECT_TRUE(T.isArmMClass());
2143 }
2144 {
2145 Triple T = Triple("armv7m");
2146 EXPECT_TRUE(T.isArmMClass());
2147 }
2148 {
2149 Triple T = Triple("armv7em");
2150 EXPECT_TRUE(T.isArmMClass());
2151 }
2152 {
2153 Triple T = Triple("armv8m.base");
2154 EXPECT_TRUE(T.isArmMClass());
2155 }
2156 {
2157 Triple T = Triple("armv8m.main");
2158 EXPECT_TRUE(T.isArmMClass());
2159 }
2160 {
2161 Triple T = Triple("armv8.1m.main");
2162 EXPECT_TRUE(T.isArmMClass());
2163 }
2164 }
2165 } // end anonymous namespace