• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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  
TEST(TripleTest,BasicParsing)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  
TEST(TripleTest,ParsedIDs)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("x86_64-pc-linux-gnu");
85    EXPECT_EQ(Triple::x86_64, T.getArch());
86    EXPECT_EQ(Triple::PC, T.getVendor());
87    EXPECT_EQ(Triple::Linux, T.getOS());
88    EXPECT_EQ(Triple::GNU, T.getEnvironment());
89  
90    T = Triple("powerpc-bgp-linux");
91    EXPECT_EQ(Triple::ppc, T.getArch());
92    EXPECT_EQ(Triple::BGP, T.getVendor());
93    EXPECT_EQ(Triple::Linux, T.getOS());
94    EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
95  
96    T = Triple("powerpc-bgp-cnk");
97    EXPECT_EQ(Triple::ppc, T.getArch());
98    EXPECT_EQ(Triple::BGP, T.getVendor());
99    EXPECT_EQ(Triple::CNK, T.getOS());
100    EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
101  
102    T = Triple("powerpc64-bgq-linux");
103    EXPECT_EQ(Triple::ppc64, T.getArch());
104    EXPECT_EQ(Triple::BGQ, T.getVendor());
105    EXPECT_EQ(Triple::Linux, T.getOS());
106    EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
107  
108    T = Triple("powerpc-ibm-aix");
109    EXPECT_EQ(Triple::ppc, T.getArch());
110    EXPECT_EQ(Triple::IBM, T.getVendor());
111    EXPECT_EQ(Triple::AIX, T.getOS());
112    EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
113  
114    T = Triple("powerpc64-ibm-aix");
115    EXPECT_EQ(Triple::ppc64, T.getArch());
116    EXPECT_EQ(Triple::IBM, T.getVendor());
117    EXPECT_EQ(Triple::AIX, T.getOS());
118    EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
119  
120    T = Triple("powerpc-dunno-notsure");
121    EXPECT_EQ(Triple::ppc, T.getArch());
122    EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
123    EXPECT_EQ(Triple::UnknownOS, T.getOS());
124    EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
125  
126    T = Triple("arm-none-none-eabi");
127    EXPECT_EQ(Triple::arm, T.getArch());
128    EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
129    EXPECT_EQ(Triple::UnknownOS, T.getOS());
130    EXPECT_EQ(Triple::EABI, T.getEnvironment());
131  
132    T = Triple("amdil-unknown-unknown");
133    EXPECT_EQ(Triple::amdil, T.getArch());
134    EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
135    EXPECT_EQ(Triple::UnknownOS, T.getOS());
136  
137    T = Triple("amdil64-unknown-unknown");
138    EXPECT_EQ(Triple::amdil64, T.getArch());
139    EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
140    EXPECT_EQ(Triple::UnknownOS, T.getOS());
141  
142    T = Triple("hsail-unknown-unknown");
143    EXPECT_EQ(Triple::hsail, T.getArch());
144    EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
145    EXPECT_EQ(Triple::UnknownOS, T.getOS());
146  
147    T = Triple("hsail64-unknown-unknown");
148    EXPECT_EQ(Triple::hsail64, T.getArch());
149    EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
150    EXPECT_EQ(Triple::UnknownOS, T.getOS());
151  
152    T = Triple("spir-unknown-unknown");
153    EXPECT_EQ(Triple::spir, T.getArch());
154    EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
155    EXPECT_EQ(Triple::UnknownOS, T.getOS());
156  
157    T = Triple("spir64-unknown-unknown");
158    EXPECT_EQ(Triple::spir64, T.getArch());
159    EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
160    EXPECT_EQ(Triple::UnknownOS, T.getOS());
161  
162    T = Triple("x86_64-unknown-cloudabi");
163    EXPECT_EQ(Triple::x86_64, T.getArch());
164    EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
165    EXPECT_EQ(Triple::CloudABI, T.getOS());
166    EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
167  
168    T = Triple("huh");
169    EXPECT_EQ(Triple::UnknownArch, T.getArch());
170  }
171  
Join(StringRef A,StringRef B,StringRef C)172  static std::string Join(StringRef A, StringRef B, StringRef C) {
173    std::string Str = A; Str += '-'; Str += B; Str += '-'; Str += C;
174    return Str;
175  }
176  
Join(StringRef A,StringRef B,StringRef C,StringRef D)177  static std::string Join(StringRef A, StringRef B, StringRef C, StringRef D) {
178    std::string Str = A; Str += '-'; Str += B; Str += '-'; Str += C; Str += '-';
179    Str += D; return Str;
180  }
181  
TEST(TripleTest,Normalization)182  TEST(TripleTest, Normalization) {
183  
184    EXPECT_EQ("", Triple::normalize(""));
185    EXPECT_EQ("-", Triple::normalize("-"));
186    EXPECT_EQ("--", Triple::normalize("--"));
187    EXPECT_EQ("---", Triple::normalize("---"));
188    EXPECT_EQ("----", Triple::normalize("----"));
189  
190    EXPECT_EQ("a", Triple::normalize("a"));
191    EXPECT_EQ("a-b", Triple::normalize("a-b"));
192    EXPECT_EQ("a-b-c", Triple::normalize("a-b-c"));
193    EXPECT_EQ("a-b-c-d", Triple::normalize("a-b-c-d"));
194  
195    EXPECT_EQ("i386-b-c", Triple::normalize("i386-b-c"));
196    EXPECT_EQ("i386-a-c", Triple::normalize("a-i386-c"));
197    EXPECT_EQ("i386-a-b", Triple::normalize("a-b-i386"));
198    EXPECT_EQ("i386-a-b-c", Triple::normalize("a-b-c-i386"));
199  
200    EXPECT_EQ("a-pc-c", Triple::normalize("a-pc-c"));
201    EXPECT_EQ("-pc-b-c", Triple::normalize("pc-b-c"));
202    EXPECT_EQ("a-pc-b", Triple::normalize("a-b-pc"));
203    EXPECT_EQ("a-pc-b-c", Triple::normalize("a-b-c-pc"));
204  
205    EXPECT_EQ("a-b-linux", Triple::normalize("a-b-linux"));
206    EXPECT_EQ("--linux-b-c", Triple::normalize("linux-b-c"));
207    EXPECT_EQ("a--linux-c", Triple::normalize("a-linux-c"));
208  
209    EXPECT_EQ("i386-pc-a", Triple::normalize("a-pc-i386"));
210    EXPECT_EQ("i386-pc-", Triple::normalize("-pc-i386"));
211    EXPECT_EQ("-pc-linux-c", Triple::normalize("linux-pc-c"));
212    EXPECT_EQ("-pc-linux", Triple::normalize("linux-pc-"));
213  
214    EXPECT_EQ("i386", Triple::normalize("i386"));
215    EXPECT_EQ("-pc", Triple::normalize("pc"));
216    EXPECT_EQ("--linux", Triple::normalize("linux"));
217  
218    EXPECT_EQ("x86_64--linux-gnu", Triple::normalize("x86_64-gnu-linux"));
219  
220    // Check that normalizing a permutated set of valid components returns a
221    // triple with the unpermuted components.
222    StringRef C[4];
223    for (int Arch = 1+Triple::UnknownArch; Arch <= Triple::amdil; ++Arch) {
224      C[0] = Triple::getArchTypeName(Triple::ArchType(Arch));
225      for (int Vendor = 1+Triple::UnknownVendor; Vendor <= Triple::PC;
226           ++Vendor) {
227        C[1] = Triple::getVendorTypeName(Triple::VendorType(Vendor));
228        for (int OS = 1+Triple::UnknownOS; OS <= Triple::Minix; ++OS) {
229          if (OS == Triple::Win32)
230            continue;
231  
232          C[2] = Triple::getOSTypeName(Triple::OSType(OS));
233  
234          std::string E = Join(C[0], C[1], C[2]);
235          EXPECT_EQ(E, Triple::normalize(Join(C[0], C[1], C[2])));
236  
237          EXPECT_EQ(E, Triple::normalize(Join(C[0], C[2], C[1])));
238          EXPECT_EQ(E, Triple::normalize(Join(C[1], C[2], C[0])));
239          EXPECT_EQ(E, Triple::normalize(Join(C[1], C[0], C[2])));
240          EXPECT_EQ(E, Triple::normalize(Join(C[2], C[0], C[1])));
241          EXPECT_EQ(E, Triple::normalize(Join(C[2], C[1], C[0])));
242  
243          for (int Env = 1 + Triple::UnknownEnvironment; Env <= Triple::Android;
244               ++Env) {
245            C[3] = Triple::getEnvironmentTypeName(Triple::EnvironmentType(Env));
246  
247            std::string F = Join(C[0], C[1], C[2], C[3]);
248            EXPECT_EQ(F, Triple::normalize(Join(C[0], C[1], C[2], C[3])));
249  
250            EXPECT_EQ(F, Triple::normalize(Join(C[0], C[1], C[3], C[2])));
251            EXPECT_EQ(F, Triple::normalize(Join(C[0], C[2], C[3], C[1])));
252            EXPECT_EQ(F, Triple::normalize(Join(C[0], C[2], C[1], C[3])));
253            EXPECT_EQ(F, Triple::normalize(Join(C[0], C[3], C[1], C[2])));
254            EXPECT_EQ(F, Triple::normalize(Join(C[0], C[3], C[2], C[1])));
255            EXPECT_EQ(F, Triple::normalize(Join(C[1], C[2], C[3], C[0])));
256            EXPECT_EQ(F, Triple::normalize(Join(C[1], C[2], C[0], C[3])));
257            EXPECT_EQ(F, Triple::normalize(Join(C[1], C[3], C[0], C[2])));
258            EXPECT_EQ(F, Triple::normalize(Join(C[1], C[3], C[2], C[0])));
259            EXPECT_EQ(F, Triple::normalize(Join(C[1], C[0], C[2], C[3])));
260            EXPECT_EQ(F, Triple::normalize(Join(C[1], C[0], C[3], C[2])));
261            EXPECT_EQ(F, Triple::normalize(Join(C[2], C[3], C[0], C[1])));
262            EXPECT_EQ(F, Triple::normalize(Join(C[2], C[3], C[1], C[0])));
263            EXPECT_EQ(F, Triple::normalize(Join(C[2], C[0], C[1], C[3])));
264            EXPECT_EQ(F, Triple::normalize(Join(C[2], C[0], C[3], C[1])));
265            EXPECT_EQ(F, Triple::normalize(Join(C[2], C[1], C[3], C[0])));
266            EXPECT_EQ(F, Triple::normalize(Join(C[2], C[1], C[0], C[3])));
267            EXPECT_EQ(F, Triple::normalize(Join(C[3], C[0], C[1], C[2])));
268            EXPECT_EQ(F, Triple::normalize(Join(C[3], C[0], C[2], C[1])));
269            EXPECT_EQ(F, Triple::normalize(Join(C[3], C[1], C[2], C[0])));
270            EXPECT_EQ(F, Triple::normalize(Join(C[3], C[1], C[0], C[2])));
271            EXPECT_EQ(F, Triple::normalize(Join(C[3], C[2], C[0], C[1])));
272            EXPECT_EQ(F, Triple::normalize(Join(C[3], C[2], C[1], C[0])));
273          }
274        }
275      }
276    }
277  
278    // Various real-world funky triples.  The value returned by GCC's config.sub
279    // is given in the comment.
280    EXPECT_EQ("i386--windows-gnu", Triple::normalize("i386-mingw32")); // i386-pc-mingw32
281    EXPECT_EQ("x86_64--linux-gnu", Triple::normalize("x86_64-linux-gnu")); // x86_64-pc-linux-gnu
282    EXPECT_EQ("i486--linux-gnu", Triple::normalize("i486-linux-gnu")); // i486-pc-linux-gnu
283    EXPECT_EQ("i386-redhat-linux", Triple::normalize("i386-redhat-linux")); // i386-redhat-linux-gnu
284    EXPECT_EQ("i686--linux", Triple::normalize("i686-linux")); // i686-pc-linux-gnu
285    EXPECT_EQ("arm-none--eabi", Triple::normalize("arm-none-eabi")); // arm-none-eabi
286  }
287  
TEST(TripleTest,MutateName)288  TEST(TripleTest, MutateName) {
289    Triple T;
290    EXPECT_EQ(Triple::UnknownArch, T.getArch());
291    EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
292    EXPECT_EQ(Triple::UnknownOS, T.getOS());
293    EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
294  
295    T.setArchName("i386");
296    EXPECT_EQ(Triple::x86, T.getArch());
297    EXPECT_EQ("i386--", T.getTriple());
298  
299    T.setVendorName("pc");
300    EXPECT_EQ(Triple::x86, T.getArch());
301    EXPECT_EQ(Triple::PC, T.getVendor());
302    EXPECT_EQ("i386-pc-", T.getTriple());
303  
304    T.setOSName("linux");
305    EXPECT_EQ(Triple::x86, T.getArch());
306    EXPECT_EQ(Triple::PC, T.getVendor());
307    EXPECT_EQ(Triple::Linux, T.getOS());
308    EXPECT_EQ("i386-pc-linux", T.getTriple());
309  
310    T.setEnvironmentName("gnu");
311    EXPECT_EQ(Triple::x86, T.getArch());
312    EXPECT_EQ(Triple::PC, T.getVendor());
313    EXPECT_EQ(Triple::Linux, T.getOS());
314    EXPECT_EQ("i386-pc-linux-gnu", T.getTriple());
315  
316    T.setOSName("freebsd");
317    EXPECT_EQ(Triple::x86, T.getArch());
318    EXPECT_EQ(Triple::PC, T.getVendor());
319    EXPECT_EQ(Triple::FreeBSD, T.getOS());
320    EXPECT_EQ("i386-pc-freebsd-gnu", T.getTriple());
321  
322    T.setOSAndEnvironmentName("darwin");
323    EXPECT_EQ(Triple::x86, T.getArch());
324    EXPECT_EQ(Triple::PC, T.getVendor());
325    EXPECT_EQ(Triple::Darwin, T.getOS());
326    EXPECT_EQ("i386-pc-darwin", T.getTriple());
327  
328  }
329  
TEST(TripleTest,BitWidthPredicates)330  TEST(TripleTest, BitWidthPredicates) {
331    Triple T;
332    EXPECT_FALSE(T.isArch16Bit());
333    EXPECT_FALSE(T.isArch32Bit());
334    EXPECT_FALSE(T.isArch64Bit());
335  
336    T.setArch(Triple::arm);
337    EXPECT_FALSE(T.isArch16Bit());
338    EXPECT_TRUE(T.isArch32Bit());
339    EXPECT_FALSE(T.isArch64Bit());
340  
341    T.setArch(Triple::hexagon);
342    EXPECT_FALSE(T.isArch16Bit());
343    EXPECT_TRUE(T.isArch32Bit());
344    EXPECT_FALSE(T.isArch64Bit());
345  
346    T.setArch(Triple::mips);
347    EXPECT_FALSE(T.isArch16Bit());
348    EXPECT_TRUE(T.isArch32Bit());
349    EXPECT_FALSE(T.isArch64Bit());
350  
351    T.setArch(Triple::mips64);
352    EXPECT_FALSE(T.isArch16Bit());
353    EXPECT_FALSE(T.isArch32Bit());
354    EXPECT_TRUE(T.isArch64Bit());
355  
356    T.setArch(Triple::msp430);
357    EXPECT_TRUE(T.isArch16Bit());
358    EXPECT_FALSE(T.isArch32Bit());
359    EXPECT_FALSE(T.isArch64Bit());
360  
361    T.setArch(Triple::ppc);
362    EXPECT_FALSE(T.isArch16Bit());
363    EXPECT_TRUE(T.isArch32Bit());
364    EXPECT_FALSE(T.isArch64Bit());
365  
366    T.setArch(Triple::ppc64);
367    EXPECT_FALSE(T.isArch16Bit());
368    EXPECT_FALSE(T.isArch32Bit());
369    EXPECT_TRUE(T.isArch64Bit());
370  
371    T.setArch(Triple::x86);
372    EXPECT_FALSE(T.isArch16Bit());
373    EXPECT_TRUE(T.isArch32Bit());
374    EXPECT_FALSE(T.isArch64Bit());
375  
376    T.setArch(Triple::x86_64);
377    EXPECT_FALSE(T.isArch16Bit());
378    EXPECT_FALSE(T.isArch32Bit());
379    EXPECT_TRUE(T.isArch64Bit());
380  
381    T.setArch(Triple::amdil);
382    EXPECT_FALSE(T.isArch16Bit());
383    EXPECT_TRUE(T.isArch32Bit());
384    EXPECT_FALSE(T.isArch64Bit());
385  
386    T.setArch(Triple::amdil64);
387    EXPECT_FALSE(T.isArch16Bit());
388    EXPECT_FALSE(T.isArch32Bit());
389    EXPECT_TRUE(T.isArch64Bit());
390  
391    T.setArch(Triple::hsail);
392    EXPECT_FALSE(T.isArch16Bit());
393    EXPECT_TRUE(T.isArch32Bit());
394    EXPECT_FALSE(T.isArch64Bit());
395  
396    T.setArch(Triple::hsail64);
397    EXPECT_FALSE(T.isArch16Bit());
398    EXPECT_FALSE(T.isArch32Bit());
399    EXPECT_TRUE(T.isArch64Bit());
400  
401    T.setArch(Triple::spir);
402    EXPECT_FALSE(T.isArch16Bit());
403    EXPECT_TRUE(T.isArch32Bit());
404    EXPECT_FALSE(T.isArch64Bit());
405  
406    T.setArch(Triple::spir64);
407    EXPECT_FALSE(T.isArch16Bit());
408    EXPECT_FALSE(T.isArch32Bit());
409    EXPECT_TRUE(T.isArch64Bit());
410  }
411  
TEST(TripleTest,BitWidthArchVariants)412  TEST(TripleTest, BitWidthArchVariants) {
413    Triple T;
414    EXPECT_EQ(Triple::UnknownArch, T.get32BitArchVariant().getArch());
415    EXPECT_EQ(Triple::UnknownArch, T.get64BitArchVariant().getArch());
416  
417    T.setArch(Triple::UnknownArch);
418    EXPECT_EQ(Triple::UnknownArch, T.get32BitArchVariant().getArch());
419    EXPECT_EQ(Triple::UnknownArch, T.get64BitArchVariant().getArch());
420  
421    T.setArch(Triple::mips);
422    EXPECT_EQ(Triple::mips, T.get32BitArchVariant().getArch());
423    EXPECT_EQ(Triple::mips64, T.get64BitArchVariant().getArch());
424  
425    T.setArch(Triple::mipsel);
426    EXPECT_EQ(Triple::mipsel, T.get32BitArchVariant().getArch());
427    EXPECT_EQ(Triple::mips64el, T.get64BitArchVariant().getArch());
428  
429    T.setArch(Triple::ppc);
430    EXPECT_EQ(Triple::ppc, T.get32BitArchVariant().getArch());
431    EXPECT_EQ(Triple::ppc64, T.get64BitArchVariant().getArch());
432  
433    T.setArch(Triple::nvptx);
434    EXPECT_EQ(Triple::nvptx, T.get32BitArchVariant().getArch());
435    EXPECT_EQ(Triple::nvptx64, T.get64BitArchVariant().getArch());
436  
437    T.setArch(Triple::sparc);
438    EXPECT_EQ(Triple::sparc, T.get32BitArchVariant().getArch());
439    EXPECT_EQ(Triple::sparcv9, T.get64BitArchVariant().getArch());
440  
441    T.setArch(Triple::x86);
442    EXPECT_EQ(Triple::x86, T.get32BitArchVariant().getArch());
443    EXPECT_EQ(Triple::x86_64, T.get64BitArchVariant().getArch());
444  
445    T.setArch(Triple::mips64);
446    EXPECT_EQ(Triple::mips, T.get32BitArchVariant().getArch());
447    EXPECT_EQ(Triple::mips64, T.get64BitArchVariant().getArch());
448  
449    T.setArch(Triple::mips64el);
450    EXPECT_EQ(Triple::mipsel, T.get32BitArchVariant().getArch());
451    EXPECT_EQ(Triple::mips64el, T.get64BitArchVariant().getArch());
452  
453    T.setArch(Triple::ppc64);
454    EXPECT_EQ(Triple::ppc, T.get32BitArchVariant().getArch());
455    EXPECT_EQ(Triple::ppc64, T.get64BitArchVariant().getArch());
456  
457    T.setArch(Triple::nvptx64);
458    EXPECT_EQ(Triple::nvptx, T.get32BitArchVariant().getArch());
459    EXPECT_EQ(Triple::nvptx64, T.get64BitArchVariant().getArch());
460  
461    T.setArch(Triple::sparcv9);
462    EXPECT_EQ(Triple::sparc, T.get32BitArchVariant().getArch());
463    EXPECT_EQ(Triple::sparcv9, T.get64BitArchVariant().getArch());
464  
465    T.setArch(Triple::x86_64);
466    EXPECT_EQ(Triple::x86, T.get32BitArchVariant().getArch());
467    EXPECT_EQ(Triple::x86_64, T.get64BitArchVariant().getArch());
468  
469    T.setArch(Triple::amdil);
470    EXPECT_EQ(Triple::amdil, T.get32BitArchVariant().getArch());
471    EXPECT_EQ(Triple::amdil64, T.get64BitArchVariant().getArch());
472  
473    T.setArch(Triple::amdil64);
474    EXPECT_EQ(Triple::amdil, T.get32BitArchVariant().getArch());
475    EXPECT_EQ(Triple::amdil64, T.get64BitArchVariant().getArch());
476  
477    T.setArch(Triple::hsail);
478    EXPECT_EQ(Triple::hsail, T.get32BitArchVariant().getArch());
479    EXPECT_EQ(Triple::hsail64, T.get64BitArchVariant().getArch());
480  
481    T.setArch(Triple::hsail64);
482    EXPECT_EQ(Triple::hsail, T.get32BitArchVariant().getArch());
483    EXPECT_EQ(Triple::hsail64, T.get64BitArchVariant().getArch());
484  
485    T.setArch(Triple::spir);
486    EXPECT_EQ(Triple::spir, T.get32BitArchVariant().getArch());
487    EXPECT_EQ(Triple::spir64, T.get64BitArchVariant().getArch());
488  
489    T.setArch(Triple::spir64);
490    EXPECT_EQ(Triple::spir, T.get32BitArchVariant().getArch());
491    EXPECT_EQ(Triple::spir64, T.get64BitArchVariant().getArch());
492  }
493  
TEST(TripleTest,getOSVersion)494  TEST(TripleTest, getOSVersion) {
495    Triple T;
496    unsigned Major, Minor, Micro;
497  
498    T = Triple("i386-apple-darwin9");
499    EXPECT_TRUE(T.isMacOSX());
500    EXPECT_FALSE(T.isiOS());
501    EXPECT_FALSE(T.isArch16Bit());
502    EXPECT_TRUE(T.isArch32Bit());
503    EXPECT_FALSE(T.isArch64Bit());
504    T.getMacOSXVersion(Major, Minor, Micro);
505    EXPECT_EQ((unsigned)10, Major);
506    EXPECT_EQ((unsigned)5, Minor);
507    EXPECT_EQ((unsigned)0, Micro);
508    T.getiOSVersion(Major, Minor, Micro);
509    EXPECT_EQ((unsigned)5, Major);
510    EXPECT_EQ((unsigned)0, Minor);
511    EXPECT_EQ((unsigned)0, Micro);
512  
513    T = Triple("x86_64-apple-darwin9");
514    EXPECT_TRUE(T.isMacOSX());
515    EXPECT_FALSE(T.isiOS());
516    EXPECT_FALSE(T.isArch16Bit());
517    EXPECT_FALSE(T.isArch32Bit());
518    EXPECT_TRUE(T.isArch64Bit());
519    T.getMacOSXVersion(Major, Minor, Micro);
520    EXPECT_EQ((unsigned)10, Major);
521    EXPECT_EQ((unsigned)5, Minor);
522    EXPECT_EQ((unsigned)0, Micro);
523    T.getiOSVersion(Major, Minor, Micro);
524    EXPECT_EQ((unsigned)5, Major);
525    EXPECT_EQ((unsigned)0, Minor);
526    EXPECT_EQ((unsigned)0, Micro);
527  
528    T = Triple("x86_64-apple-macosx");
529    EXPECT_TRUE(T.isMacOSX());
530    EXPECT_FALSE(T.isiOS());
531    EXPECT_FALSE(T.isArch16Bit());
532    EXPECT_FALSE(T.isArch32Bit());
533    EXPECT_TRUE(T.isArch64Bit());
534    T.getMacOSXVersion(Major, Minor, Micro);
535    EXPECT_EQ((unsigned)10, Major);
536    EXPECT_EQ((unsigned)4, Minor);
537    EXPECT_EQ((unsigned)0, Micro);
538    T.getiOSVersion(Major, Minor, Micro);
539    EXPECT_EQ((unsigned)5, Major);
540    EXPECT_EQ((unsigned)0, Minor);
541    EXPECT_EQ((unsigned)0, Micro);
542  
543    T = Triple("x86_64-apple-macosx10.7");
544    EXPECT_TRUE(T.isMacOSX());
545    EXPECT_FALSE(T.isiOS());
546    EXPECT_FALSE(T.isArch16Bit());
547    EXPECT_FALSE(T.isArch32Bit());
548    EXPECT_TRUE(T.isArch64Bit());
549    T.getMacOSXVersion(Major, Minor, Micro);
550    EXPECT_EQ((unsigned)10, Major);
551    EXPECT_EQ((unsigned)7, Minor);
552    EXPECT_EQ((unsigned)0, Micro);
553    T.getiOSVersion(Major, Minor, Micro);
554    EXPECT_EQ((unsigned)5, Major);
555    EXPECT_EQ((unsigned)0, Minor);
556    EXPECT_EQ((unsigned)0, Micro);
557  
558    T = Triple("armv7-apple-ios");
559    EXPECT_FALSE(T.isMacOSX());
560    EXPECT_TRUE(T.isiOS());
561    EXPECT_FALSE(T.isArch16Bit());
562    EXPECT_TRUE(T.isArch32Bit());
563    EXPECT_FALSE(T.isArch64Bit());
564    T.getMacOSXVersion(Major, Minor, Micro);
565    EXPECT_EQ((unsigned)10, Major);
566    EXPECT_EQ((unsigned)4, Minor);
567    EXPECT_EQ((unsigned)0, Micro);
568    T.getiOSVersion(Major, Minor, Micro);
569    EXPECT_EQ((unsigned)5, Major);
570    EXPECT_EQ((unsigned)0, Minor);
571    EXPECT_EQ((unsigned)0, Micro);
572  
573    T = Triple("armv7-apple-ios7.0");
574    EXPECT_FALSE(T.isMacOSX());
575    EXPECT_TRUE(T.isiOS());
576    EXPECT_FALSE(T.isArch16Bit());
577    EXPECT_TRUE(T.isArch32Bit());
578    EXPECT_FALSE(T.isArch64Bit());
579    T.getMacOSXVersion(Major, Minor, Micro);
580    EXPECT_EQ((unsigned)10, Major);
581    EXPECT_EQ((unsigned)4, Minor);
582    EXPECT_EQ((unsigned)0, Micro);
583    T.getiOSVersion(Major, Minor, Micro);
584    EXPECT_EQ((unsigned)7, Major);
585    EXPECT_EQ((unsigned)0, Minor);
586    EXPECT_EQ((unsigned)0, Micro);
587  }
588  
TEST(TripleTest,FileFormat)589  TEST(TripleTest, FileFormat) {
590    EXPECT_EQ(Triple::ELF, Triple("i686-unknown-linux-gnu").getObjectFormat());
591    EXPECT_EQ(Triple::ELF, Triple("i686-unknown-freebsd").getObjectFormat());
592    EXPECT_EQ(Triple::ELF, Triple("i686-unknown-netbsd").getObjectFormat());
593    EXPECT_EQ(Triple::ELF, Triple("i686--win32-elf").getObjectFormat());
594    EXPECT_EQ(Triple::ELF, Triple("i686---elf").getObjectFormat());
595  
596    EXPECT_EQ(Triple::MachO, Triple("i686-apple-macosx").getObjectFormat());
597    EXPECT_EQ(Triple::MachO, Triple("i686-apple-ios").getObjectFormat());
598    EXPECT_EQ(Triple::MachO, Triple("i686---macho").getObjectFormat());
599  
600    EXPECT_EQ(Triple::COFF, Triple("i686--win32").getObjectFormat());
601  
602    EXPECT_EQ(Triple::ELF, Triple("i686-pc-windows-msvc-elf").getObjectFormat());
603    EXPECT_EQ(Triple::ELF, Triple("i686-pc-cygwin-elf").getObjectFormat());
604  
605    Triple MSVCNormalized(Triple::normalize("i686-pc-windows-msvc-elf"));
606    EXPECT_EQ(Triple::ELF, MSVCNormalized.getObjectFormat());
607  
608    Triple GNUWindowsNormalized(Triple::normalize("i686-pc-windows-gnu-elf"));
609    EXPECT_EQ(Triple::ELF, GNUWindowsNormalized.getObjectFormat());
610  
611    Triple CygnusNormalised(Triple::normalize("i686-pc-windows-cygnus-elf"));
612    EXPECT_EQ(Triple::ELF, CygnusNormalised.getObjectFormat());
613  
614    Triple CygwinNormalized(Triple::normalize("i686-pc-cygwin-elf"));
615    EXPECT_EQ(Triple::ELF, CygwinNormalized.getObjectFormat());
616  
617    Triple T = Triple("");
618    T.setObjectFormat(Triple::ELF);
619    EXPECT_EQ(Triple::ELF, T.getObjectFormat());
620  }
621  
TEST(TripleTest,NormalizeWindows)622  TEST(TripleTest, NormalizeWindows) {
623    EXPECT_EQ("i686-pc-windows-msvc", Triple::normalize("i686-pc-win32"));
624    EXPECT_EQ("i686--windows-msvc", Triple::normalize("i686-win32"));
625    EXPECT_EQ("i686-pc-windows-gnu", Triple::normalize("i686-pc-mingw32"));
626    EXPECT_EQ("i686--windows-gnu", Triple::normalize("i686-mingw32"));
627    EXPECT_EQ("i686-pc-windows-gnu", Triple::normalize("i686-pc-mingw32-w64"));
628    EXPECT_EQ("i686--windows-gnu", Triple::normalize("i686-mingw32-w64"));
629    EXPECT_EQ("i686-pc-windows-cygnus", Triple::normalize("i686-pc-cygwin"));
630    EXPECT_EQ("i686--windows-cygnus", Triple::normalize("i686-cygwin"));
631  
632    EXPECT_EQ("x86_64-pc-windows-msvc", Triple::normalize("x86_64-pc-win32"));
633    EXPECT_EQ("x86_64--windows-msvc", Triple::normalize("x86_64-win32"));
634    EXPECT_EQ("x86_64-pc-windows-gnu", Triple::normalize("x86_64-pc-mingw32"));
635    EXPECT_EQ("x86_64--windows-gnu", Triple::normalize("x86_64-mingw32"));
636    EXPECT_EQ("x86_64-pc-windows-gnu", Triple::normalize("x86_64-pc-mingw32-w64"));
637    EXPECT_EQ("x86_64--windows-gnu", Triple::normalize("x86_64-mingw32-w64"));
638  
639    EXPECT_EQ("i686-pc-windows-elf", Triple::normalize("i686-pc-win32-elf"));
640    EXPECT_EQ("i686--windows-elf", Triple::normalize("i686-win32-elf"));
641    EXPECT_EQ("i686-pc-windows-macho", Triple::normalize("i686-pc-win32-macho"));
642    EXPECT_EQ("i686--windows-macho", Triple::normalize("i686-win32-macho"));
643  
644    EXPECT_EQ("x86_64-pc-windows-elf", Triple::normalize("x86_64-pc-win32-elf"));
645    EXPECT_EQ("x86_64--windows-elf", Triple::normalize("x86_64-win32-elf"));
646    EXPECT_EQ("x86_64-pc-windows-macho", Triple::normalize("x86_64-pc-win32-macho"));
647    EXPECT_EQ("x86_64--windows-macho", Triple::normalize("x86_64-win32-macho"));
648  
649    EXPECT_EQ("i686-pc-windows-cygnus",
650              Triple::normalize("i686-pc-windows-cygnus"));
651    EXPECT_EQ("i686-pc-windows-gnu", Triple::normalize("i686-pc-windows-gnu"));
652    EXPECT_EQ("i686-pc-windows-itanium", Triple::normalize("i686-pc-windows-itanium"));
653    EXPECT_EQ("i686-pc-windows-msvc", Triple::normalize("i686-pc-windows-msvc"));
654  
655    EXPECT_EQ("i686-pc-windows-elf", Triple::normalize("i686-pc-windows-elf-elf"));
656  }
657  
TEST(TripleTest,getARMCPUForArch)658  TEST(TripleTest, getARMCPUForArch) {
659    {
660      llvm::Triple Triple("armv6-unknown-freebsd");
661      EXPECT_STREQ("arm1176jzf-s", Triple.getARMCPUForArch());
662    }
663    {
664      llvm::Triple Triple("armv7s-apple-ios7");
665      EXPECT_STREQ("swift", Triple.getARMCPUForArch());
666    }
667    {
668      llvm::Triple Triple("armv7-apple-ios7");
669      EXPECT_STREQ("cortex-a8", Triple.getARMCPUForArch());
670      EXPECT_STREQ("swift", Triple.getARMCPUForArch("armv7s"));
671    }
672    {
673      llvm::Triple Triple("arm--nacl");
674      EXPECT_STREQ("cortex-a8", Triple.getARMCPUForArch("arm"));
675    }
676  }
677  }
678  
TEST(TripleTest,NormalizeARM)679  TEST(TripleTest, NormalizeARM) {
680    EXPECT_EQ("armv6--netbsd-eabi", Triple::normalize("armv6-netbsd-eabi"));
681    EXPECT_EQ("armv7--netbsd-eabi", Triple::normalize("armv7-netbsd-eabi"));
682    EXPECT_EQ("armv6eb--netbsd-eabi", Triple::normalize("armv6eb-netbsd-eabi"));
683    EXPECT_EQ("armv7eb--netbsd-eabi", Triple::normalize("armv7eb-netbsd-eabi"));
684    EXPECT_EQ("armv6--netbsd-eabihf", Triple::normalize("armv6-netbsd-eabihf"));
685    EXPECT_EQ("armv7--netbsd-eabihf", Triple::normalize("armv7-netbsd-eabihf"));
686    EXPECT_EQ("armv6eb--netbsd-eabihf", Triple::normalize("armv6eb-netbsd-eabihf"));
687    EXPECT_EQ("armv7eb--netbsd-eabihf", Triple::normalize("armv7eb-netbsd-eabihf"));
688  
689    Triple T;
690    T = Triple("armv6--netbsd-eabi");
691    EXPECT_EQ(Triple::arm, T.getArch());
692    T = Triple("armv6eb--netbsd-eabi");
693    EXPECT_EQ(Triple::armeb, T.getArch());
694  }
695