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