]>
git.proxmox.com Git - rustc.git/blob - src/llvm/unittests/ADT/TripleTest.cpp
1 //===----------- Triple.cpp - Triple unit tests ---------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "gtest/gtest.h"
11 #include "llvm/ADT/Triple.h"
17 TEST(TripleTest
, BasicParsing
) {
21 EXPECT_EQ("", T
.getArchName().str());
22 EXPECT_EQ("", T
.getVendorName().str());
23 EXPECT_EQ("", T
.getOSName().str());
24 EXPECT_EQ("", T
.getEnvironmentName().str());
27 EXPECT_EQ("", T
.getArchName().str());
28 EXPECT_EQ("", T
.getVendorName().str());
29 EXPECT_EQ("", T
.getOSName().str());
30 EXPECT_EQ("", T
.getEnvironmentName().str());
33 EXPECT_EQ("", T
.getArchName().str());
34 EXPECT_EQ("", T
.getVendorName().str());
35 EXPECT_EQ("", T
.getOSName().str());
36 EXPECT_EQ("", T
.getEnvironmentName().str());
39 EXPECT_EQ("", T
.getArchName().str());
40 EXPECT_EQ("", T
.getVendorName().str());
41 EXPECT_EQ("", T
.getOSName().str());
42 EXPECT_EQ("", T
.getEnvironmentName().str());
45 EXPECT_EQ("", T
.getArchName().str());
46 EXPECT_EQ("", T
.getVendorName().str());
47 EXPECT_EQ("", T
.getOSName().str());
48 EXPECT_EQ("-", T
.getEnvironmentName().str());
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());
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());
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());
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());
75 TEST(TripleTest
, ParsedIDs
) {
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());
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());
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());
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());
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());
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());
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());
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());
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());
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());
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());
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());
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());
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());
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());
163 EXPECT_EQ(Triple::UnknownArch
, T
.getArch());
166 static std::string
Join(StringRef A
, StringRef B
, StringRef C
) {
167 std::string Str
= A
; Str
+= '-'; Str
+= B
; Str
+= '-'; Str
+= C
;
171 static std::string
Join(StringRef A
, StringRef B
, StringRef C
, StringRef D
) {
172 std::string Str
= A
; Str
+= '-'; Str
+= B
; Str
+= '-'; Str
+= C
; Str
+= '-';
173 Str
+= D
; return Str
;
176 TEST(TripleTest
, Normalization
) {
178 EXPECT_EQ("", Triple::normalize(""));
179 EXPECT_EQ("-", Triple::normalize("-"));
180 EXPECT_EQ("--", Triple::normalize("--"));
181 EXPECT_EQ("---", Triple::normalize("---"));
182 EXPECT_EQ("----", Triple::normalize("----"));
184 EXPECT_EQ("a", Triple::normalize("a"));
185 EXPECT_EQ("a-b", Triple::normalize("a-b"));
186 EXPECT_EQ("a-b-c", Triple::normalize("a-b-c"));
187 EXPECT_EQ("a-b-c-d", Triple::normalize("a-b-c-d"));
189 EXPECT_EQ("i386-b-c", Triple::normalize("i386-b-c"));
190 EXPECT_EQ("i386-a-c", Triple::normalize("a-i386-c"));
191 EXPECT_EQ("i386-a-b", Triple::normalize("a-b-i386"));
192 EXPECT_EQ("i386-a-b-c", Triple::normalize("a-b-c-i386"));
194 EXPECT_EQ("a-pc-c", Triple::normalize("a-pc-c"));
195 EXPECT_EQ("-pc-b-c", Triple::normalize("pc-b-c"));
196 EXPECT_EQ("a-pc-b", Triple::normalize("a-b-pc"));
197 EXPECT_EQ("a-pc-b-c", Triple::normalize("a-b-c-pc"));
199 EXPECT_EQ("a-b-linux", Triple::normalize("a-b-linux"));
200 EXPECT_EQ("--linux-b-c", Triple::normalize("linux-b-c"));
201 EXPECT_EQ("a--linux-c", Triple::normalize("a-linux-c"));
203 EXPECT_EQ("i386-pc-a", Triple::normalize("a-pc-i386"));
204 EXPECT_EQ("i386-pc-", Triple::normalize("-pc-i386"));
205 EXPECT_EQ("-pc-linux-c", Triple::normalize("linux-pc-c"));
206 EXPECT_EQ("-pc-linux", Triple::normalize("linux-pc-"));
208 EXPECT_EQ("i386", Triple::normalize("i386"));
209 EXPECT_EQ("-pc", Triple::normalize("pc"));
210 EXPECT_EQ("--linux", Triple::normalize("linux"));
212 EXPECT_EQ("x86_64--linux-gnu", Triple::normalize("x86_64-gnu-linux"));
214 // Check that normalizing a permutated set of valid components returns a
215 // triple with the unpermuted components.
217 for (int Arch
= 1+Triple::UnknownArch
; Arch
<= Triple::amdil
; ++Arch
) {
218 C
[0] = Triple::getArchTypeName(Triple::ArchType(Arch
));
219 for (int Vendor
= 1+Triple::UnknownVendor
; Vendor
<= Triple::PC
;
221 C
[1] = Triple::getVendorTypeName(Triple::VendorType(Vendor
));
222 for (int OS
= 1+Triple::UnknownOS
; OS
<= Triple::Minix
; ++OS
) {
223 if (OS
== Triple::Win32
)
226 C
[2] = Triple::getOSTypeName(Triple::OSType(OS
));
228 std::string E
= Join(C
[0], C
[1], C
[2]);
229 EXPECT_EQ(E
, Triple::normalize(Join(C
[0], C
[1], C
[2])));
231 EXPECT_EQ(E
, Triple::normalize(Join(C
[0], C
[2], C
[1])));
232 EXPECT_EQ(E
, Triple::normalize(Join(C
[1], C
[2], C
[0])));
233 EXPECT_EQ(E
, Triple::normalize(Join(C
[1], C
[0], C
[2])));
234 EXPECT_EQ(E
, Triple::normalize(Join(C
[2], C
[0], C
[1])));
235 EXPECT_EQ(E
, Triple::normalize(Join(C
[2], C
[1], C
[0])));
237 for (int Env
= 1 + Triple::UnknownEnvironment
; Env
<= Triple::Android
;
239 C
[3] = Triple::getEnvironmentTypeName(Triple::EnvironmentType(Env
));
241 std::string F
= Join(C
[0], C
[1], C
[2], C
[3]);
242 EXPECT_EQ(F
, Triple::normalize(Join(C
[0], C
[1], C
[2], C
[3])));
244 EXPECT_EQ(F
, Triple::normalize(Join(C
[0], C
[1], C
[3], C
[2])));
245 EXPECT_EQ(F
, Triple::normalize(Join(C
[0], C
[2], C
[3], C
[1])));
246 EXPECT_EQ(F
, Triple::normalize(Join(C
[0], C
[2], C
[1], C
[3])));
247 EXPECT_EQ(F
, Triple::normalize(Join(C
[0], C
[3], C
[1], C
[2])));
248 EXPECT_EQ(F
, Triple::normalize(Join(C
[0], C
[3], C
[2], C
[1])));
249 EXPECT_EQ(F
, Triple::normalize(Join(C
[1], C
[2], C
[3], C
[0])));
250 EXPECT_EQ(F
, Triple::normalize(Join(C
[1], C
[2], C
[0], C
[3])));
251 EXPECT_EQ(F
, Triple::normalize(Join(C
[1], C
[3], C
[0], C
[2])));
252 EXPECT_EQ(F
, Triple::normalize(Join(C
[1], C
[3], C
[2], C
[0])));
253 EXPECT_EQ(F
, Triple::normalize(Join(C
[1], C
[0], C
[2], C
[3])));
254 EXPECT_EQ(F
, Triple::normalize(Join(C
[1], C
[0], C
[3], C
[2])));
255 EXPECT_EQ(F
, Triple::normalize(Join(C
[2], C
[3], C
[0], C
[1])));
256 EXPECT_EQ(F
, Triple::normalize(Join(C
[2], C
[3], C
[1], C
[0])));
257 EXPECT_EQ(F
, Triple::normalize(Join(C
[2], C
[0], C
[1], C
[3])));
258 EXPECT_EQ(F
, Triple::normalize(Join(C
[2], C
[0], C
[3], C
[1])));
259 EXPECT_EQ(F
, Triple::normalize(Join(C
[2], C
[1], C
[3], C
[0])));
260 EXPECT_EQ(F
, Triple::normalize(Join(C
[2], C
[1], C
[0], C
[3])));
261 EXPECT_EQ(F
, Triple::normalize(Join(C
[3], C
[0], C
[1], C
[2])));
262 EXPECT_EQ(F
, Triple::normalize(Join(C
[3], C
[0], C
[2], C
[1])));
263 EXPECT_EQ(F
, Triple::normalize(Join(C
[3], C
[1], C
[2], C
[0])));
264 EXPECT_EQ(F
, Triple::normalize(Join(C
[3], C
[1], C
[0], C
[2])));
265 EXPECT_EQ(F
, Triple::normalize(Join(C
[3], C
[2], C
[0], C
[1])));
266 EXPECT_EQ(F
, Triple::normalize(Join(C
[3], C
[2], C
[1], C
[0])));
272 // Various real-world funky triples. The value returned by GCC's config.sub
273 // is given in the comment.
274 EXPECT_EQ("i386--windows-gnu", Triple::normalize("i386-mingw32")); // i386-pc-mingw32
275 EXPECT_EQ("x86_64--linux-gnu", Triple::normalize("x86_64-linux-gnu")); // x86_64-pc-linux-gnu
276 EXPECT_EQ("i486--linux-gnu", Triple::normalize("i486-linux-gnu")); // i486-pc-linux-gnu
277 EXPECT_EQ("i386-redhat-linux", Triple::normalize("i386-redhat-linux")); // i386-redhat-linux-gnu
278 EXPECT_EQ("i686--linux", Triple::normalize("i686-linux")); // i686-pc-linux-gnu
279 EXPECT_EQ("arm-none--eabi", Triple::normalize("arm-none-eabi")); // arm-none-eabi
282 TEST(TripleTest
, MutateName
) {
284 EXPECT_EQ(Triple::UnknownArch
, T
.getArch());
285 EXPECT_EQ(Triple::UnknownVendor
, T
.getVendor());
286 EXPECT_EQ(Triple::UnknownOS
, T
.getOS());
287 EXPECT_EQ(Triple::UnknownEnvironment
, T
.getEnvironment());
289 T
.setArchName("i386");
290 EXPECT_EQ(Triple::x86
, T
.getArch());
291 EXPECT_EQ("i386--", T
.getTriple());
293 T
.setVendorName("pc");
294 EXPECT_EQ(Triple::x86
, T
.getArch());
295 EXPECT_EQ(Triple::PC
, T
.getVendor());
296 EXPECT_EQ("i386-pc-", T
.getTriple());
298 T
.setOSName("linux");
299 EXPECT_EQ(Triple::x86
, T
.getArch());
300 EXPECT_EQ(Triple::PC
, T
.getVendor());
301 EXPECT_EQ(Triple::Linux
, T
.getOS());
302 EXPECT_EQ("i386-pc-linux", T
.getTriple());
304 T
.setEnvironmentName("gnu");
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-gnu", T
.getTriple());
310 T
.setOSName("freebsd");
311 EXPECT_EQ(Triple::x86
, T
.getArch());
312 EXPECT_EQ(Triple::PC
, T
.getVendor());
313 EXPECT_EQ(Triple::FreeBSD
, T
.getOS());
314 EXPECT_EQ("i386-pc-freebsd-gnu", T
.getTriple());
316 T
.setOSAndEnvironmentName("darwin");
317 EXPECT_EQ(Triple::x86
, T
.getArch());
318 EXPECT_EQ(Triple::PC
, T
.getVendor());
319 EXPECT_EQ(Triple::Darwin
, T
.getOS());
320 EXPECT_EQ("i386-pc-darwin", T
.getTriple());
324 TEST(TripleTest
, BitWidthPredicates
) {
326 EXPECT_FALSE(T
.isArch16Bit());
327 EXPECT_FALSE(T
.isArch32Bit());
328 EXPECT_FALSE(T
.isArch64Bit());
330 T
.setArch(Triple::arm
);
331 EXPECT_FALSE(T
.isArch16Bit());
332 EXPECT_TRUE(T
.isArch32Bit());
333 EXPECT_FALSE(T
.isArch64Bit());
335 T
.setArch(Triple::hexagon
);
336 EXPECT_FALSE(T
.isArch16Bit());
337 EXPECT_TRUE(T
.isArch32Bit());
338 EXPECT_FALSE(T
.isArch64Bit());
340 T
.setArch(Triple::mips
);
341 EXPECT_FALSE(T
.isArch16Bit());
342 EXPECT_TRUE(T
.isArch32Bit());
343 EXPECT_FALSE(T
.isArch64Bit());
345 T
.setArch(Triple::mips64
);
346 EXPECT_FALSE(T
.isArch16Bit());
347 EXPECT_FALSE(T
.isArch32Bit());
348 EXPECT_TRUE(T
.isArch64Bit());
350 T
.setArch(Triple::msp430
);
351 EXPECT_TRUE(T
.isArch16Bit());
352 EXPECT_FALSE(T
.isArch32Bit());
353 EXPECT_FALSE(T
.isArch64Bit());
355 T
.setArch(Triple::ppc
);
356 EXPECT_FALSE(T
.isArch16Bit());
357 EXPECT_TRUE(T
.isArch32Bit());
358 EXPECT_FALSE(T
.isArch64Bit());
360 T
.setArch(Triple::ppc64
);
361 EXPECT_FALSE(T
.isArch16Bit());
362 EXPECT_FALSE(T
.isArch32Bit());
363 EXPECT_TRUE(T
.isArch64Bit());
365 T
.setArch(Triple::x86
);
366 EXPECT_FALSE(T
.isArch16Bit());
367 EXPECT_TRUE(T
.isArch32Bit());
368 EXPECT_FALSE(T
.isArch64Bit());
370 T
.setArch(Triple::x86_64
);
371 EXPECT_FALSE(T
.isArch16Bit());
372 EXPECT_FALSE(T
.isArch32Bit());
373 EXPECT_TRUE(T
.isArch64Bit());
375 T
.setArch(Triple::amdil
);
376 EXPECT_FALSE(T
.isArch16Bit());
377 EXPECT_TRUE(T
.isArch32Bit());
378 EXPECT_FALSE(T
.isArch64Bit());
380 T
.setArch(Triple::amdil64
);
381 EXPECT_FALSE(T
.isArch16Bit());
382 EXPECT_FALSE(T
.isArch32Bit());
383 EXPECT_TRUE(T
.isArch64Bit());
385 T
.setArch(Triple::hsail
);
386 EXPECT_FALSE(T
.isArch16Bit());
387 EXPECT_TRUE(T
.isArch32Bit());
388 EXPECT_FALSE(T
.isArch64Bit());
390 T
.setArch(Triple::hsail64
);
391 EXPECT_FALSE(T
.isArch16Bit());
392 EXPECT_FALSE(T
.isArch32Bit());
393 EXPECT_TRUE(T
.isArch64Bit());
395 T
.setArch(Triple::spir
);
396 EXPECT_FALSE(T
.isArch16Bit());
397 EXPECT_TRUE(T
.isArch32Bit());
398 EXPECT_FALSE(T
.isArch64Bit());
400 T
.setArch(Triple::spir64
);
401 EXPECT_FALSE(T
.isArch16Bit());
402 EXPECT_FALSE(T
.isArch32Bit());
403 EXPECT_TRUE(T
.isArch64Bit());
406 TEST(TripleTest
, BitWidthArchVariants
) {
408 EXPECT_EQ(Triple::UnknownArch
, T
.get32BitArchVariant().getArch());
409 EXPECT_EQ(Triple::UnknownArch
, T
.get64BitArchVariant().getArch());
411 T
.setArch(Triple::UnknownArch
);
412 EXPECT_EQ(Triple::UnknownArch
, T
.get32BitArchVariant().getArch());
413 EXPECT_EQ(Triple::UnknownArch
, T
.get64BitArchVariant().getArch());
415 T
.setArch(Triple::mips
);
416 EXPECT_EQ(Triple::mips
, T
.get32BitArchVariant().getArch());
417 EXPECT_EQ(Triple::mips64
, T
.get64BitArchVariant().getArch());
419 T
.setArch(Triple::mipsel
);
420 EXPECT_EQ(Triple::mipsel
, T
.get32BitArchVariant().getArch());
421 EXPECT_EQ(Triple::mips64el
, T
.get64BitArchVariant().getArch());
423 T
.setArch(Triple::ppc
);
424 EXPECT_EQ(Triple::ppc
, T
.get32BitArchVariant().getArch());
425 EXPECT_EQ(Triple::ppc64
, T
.get64BitArchVariant().getArch());
427 T
.setArch(Triple::nvptx
);
428 EXPECT_EQ(Triple::nvptx
, T
.get32BitArchVariant().getArch());
429 EXPECT_EQ(Triple::nvptx64
, T
.get64BitArchVariant().getArch());
431 T
.setArch(Triple::sparc
);
432 EXPECT_EQ(Triple::sparc
, T
.get32BitArchVariant().getArch());
433 EXPECT_EQ(Triple::sparcv9
, T
.get64BitArchVariant().getArch());
435 T
.setArch(Triple::x86
);
436 EXPECT_EQ(Triple::x86
, T
.get32BitArchVariant().getArch());
437 EXPECT_EQ(Triple::x86_64
, T
.get64BitArchVariant().getArch());
439 T
.setArch(Triple::mips64
);
440 EXPECT_EQ(Triple::mips
, T
.get32BitArchVariant().getArch());
441 EXPECT_EQ(Triple::mips64
, T
.get64BitArchVariant().getArch());
443 T
.setArch(Triple::mips64el
);
444 EXPECT_EQ(Triple::mipsel
, T
.get32BitArchVariant().getArch());
445 EXPECT_EQ(Triple::mips64el
, T
.get64BitArchVariant().getArch());
447 T
.setArch(Triple::ppc64
);
448 EXPECT_EQ(Triple::ppc
, T
.get32BitArchVariant().getArch());
449 EXPECT_EQ(Triple::ppc64
, T
.get64BitArchVariant().getArch());
451 T
.setArch(Triple::nvptx64
);
452 EXPECT_EQ(Triple::nvptx
, T
.get32BitArchVariant().getArch());
453 EXPECT_EQ(Triple::nvptx64
, T
.get64BitArchVariant().getArch());
455 T
.setArch(Triple::sparcv9
);
456 EXPECT_EQ(Triple::sparc
, T
.get32BitArchVariant().getArch());
457 EXPECT_EQ(Triple::sparcv9
, T
.get64BitArchVariant().getArch());
459 T
.setArch(Triple::x86_64
);
460 EXPECT_EQ(Triple::x86
, T
.get32BitArchVariant().getArch());
461 EXPECT_EQ(Triple::x86_64
, T
.get64BitArchVariant().getArch());
463 T
.setArch(Triple::amdil
);
464 EXPECT_EQ(Triple::amdil
, T
.get32BitArchVariant().getArch());
465 EXPECT_EQ(Triple::amdil64
, T
.get64BitArchVariant().getArch());
467 T
.setArch(Triple::amdil64
);
468 EXPECT_EQ(Triple::amdil
, T
.get32BitArchVariant().getArch());
469 EXPECT_EQ(Triple::amdil64
, T
.get64BitArchVariant().getArch());
471 T
.setArch(Triple::hsail
);
472 EXPECT_EQ(Triple::hsail
, T
.get32BitArchVariant().getArch());
473 EXPECT_EQ(Triple::hsail64
, T
.get64BitArchVariant().getArch());
475 T
.setArch(Triple::hsail64
);
476 EXPECT_EQ(Triple::hsail
, T
.get32BitArchVariant().getArch());
477 EXPECT_EQ(Triple::hsail64
, T
.get64BitArchVariant().getArch());
479 T
.setArch(Triple::spir
);
480 EXPECT_EQ(Triple::spir
, T
.get32BitArchVariant().getArch());
481 EXPECT_EQ(Triple::spir64
, T
.get64BitArchVariant().getArch());
483 T
.setArch(Triple::spir64
);
484 EXPECT_EQ(Triple::spir
, T
.get32BitArchVariant().getArch());
485 EXPECT_EQ(Triple::spir64
, T
.get64BitArchVariant().getArch());
488 TEST(TripleTest
, getOSVersion
) {
490 unsigned Major
, Minor
, Micro
;
492 T
= Triple("i386-apple-darwin9");
493 EXPECT_TRUE(T
.isMacOSX());
494 EXPECT_FALSE(T
.isiOS());
495 EXPECT_FALSE(T
.isArch16Bit());
496 EXPECT_TRUE(T
.isArch32Bit());
497 EXPECT_FALSE(T
.isArch64Bit());
498 T
.getMacOSXVersion(Major
, Minor
, Micro
);
499 EXPECT_EQ((unsigned)10, Major
);
500 EXPECT_EQ((unsigned)5, Minor
);
501 EXPECT_EQ((unsigned)0, Micro
);
502 T
.getiOSVersion(Major
, Minor
, Micro
);
503 EXPECT_EQ((unsigned)5, Major
);
504 EXPECT_EQ((unsigned)0, Minor
);
505 EXPECT_EQ((unsigned)0, Micro
);
507 T
= Triple("x86_64-apple-darwin9");
508 EXPECT_TRUE(T
.isMacOSX());
509 EXPECT_FALSE(T
.isiOS());
510 EXPECT_FALSE(T
.isArch16Bit());
511 EXPECT_FALSE(T
.isArch32Bit());
512 EXPECT_TRUE(T
.isArch64Bit());
513 T
.getMacOSXVersion(Major
, Minor
, Micro
);
514 EXPECT_EQ((unsigned)10, Major
);
515 EXPECT_EQ((unsigned)5, Minor
);
516 EXPECT_EQ((unsigned)0, Micro
);
517 T
.getiOSVersion(Major
, Minor
, Micro
);
518 EXPECT_EQ((unsigned)5, Major
);
519 EXPECT_EQ((unsigned)0, Minor
);
520 EXPECT_EQ((unsigned)0, Micro
);
522 T
= Triple("x86_64-apple-macosx");
523 EXPECT_TRUE(T
.isMacOSX());
524 EXPECT_FALSE(T
.isiOS());
525 EXPECT_FALSE(T
.isArch16Bit());
526 EXPECT_FALSE(T
.isArch32Bit());
527 EXPECT_TRUE(T
.isArch64Bit());
528 T
.getMacOSXVersion(Major
, Minor
, Micro
);
529 EXPECT_EQ((unsigned)10, Major
);
530 EXPECT_EQ((unsigned)4, Minor
);
531 EXPECT_EQ((unsigned)0, Micro
);
532 T
.getiOSVersion(Major
, Minor
, Micro
);
533 EXPECT_EQ((unsigned)5, Major
);
534 EXPECT_EQ((unsigned)0, Minor
);
535 EXPECT_EQ((unsigned)0, Micro
);
537 T
= Triple("x86_64-apple-macosx10.7");
538 EXPECT_TRUE(T
.isMacOSX());
539 EXPECT_FALSE(T
.isiOS());
540 EXPECT_FALSE(T
.isArch16Bit());
541 EXPECT_FALSE(T
.isArch32Bit());
542 EXPECT_TRUE(T
.isArch64Bit());
543 T
.getMacOSXVersion(Major
, Minor
, Micro
);
544 EXPECT_EQ((unsigned)10, Major
);
545 EXPECT_EQ((unsigned)7, Minor
);
546 EXPECT_EQ((unsigned)0, Micro
);
547 T
.getiOSVersion(Major
, Minor
, Micro
);
548 EXPECT_EQ((unsigned)5, Major
);
549 EXPECT_EQ((unsigned)0, Minor
);
550 EXPECT_EQ((unsigned)0, Micro
);
552 T
= Triple("armv7-apple-ios");
553 EXPECT_FALSE(T
.isMacOSX());
554 EXPECT_TRUE(T
.isiOS());
555 EXPECT_FALSE(T
.isArch16Bit());
556 EXPECT_TRUE(T
.isArch32Bit());
557 EXPECT_FALSE(T
.isArch64Bit());
558 T
.getMacOSXVersion(Major
, Minor
, Micro
);
559 EXPECT_EQ((unsigned)10, Major
);
560 EXPECT_EQ((unsigned)4, Minor
);
561 EXPECT_EQ((unsigned)0, Micro
);
562 T
.getiOSVersion(Major
, Minor
, Micro
);
563 EXPECT_EQ((unsigned)5, Major
);
564 EXPECT_EQ((unsigned)0, Minor
);
565 EXPECT_EQ((unsigned)0, Micro
);
567 T
= Triple("armv7-apple-ios7.0");
568 EXPECT_FALSE(T
.isMacOSX());
569 EXPECT_TRUE(T
.isiOS());
570 EXPECT_FALSE(T
.isArch16Bit());
571 EXPECT_TRUE(T
.isArch32Bit());
572 EXPECT_FALSE(T
.isArch64Bit());
573 T
.getMacOSXVersion(Major
, Minor
, Micro
);
574 EXPECT_EQ((unsigned)10, Major
);
575 EXPECT_EQ((unsigned)4, Minor
);
576 EXPECT_EQ((unsigned)0, Micro
);
577 T
.getiOSVersion(Major
, Minor
, Micro
);
578 EXPECT_EQ((unsigned)7, Major
);
579 EXPECT_EQ((unsigned)0, Minor
);
580 EXPECT_EQ((unsigned)0, Micro
);
583 TEST(TripleTest
, FileFormat
) {
584 EXPECT_EQ(Triple::ELF
, Triple("i686-unknown-linux-gnu").getObjectFormat());
585 EXPECT_EQ(Triple::ELF
, Triple("i686-unknown-freebsd").getObjectFormat());
586 EXPECT_EQ(Triple::ELF
, Triple("i686-unknown-netbsd").getObjectFormat());
587 EXPECT_EQ(Triple::ELF
, Triple("i686--win32-elf").getObjectFormat());
588 EXPECT_EQ(Triple::ELF
, Triple("i686---elf").getObjectFormat());
590 EXPECT_EQ(Triple::MachO
, Triple("i686-apple-macosx").getObjectFormat());
591 EXPECT_EQ(Triple::MachO
, Triple("i686-apple-ios").getObjectFormat());
592 EXPECT_EQ(Triple::MachO
, Triple("i686---macho").getObjectFormat());
594 EXPECT_EQ(Triple::COFF
, Triple("i686--win32").getObjectFormat());
596 EXPECT_EQ(Triple::ELF
, Triple("i686-pc-windows-msvc-elf").getObjectFormat());
597 EXPECT_EQ(Triple::ELF
, Triple("i686-pc-cygwin-elf").getObjectFormat());
599 Triple
MSVCNormalized(Triple::normalize("i686-pc-windows-msvc-elf"));
600 EXPECT_EQ(Triple::ELF
, MSVCNormalized
.getObjectFormat());
602 Triple
GNUWindowsNormalized(Triple::normalize("i686-pc-windows-gnu-elf"));
603 EXPECT_EQ(Triple::ELF
, GNUWindowsNormalized
.getObjectFormat());
605 Triple
CygnusNormalised(Triple::normalize("i686-pc-windows-cygnus-elf"));
606 EXPECT_EQ(Triple::ELF
, CygnusNormalised
.getObjectFormat());
608 Triple
CygwinNormalized(Triple::normalize("i686-pc-cygwin-elf"));
609 EXPECT_EQ(Triple::ELF
, CygwinNormalized
.getObjectFormat());
611 Triple T
= Triple("");
612 T
.setObjectFormat(Triple::ELF
);
613 EXPECT_EQ(Triple::ELF
, T
.getObjectFormat());
616 TEST(TripleTest
, NormalizeWindows
) {
617 EXPECT_EQ("i686-pc-windows-msvc", Triple::normalize("i686-pc-win32"));
618 EXPECT_EQ("i686--windows-msvc", Triple::normalize("i686-win32"));
619 EXPECT_EQ("i686-pc-windows-gnu", Triple::normalize("i686-pc-mingw32"));
620 EXPECT_EQ("i686--windows-gnu", Triple::normalize("i686-mingw32"));
621 EXPECT_EQ("i686-pc-windows-gnu", Triple::normalize("i686-pc-mingw32-w64"));
622 EXPECT_EQ("i686--windows-gnu", Triple::normalize("i686-mingw32-w64"));
623 EXPECT_EQ("i686-pc-windows-cygnus", Triple::normalize("i686-pc-cygwin"));
624 EXPECT_EQ("i686--windows-cygnus", Triple::normalize("i686-cygwin"));
626 EXPECT_EQ("x86_64-pc-windows-msvc", Triple::normalize("x86_64-pc-win32"));
627 EXPECT_EQ("x86_64--windows-msvc", Triple::normalize("x86_64-win32"));
628 EXPECT_EQ("x86_64-pc-windows-gnu", Triple::normalize("x86_64-pc-mingw32"));
629 EXPECT_EQ("x86_64--windows-gnu", Triple::normalize("x86_64-mingw32"));
630 EXPECT_EQ("x86_64-pc-windows-gnu", Triple::normalize("x86_64-pc-mingw32-w64"));
631 EXPECT_EQ("x86_64--windows-gnu", Triple::normalize("x86_64-mingw32-w64"));
633 EXPECT_EQ("i686-pc-windows-elf", Triple::normalize("i686-pc-win32-elf"));
634 EXPECT_EQ("i686--windows-elf", Triple::normalize("i686-win32-elf"));
635 EXPECT_EQ("i686-pc-windows-macho", Triple::normalize("i686-pc-win32-macho"));
636 EXPECT_EQ("i686--windows-macho", Triple::normalize("i686-win32-macho"));
638 EXPECT_EQ("x86_64-pc-windows-elf", Triple::normalize("x86_64-pc-win32-elf"));
639 EXPECT_EQ("x86_64--windows-elf", Triple::normalize("x86_64-win32-elf"));
640 EXPECT_EQ("x86_64-pc-windows-macho", Triple::normalize("x86_64-pc-win32-macho"));
641 EXPECT_EQ("x86_64--windows-macho", Triple::normalize("x86_64-win32-macho"));
643 EXPECT_EQ("i686-pc-windows-cygnus",
644 Triple::normalize("i686-pc-windows-cygnus"));
645 EXPECT_EQ("i686-pc-windows-gnu", Triple::normalize("i686-pc-windows-gnu"));
646 EXPECT_EQ("i686-pc-windows-itanium", Triple::normalize("i686-pc-windows-itanium"));
647 EXPECT_EQ("i686-pc-windows-msvc", Triple::normalize("i686-pc-windows-msvc"));
649 EXPECT_EQ("i686-pc-windows-elf", Triple::normalize("i686-pc-windows-elf-elf"));
652 TEST(TripleTest
, getARMCPUForArch
) {
654 llvm::Triple
Triple("armv6-unknown-freebsd");
655 EXPECT_STREQ("arm1176jzf-s", Triple
.getARMCPUForArch());
658 llvm::Triple
Triple("armv7s-apple-ios7");
659 EXPECT_STREQ("swift", Triple
.getARMCPUForArch());
662 llvm::Triple
Triple("armv7-apple-ios7");
663 EXPECT_STREQ("cortex-a8", Triple
.getARMCPUForArch());
664 EXPECT_STREQ("swift", Triple
.getARMCPUForArch("armv7s"));
669 TEST(TripleTest
, NormalizeARM
) {
670 EXPECT_EQ("armv6--netbsd-eabi", Triple::normalize("armv6-netbsd-eabi"));
671 EXPECT_EQ("armv7--netbsd-eabi", Triple::normalize("armv7-netbsd-eabi"));
672 EXPECT_EQ("armv6eb--netbsd-eabi", Triple::normalize("armv6eb-netbsd-eabi"));
673 EXPECT_EQ("armv7eb--netbsd-eabi", Triple::normalize("armv7eb-netbsd-eabi"));
674 EXPECT_EQ("armv6--netbsd-eabihf", Triple::normalize("armv6-netbsd-eabihf"));
675 EXPECT_EQ("armv7--netbsd-eabihf", Triple::normalize("armv7-netbsd-eabihf"));
676 EXPECT_EQ("armv6eb--netbsd-eabihf", Triple::normalize("armv6eb-netbsd-eabihf"));
677 EXPECT_EQ("armv7eb--netbsd-eabihf", Triple::normalize("armv7eb-netbsd-eabihf"));
680 T
= Triple("armv6--netbsd-eabi");
681 EXPECT_EQ(Triple::arm
, T
.getArch());
682 T
= Triple("armv6eb--netbsd-eabi");
683 EXPECT_EQ(Triple::armeb
, T
.getArch());