1 //===----------- Triple.cpp - Triple unit tests ---------------------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "llvm/ADT/Triple.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("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("powerpc-bgp-linux");
109   EXPECT_EQ(Triple::ppc, T.getArch());
110   EXPECT_EQ(Triple::BGP, T.getVendor());
111   EXPECT_EQ(Triple::Linux, T.getOS());
112   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
113 
114   T = Triple("powerpc-bgp-cnk");
115   EXPECT_EQ(Triple::ppc, T.getArch());
116   EXPECT_EQ(Triple::BGP, T.getVendor());
117   EXPECT_EQ(Triple::CNK, T.getOS());
118   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
119 
120   T = Triple("powerpc64-bgq-linux");
121   EXPECT_EQ(Triple::ppc64, T.getArch());
122   EXPECT_EQ(Triple::BGQ, T.getVendor());
123   EXPECT_EQ(Triple::Linux, T.getOS());
124   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
125 
126   T = Triple("powerpc-ibm-aix");
127   EXPECT_EQ(Triple::ppc, T.getArch());
128   EXPECT_EQ(Triple::IBM, T.getVendor());
129   EXPECT_EQ(Triple::AIX, T.getOS());
130   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
131 
132   T = Triple("powerpc64-ibm-aix");
133   EXPECT_EQ(Triple::ppc64, T.getArch());
134   EXPECT_EQ(Triple::IBM, T.getVendor());
135   EXPECT_EQ(Triple::AIX, T.getOS());
136   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
137 
138   T = Triple("powerpc-dunno-notsure");
139   EXPECT_EQ(Triple::ppc, T.getArch());
140   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
141   EXPECT_EQ(Triple::UnknownOS, T.getOS());
142   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
143 
144   T = Triple("arm-none-none-eabi");
145   EXPECT_EQ(Triple::arm, T.getArch());
146   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
147   EXPECT_EQ(Triple::UnknownOS, T.getOS());
148   EXPECT_EQ(Triple::EABI, T.getEnvironment());
149 
150   T = Triple("arm-none-linux-musleabi");
151   EXPECT_EQ(Triple::arm, T.getArch());
152   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
153   EXPECT_EQ(Triple::Linux, T.getOS());
154   EXPECT_EQ(Triple::MuslEABI, T.getEnvironment());
155 
156   T = Triple("armv6hl-none-linux-gnueabi");
157   EXPECT_EQ(Triple::arm, T.getArch());
158   EXPECT_EQ(Triple::Linux, T.getOS());
159   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
160   EXPECT_EQ(Triple::GNUEABI, T.getEnvironment());
161 
162   T = Triple("armv7hl-none-linux-gnueabi");
163   EXPECT_EQ(Triple::arm, T.getArch());
164   EXPECT_EQ(Triple::Linux, T.getOS());
165   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
166   EXPECT_EQ(Triple::GNUEABI, T.getEnvironment());
167 
168   T = Triple("amdil-unknown-unknown");
169   EXPECT_EQ(Triple::amdil, T.getArch());
170   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
171   EXPECT_EQ(Triple::UnknownOS, T.getOS());
172 
173   T = Triple("amdil64-unknown-unknown");
174   EXPECT_EQ(Triple::amdil64, T.getArch());
175   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
176   EXPECT_EQ(Triple::UnknownOS, T.getOS());
177 
178   T = Triple("hsail-unknown-unknown");
179   EXPECT_EQ(Triple::hsail, T.getArch());
180   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
181   EXPECT_EQ(Triple::UnknownOS, T.getOS());
182 
183   T = Triple("hsail64-unknown-unknown");
184   EXPECT_EQ(Triple::hsail64, T.getArch());
185   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
186   EXPECT_EQ(Triple::UnknownOS, T.getOS());
187 
188   T = Triple("sparcel-unknown-unknown");
189   EXPECT_EQ(Triple::sparcel, T.getArch());
190   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
191   EXPECT_EQ(Triple::UnknownOS, T.getOS());
192 
193   T = Triple("spir-unknown-unknown");
194   EXPECT_EQ(Triple::spir, T.getArch());
195   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
196   EXPECT_EQ(Triple::UnknownOS, T.getOS());
197 
198   T = Triple("spir64-unknown-unknown");
199   EXPECT_EQ(Triple::spir64, T.getArch());
200   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
201   EXPECT_EQ(Triple::UnknownOS, T.getOS());
202 
203   T = Triple("x86_64-unknown-ananas");
204   EXPECT_EQ(Triple::x86_64, T.getArch());
205   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
206   EXPECT_EQ(Triple::Ananas, T.getOS());
207   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
208 
209   T = Triple("x86_64-unknown-cloudabi");
210   EXPECT_EQ(Triple::x86_64, T.getArch());
211   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
212   EXPECT_EQ(Triple::CloudABI, T.getOS());
213   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
214 
215   T = Triple("x86_64-unknown-fuchsia");
216   EXPECT_EQ(Triple::x86_64, T.getArch());
217   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
218   EXPECT_EQ(Triple::Fuchsia, T.getOS());
219   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
220 
221   T = Triple("wasm32-unknown-unknown");
222   EXPECT_EQ(Triple::wasm32, T.getArch());
223   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
224   EXPECT_EQ(Triple::UnknownOS, T.getOS());
225   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
226 
227   T = Triple("wasm64-unknown-unknown");
228   EXPECT_EQ(Triple::wasm64, T.getArch());
229   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
230   EXPECT_EQ(Triple::UnknownOS, T.getOS());
231   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
232 
233   T = Triple("avr-unknown-unknown");
234   EXPECT_EQ(Triple::avr, T.getArch());
235   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
236   EXPECT_EQ(Triple::UnknownOS, T.getOS());
237   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
238 
239   T = Triple("avr");
240   EXPECT_EQ(Triple::avr, T.getArch());
241   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
242   EXPECT_EQ(Triple::UnknownOS, T.getOS());
243   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
244 
245   T = Triple("lanai-unknown-unknown");
246   EXPECT_EQ(Triple::lanai, T.getArch());
247   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
248   EXPECT_EQ(Triple::UnknownOS, T.getOS());
249   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
250 
251   T = Triple("lanai");
252   EXPECT_EQ(Triple::lanai, T.getArch());
253   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
254   EXPECT_EQ(Triple::UnknownOS, T.getOS());
255   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
256 
257   T = Triple("amdgcn-mesa-mesa3d");
258   EXPECT_EQ(Triple::amdgcn, T.getArch());
259   EXPECT_EQ(Triple::Mesa, T.getVendor());
260   EXPECT_EQ(Triple::Mesa3D, T.getOS());
261   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
262 
263   T = Triple("amdgcn-amd-amdhsa");
264   EXPECT_EQ(Triple::amdgcn, T.getArch());
265   EXPECT_EQ(Triple::AMD, T.getVendor());
266   EXPECT_EQ(Triple::AMDHSA, T.getOS());
267   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
268 
269   T = Triple("amdgcn-amd-amdhsa-opencl");
270   EXPECT_EQ(Triple::amdgcn, T.getArch());
271   EXPECT_EQ(Triple::AMD, T.getVendor());
272   EXPECT_EQ(Triple::AMDHSA, T.getOS());
273   EXPECT_EQ(Triple::OpenCL, T.getEnvironment());
274 
275   T = Triple("amdgcn-amd-amdpal");
276   EXPECT_EQ(Triple::amdgcn, T.getArch());
277   EXPECT_EQ(Triple::AMD, T.getVendor());
278   EXPECT_EQ(Triple::AMDPAL, T.getOS());
279   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
280 
281   T = Triple("riscv32-unknown-unknown");
282   EXPECT_EQ(Triple::riscv32, T.getArch());
283   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
284   EXPECT_EQ(Triple::UnknownOS, T.getOS());
285   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
286 
287   T = Triple("riscv64-unknown-linux");
288   EXPECT_EQ(Triple::riscv64, T.getArch());
289   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
290   EXPECT_EQ(Triple::Linux, T.getOS());
291   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
292 
293   T = Triple("riscv64-unknown-freebsd");
294   EXPECT_EQ(Triple::riscv64, T.getArch());
295   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
296   EXPECT_EQ(Triple::FreeBSD, T.getOS());
297   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
298 
299   T = Triple("armv7hl-suse-linux-gnueabi");
300   EXPECT_EQ(Triple::arm, T.getArch());
301   EXPECT_EQ(Triple::SUSE, T.getVendor());
302   EXPECT_EQ(Triple::Linux, T.getOS());
303   EXPECT_EQ(Triple::GNUEABI, T.getEnvironment());
304 
305   T = Triple("i586-pc-haiku");
306   EXPECT_EQ(Triple::x86, T.getArch());
307   EXPECT_EQ(Triple::PC, T.getVendor());
308   EXPECT_EQ(Triple::Haiku, T.getOS());
309   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
310 
311   T = Triple("x86_64-unknown-haiku");
312   EXPECT_EQ(Triple::x86_64, T.getArch());
313   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
314   EXPECT_EQ(Triple::Haiku, T.getOS());
315   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
316 
317   T = Triple("mips-mti-linux-gnu");
318   EXPECT_EQ(Triple::mips, T.getArch());
319   EXPECT_EQ(Triple::MipsTechnologies, T.getVendor());
320   EXPECT_EQ(Triple::Linux, T.getOS());
321   EXPECT_EQ(Triple::GNU, T.getEnvironment());
322 
323   T = Triple("mipsel-img-linux-gnu");
324   EXPECT_EQ(Triple::mipsel, T.getArch());
325   EXPECT_EQ(Triple::ImaginationTechnologies, T.getVendor());
326   EXPECT_EQ(Triple::Linux, T.getOS());
327   EXPECT_EQ(Triple::GNU, T.getEnvironment());
328 
329   T = Triple("mips64-mti-linux-gnu");
330   EXPECT_EQ(Triple::mips64, T.getArch());
331   EXPECT_EQ(Triple::MipsTechnologies, T.getVendor());
332   EXPECT_EQ(Triple::Linux, T.getOS());
333   EXPECT_EQ(Triple::GNU, T.getEnvironment());
334 
335   T = Triple("mips64el-img-linux-gnu");
336   EXPECT_EQ(Triple::mips64el, T.getArch());
337   EXPECT_EQ(Triple::ImaginationTechnologies, T.getVendor());
338   EXPECT_EQ(Triple::Linux, T.getOS());
339   EXPECT_EQ(Triple::GNU, T.getEnvironment());
340 
341   T = Triple("mips64el-img-linux-gnuabin32");
342   EXPECT_EQ(Triple::mips64el, T.getArch());
343   EXPECT_EQ(Triple::ImaginationTechnologies, T.getVendor());
344   EXPECT_EQ(Triple::Linux, T.getOS());
345   EXPECT_EQ(Triple::GNUABIN32, T.getEnvironment());
346 
347   T = Triple("mips64el-unknown-linux-gnuabi64");
348   EXPECT_EQ(Triple::mips64el, T.getArch());
349   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
350   EXPECT_EQ(Triple::Linux, T.getOS());
351   EXPECT_EQ(Triple::GNUABI64, T.getEnvironment());
352 
353   T = Triple("huh");
354   EXPECT_EQ(Triple::UnknownArch, T.getArch());
355 }
356 
357 static std::string Join(StringRef A, StringRef B, StringRef C) {
358   std::string Str = A; Str += '-'; Str += B; Str += '-'; Str += C;
359   return Str;
360 }
361 
362 static std::string Join(StringRef A, StringRef B, StringRef C, StringRef D) {
363   std::string Str = A; Str += '-'; Str += B; Str += '-'; Str += C; Str += '-';
364   Str += D; return Str;
365 }
366 
367 TEST(TripleTest, Normalization) {
368 
369   EXPECT_EQ("", Triple::normalize(""));
370   EXPECT_EQ("-", Triple::normalize("-"));
371   EXPECT_EQ("--", Triple::normalize("--"));
372   EXPECT_EQ("---", Triple::normalize("---"));
373   EXPECT_EQ("----", Triple::normalize("----"));
374 
375   EXPECT_EQ("a", Triple::normalize("a"));
376   EXPECT_EQ("a-b", Triple::normalize("a-b"));
377   EXPECT_EQ("a-b-c", Triple::normalize("a-b-c"));
378   EXPECT_EQ("a-b-c-d", Triple::normalize("a-b-c-d"));
379 
380   EXPECT_EQ("i386-b-c", Triple::normalize("i386-b-c"));
381   EXPECT_EQ("i386-a-c", Triple::normalize("a-i386-c"));
382   EXPECT_EQ("i386-a-b", Triple::normalize("a-b-i386"));
383   EXPECT_EQ("i386-a-b-c", Triple::normalize("a-b-c-i386"));
384 
385   EXPECT_EQ("a-pc-c", Triple::normalize("a-pc-c"));
386   EXPECT_EQ("-pc-b-c", Triple::normalize("pc-b-c"));
387   EXPECT_EQ("a-pc-b", Triple::normalize("a-b-pc"));
388   EXPECT_EQ("a-pc-b-c", Triple::normalize("a-b-c-pc"));
389 
390   EXPECT_EQ("a-b-linux", Triple::normalize("a-b-linux"));
391   EXPECT_EQ("--linux-b-c", Triple::normalize("linux-b-c"));
392   EXPECT_EQ("a--linux-c", Triple::normalize("a-linux-c"));
393 
394   EXPECT_EQ("i386-pc-a", Triple::normalize("a-pc-i386"));
395   EXPECT_EQ("i386-pc-", Triple::normalize("-pc-i386"));
396   EXPECT_EQ("-pc-linux-c", Triple::normalize("linux-pc-c"));
397   EXPECT_EQ("-pc-linux", Triple::normalize("linux-pc-"));
398 
399   EXPECT_EQ("i386", Triple::normalize("i386"));
400   EXPECT_EQ("-pc", Triple::normalize("pc"));
401   EXPECT_EQ("--linux", Triple::normalize("linux"));
402 
403   EXPECT_EQ("x86_64--linux-gnu", Triple::normalize("x86_64-gnu-linux"));
404 
405   // Check that normalizing a permutated set of valid components returns a
406   // triple with the unpermuted components.
407   //
408   // We don't check every possible combination. For the set of architectures A,
409   // vendors V, operating systems O, and environments E, that would require |A|
410   // * |V| * |O| * |E| * 4! tests. Instead we check every option for any given
411   // slot and make sure it gets normalized to the correct position from every
412   // permutation. This should cover the core logic while being a tractable
413   // number of tests at (|A| + |V| + |O| + |E|) * 4!.
414   auto FirstArchType = Triple::ArchType(Triple::UnknownArch + 1);
415   auto FirstVendorType = Triple::VendorType(Triple::UnknownVendor + 1);
416   auto FirstOSType = Triple::OSType(Triple::UnknownOS + 1);
417   auto FirstEnvType = Triple::EnvironmentType(Triple::UnknownEnvironment + 1);
418   StringRef InitialC[] = {Triple::getArchTypeName(FirstArchType),
419                           Triple::getVendorTypeName(FirstVendorType),
420                           Triple::getOSTypeName(FirstOSType),
421                           Triple::getEnvironmentTypeName(FirstEnvType)};
422   for (int Arch = FirstArchType; Arch <= Triple::LastArchType; ++Arch) {
423     StringRef C[] = {InitialC[0], InitialC[1], InitialC[2], InitialC[3]};
424     C[0] = Triple::getArchTypeName(Triple::ArchType(Arch));
425     std::string E = Join(C[0], C[1], C[2]);
426     int I[] = {0, 1, 2};
427     do {
428       EXPECT_EQ(E, Triple::normalize(Join(C[I[0]], C[I[1]], C[I[2]])));
429     } while (std::next_permutation(std::begin(I), std::end(I)));
430     std::string F = Join(C[0], C[1], C[2], C[3]);
431     int J[] = {0, 1, 2, 3};
432     do {
433       EXPECT_EQ(F, Triple::normalize(Join(C[J[0]], C[J[1]], C[J[2]], C[J[3]])));
434     } while (std::next_permutation(std::begin(J), std::end(J)));
435   }
436   for (int Vendor = FirstVendorType; Vendor <= Triple::LastVendorType;
437        ++Vendor) {
438     StringRef C[] = {InitialC[0], InitialC[1], InitialC[2], InitialC[3]};
439     C[1] = Triple::getVendorTypeName(Triple::VendorType(Vendor));
440     std::string E = Join(C[0], C[1], C[2]);
441     int I[] = {0, 1, 2};
442     do {
443       EXPECT_EQ(E, Triple::normalize(Join(C[I[0]], C[I[1]], C[I[2]])));
444     } while (std::next_permutation(std::begin(I), std::end(I)));
445     std::string F = Join(C[0], C[1], C[2], C[3]);
446     int J[] = {0, 1, 2, 3};
447     do {
448       EXPECT_EQ(F, Triple::normalize(Join(C[J[0]], C[J[1]], C[J[2]], C[J[3]])));
449     } while (std::next_permutation(std::begin(J), std::end(J)));
450   }
451   for (int OS = FirstOSType; OS <= Triple::LastOSType; ++OS) {
452     if (OS == Triple::Win32)
453       continue;
454     StringRef C[] = {InitialC[0], InitialC[1], InitialC[2], InitialC[3]};
455     C[2] = Triple::getOSTypeName(Triple::OSType(OS));
456     std::string E = Join(C[0], C[1], C[2]);
457     int I[] = {0, 1, 2};
458     do {
459       EXPECT_EQ(E, Triple::normalize(Join(C[I[0]], C[I[1]], C[I[2]])));
460     } while (std::next_permutation(std::begin(I), std::end(I)));
461     std::string F = Join(C[0], C[1], C[2], C[3]);
462     int J[] = {0, 1, 2, 3};
463     do {
464       EXPECT_EQ(F, Triple::normalize(Join(C[J[0]], C[J[1]], C[J[2]], C[J[3]])));
465     } while (std::next_permutation(std::begin(J), std::end(J)));
466   }
467   for (int Env = FirstEnvType; Env <= Triple::LastEnvironmentType; ++Env) {
468     StringRef C[] = {InitialC[0], InitialC[1], InitialC[2], InitialC[3]};
469     C[3] = Triple::getEnvironmentTypeName(Triple::EnvironmentType(Env));
470     std::string F = Join(C[0], C[1], C[2], C[3]);
471     int J[] = {0, 1, 2, 3};
472     do {
473       EXPECT_EQ(F, Triple::normalize(Join(C[J[0]], C[J[1]], C[J[2]], C[J[3]])));
474     } while (std::next_permutation(std::begin(J), std::end(J)));
475   }
476 
477   // Various real-world funky triples.  The value returned by GCC's config.sub
478   // is given in the comment.
479   EXPECT_EQ("i386--windows-gnu", Triple::normalize("i386-mingw32")); // i386-pc-mingw32
480   EXPECT_EQ("x86_64--linux-gnu", Triple::normalize("x86_64-linux-gnu")); // x86_64-pc-linux-gnu
481   EXPECT_EQ("i486--linux-gnu", Triple::normalize("i486-linux-gnu")); // i486-pc-linux-gnu
482   EXPECT_EQ("i386-redhat-linux", Triple::normalize("i386-redhat-linux")); // i386-redhat-linux-gnu
483   EXPECT_EQ("i686--linux", Triple::normalize("i686-linux")); // i686-pc-linux-gnu
484   EXPECT_EQ("arm-none--eabi", Triple::normalize("arm-none-eabi")); // arm-none-eabi
485 }
486 
487 TEST(TripleTest, MutateName) {
488   Triple T;
489   EXPECT_EQ(Triple::UnknownArch, T.getArch());
490   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
491   EXPECT_EQ(Triple::UnknownOS, T.getOS());
492   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
493 
494   T.setArchName("i386");
495   EXPECT_EQ(Triple::x86, T.getArch());
496   EXPECT_EQ("i386--", T.getTriple());
497 
498   T.setVendorName("pc");
499   EXPECT_EQ(Triple::x86, T.getArch());
500   EXPECT_EQ(Triple::PC, T.getVendor());
501   EXPECT_EQ("i386-pc-", T.getTriple());
502 
503   T.setOSName("linux");
504   EXPECT_EQ(Triple::x86, T.getArch());
505   EXPECT_EQ(Triple::PC, T.getVendor());
506   EXPECT_EQ(Triple::Linux, T.getOS());
507   EXPECT_EQ("i386-pc-linux", T.getTriple());
508 
509   T.setEnvironmentName("gnu");
510   EXPECT_EQ(Triple::x86, T.getArch());
511   EXPECT_EQ(Triple::PC, T.getVendor());
512   EXPECT_EQ(Triple::Linux, T.getOS());
513   EXPECT_EQ("i386-pc-linux-gnu", T.getTriple());
514 
515   T.setOSName("freebsd");
516   EXPECT_EQ(Triple::x86, T.getArch());
517   EXPECT_EQ(Triple::PC, T.getVendor());
518   EXPECT_EQ(Triple::FreeBSD, T.getOS());
519   EXPECT_EQ("i386-pc-freebsd-gnu", T.getTriple());
520 
521   T.setOSAndEnvironmentName("darwin");
522   EXPECT_EQ(Triple::x86, T.getArch());
523   EXPECT_EQ(Triple::PC, T.getVendor());
524   EXPECT_EQ(Triple::Darwin, T.getOS());
525   EXPECT_EQ("i386-pc-darwin", T.getTriple());
526 
527   T.setEnvironmentName("amdopencl");
528   EXPECT_EQ(Triple::AMDOpenCL, T.getEnvironment());
529 }
530 
531 TEST(TripleTest, BitWidthPredicates) {
532   Triple T;
533   EXPECT_FALSE(T.isArch16Bit());
534   EXPECT_FALSE(T.isArch32Bit());
535   EXPECT_FALSE(T.isArch64Bit());
536 
537   T.setArch(Triple::arm);
538   EXPECT_FALSE(T.isArch16Bit());
539   EXPECT_TRUE(T.isArch32Bit());
540   EXPECT_FALSE(T.isArch64Bit());
541 
542   T.setArch(Triple::hexagon);
543   EXPECT_FALSE(T.isArch16Bit());
544   EXPECT_TRUE(T.isArch32Bit());
545   EXPECT_FALSE(T.isArch64Bit());
546 
547   T.setArch(Triple::mips);
548   EXPECT_FALSE(T.isArch16Bit());
549   EXPECT_TRUE(T.isArch32Bit());
550   EXPECT_FALSE(T.isArch64Bit());
551 
552   T.setArch(Triple::mips64);
553   EXPECT_FALSE(T.isArch16Bit());
554   EXPECT_FALSE(T.isArch32Bit());
555   EXPECT_TRUE(T.isArch64Bit());
556 
557   T.setArch(Triple::msp430);
558   EXPECT_TRUE(T.isArch16Bit());
559   EXPECT_FALSE(T.isArch32Bit());
560   EXPECT_FALSE(T.isArch64Bit());
561 
562   T.setArch(Triple::ppc);
563   EXPECT_FALSE(T.isArch16Bit());
564   EXPECT_TRUE(T.isArch32Bit());
565   EXPECT_FALSE(T.isArch64Bit());
566 
567   T.setArch(Triple::ppc64);
568   EXPECT_FALSE(T.isArch16Bit());
569   EXPECT_FALSE(T.isArch32Bit());
570   EXPECT_TRUE(T.isArch64Bit());
571 
572   T.setArch(Triple::x86);
573   EXPECT_FALSE(T.isArch16Bit());
574   EXPECT_TRUE(T.isArch32Bit());
575   EXPECT_FALSE(T.isArch64Bit());
576 
577   T.setArch(Triple::x86_64);
578   EXPECT_FALSE(T.isArch16Bit());
579   EXPECT_FALSE(T.isArch32Bit());
580   EXPECT_TRUE(T.isArch64Bit());
581 
582   T.setArch(Triple::amdil);
583   EXPECT_FALSE(T.isArch16Bit());
584   EXPECT_TRUE(T.isArch32Bit());
585   EXPECT_FALSE(T.isArch64Bit());
586 
587   T.setArch(Triple::amdil64);
588   EXPECT_FALSE(T.isArch16Bit());
589   EXPECT_FALSE(T.isArch32Bit());
590   EXPECT_TRUE(T.isArch64Bit());
591 
592   T.setArch(Triple::hsail);
593   EXPECT_FALSE(T.isArch16Bit());
594   EXPECT_TRUE(T.isArch32Bit());
595   EXPECT_FALSE(T.isArch64Bit());
596 
597   T.setArch(Triple::hsail64);
598   EXPECT_FALSE(T.isArch16Bit());
599   EXPECT_FALSE(T.isArch32Bit());
600   EXPECT_TRUE(T.isArch64Bit());
601 
602   T.setArch(Triple::spir);
603   EXPECT_FALSE(T.isArch16Bit());
604   EXPECT_TRUE(T.isArch32Bit());
605   EXPECT_FALSE(T.isArch64Bit());
606 
607   T.setArch(Triple::spir64);
608   EXPECT_FALSE(T.isArch16Bit());
609   EXPECT_FALSE(T.isArch32Bit());
610   EXPECT_TRUE(T.isArch64Bit());
611 
612   T.setArch(Triple::sparc);
613   EXPECT_FALSE(T.isArch16Bit());
614   EXPECT_TRUE(T.isArch32Bit());
615   EXPECT_FALSE(T.isArch64Bit());
616 
617   T.setArch(Triple::sparcel);
618   EXPECT_FALSE(T.isArch16Bit());
619   EXPECT_TRUE(T.isArch32Bit());
620   EXPECT_FALSE(T.isArch64Bit());
621 
622   T.setArch(Triple::sparcv9);
623   EXPECT_FALSE(T.isArch16Bit());
624   EXPECT_FALSE(T.isArch32Bit());
625   EXPECT_TRUE(T.isArch64Bit());
626 
627   T.setArch(Triple::wasm32);
628   EXPECT_FALSE(T.isArch16Bit());
629   EXPECT_TRUE(T.isArch32Bit());
630   EXPECT_FALSE(T.isArch64Bit());
631 
632   T.setArch(Triple::wasm64);
633   EXPECT_FALSE(T.isArch16Bit());
634   EXPECT_FALSE(T.isArch32Bit());
635   EXPECT_TRUE(T.isArch64Bit());
636 
637   T.setArch(Triple::avr);
638   EXPECT_TRUE(T.isArch16Bit());
639   EXPECT_FALSE(T.isArch32Bit());
640   EXPECT_FALSE(T.isArch64Bit());
641 
642   T.setArch(Triple::lanai);
643   EXPECT_FALSE(T.isArch16Bit());
644   EXPECT_TRUE(T.isArch32Bit());
645   EXPECT_FALSE(T.isArch64Bit());
646 
647   T.setArch(Triple::riscv32);
648   EXPECT_FALSE(T.isArch16Bit());
649   EXPECT_TRUE(T.isArch32Bit());
650   EXPECT_FALSE(T.isArch64Bit());
651 
652   T.setArch(Triple::riscv64);
653   EXPECT_FALSE(T.isArch16Bit());
654   EXPECT_FALSE(T.isArch32Bit());
655   EXPECT_TRUE(T.isArch64Bit());
656 }
657 
658 TEST(TripleTest, BitWidthArchVariants) {
659   Triple T;
660   EXPECT_EQ(Triple::UnknownArch, T.get32BitArchVariant().getArch());
661   EXPECT_EQ(Triple::UnknownArch, T.get64BitArchVariant().getArch());
662 
663   T.setArch(Triple::UnknownArch);
664   EXPECT_EQ(Triple::UnknownArch, T.get32BitArchVariant().getArch());
665   EXPECT_EQ(Triple::UnknownArch, T.get64BitArchVariant().getArch());
666 
667   T.setArch(Triple::mips);
668   EXPECT_EQ(Triple::mips, T.get32BitArchVariant().getArch());
669   EXPECT_EQ(Triple::mips64, T.get64BitArchVariant().getArch());
670 
671   T.setArch(Triple::mipsel);
672   EXPECT_EQ(Triple::mipsel, T.get32BitArchVariant().getArch());
673   EXPECT_EQ(Triple::mips64el, T.get64BitArchVariant().getArch());
674 
675   T.setArch(Triple::ppc);
676   EXPECT_EQ(Triple::ppc, T.get32BitArchVariant().getArch());
677   EXPECT_EQ(Triple::ppc64, T.get64BitArchVariant().getArch());
678 
679   T.setArch(Triple::nvptx);
680   EXPECT_EQ(Triple::nvptx, T.get32BitArchVariant().getArch());
681   EXPECT_EQ(Triple::nvptx64, T.get64BitArchVariant().getArch());
682 
683   T.setArch(Triple::sparc);
684   EXPECT_EQ(Triple::sparc, T.get32BitArchVariant().getArch());
685   EXPECT_EQ(Triple::sparcv9, T.get64BitArchVariant().getArch());
686 
687   T.setArch(Triple::x86);
688   EXPECT_EQ(Triple::x86, T.get32BitArchVariant().getArch());
689   EXPECT_EQ(Triple::x86_64, T.get64BitArchVariant().getArch());
690 
691   T.setArch(Triple::mips64);
692   EXPECT_EQ(Triple::mips, T.get32BitArchVariant().getArch());
693   EXPECT_EQ(Triple::mips64, T.get64BitArchVariant().getArch());
694 
695   T.setArch(Triple::mips64el);
696   EXPECT_EQ(Triple::mipsel, T.get32BitArchVariant().getArch());
697   EXPECT_EQ(Triple::mips64el, T.get64BitArchVariant().getArch());
698 
699   T.setArch(Triple::ppc64);
700   EXPECT_EQ(Triple::ppc, T.get32BitArchVariant().getArch());
701   EXPECT_EQ(Triple::ppc64, T.get64BitArchVariant().getArch());
702 
703   T.setArch(Triple::nvptx64);
704   EXPECT_EQ(Triple::nvptx, T.get32BitArchVariant().getArch());
705   EXPECT_EQ(Triple::nvptx64, T.get64BitArchVariant().getArch());
706 
707   T.setArch(Triple::sparcv9);
708   EXPECT_EQ(Triple::sparc, T.get32BitArchVariant().getArch());
709   EXPECT_EQ(Triple::sparcv9, T.get64BitArchVariant().getArch());
710 
711   T.setArch(Triple::x86_64);
712   EXPECT_EQ(Triple::x86, T.get32BitArchVariant().getArch());
713   EXPECT_EQ(Triple::x86_64, T.get64BitArchVariant().getArch());
714 
715   T.setArch(Triple::amdil);
716   EXPECT_EQ(Triple::amdil, T.get32BitArchVariant().getArch());
717   EXPECT_EQ(Triple::amdil64, T.get64BitArchVariant().getArch());
718 
719   T.setArch(Triple::amdil64);
720   EXPECT_EQ(Triple::amdil, T.get32BitArchVariant().getArch());
721   EXPECT_EQ(Triple::amdil64, T.get64BitArchVariant().getArch());
722 
723   T.setArch(Triple::hsail);
724   EXPECT_EQ(Triple::hsail, T.get32BitArchVariant().getArch());
725   EXPECT_EQ(Triple::hsail64, T.get64BitArchVariant().getArch());
726 
727   T.setArch(Triple::hsail64);
728   EXPECT_EQ(Triple::hsail, T.get32BitArchVariant().getArch());
729   EXPECT_EQ(Triple::hsail64, T.get64BitArchVariant().getArch());
730 
731   T.setArch(Triple::spir);
732   EXPECT_EQ(Triple::spir, T.get32BitArchVariant().getArch());
733   EXPECT_EQ(Triple::spir64, T.get64BitArchVariant().getArch());
734 
735   T.setArch(Triple::spir64);
736   EXPECT_EQ(Triple::spir, T.get32BitArchVariant().getArch());
737   EXPECT_EQ(Triple::spir64, T.get64BitArchVariant().getArch());
738 
739   T.setArch(Triple::wasm32);
740   EXPECT_EQ(Triple::wasm32, T.get32BitArchVariant().getArch());
741   EXPECT_EQ(Triple::wasm64, T.get64BitArchVariant().getArch());
742 
743   T.setArch(Triple::wasm64);
744   EXPECT_EQ(Triple::wasm32, T.get32BitArchVariant().getArch());
745   EXPECT_EQ(Triple::wasm64, T.get64BitArchVariant().getArch());
746 
747   T.setArch(Triple::riscv32);
748   EXPECT_EQ(Triple::riscv32, T.get32BitArchVariant().getArch());
749   EXPECT_EQ(Triple::riscv64, T.get64BitArchVariant().getArch());
750 
751   T.setArch(Triple::riscv64);
752   EXPECT_EQ(Triple::riscv32, T.get32BitArchVariant().getArch());
753   EXPECT_EQ(Triple::riscv64, T.get64BitArchVariant().getArch());
754 
755   T.setArch(Triple::thumbeb);
756   EXPECT_EQ(Triple::thumbeb, T.get32BitArchVariant().getArch());
757   EXPECT_EQ(Triple::aarch64_be, T.get64BitArchVariant().getArch());
758 
759   T.setArch(Triple::thumb);
760   EXPECT_EQ(Triple::thumb, T.get32BitArchVariant().getArch());
761   EXPECT_EQ(Triple::aarch64, T.get64BitArchVariant().getArch());
762 
763   T.setArch(Triple::aarch64);
764   EXPECT_EQ(Triple::arm, T.get32BitArchVariant().getArch());
765   EXPECT_EQ(Triple::aarch64, T.get64BitArchVariant().getArch());
766 
767   T.setArch(Triple::aarch64_be);
768   EXPECT_EQ(Triple::armeb, T.get32BitArchVariant().getArch());
769   EXPECT_EQ(Triple::aarch64_be, T.get64BitArchVariant().getArch());
770 
771   T.setArch(Triple::renderscript32);
772   EXPECT_EQ(Triple::renderscript32, T.get32BitArchVariant().getArch());
773   EXPECT_EQ(Triple::renderscript64, T.get64BitArchVariant().getArch());
774 
775   T.setArch(Triple::renderscript64);
776   EXPECT_EQ(Triple::renderscript32, T.get32BitArchVariant().getArch());
777   EXPECT_EQ(Triple::renderscript64, T.get64BitArchVariant().getArch());
778 
779   T.setArch(Triple::le32);
780   EXPECT_EQ(Triple::le32, T.get32BitArchVariant().getArch());
781   EXPECT_EQ(Triple::le64, T.get64BitArchVariant().getArch());
782 
783   T.setArch(Triple::le64);
784   EXPECT_EQ(Triple::le32, T.get32BitArchVariant().getArch());
785   EXPECT_EQ(Triple::le64, T.get64BitArchVariant().getArch());
786 
787   T.setArch(Triple::armeb);
788   EXPECT_EQ(Triple::armeb, T.get32BitArchVariant().getArch());
789   EXPECT_EQ(Triple::aarch64_be, T.get64BitArchVariant().getArch());
790 
791   T.setArch(Triple::arm);
792   EXPECT_EQ(Triple::arm, T.get32BitArchVariant().getArch());
793   EXPECT_EQ(Triple::aarch64, T.get64BitArchVariant().getArch());
794 
795   T.setArch(Triple::systemz);
796   EXPECT_EQ(Triple::UnknownArch, T.get32BitArchVariant().getArch());
797   EXPECT_EQ(Triple::systemz, T.get64BitArchVariant().getArch());
798 
799   T.setArch(Triple::xcore);
800   EXPECT_EQ(Triple::xcore, T.get32BitArchVariant().getArch());
801   EXPECT_EQ(Triple::UnknownArch, T.get64BitArchVariant().getArch());
802 }
803 
804 TEST(TripleTest, EndianArchVariants) {
805   Triple T;
806   EXPECT_EQ(Triple::UnknownArch, T.getBigEndianArchVariant().getArch());
807   EXPECT_EQ(Triple::UnknownArch, T.getLittleEndianArchVariant().getArch());
808 
809   T.setArch(Triple::UnknownArch);
810   EXPECT_EQ(Triple::UnknownArch, T.getBigEndianArchVariant().getArch());
811   EXPECT_EQ(Triple::UnknownArch, T.getLittleEndianArchVariant().getArch());
812 
813   T.setArch(Triple::aarch64_be);
814   EXPECT_EQ(Triple::aarch64_be, T.getBigEndianArchVariant().getArch());
815   EXPECT_EQ(Triple::aarch64, T.getLittleEndianArchVariant().getArch());
816 
817   T.setArch(Triple::aarch64);
818   EXPECT_EQ(Triple::aarch64_be, T.getBigEndianArchVariant().getArch());
819   EXPECT_EQ(Triple::aarch64, T.getLittleEndianArchVariant().getArch());
820 
821   T.setArch(Triple::armeb);
822   EXPECT_EQ(Triple::armeb, T.getBigEndianArchVariant().getArch());
823   EXPECT_EQ(Triple::UnknownArch, T.getLittleEndianArchVariant().getArch());
824 
825   T.setArch(Triple::arm);
826   EXPECT_EQ(Triple::UnknownArch, T.getBigEndianArchVariant().getArch());
827   EXPECT_EQ(Triple::arm, T.getLittleEndianArchVariant().getArch());
828   T = Triple("arm");
829   EXPECT_TRUE(T.isLittleEndian());
830   T = Triple("thumb");
831   EXPECT_TRUE(T.isLittleEndian());
832   T = Triple("armeb");
833   EXPECT_FALSE(T.isLittleEndian());
834   T = Triple("thumbeb");
835   EXPECT_FALSE(T.isLittleEndian());
836 
837   T.setArch(Triple::bpfeb);
838   EXPECT_EQ(Triple::bpfeb, T.getBigEndianArchVariant().getArch());
839   EXPECT_EQ(Triple::bpfel, T.getLittleEndianArchVariant().getArch());
840 
841   T.setArch(Triple::bpfel);
842   EXPECT_EQ(Triple::bpfeb, T.getBigEndianArchVariant().getArch());
843   EXPECT_EQ(Triple::bpfel, T.getLittleEndianArchVariant().getArch());
844 
845   T.setArch(Triple::mips64);
846   EXPECT_EQ(Triple::mips64, T.getBigEndianArchVariant().getArch());
847   EXPECT_EQ(Triple::mips64el, T.getLittleEndianArchVariant().getArch());
848 
849   T.setArch(Triple::mips64el);
850   EXPECT_EQ(Triple::mips64, T.getBigEndianArchVariant().getArch());
851   EXPECT_EQ(Triple::mips64el, T.getLittleEndianArchVariant().getArch());
852 
853   T.setArch(Triple::mips);
854   EXPECT_EQ(Triple::mips, T.getBigEndianArchVariant().getArch());
855   EXPECT_EQ(Triple::mipsel, T.getLittleEndianArchVariant().getArch());
856 
857   T.setArch(Triple::mipsel);
858   EXPECT_EQ(Triple::mips, T.getBigEndianArchVariant().getArch());
859   EXPECT_EQ(Triple::mipsel, T.getLittleEndianArchVariant().getArch());
860 
861   T.setArch(Triple::ppc);
862   EXPECT_EQ(Triple::ppc, T.getBigEndianArchVariant().getArch());
863   EXPECT_EQ(Triple::UnknownArch, T.getLittleEndianArchVariant().getArch());
864 
865   T.setArch(Triple::ppc64);
866   EXPECT_EQ(Triple::ppc64, T.getBigEndianArchVariant().getArch());
867   EXPECT_EQ(Triple::ppc64le, T.getLittleEndianArchVariant().getArch());
868 
869   T.setArch(Triple::ppc64le);
870   EXPECT_EQ(Triple::ppc64, T.getBigEndianArchVariant().getArch());
871   EXPECT_EQ(Triple::ppc64le, T.getLittleEndianArchVariant().getArch());
872 
873   T.setArch(Triple::sparc);
874   EXPECT_EQ(Triple::sparc, T.getBigEndianArchVariant().getArch());
875   EXPECT_EQ(Triple::sparcel, T.getLittleEndianArchVariant().getArch());
876 
877   T.setArch(Triple::sparcel);
878   EXPECT_EQ(Triple::sparc, T.getBigEndianArchVariant().getArch());
879   EXPECT_EQ(Triple::sparcel, T.getLittleEndianArchVariant().getArch());
880 
881   T.setArch(Triple::thumb);
882   EXPECT_EQ(Triple::UnknownArch, T.getBigEndianArchVariant().getArch());
883   EXPECT_EQ(Triple::thumb, T.getLittleEndianArchVariant().getArch());
884 
885   T.setArch(Triple::thumbeb);
886   EXPECT_EQ(Triple::thumbeb, T.getBigEndianArchVariant().getArch());
887   EXPECT_EQ(Triple::UnknownArch, T.getLittleEndianArchVariant().getArch());
888 
889   T.setArch(Triple::lanai);
890   EXPECT_EQ(Triple::lanai, T.getBigEndianArchVariant().getArch());
891   EXPECT_EQ(Triple::UnknownArch, T.getLittleEndianArchVariant().getArch());
892 
893   T.setArch(Triple::tcele);
894   EXPECT_EQ(Triple::tce, T.getBigEndianArchVariant().getArch());
895   EXPECT_EQ(Triple::tcele, T.getLittleEndianArchVariant().getArch());
896 
897   T.setArch(Triple::tce);
898   EXPECT_EQ(Triple::tce, T.getBigEndianArchVariant().getArch());
899   EXPECT_EQ(Triple::tcele, T.getLittleEndianArchVariant().getArch());
900 
901   T.setArch(Triple::le32);
902   EXPECT_EQ(Triple::UnknownArch, T.getBigEndianArchVariant().getArch());
903   EXPECT_EQ(Triple::le32, T.getLittleEndianArchVariant().getArch());
904 
905   T.setArch(Triple::le64);
906   EXPECT_EQ(Triple::UnknownArch, T.getBigEndianArchVariant().getArch());
907   EXPECT_EQ(Triple::le64, T.getLittleEndianArchVariant().getArch());
908 }
909 
910 TEST(TripleTest, getOSVersion) {
911   Triple T;
912   unsigned Major, Minor, Micro;
913 
914   T = Triple("i386-apple-darwin9");
915   EXPECT_TRUE(T.isMacOSX());
916   EXPECT_FALSE(T.isiOS());
917   EXPECT_FALSE(T.isArch16Bit());
918   EXPECT_TRUE(T.isArch32Bit());
919   EXPECT_FALSE(T.isArch64Bit());
920   T.getMacOSXVersion(Major, Minor, Micro);
921   EXPECT_EQ((unsigned)10, Major);
922   EXPECT_EQ((unsigned)5, Minor);
923   EXPECT_EQ((unsigned)0, Micro);
924   T.getiOSVersion(Major, Minor, Micro);
925   EXPECT_EQ((unsigned)5, Major);
926   EXPECT_EQ((unsigned)0, Minor);
927   EXPECT_EQ((unsigned)0, Micro);
928 
929   T = Triple("x86_64-apple-darwin9");
930   EXPECT_TRUE(T.isMacOSX());
931   EXPECT_FALSE(T.isiOS());
932   EXPECT_FALSE(T.isArch16Bit());
933   EXPECT_FALSE(T.isArch32Bit());
934   EXPECT_TRUE(T.isArch64Bit());
935   T.getMacOSXVersion(Major, Minor, Micro);
936   EXPECT_EQ((unsigned)10, Major);
937   EXPECT_EQ((unsigned)5, Minor);
938   EXPECT_EQ((unsigned)0, Micro);
939   T.getiOSVersion(Major, Minor, Micro);
940   EXPECT_EQ((unsigned)5, Major);
941   EXPECT_EQ((unsigned)0, Minor);
942   EXPECT_EQ((unsigned)0, Micro);
943 
944   T = Triple("x86_64-apple-macosx");
945   EXPECT_TRUE(T.isMacOSX());
946   EXPECT_FALSE(T.isiOS());
947   EXPECT_FALSE(T.isArch16Bit());
948   EXPECT_FALSE(T.isArch32Bit());
949   EXPECT_TRUE(T.isArch64Bit());
950   T.getMacOSXVersion(Major, Minor, Micro);
951   EXPECT_EQ((unsigned)10, Major);
952   EXPECT_EQ((unsigned)4, Minor);
953   EXPECT_EQ((unsigned)0, Micro);
954   T.getiOSVersion(Major, Minor, Micro);
955   EXPECT_EQ((unsigned)5, Major);
956   EXPECT_EQ((unsigned)0, Minor);
957   EXPECT_EQ((unsigned)0, Micro);
958 
959   T = Triple("x86_64-apple-macosx10.7");
960   EXPECT_TRUE(T.isMacOSX());
961   EXPECT_FALSE(T.isiOS());
962   EXPECT_FALSE(T.isArch16Bit());
963   EXPECT_FALSE(T.isArch32Bit());
964   EXPECT_TRUE(T.isArch64Bit());
965   T.getMacOSXVersion(Major, Minor, Micro);
966   EXPECT_EQ((unsigned)10, Major);
967   EXPECT_EQ((unsigned)7, Minor);
968   EXPECT_EQ((unsigned)0, Micro);
969   T.getiOSVersion(Major, Minor, Micro);
970   EXPECT_EQ((unsigned)5, Major);
971   EXPECT_EQ((unsigned)0, Minor);
972   EXPECT_EQ((unsigned)0, Micro);
973 
974   T = Triple("armv7-apple-ios");
975   EXPECT_FALSE(T.isMacOSX());
976   EXPECT_TRUE(T.isiOS());
977   EXPECT_FALSE(T.isArch16Bit());
978   EXPECT_TRUE(T.isArch32Bit());
979   EXPECT_FALSE(T.isArch64Bit());
980   T.getMacOSXVersion(Major, Minor, Micro);
981   EXPECT_EQ((unsigned)10, Major);
982   EXPECT_EQ((unsigned)4, Minor);
983   EXPECT_EQ((unsigned)0, Micro);
984   T.getiOSVersion(Major, Minor, Micro);
985   EXPECT_EQ((unsigned)5, Major);
986   EXPECT_EQ((unsigned)0, Minor);
987   EXPECT_EQ((unsigned)0, Micro);
988 
989   T = Triple("armv7-apple-ios7.0");
990   EXPECT_FALSE(T.isMacOSX());
991   EXPECT_TRUE(T.isiOS());
992   EXPECT_FALSE(T.isArch16Bit());
993   EXPECT_TRUE(T.isArch32Bit());
994   EXPECT_FALSE(T.isArch64Bit());
995   T.getMacOSXVersion(Major, Minor, Micro);
996   EXPECT_EQ((unsigned)10, Major);
997   EXPECT_EQ((unsigned)4, Minor);
998   EXPECT_EQ((unsigned)0, Micro);
999   T.getiOSVersion(Major, Minor, Micro);
1000   EXPECT_EQ((unsigned)7, Major);
1001   EXPECT_EQ((unsigned)0, Minor);
1002   EXPECT_EQ((unsigned)0, Micro);
1003   EXPECT_FALSE(T.isSimulatorEnvironment());
1004 
1005   T = Triple("x86_64-apple-ios10.3-simulator");
1006   EXPECT_TRUE(T.isiOS());
1007   T.getiOSVersion(Major, Minor, Micro);
1008   EXPECT_EQ((unsigned)10, Major);
1009   EXPECT_EQ((unsigned)3, Minor);
1010   EXPECT_EQ((unsigned)0, Micro);
1011   EXPECT_TRUE(T.isSimulatorEnvironment());
1012 }
1013 
1014 TEST(TripleTest, FileFormat) {
1015   EXPECT_EQ(Triple::ELF, Triple("i686-unknown-linux-gnu").getObjectFormat());
1016   EXPECT_EQ(Triple::ELF, Triple("i686-unknown-freebsd").getObjectFormat());
1017   EXPECT_EQ(Triple::ELF, Triple("i686-unknown-netbsd").getObjectFormat());
1018   EXPECT_EQ(Triple::ELF, Triple("i686--win32-elf").getObjectFormat());
1019   EXPECT_EQ(Triple::ELF, Triple("i686---elf").getObjectFormat());
1020 
1021   EXPECT_EQ(Triple::MachO, Triple("i686-apple-macosx").getObjectFormat());
1022   EXPECT_EQ(Triple::MachO, Triple("i686-apple-ios").getObjectFormat());
1023   EXPECT_EQ(Triple::MachO, Triple("i686---macho").getObjectFormat());
1024 
1025   EXPECT_EQ(Triple::COFF, Triple("i686--win32").getObjectFormat());
1026 
1027   EXPECT_EQ(Triple::ELF, Triple("i686-pc-windows-msvc-elf").getObjectFormat());
1028   EXPECT_EQ(Triple::ELF, Triple("i686-pc-cygwin-elf").getObjectFormat());
1029 
1030   EXPECT_EQ(Triple::Wasm, Triple("wasm32-unknown-unknown-wasm").getObjectFormat());
1031   EXPECT_EQ(Triple::Wasm, Triple("wasm64-unknown-unknown-wasm").getObjectFormat());
1032 
1033   Triple MSVCNormalized(Triple::normalize("i686-pc-windows-msvc-elf"));
1034   EXPECT_EQ(Triple::ELF, MSVCNormalized.getObjectFormat());
1035 
1036   Triple GNUWindowsNormalized(Triple::normalize("i686-pc-windows-gnu-elf"));
1037   EXPECT_EQ(Triple::ELF, GNUWindowsNormalized.getObjectFormat());
1038 
1039   Triple CygnusNormalised(Triple::normalize("i686-pc-windows-cygnus-elf"));
1040   EXPECT_EQ(Triple::ELF, CygnusNormalised.getObjectFormat());
1041 
1042   Triple CygwinNormalized(Triple::normalize("i686-pc-cygwin-elf"));
1043   EXPECT_EQ(Triple::ELF, CygwinNormalized.getObjectFormat());
1044 
1045   Triple T = Triple("");
1046   T.setObjectFormat(Triple::ELF);
1047   EXPECT_EQ(Triple::ELF, T.getObjectFormat());
1048 
1049   T.setObjectFormat(Triple::MachO);
1050   EXPECT_EQ(Triple::MachO, T.getObjectFormat());
1051 }
1052 
1053 TEST(TripleTest, NormalizeWindows) {
1054   EXPECT_EQ("i686-pc-windows-msvc", Triple::normalize("i686-pc-win32"));
1055   EXPECT_EQ("i686--windows-msvc", Triple::normalize("i686-win32"));
1056   EXPECT_EQ("i686-pc-windows-gnu", Triple::normalize("i686-pc-mingw32"));
1057   EXPECT_EQ("i686--windows-gnu", Triple::normalize("i686-mingw32"));
1058   EXPECT_EQ("i686-pc-windows-gnu", Triple::normalize("i686-pc-mingw32-w64"));
1059   EXPECT_EQ("i686--windows-gnu", Triple::normalize("i686-mingw32-w64"));
1060   EXPECT_EQ("i686-pc-windows-cygnus", Triple::normalize("i686-pc-cygwin"));
1061   EXPECT_EQ("i686--windows-cygnus", Triple::normalize("i686-cygwin"));
1062 
1063   EXPECT_EQ("x86_64-pc-windows-msvc", Triple::normalize("x86_64-pc-win32"));
1064   EXPECT_EQ("x86_64--windows-msvc", Triple::normalize("x86_64-win32"));
1065   EXPECT_EQ("x86_64-pc-windows-gnu", Triple::normalize("x86_64-pc-mingw32"));
1066   EXPECT_EQ("x86_64--windows-gnu", Triple::normalize("x86_64-mingw32"));
1067   EXPECT_EQ("x86_64-pc-windows-gnu", Triple::normalize("x86_64-pc-mingw32-w64"));
1068   EXPECT_EQ("x86_64--windows-gnu", Triple::normalize("x86_64-mingw32-w64"));
1069 
1070   EXPECT_EQ("i686-pc-windows-elf", Triple::normalize("i686-pc-win32-elf"));
1071   EXPECT_EQ("i686--windows-elf", Triple::normalize("i686-win32-elf"));
1072   EXPECT_EQ("i686-pc-windows-macho", Triple::normalize("i686-pc-win32-macho"));
1073   EXPECT_EQ("i686--windows-macho", Triple::normalize("i686-win32-macho"));
1074 
1075   EXPECT_EQ("x86_64-pc-windows-elf", Triple::normalize("x86_64-pc-win32-elf"));
1076   EXPECT_EQ("x86_64--windows-elf", Triple::normalize("x86_64-win32-elf"));
1077   EXPECT_EQ("x86_64-pc-windows-macho", Triple::normalize("x86_64-pc-win32-macho"));
1078   EXPECT_EQ("x86_64--windows-macho", Triple::normalize("x86_64-win32-macho"));
1079 
1080   EXPECT_EQ("i686-pc-windows-cygnus",
1081             Triple::normalize("i686-pc-windows-cygnus"));
1082   EXPECT_EQ("i686-pc-windows-gnu", Triple::normalize("i686-pc-windows-gnu"));
1083   EXPECT_EQ("i686-pc-windows-itanium", Triple::normalize("i686-pc-windows-itanium"));
1084   EXPECT_EQ("i686-pc-windows-msvc", Triple::normalize("i686-pc-windows-msvc"));
1085 
1086   EXPECT_EQ("i686-pc-windows-elf", Triple::normalize("i686-pc-windows-elf-elf"));
1087 }
1088 
1089 TEST(TripleTest, getARMCPUForArch) {
1090   // Platform specific defaults.
1091   {
1092     llvm::Triple Triple("arm--nacl");
1093     EXPECT_EQ("cortex-a8", Triple.getARMCPUForArch());
1094   }
1095   {
1096     llvm::Triple Triple("arm--openbsd");
1097     EXPECT_EQ("cortex-a8", Triple.getARMCPUForArch());
1098   }
1099   {
1100     llvm::Triple Triple("armv6-unknown-freebsd");
1101     EXPECT_EQ("arm1176jzf-s", Triple.getARMCPUForArch());
1102   }
1103   {
1104     llvm::Triple Triple("thumbv6-unknown-freebsd");
1105     EXPECT_EQ("arm1176jzf-s", Triple.getARMCPUForArch());
1106   }
1107   {
1108     llvm::Triple Triple("armebv6-unknown-freebsd");
1109     EXPECT_EQ("arm1176jzf-s", Triple.getARMCPUForArch());
1110   }
1111   {
1112     llvm::Triple Triple("arm--win32");
1113     EXPECT_EQ("cortex-a9", Triple.getARMCPUForArch());
1114   }
1115   // Some alternative architectures
1116   {
1117     llvm::Triple Triple("armv7k-apple-ios9");
1118     EXPECT_EQ("cortex-a7", Triple.getARMCPUForArch());
1119   }
1120   {
1121     llvm::Triple Triple("armv7k-apple-watchos3");
1122     EXPECT_EQ("cortex-a7", Triple.getARMCPUForArch());
1123   }
1124   {
1125     llvm::Triple Triple("armv7k-apple-tvos9");
1126     EXPECT_EQ("cortex-a7", Triple.getARMCPUForArch());
1127   }
1128   // armeb is permitted, but armebeb is not
1129   {
1130     llvm::Triple Triple("armeb-none-eabi");
1131     EXPECT_EQ("arm7tdmi", Triple.getARMCPUForArch());
1132   }
1133   {
1134     llvm::Triple Triple("armebeb-none-eabi");
1135     EXPECT_EQ("", Triple.getARMCPUForArch());
1136   }
1137   {
1138     llvm::Triple Triple("armebv6eb-none-eabi");
1139     EXPECT_EQ("", Triple.getARMCPUForArch());
1140   }
1141   // xscaleeb is permitted, but armebxscale is not
1142   {
1143     llvm::Triple Triple("xscaleeb-none-eabi");
1144     EXPECT_EQ("xscale", Triple.getARMCPUForArch());
1145   }
1146   {
1147     llvm::Triple Triple("armebxscale-none-eabi");
1148     EXPECT_EQ("", Triple.getARMCPUForArch());
1149   }
1150 }
1151 
1152 TEST(TripleTest, NormalizeARM) {
1153   EXPECT_EQ("armv6--netbsd-eabi", Triple::normalize("armv6-netbsd-eabi"));
1154   EXPECT_EQ("armv7--netbsd-eabi", Triple::normalize("armv7-netbsd-eabi"));
1155   EXPECT_EQ("armv6eb--netbsd-eabi", Triple::normalize("armv6eb-netbsd-eabi"));
1156   EXPECT_EQ("armv7eb--netbsd-eabi", Triple::normalize("armv7eb-netbsd-eabi"));
1157   EXPECT_EQ("armv6--netbsd-eabihf", Triple::normalize("armv6-netbsd-eabihf"));
1158   EXPECT_EQ("armv7--netbsd-eabihf", Triple::normalize("armv7-netbsd-eabihf"));
1159   EXPECT_EQ("armv6eb--netbsd-eabihf", Triple::normalize("armv6eb-netbsd-eabihf"));
1160   EXPECT_EQ("armv7eb--netbsd-eabihf", Triple::normalize("armv7eb-netbsd-eabihf"));
1161 
1162   EXPECT_EQ("armv7-suse-linux-gnueabihf",
1163             Triple::normalize("armv7-suse-linux-gnueabi"));
1164 
1165   Triple T;
1166   T = Triple("armv6--netbsd-eabi");
1167   EXPECT_EQ(Triple::arm, T.getArch());
1168   T = Triple("armv6eb--netbsd-eabi");
1169   EXPECT_EQ(Triple::armeb, T.getArch());
1170   T = Triple("armv7-suse-linux-gnueabihf");
1171   EXPECT_EQ(Triple::GNUEABIHF, T.getEnvironment());
1172 }
1173 
1174 TEST(TripleTest, ParseARMArch) {
1175   // ARM
1176   {
1177     Triple T = Triple("arm");
1178     EXPECT_EQ(Triple::arm, T.getArch());
1179   }
1180   {
1181     Triple T = Triple("armeb");
1182     EXPECT_EQ(Triple::armeb, T.getArch());
1183   }
1184   // THUMB
1185   {
1186     Triple T = Triple("thumb");
1187     EXPECT_EQ(Triple::thumb, T.getArch());
1188   }
1189   {
1190     Triple T = Triple("thumbeb");
1191     EXPECT_EQ(Triple::thumbeb, T.getArch());
1192   }
1193   // AARCH64
1194   {
1195     Triple T = Triple("arm64");
1196     EXPECT_EQ(Triple::aarch64, T.getArch());
1197   }
1198   {
1199     Triple T = Triple("aarch64");
1200     EXPECT_EQ(Triple::aarch64, T.getArch());
1201   }
1202   {
1203     Triple T = Triple("aarch64_be");
1204     EXPECT_EQ(Triple::aarch64_be, T.getArch());
1205   }
1206 }
1207 } // end anonymous namespace
1208