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