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