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 "gtest/gtest.h"
11 #include "llvm/ADT/Triple.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-cloudabi");
204   EXPECT_EQ(Triple::x86_64, T.getArch());
205   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
206   EXPECT_EQ(Triple::CloudABI, T.getOS());
207   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
208 
209   T = Triple("x86_64-unknown-fuchsia");
210   EXPECT_EQ(Triple::x86_64, T.getArch());
211   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
212   EXPECT_EQ(Triple::Fuchsia, T.getOS());
213   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
214 
215   T = Triple("wasm32-unknown-unknown");
216   EXPECT_EQ(Triple::wasm32, T.getArch());
217   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
218   EXPECT_EQ(Triple::UnknownOS, T.getOS());
219   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
220 
221   T = Triple("wasm64-unknown-unknown");
222   EXPECT_EQ(Triple::wasm64, 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("avr-unknown-unknown");
228   EXPECT_EQ(Triple::avr, 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");
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("lanai-unknown-unknown");
240   EXPECT_EQ(Triple::lanai, 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");
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("amdgcn-mesa-mesa3d");
252   EXPECT_EQ(Triple::amdgcn, T.getArch());
253   EXPECT_EQ(Triple::Mesa, T.getVendor());
254   EXPECT_EQ(Triple::Mesa3D, T.getOS());
255   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
256 
257   T = Triple("amdgcn-amd-amdhsa");
258   EXPECT_EQ(Triple::amdgcn, T.getArch());
259   EXPECT_EQ(Triple::AMD, T.getVendor());
260   EXPECT_EQ(Triple::AMDHSA, T.getOS());
261   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
262 
263   T = Triple("amdgcn-amd-amdhsa-opencl");
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::OpenCL, T.getEnvironment());
268 
269   T = Triple("huh");
270   EXPECT_EQ(Triple::UnknownArch, T.getArch());
271 }
272 
273 static std::string Join(StringRef A, StringRef B, StringRef C) {
274   std::string Str = A; Str += '-'; Str += B; Str += '-'; Str += C;
275   return Str;
276 }
277 
278 static std::string Join(StringRef A, StringRef B, StringRef C, StringRef D) {
279   std::string Str = A; Str += '-'; Str += B; Str += '-'; Str += C; Str += '-';
280   Str += D; return Str;
281 }
282 
283 TEST(TripleTest, Normalization) {
284 
285   EXPECT_EQ("", Triple::normalize(""));
286   EXPECT_EQ("-", Triple::normalize("-"));
287   EXPECT_EQ("--", Triple::normalize("--"));
288   EXPECT_EQ("---", Triple::normalize("---"));
289   EXPECT_EQ("----", Triple::normalize("----"));
290 
291   EXPECT_EQ("a", Triple::normalize("a"));
292   EXPECT_EQ("a-b", Triple::normalize("a-b"));
293   EXPECT_EQ("a-b-c", Triple::normalize("a-b-c"));
294   EXPECT_EQ("a-b-c-d", Triple::normalize("a-b-c-d"));
295 
296   EXPECT_EQ("i386-b-c", Triple::normalize("i386-b-c"));
297   EXPECT_EQ("i386-a-c", Triple::normalize("a-i386-c"));
298   EXPECT_EQ("i386-a-b", Triple::normalize("a-b-i386"));
299   EXPECT_EQ("i386-a-b-c", Triple::normalize("a-b-c-i386"));
300 
301   EXPECT_EQ("a-pc-c", Triple::normalize("a-pc-c"));
302   EXPECT_EQ("-pc-b-c", Triple::normalize("pc-b-c"));
303   EXPECT_EQ("a-pc-b", Triple::normalize("a-b-pc"));
304   EXPECT_EQ("a-pc-b-c", Triple::normalize("a-b-c-pc"));
305 
306   EXPECT_EQ("a-b-linux", Triple::normalize("a-b-linux"));
307   EXPECT_EQ("--linux-b-c", Triple::normalize("linux-b-c"));
308   EXPECT_EQ("a--linux-c", Triple::normalize("a-linux-c"));
309 
310   EXPECT_EQ("i386-pc-a", Triple::normalize("a-pc-i386"));
311   EXPECT_EQ("i386-pc-", Triple::normalize("-pc-i386"));
312   EXPECT_EQ("-pc-linux-c", Triple::normalize("linux-pc-c"));
313   EXPECT_EQ("-pc-linux", Triple::normalize("linux-pc-"));
314 
315   EXPECT_EQ("i386", Triple::normalize("i386"));
316   EXPECT_EQ("-pc", Triple::normalize("pc"));
317   EXPECT_EQ("--linux", Triple::normalize("linux"));
318 
319   EXPECT_EQ("x86_64--linux-gnu", Triple::normalize("x86_64-gnu-linux"));
320 
321   // Check that normalizing a permutated set of valid components returns a
322   // triple with the unpermuted components.
323   //
324   // We don't check every possible combination. For the set of architectures A,
325   // vendors V, operating systems O, and environments E, that would require |A|
326   // * |V| * |O| * |E| * 4! tests. Instead we check every option for any given
327   // slot and make sure it gets normalized to the correct position from every
328   // permutation. This should cover the core logic while being a tractable
329   // number of tests at (|A| + |V| + |O| + |E|) * 4!.
330   auto FirstArchType = Triple::ArchType(Triple::UnknownArch + 1);
331   auto FirstVendorType = Triple::VendorType(Triple::UnknownVendor + 1);
332   auto FirstOSType = Triple::OSType(Triple::UnknownOS + 1);
333   auto FirstEnvType = Triple::EnvironmentType(Triple::UnknownEnvironment + 1);
334   StringRef InitialC[] = {Triple::getArchTypeName(FirstArchType),
335                           Triple::getVendorTypeName(FirstVendorType),
336                           Triple::getOSTypeName(FirstOSType),
337                           Triple::getEnvironmentTypeName(FirstEnvType)};
338   for (int Arch = FirstArchType; Arch <= Triple::LastArchType; ++Arch) {
339     StringRef C[] = {InitialC[0], InitialC[1], InitialC[2], InitialC[3]};
340     C[0] = Triple::getArchTypeName(Triple::ArchType(Arch));
341     std::string E = Join(C[0], C[1], C[2]);
342     int I[] = {0, 1, 2};
343     do {
344       EXPECT_EQ(E, Triple::normalize(Join(C[I[0]], C[I[1]], C[I[2]])));
345     } while (std::next_permutation(std::begin(I), std::end(I)));
346     std::string F = Join(C[0], C[1], C[2], C[3]);
347     int J[] = {0, 1, 2, 3};
348     do {
349       EXPECT_EQ(F, Triple::normalize(Join(C[J[0]], C[J[1]], C[J[2]], C[J[3]])));
350     } while (std::next_permutation(std::begin(J), std::end(J)));
351   }
352   for (int Vendor = FirstVendorType; Vendor <= Triple::LastVendorType;
353        ++Vendor) {
354     StringRef C[] = {InitialC[0], InitialC[1], InitialC[2], InitialC[3]};
355     C[1] = Triple::getVendorTypeName(Triple::VendorType(Vendor));
356     std::string E = Join(C[0], C[1], C[2]);
357     int I[] = {0, 1, 2};
358     do {
359       EXPECT_EQ(E, Triple::normalize(Join(C[I[0]], C[I[1]], C[I[2]])));
360     } while (std::next_permutation(std::begin(I), std::end(I)));
361     std::string F = Join(C[0], C[1], C[2], C[3]);
362     int J[] = {0, 1, 2, 3};
363     do {
364       EXPECT_EQ(F, Triple::normalize(Join(C[J[0]], C[J[1]], C[J[2]], C[J[3]])));
365     } while (std::next_permutation(std::begin(J), std::end(J)));
366   }
367   for (int OS = FirstOSType; OS <= Triple::LastOSType; ++OS) {
368     if (OS == Triple::Win32)
369       continue;
370     StringRef C[] = {InitialC[0], InitialC[1], InitialC[2], InitialC[3]};
371     C[2] = Triple::getOSTypeName(Triple::OSType(OS));
372     std::string E = Join(C[0], C[1], C[2]);
373     int I[] = {0, 1, 2};
374     do {
375       EXPECT_EQ(E, Triple::normalize(Join(C[I[0]], C[I[1]], C[I[2]])));
376     } while (std::next_permutation(std::begin(I), std::end(I)));
377     std::string F = Join(C[0], C[1], C[2], C[3]);
378     int J[] = {0, 1, 2, 3};
379     do {
380       EXPECT_EQ(F, Triple::normalize(Join(C[J[0]], C[J[1]], C[J[2]], C[J[3]])));
381     } while (std::next_permutation(std::begin(J), std::end(J)));
382   }
383   for (int Env = FirstEnvType; Env <= Triple::LastEnvironmentType; ++Env) {
384     StringRef C[] = {InitialC[0], InitialC[1], InitialC[2], InitialC[3]};
385     C[3] = Triple::getEnvironmentTypeName(Triple::EnvironmentType(Env));
386     std::string F = Join(C[0], C[1], C[2], C[3]);
387     int J[] = {0, 1, 2, 3};
388     do {
389       EXPECT_EQ(F, Triple::normalize(Join(C[J[0]], C[J[1]], C[J[2]], C[J[3]])));
390     } while (std::next_permutation(std::begin(J), std::end(J)));
391   }
392 
393   // Various real-world funky triples.  The value returned by GCC's config.sub
394   // is given in the comment.
395   EXPECT_EQ("i386--windows-gnu", Triple::normalize("i386-mingw32")); // i386-pc-mingw32
396   EXPECT_EQ("x86_64--linux-gnu", Triple::normalize("x86_64-linux-gnu")); // x86_64-pc-linux-gnu
397   EXPECT_EQ("i486--linux-gnu", Triple::normalize("i486-linux-gnu")); // i486-pc-linux-gnu
398   EXPECT_EQ("i386-redhat-linux", Triple::normalize("i386-redhat-linux")); // i386-redhat-linux-gnu
399   EXPECT_EQ("i686--linux", Triple::normalize("i686-linux")); // i686-pc-linux-gnu
400   EXPECT_EQ("arm-none--eabi", Triple::normalize("arm-none-eabi")); // arm-none-eabi
401 }
402 
403 TEST(TripleTest, MutateName) {
404   Triple T;
405   EXPECT_EQ(Triple::UnknownArch, T.getArch());
406   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
407   EXPECT_EQ(Triple::UnknownOS, T.getOS());
408   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
409 
410   T.setArchName("i386");
411   EXPECT_EQ(Triple::x86, T.getArch());
412   EXPECT_EQ("i386--", T.getTriple());
413 
414   T.setVendorName("pc");
415   EXPECT_EQ(Triple::x86, T.getArch());
416   EXPECT_EQ(Triple::PC, T.getVendor());
417   EXPECT_EQ("i386-pc-", T.getTriple());
418 
419   T.setOSName("linux");
420   EXPECT_EQ(Triple::x86, T.getArch());
421   EXPECT_EQ(Triple::PC, T.getVendor());
422   EXPECT_EQ(Triple::Linux, T.getOS());
423   EXPECT_EQ("i386-pc-linux", T.getTriple());
424 
425   T.setEnvironmentName("gnu");
426   EXPECT_EQ(Triple::x86, T.getArch());
427   EXPECT_EQ(Triple::PC, T.getVendor());
428   EXPECT_EQ(Triple::Linux, T.getOS());
429   EXPECT_EQ("i386-pc-linux-gnu", T.getTriple());
430 
431   T.setOSName("freebsd");
432   EXPECT_EQ(Triple::x86, T.getArch());
433   EXPECT_EQ(Triple::PC, T.getVendor());
434   EXPECT_EQ(Triple::FreeBSD, T.getOS());
435   EXPECT_EQ("i386-pc-freebsd-gnu", T.getTriple());
436 
437   T.setOSAndEnvironmentName("darwin");
438   EXPECT_EQ(Triple::x86, T.getArch());
439   EXPECT_EQ(Triple::PC, T.getVendor());
440   EXPECT_EQ(Triple::Darwin, T.getOS());
441   EXPECT_EQ("i386-pc-darwin", T.getTriple());
442 
443   T.setEnvironmentName("amdopencl");
444   EXPECT_EQ(Triple::AMDOpenCL, T.getEnvironment());
445 }
446 
447 TEST(TripleTest, BitWidthPredicates) {
448   Triple T;
449   EXPECT_FALSE(T.isArch16Bit());
450   EXPECT_FALSE(T.isArch32Bit());
451   EXPECT_FALSE(T.isArch64Bit());
452 
453   T.setArch(Triple::arm);
454   EXPECT_FALSE(T.isArch16Bit());
455   EXPECT_TRUE(T.isArch32Bit());
456   EXPECT_FALSE(T.isArch64Bit());
457 
458   T.setArch(Triple::hexagon);
459   EXPECT_FALSE(T.isArch16Bit());
460   EXPECT_TRUE(T.isArch32Bit());
461   EXPECT_FALSE(T.isArch64Bit());
462 
463   T.setArch(Triple::mips);
464   EXPECT_FALSE(T.isArch16Bit());
465   EXPECT_TRUE(T.isArch32Bit());
466   EXPECT_FALSE(T.isArch64Bit());
467 
468   T.setArch(Triple::mips64);
469   EXPECT_FALSE(T.isArch16Bit());
470   EXPECT_FALSE(T.isArch32Bit());
471   EXPECT_TRUE(T.isArch64Bit());
472 
473   T.setArch(Triple::msp430);
474   EXPECT_TRUE(T.isArch16Bit());
475   EXPECT_FALSE(T.isArch32Bit());
476   EXPECT_FALSE(T.isArch64Bit());
477 
478   T.setArch(Triple::ppc);
479   EXPECT_FALSE(T.isArch16Bit());
480   EXPECT_TRUE(T.isArch32Bit());
481   EXPECT_FALSE(T.isArch64Bit());
482 
483   T.setArch(Triple::ppc64);
484   EXPECT_FALSE(T.isArch16Bit());
485   EXPECT_FALSE(T.isArch32Bit());
486   EXPECT_TRUE(T.isArch64Bit());
487 
488   T.setArch(Triple::x86);
489   EXPECT_FALSE(T.isArch16Bit());
490   EXPECT_TRUE(T.isArch32Bit());
491   EXPECT_FALSE(T.isArch64Bit());
492 
493   T.setArch(Triple::x86_64);
494   EXPECT_FALSE(T.isArch16Bit());
495   EXPECT_FALSE(T.isArch32Bit());
496   EXPECT_TRUE(T.isArch64Bit());
497 
498   T.setArch(Triple::amdil);
499   EXPECT_FALSE(T.isArch16Bit());
500   EXPECT_TRUE(T.isArch32Bit());
501   EXPECT_FALSE(T.isArch64Bit());
502 
503   T.setArch(Triple::amdil64);
504   EXPECT_FALSE(T.isArch16Bit());
505   EXPECT_FALSE(T.isArch32Bit());
506   EXPECT_TRUE(T.isArch64Bit());
507 
508   T.setArch(Triple::hsail);
509   EXPECT_FALSE(T.isArch16Bit());
510   EXPECT_TRUE(T.isArch32Bit());
511   EXPECT_FALSE(T.isArch64Bit());
512 
513   T.setArch(Triple::hsail64);
514   EXPECT_FALSE(T.isArch16Bit());
515   EXPECT_FALSE(T.isArch32Bit());
516   EXPECT_TRUE(T.isArch64Bit());
517 
518   T.setArch(Triple::spir);
519   EXPECT_FALSE(T.isArch16Bit());
520   EXPECT_TRUE(T.isArch32Bit());
521   EXPECT_FALSE(T.isArch64Bit());
522 
523   T.setArch(Triple::spir64);
524   EXPECT_FALSE(T.isArch16Bit());
525   EXPECT_FALSE(T.isArch32Bit());
526   EXPECT_TRUE(T.isArch64Bit());
527 
528   T.setArch(Triple::sparc);
529   EXPECT_FALSE(T.isArch16Bit());
530   EXPECT_TRUE(T.isArch32Bit());
531   EXPECT_FALSE(T.isArch64Bit());
532 
533   T.setArch(Triple::sparcel);
534   EXPECT_FALSE(T.isArch16Bit());
535   EXPECT_TRUE(T.isArch32Bit());
536   EXPECT_FALSE(T.isArch64Bit());
537 
538   T.setArch(Triple::sparcv9);
539   EXPECT_FALSE(T.isArch16Bit());
540   EXPECT_FALSE(T.isArch32Bit());
541   EXPECT_TRUE(T.isArch64Bit());
542 
543   T.setArch(Triple::wasm32);
544   EXPECT_FALSE(T.isArch16Bit());
545   EXPECT_TRUE(T.isArch32Bit());
546   EXPECT_FALSE(T.isArch64Bit());
547 
548   T.setArch(Triple::wasm64);
549   EXPECT_FALSE(T.isArch16Bit());
550   EXPECT_FALSE(T.isArch32Bit());
551   EXPECT_TRUE(T.isArch64Bit());
552 
553   T.setArch(Triple::avr);
554   EXPECT_TRUE(T.isArch16Bit());
555   EXPECT_FALSE(T.isArch32Bit());
556   EXPECT_FALSE(T.isArch64Bit());
557 
558   T.setArch(Triple::lanai);
559   EXPECT_FALSE(T.isArch16Bit());
560   EXPECT_TRUE(T.isArch32Bit());
561   EXPECT_FALSE(T.isArch64Bit());
562 }
563 
564 TEST(TripleTest, BitWidthArchVariants) {
565   Triple T;
566   EXPECT_EQ(Triple::UnknownArch, T.get32BitArchVariant().getArch());
567   EXPECT_EQ(Triple::UnknownArch, T.get64BitArchVariant().getArch());
568 
569   T.setArch(Triple::UnknownArch);
570   EXPECT_EQ(Triple::UnknownArch, T.get32BitArchVariant().getArch());
571   EXPECT_EQ(Triple::UnknownArch, T.get64BitArchVariant().getArch());
572 
573   T.setArch(Triple::mips);
574   EXPECT_EQ(Triple::mips, T.get32BitArchVariant().getArch());
575   EXPECT_EQ(Triple::mips64, T.get64BitArchVariant().getArch());
576 
577   T.setArch(Triple::mipsel);
578   EXPECT_EQ(Triple::mipsel, T.get32BitArchVariant().getArch());
579   EXPECT_EQ(Triple::mips64el, T.get64BitArchVariant().getArch());
580 
581   T.setArch(Triple::ppc);
582   EXPECT_EQ(Triple::ppc, T.get32BitArchVariant().getArch());
583   EXPECT_EQ(Triple::ppc64, T.get64BitArchVariant().getArch());
584 
585   T.setArch(Triple::nvptx);
586   EXPECT_EQ(Triple::nvptx, T.get32BitArchVariant().getArch());
587   EXPECT_EQ(Triple::nvptx64, T.get64BitArchVariant().getArch());
588 
589   T.setArch(Triple::sparc);
590   EXPECT_EQ(Triple::sparc, T.get32BitArchVariant().getArch());
591   EXPECT_EQ(Triple::sparcv9, T.get64BitArchVariant().getArch());
592 
593   T.setArch(Triple::x86);
594   EXPECT_EQ(Triple::x86, T.get32BitArchVariant().getArch());
595   EXPECT_EQ(Triple::x86_64, T.get64BitArchVariant().getArch());
596 
597   T.setArch(Triple::mips64);
598   EXPECT_EQ(Triple::mips, T.get32BitArchVariant().getArch());
599   EXPECT_EQ(Triple::mips64, T.get64BitArchVariant().getArch());
600 
601   T.setArch(Triple::mips64el);
602   EXPECT_EQ(Triple::mipsel, T.get32BitArchVariant().getArch());
603   EXPECT_EQ(Triple::mips64el, T.get64BitArchVariant().getArch());
604 
605   T.setArch(Triple::ppc64);
606   EXPECT_EQ(Triple::ppc, T.get32BitArchVariant().getArch());
607   EXPECT_EQ(Triple::ppc64, T.get64BitArchVariant().getArch());
608 
609   T.setArch(Triple::nvptx64);
610   EXPECT_EQ(Triple::nvptx, T.get32BitArchVariant().getArch());
611   EXPECT_EQ(Triple::nvptx64, T.get64BitArchVariant().getArch());
612 
613   T.setArch(Triple::sparcv9);
614   EXPECT_EQ(Triple::sparc, T.get32BitArchVariant().getArch());
615   EXPECT_EQ(Triple::sparcv9, T.get64BitArchVariant().getArch());
616 
617   T.setArch(Triple::x86_64);
618   EXPECT_EQ(Triple::x86, T.get32BitArchVariant().getArch());
619   EXPECT_EQ(Triple::x86_64, T.get64BitArchVariant().getArch());
620 
621   T.setArch(Triple::amdil);
622   EXPECT_EQ(Triple::amdil, T.get32BitArchVariant().getArch());
623   EXPECT_EQ(Triple::amdil64, T.get64BitArchVariant().getArch());
624 
625   T.setArch(Triple::amdil64);
626   EXPECT_EQ(Triple::amdil, T.get32BitArchVariant().getArch());
627   EXPECT_EQ(Triple::amdil64, T.get64BitArchVariant().getArch());
628 
629   T.setArch(Triple::hsail);
630   EXPECT_EQ(Triple::hsail, T.get32BitArchVariant().getArch());
631   EXPECT_EQ(Triple::hsail64, T.get64BitArchVariant().getArch());
632 
633   T.setArch(Triple::hsail64);
634   EXPECT_EQ(Triple::hsail, T.get32BitArchVariant().getArch());
635   EXPECT_EQ(Triple::hsail64, T.get64BitArchVariant().getArch());
636 
637   T.setArch(Triple::spir);
638   EXPECT_EQ(Triple::spir, T.get32BitArchVariant().getArch());
639   EXPECT_EQ(Triple::spir64, T.get64BitArchVariant().getArch());
640 
641   T.setArch(Triple::spir64);
642   EXPECT_EQ(Triple::spir, T.get32BitArchVariant().getArch());
643   EXPECT_EQ(Triple::spir64, T.get64BitArchVariant().getArch());
644 
645   T.setArch(Triple::wasm32);
646   EXPECT_EQ(Triple::wasm32, T.get32BitArchVariant().getArch());
647   EXPECT_EQ(Triple::wasm64, T.get64BitArchVariant().getArch());
648 
649   T.setArch(Triple::wasm64);
650   EXPECT_EQ(Triple::wasm32, T.get32BitArchVariant().getArch());
651   EXPECT_EQ(Triple::wasm64, T.get64BitArchVariant().getArch());
652 }
653 
654 TEST(TripleTest, EndianArchVariants) {
655   Triple T;
656   EXPECT_EQ(Triple::UnknownArch, T.getBigEndianArchVariant().getArch());
657   EXPECT_EQ(Triple::UnknownArch, T.getLittleEndianArchVariant().getArch());
658 
659   T.setArch(Triple::UnknownArch);
660   EXPECT_EQ(Triple::UnknownArch, T.getBigEndianArchVariant().getArch());
661   EXPECT_EQ(Triple::UnknownArch, T.getLittleEndianArchVariant().getArch());
662 
663   T.setArch(Triple::aarch64_be);
664   EXPECT_EQ(Triple::aarch64_be, T.getBigEndianArchVariant().getArch());
665   EXPECT_EQ(Triple::aarch64, T.getLittleEndianArchVariant().getArch());
666 
667   T.setArch(Triple::aarch64);
668   EXPECT_EQ(Triple::aarch64_be, T.getBigEndianArchVariant().getArch());
669   EXPECT_EQ(Triple::aarch64, T.getLittleEndianArchVariant().getArch());
670 
671   T.setArch(Triple::armeb);
672   EXPECT_EQ(Triple::armeb, T.getBigEndianArchVariant().getArch());
673   EXPECT_EQ(Triple::UnknownArch, T.getLittleEndianArchVariant().getArch());
674 
675   T.setArch(Triple::arm);
676   EXPECT_EQ(Triple::UnknownArch, T.getBigEndianArchVariant().getArch());
677   EXPECT_EQ(Triple::arm, T.getLittleEndianArchVariant().getArch());
678   T = Triple("arm");
679   EXPECT_TRUE(T.isLittleEndian());
680   T = Triple("thumb");
681   EXPECT_TRUE(T.isLittleEndian());
682   T = Triple("armeb");
683   EXPECT_FALSE(T.isLittleEndian());
684   T = Triple("thumbeb");
685   EXPECT_FALSE(T.isLittleEndian());
686 
687   T.setArch(Triple::bpfeb);
688   EXPECT_EQ(Triple::bpfeb, T.getBigEndianArchVariant().getArch());
689   EXPECT_EQ(Triple::bpfel, T.getLittleEndianArchVariant().getArch());
690 
691   T.setArch(Triple::bpfel);
692   EXPECT_EQ(Triple::bpfeb, T.getBigEndianArchVariant().getArch());
693   EXPECT_EQ(Triple::bpfel, T.getLittleEndianArchVariant().getArch());
694 
695   T.setArch(Triple::mips64);
696   EXPECT_EQ(Triple::mips64, T.getBigEndianArchVariant().getArch());
697   EXPECT_EQ(Triple::mips64el, T.getLittleEndianArchVariant().getArch());
698 
699   T.setArch(Triple::mips64el);
700   EXPECT_EQ(Triple::mips64, T.getBigEndianArchVariant().getArch());
701   EXPECT_EQ(Triple::mips64el, T.getLittleEndianArchVariant().getArch());
702 
703   T.setArch(Triple::mips);
704   EXPECT_EQ(Triple::mips, T.getBigEndianArchVariant().getArch());
705   EXPECT_EQ(Triple::mipsel, T.getLittleEndianArchVariant().getArch());
706 
707   T.setArch(Triple::mipsel);
708   EXPECT_EQ(Triple::mips, T.getBigEndianArchVariant().getArch());
709   EXPECT_EQ(Triple::mipsel, T.getLittleEndianArchVariant().getArch());
710 
711   T.setArch(Triple::ppc);
712   EXPECT_EQ(Triple::ppc, T.getBigEndianArchVariant().getArch());
713   EXPECT_EQ(Triple::UnknownArch, T.getLittleEndianArchVariant().getArch());
714 
715   T.setArch(Triple::ppc64);
716   EXPECT_EQ(Triple::ppc64, T.getBigEndianArchVariant().getArch());
717   EXPECT_EQ(Triple::ppc64le, T.getLittleEndianArchVariant().getArch());
718 
719   T.setArch(Triple::ppc64le);
720   EXPECT_EQ(Triple::ppc64, T.getBigEndianArchVariant().getArch());
721   EXPECT_EQ(Triple::ppc64le, T.getLittleEndianArchVariant().getArch());
722 
723   T.setArch(Triple::sparc);
724   EXPECT_EQ(Triple::sparc, T.getBigEndianArchVariant().getArch());
725   EXPECT_EQ(Triple::sparcel, T.getLittleEndianArchVariant().getArch());
726 
727   T.setArch(Triple::sparcel);
728   EXPECT_EQ(Triple::sparc, T.getBigEndianArchVariant().getArch());
729   EXPECT_EQ(Triple::sparcel, T.getLittleEndianArchVariant().getArch());
730 
731   T.setArch(Triple::thumb);
732   EXPECT_EQ(Triple::UnknownArch, T.getBigEndianArchVariant().getArch());
733   EXPECT_EQ(Triple::thumb, T.getLittleEndianArchVariant().getArch());
734 
735   T.setArch(Triple::thumbeb);
736   EXPECT_EQ(Triple::thumbeb, T.getBigEndianArchVariant().getArch());
737   EXPECT_EQ(Triple::UnknownArch, T.getLittleEndianArchVariant().getArch());
738 
739   T.setArch(Triple::lanai);
740   EXPECT_EQ(Triple::lanai, T.getBigEndianArchVariant().getArch());
741   EXPECT_EQ(Triple::UnknownArch, T.getLittleEndianArchVariant().getArch());
742 }
743 
744 TEST(TripleTest, getOSVersion) {
745   Triple T;
746   unsigned Major, Minor, Micro;
747 
748   T = Triple("i386-apple-darwin9");
749   EXPECT_TRUE(T.isMacOSX());
750   EXPECT_FALSE(T.isiOS());
751   EXPECT_FALSE(T.isArch16Bit());
752   EXPECT_TRUE(T.isArch32Bit());
753   EXPECT_FALSE(T.isArch64Bit());
754   T.getMacOSXVersion(Major, Minor, Micro);
755   EXPECT_EQ((unsigned)10, Major);
756   EXPECT_EQ((unsigned)5, Minor);
757   EXPECT_EQ((unsigned)0, Micro);
758   T.getiOSVersion(Major, Minor, Micro);
759   EXPECT_EQ((unsigned)5, Major);
760   EXPECT_EQ((unsigned)0, Minor);
761   EXPECT_EQ((unsigned)0, Micro);
762 
763   T = Triple("x86_64-apple-darwin9");
764   EXPECT_TRUE(T.isMacOSX());
765   EXPECT_FALSE(T.isiOS());
766   EXPECT_FALSE(T.isArch16Bit());
767   EXPECT_FALSE(T.isArch32Bit());
768   EXPECT_TRUE(T.isArch64Bit());
769   T.getMacOSXVersion(Major, Minor, Micro);
770   EXPECT_EQ((unsigned)10, Major);
771   EXPECT_EQ((unsigned)5, Minor);
772   EXPECT_EQ((unsigned)0, Micro);
773   T.getiOSVersion(Major, Minor, Micro);
774   EXPECT_EQ((unsigned)5, Major);
775   EXPECT_EQ((unsigned)0, Minor);
776   EXPECT_EQ((unsigned)0, Micro);
777 
778   T = Triple("x86_64-apple-macosx");
779   EXPECT_TRUE(T.isMacOSX());
780   EXPECT_FALSE(T.isiOS());
781   EXPECT_FALSE(T.isArch16Bit());
782   EXPECT_FALSE(T.isArch32Bit());
783   EXPECT_TRUE(T.isArch64Bit());
784   T.getMacOSXVersion(Major, Minor, Micro);
785   EXPECT_EQ((unsigned)10, Major);
786   EXPECT_EQ((unsigned)4, Minor);
787   EXPECT_EQ((unsigned)0, Micro);
788   T.getiOSVersion(Major, Minor, Micro);
789   EXPECT_EQ((unsigned)5, Major);
790   EXPECT_EQ((unsigned)0, Minor);
791   EXPECT_EQ((unsigned)0, Micro);
792 
793   T = Triple("x86_64-apple-macosx10.7");
794   EXPECT_TRUE(T.isMacOSX());
795   EXPECT_FALSE(T.isiOS());
796   EXPECT_FALSE(T.isArch16Bit());
797   EXPECT_FALSE(T.isArch32Bit());
798   EXPECT_TRUE(T.isArch64Bit());
799   T.getMacOSXVersion(Major, Minor, Micro);
800   EXPECT_EQ((unsigned)10, Major);
801   EXPECT_EQ((unsigned)7, Minor);
802   EXPECT_EQ((unsigned)0, Micro);
803   T.getiOSVersion(Major, Minor, Micro);
804   EXPECT_EQ((unsigned)5, Major);
805   EXPECT_EQ((unsigned)0, Minor);
806   EXPECT_EQ((unsigned)0, Micro);
807 
808   T = Triple("armv7-apple-ios");
809   EXPECT_FALSE(T.isMacOSX());
810   EXPECT_TRUE(T.isiOS());
811   EXPECT_FALSE(T.isArch16Bit());
812   EXPECT_TRUE(T.isArch32Bit());
813   EXPECT_FALSE(T.isArch64Bit());
814   T.getMacOSXVersion(Major, Minor, Micro);
815   EXPECT_EQ((unsigned)10, Major);
816   EXPECT_EQ((unsigned)4, Minor);
817   EXPECT_EQ((unsigned)0, Micro);
818   T.getiOSVersion(Major, Minor, Micro);
819   EXPECT_EQ((unsigned)5, Major);
820   EXPECT_EQ((unsigned)0, Minor);
821   EXPECT_EQ((unsigned)0, Micro);
822 
823   T = Triple("armv7-apple-ios7.0");
824   EXPECT_FALSE(T.isMacOSX());
825   EXPECT_TRUE(T.isiOS());
826   EXPECT_FALSE(T.isArch16Bit());
827   EXPECT_TRUE(T.isArch32Bit());
828   EXPECT_FALSE(T.isArch64Bit());
829   T.getMacOSXVersion(Major, Minor, Micro);
830   EXPECT_EQ((unsigned)10, Major);
831   EXPECT_EQ((unsigned)4, Minor);
832   EXPECT_EQ((unsigned)0, Micro);
833   T.getiOSVersion(Major, Minor, Micro);
834   EXPECT_EQ((unsigned)7, Major);
835   EXPECT_EQ((unsigned)0, Minor);
836   EXPECT_EQ((unsigned)0, Micro);
837 }
838 
839 TEST(TripleTest, FileFormat) {
840   EXPECT_EQ(Triple::ELF, Triple("i686-unknown-linux-gnu").getObjectFormat());
841   EXPECT_EQ(Triple::ELF, Triple("i686-unknown-freebsd").getObjectFormat());
842   EXPECT_EQ(Triple::ELF, Triple("i686-unknown-netbsd").getObjectFormat());
843   EXPECT_EQ(Triple::ELF, Triple("i686--win32-elf").getObjectFormat());
844   EXPECT_EQ(Triple::ELF, Triple("i686---elf").getObjectFormat());
845 
846   EXPECT_EQ(Triple::MachO, Triple("i686-apple-macosx").getObjectFormat());
847   EXPECT_EQ(Triple::MachO, Triple("i686-apple-ios").getObjectFormat());
848   EXPECT_EQ(Triple::MachO, Triple("i686---macho").getObjectFormat());
849 
850   EXPECT_EQ(Triple::COFF, Triple("i686--win32").getObjectFormat());
851 
852   EXPECT_EQ(Triple::ELF, Triple("i686-pc-windows-msvc-elf").getObjectFormat());
853   EXPECT_EQ(Triple::ELF, Triple("i686-pc-cygwin-elf").getObjectFormat());
854 
855   Triple MSVCNormalized(Triple::normalize("i686-pc-windows-msvc-elf"));
856   EXPECT_EQ(Triple::ELF, MSVCNormalized.getObjectFormat());
857 
858   Triple GNUWindowsNormalized(Triple::normalize("i686-pc-windows-gnu-elf"));
859   EXPECT_EQ(Triple::ELF, GNUWindowsNormalized.getObjectFormat());
860 
861   Triple CygnusNormalised(Triple::normalize("i686-pc-windows-cygnus-elf"));
862   EXPECT_EQ(Triple::ELF, CygnusNormalised.getObjectFormat());
863 
864   Triple CygwinNormalized(Triple::normalize("i686-pc-cygwin-elf"));
865   EXPECT_EQ(Triple::ELF, CygwinNormalized.getObjectFormat());
866 
867   Triple T = Triple("");
868   T.setObjectFormat(Triple::ELF);
869   EXPECT_EQ(Triple::ELF, T.getObjectFormat());
870 }
871 
872 TEST(TripleTest, NormalizeWindows) {
873   EXPECT_EQ("i686-pc-windows-msvc", Triple::normalize("i686-pc-win32"));
874   EXPECT_EQ("i686--windows-msvc", Triple::normalize("i686-win32"));
875   EXPECT_EQ("i686-pc-windows-gnu", Triple::normalize("i686-pc-mingw32"));
876   EXPECT_EQ("i686--windows-gnu", Triple::normalize("i686-mingw32"));
877   EXPECT_EQ("i686-pc-windows-gnu", Triple::normalize("i686-pc-mingw32-w64"));
878   EXPECT_EQ("i686--windows-gnu", Triple::normalize("i686-mingw32-w64"));
879   EXPECT_EQ("i686-pc-windows-cygnus", Triple::normalize("i686-pc-cygwin"));
880   EXPECT_EQ("i686--windows-cygnus", Triple::normalize("i686-cygwin"));
881 
882   EXPECT_EQ("x86_64-pc-windows-msvc", Triple::normalize("x86_64-pc-win32"));
883   EXPECT_EQ("x86_64--windows-msvc", Triple::normalize("x86_64-win32"));
884   EXPECT_EQ("x86_64-pc-windows-gnu", Triple::normalize("x86_64-pc-mingw32"));
885   EXPECT_EQ("x86_64--windows-gnu", Triple::normalize("x86_64-mingw32"));
886   EXPECT_EQ("x86_64-pc-windows-gnu", Triple::normalize("x86_64-pc-mingw32-w64"));
887   EXPECT_EQ("x86_64--windows-gnu", Triple::normalize("x86_64-mingw32-w64"));
888 
889   EXPECT_EQ("i686-pc-windows-elf", Triple::normalize("i686-pc-win32-elf"));
890   EXPECT_EQ("i686--windows-elf", Triple::normalize("i686-win32-elf"));
891   EXPECT_EQ("i686-pc-windows-macho", Triple::normalize("i686-pc-win32-macho"));
892   EXPECT_EQ("i686--windows-macho", Triple::normalize("i686-win32-macho"));
893 
894   EXPECT_EQ("x86_64-pc-windows-elf", Triple::normalize("x86_64-pc-win32-elf"));
895   EXPECT_EQ("x86_64--windows-elf", Triple::normalize("x86_64-win32-elf"));
896   EXPECT_EQ("x86_64-pc-windows-macho", Triple::normalize("x86_64-pc-win32-macho"));
897   EXPECT_EQ("x86_64--windows-macho", Triple::normalize("x86_64-win32-macho"));
898 
899   EXPECT_EQ("i686-pc-windows-cygnus",
900             Triple::normalize("i686-pc-windows-cygnus"));
901   EXPECT_EQ("i686-pc-windows-gnu", Triple::normalize("i686-pc-windows-gnu"));
902   EXPECT_EQ("i686-pc-windows-itanium", Triple::normalize("i686-pc-windows-itanium"));
903   EXPECT_EQ("i686-pc-windows-msvc", Triple::normalize("i686-pc-windows-msvc"));
904 
905   EXPECT_EQ("i686-pc-windows-elf", Triple::normalize("i686-pc-windows-elf-elf"));
906 }
907 
908 TEST(TripleTest, getARMCPUForArch) {
909   // Platform specific defaults.
910   {
911     llvm::Triple Triple("arm--nacl");
912     EXPECT_EQ("cortex-a8", Triple.getARMCPUForArch());
913   }
914   {
915     llvm::Triple Triple("armv6-unknown-freebsd");
916     EXPECT_EQ("arm1176jzf-s", Triple.getARMCPUForArch());
917   }
918   {
919     llvm::Triple Triple("thumbv6-unknown-freebsd");
920     EXPECT_EQ("arm1176jzf-s", Triple.getARMCPUForArch());
921   }
922   {
923     llvm::Triple Triple("armebv6-unknown-freebsd");
924     EXPECT_EQ("arm1176jzf-s", Triple.getARMCPUForArch());
925   }
926   {
927     llvm::Triple Triple("arm--win32");
928     EXPECT_EQ("cortex-a9", Triple.getARMCPUForArch());
929   }
930   // Some alternative architectures
931   {
932     llvm::Triple Triple("armv7k-apple-ios9");
933     EXPECT_EQ("cortex-a7", Triple.getARMCPUForArch());
934   }
935   {
936     llvm::Triple Triple("armv7k-apple-watchos3");
937     EXPECT_EQ("cortex-a7", Triple.getARMCPUForArch());
938   }
939   {
940     llvm::Triple Triple("armv7k-apple-tvos9");
941     EXPECT_EQ("cortex-a7", Triple.getARMCPUForArch());
942   }
943   // armeb is permitted, but armebeb is not
944   {
945     llvm::Triple Triple("armeb-none-eabi");
946     EXPECT_EQ("arm7tdmi", Triple.getARMCPUForArch());
947   }
948   {
949     llvm::Triple Triple("armebeb-none-eabi");
950     EXPECT_EQ("", Triple.getARMCPUForArch());
951   }
952   {
953     llvm::Triple Triple("armebv6eb-none-eabi");
954     EXPECT_EQ("", Triple.getARMCPUForArch());
955   }
956   // xscaleeb is permitted, but armebxscale is not
957   {
958     llvm::Triple Triple("xscaleeb-none-eabi");
959     EXPECT_EQ("xscale", Triple.getARMCPUForArch());
960   }
961   {
962     llvm::Triple Triple("armebxscale-none-eabi");
963     EXPECT_EQ("", Triple.getARMCPUForArch());
964   }
965 }
966 
967 TEST(TripleTest, NormalizeARM) {
968   EXPECT_EQ("armv6--netbsd-eabi", Triple::normalize("armv6-netbsd-eabi"));
969   EXPECT_EQ("armv7--netbsd-eabi", Triple::normalize("armv7-netbsd-eabi"));
970   EXPECT_EQ("armv6eb--netbsd-eabi", Triple::normalize("armv6eb-netbsd-eabi"));
971   EXPECT_EQ("armv7eb--netbsd-eabi", Triple::normalize("armv7eb-netbsd-eabi"));
972   EXPECT_EQ("armv6--netbsd-eabihf", Triple::normalize("armv6-netbsd-eabihf"));
973   EXPECT_EQ("armv7--netbsd-eabihf", Triple::normalize("armv7-netbsd-eabihf"));
974   EXPECT_EQ("armv6eb--netbsd-eabihf", Triple::normalize("armv6eb-netbsd-eabihf"));
975   EXPECT_EQ("armv7eb--netbsd-eabihf", Triple::normalize("armv7eb-netbsd-eabihf"));
976 
977   Triple T;
978   T = Triple("armv6--netbsd-eabi");
979   EXPECT_EQ(Triple::arm, T.getArch());
980   T = Triple("armv6eb--netbsd-eabi");
981   EXPECT_EQ(Triple::armeb, T.getArch());
982 }
983 
984 TEST(TripleTest, ParseARMArch) {
985   // ARM
986   {
987     Triple T = Triple("arm");
988     EXPECT_EQ(Triple::arm, T.getArch());
989   }
990   {
991     Triple T = Triple("armeb");
992     EXPECT_EQ(Triple::armeb, T.getArch());
993   }
994   // THUMB
995   {
996     Triple T = Triple("thumb");
997     EXPECT_EQ(Triple::thumb, T.getArch());
998   }
999   {
1000     Triple T = Triple("thumbeb");
1001     EXPECT_EQ(Triple::thumbeb, T.getArch());
1002   }
1003   // AARCH64
1004   {
1005     Triple T = Triple("arm64");
1006     EXPECT_EQ(Triple::aarch64, T.getArch());
1007   }
1008   {
1009     Triple T = Triple("aarch64");
1010     EXPECT_EQ(Triple::aarch64, T.getArch());
1011   }
1012   {
1013     Triple T = Triple("aarch64_be");
1014     EXPECT_EQ(Triple::aarch64_be, T.getArch());
1015   }
1016 }
1017 } // end anonymous namespace
1018