unittests/ADT/TripleTest.cpp

   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("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("armv6hl-none-linux-gnueabi");
 133   EXPECT_EQ(Triple::arm, T.getArch());
 134   EXPECT_EQ(Triple::Linux, T.getOS());
 135   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 136   EXPECT_EQ(Triple::GNUEABI, T.getEnvironment());
 137
 138   T = Triple("armv7hl-none-linux-gnueabi");
 139   EXPECT_EQ(Triple::arm, T.getArch());
 140   EXPECT_EQ(Triple::Linux, T.getOS());
 141   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 142   EXPECT_EQ(Triple::GNUEABI, T.getEnvironment());
 143
 144   T = Triple("amdil-unknown-unknown");
 145   EXPECT_EQ(Triple::amdil, T.getArch());
 146   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 147   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 148
 149   T = Triple("amdil64-unknown-unknown");
 150   EXPECT_EQ(Triple::amdil64, T.getArch());
 151   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 152   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 153
 154   T = Triple("hsail-unknown-unknown");
 155   EXPECT_EQ(Triple::hsail, T.getArch());
 156   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 157   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 158
 159   T = Triple("hsail64-unknown-unknown");
 160   EXPECT_EQ(Triple::hsail64, T.getArch());
 161   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 162   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 163
 164   T = Triple("sparcel-unknown-unknown");
 165   EXPECT_EQ(Triple::sparcel, T.getArch());
 166   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 167   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 168
 169   T = Triple("spir-unknown-unknown");
 170   EXPECT_EQ(Triple::spir, T.getArch());
 171   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 172   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 173
 174   T = Triple("spir64-unknown-unknown");
 175   EXPECT_EQ(Triple::spir64, T.getArch());
 176   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 177   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 178
 179   T = Triple("x86_64-unknown-cloudabi");
 180   EXPECT_EQ(Triple::x86_64, T.getArch());
 181   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 182   EXPECT_EQ(Triple::CloudABI, T.getOS());
 183   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 184
 185   T = Triple("wasm32-unknown-unknown");
 186   EXPECT_EQ(Triple::wasm32, T.getArch());
 187   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 188   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 189   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 190
 191   T = Triple("wasm64-unknown-unknown");
 192   EXPECT_EQ(Triple::wasm64, T.getArch());
 193   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 194   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 195   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 196
 197   T = Triple("avr-unknown-unknown");
 198   EXPECT_EQ(Triple::avr, T.getArch());
 199   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 200   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 201   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 202
 203   T = Triple("avr");
 204   EXPECT_EQ(Triple::avr, T.getArch());
 205   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 206   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 207   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 208
 209   T = Triple("huh");
 210   EXPECT_EQ(Triple::UnknownArch, T.getArch());
 211 }
 212
 213 static std::string Join(StringRef A, StringRef B, StringRef C) {
 214   std::string Str = A; Str += '-'; Str += B; Str += '-'; Str += C;
 215   return Str;
 216 }
 217
 218 static std::string Join(StringRef A, StringRef B, StringRef C, StringRef D) {
 219   std::string Str = A; Str += '-'; Str += B; Str += '-'; Str += C; Str += '-';
 220   Str += D; return Str;
 221 }
 222
 223 TEST(TripleTest, Normalization) {
 224
 225   EXPECT_EQ("", Triple::normalize(""));
 226   EXPECT_EQ("-", Triple::normalize("-"));
 227   EXPECT_EQ("--", Triple::normalize("--"));
 228   EXPECT_EQ("---", Triple::normalize("---"));
 229   EXPECT_EQ("----", Triple::normalize("----"));
 230
 231   EXPECT_EQ("a", Triple::normalize("a"));
 232   EXPECT_EQ("a-b", Triple::normalize("a-b"));
 233   EXPECT_EQ("a-b-c", Triple::normalize("a-b-c"));
 234   EXPECT_EQ("a-b-c-d", Triple::normalize("a-b-c-d"));
 235
 236   EXPECT_EQ("i386-b-c", Triple::normalize("i386-b-c"));
 237   EXPECT_EQ("i386-a-c", Triple::normalize("a-i386-c"));
 238   EXPECT_EQ("i386-a-b", Triple::normalize("a-b-i386"));
 239   EXPECT_EQ("i386-a-b-c", Triple::normalize("a-b-c-i386"));
 240
 241   EXPECT_EQ("a-pc-c", Triple::normalize("a-pc-c"));
 242   EXPECT_EQ("-pc-b-c", Triple::normalize("pc-b-c"));
 243   EXPECT_EQ("a-pc-b", Triple::normalize("a-b-pc"));
 244   EXPECT_EQ("a-pc-b-c", Triple::normalize("a-b-c-pc"));
 245
 246   EXPECT_EQ("a-b-linux", Triple::normalize("a-b-linux"));
 247   EXPECT_EQ("--linux-b-c", Triple::normalize("linux-b-c"));
 248   EXPECT_EQ("a--linux-c", Triple::normalize("a-linux-c"));
 249
 250   EXPECT_EQ("i386-pc-a", Triple::normalize("a-pc-i386"));
 251   EXPECT_EQ("i386-pc-", Triple::normalize("-pc-i386"));
 252   EXPECT_EQ("-pc-linux-c", Triple::normalize("linux-pc-c"));
 253   EXPECT_EQ("-pc-linux", Triple::normalize("linux-pc-"));
 254
 255   EXPECT_EQ("i386", Triple::normalize("i386"));
 256   EXPECT_EQ("-pc", Triple::normalize("pc"));
 257   EXPECT_EQ("--linux", Triple::normalize("linux"));
 258
 259   EXPECT_EQ("x86_64--linux-gnu", Triple::normalize("x86_64-gnu-linux"));
 260
 261   // Check that normalizing a permutated set of valid components returns a
 262   // triple with the unpermuted components.
 263   StringRef C[4];
 264   for (int Arch = 1+Triple::UnknownArch; Arch <= Triple::LastArchType; ++Arch) {
 265     C[0] = Triple::getArchTypeName(Triple::ArchType(Arch));
 266     for (int Vendor = 1+Triple::UnknownVendor; Vendor <= Triple::LastVendorType;
 267          ++Vendor) {
 268       C[1] = Triple::getVendorTypeName(Triple::VendorType(Vendor));
 269       for (int OS = 1+Triple::UnknownOS; OS <= Triple::LastOSType; ++OS) {
 270         if (OS == Triple::Win32)
 271           continue;
 272
 273         C[2] = Triple::getOSTypeName(Triple::OSType(OS));
 274
 275         std::string E = Join(C[0], C[1], C[2]);
 276         EXPECT_EQ(E, Triple::normalize(Join(C[0], C[1], C[2])));
 277
 278         EXPECT_EQ(E, Triple::normalize(Join(C[0], C[2], C[1])));
 279         EXPECT_EQ(E, Triple::normalize(Join(C[1], C[2], C[0])));
 280         EXPECT_EQ(E, Triple::normalize(Join(C[1], C[0], C[2])));
 281         EXPECT_EQ(E, Triple::normalize(Join(C[2], C[0], C[1])));
 282         EXPECT_EQ(E, Triple::normalize(Join(C[2], C[1], C[0])));
 283
 284         for (int Env = 1 + Triple::UnknownEnvironment; Env <= Triple::LastEnvironmentType;
 285              ++Env) {
 286           C[3] = Triple::getEnvironmentTypeName(Triple::EnvironmentType(Env));
 287
 288           std::string F = Join(C[0], C[1], C[2], C[3]);
 289           EXPECT_EQ(F, Triple::normalize(Join(C[0], C[1], C[2], C[3])));
 290
 291           EXPECT_EQ(F, Triple::normalize(Join(C[0], C[1], C[3], C[2])));
 292           EXPECT_EQ(F, Triple::normalize(Join(C[0], C[2], C[3], C[1])));
 293           EXPECT_EQ(F, Triple::normalize(Join(C[0], C[2], C[1], C[3])));
 294           EXPECT_EQ(F, Triple::normalize(Join(C[0], C[3], C[1], C[2])));
 295           EXPECT_EQ(F, Triple::normalize(Join(C[0], C[3], C[2], C[1])));
 296           EXPECT_EQ(F, Triple::normalize(Join(C[1], C[2], C[3], C[0])));
 297           EXPECT_EQ(F, Triple::normalize(Join(C[1], C[2], C[0], C[3])));
 298           EXPECT_EQ(F, Triple::normalize(Join(C[1], C[3], C[0], C[2])));
 299           EXPECT_EQ(F, Triple::normalize(Join(C[1], C[3], C[2], C[0])));
 300           EXPECT_EQ(F, Triple::normalize(Join(C[1], C[0], C[2], C[3])));
 301           EXPECT_EQ(F, Triple::normalize(Join(C[1], C[0], C[3], C[2])));
 302           EXPECT_EQ(F, Triple::normalize(Join(C[2], C[3], C[0], C[1])));
 303           EXPECT_EQ(F, Triple::normalize(Join(C[2], C[3], C[1], C[0])));
 304           EXPECT_EQ(F, Triple::normalize(Join(C[2], C[0], C[1], C[3])));
 305           EXPECT_EQ(F, Triple::normalize(Join(C[2], C[0], C[3], C[1])));
 306           EXPECT_EQ(F, Triple::normalize(Join(C[2], C[1], C[3], C[0])));
 307           EXPECT_EQ(F, Triple::normalize(Join(C[2], C[1], C[0], C[3])));
 308           EXPECT_EQ(F, Triple::normalize(Join(C[3], C[0], C[1], C[2])));
 309           EXPECT_EQ(F, Triple::normalize(Join(C[3], C[0], C[2], C[1])));
 310           EXPECT_EQ(F, Triple::normalize(Join(C[3], C[1], C[2], C[0])));
 311           EXPECT_EQ(F, Triple::normalize(Join(C[3], C[1], C[0], C[2])));
 312           EXPECT_EQ(F, Triple::normalize(Join(C[3], C[2], C[0], C[1])));
 313           EXPECT_EQ(F, Triple::normalize(Join(C[3], C[2], C[1], C[0])));
 314         }
 315       }
 316     }
 317   }
 318
 319   // Various real-world funky triples.  The value returned by GCC's config.sub
 320   // is given in the comment.
 321   EXPECT_EQ("i386--windows-gnu", Triple::normalize("i386-mingw32")); // i386-pc-mingw32
 322   EXPECT_EQ("x86_64--linux-gnu", Triple::normalize("x86_64-linux-gnu")); // x86_64-pc-linux-gnu
 323   EXPECT_EQ("i486--linux-gnu", Triple::normalize("i486-linux-gnu")); // i486-pc-linux-gnu
 324   EXPECT_EQ("i386-redhat-linux", Triple::normalize("i386-redhat-linux")); // i386-redhat-linux-gnu
 325   EXPECT_EQ("i686--linux", Triple::normalize("i686-linux")); // i686-pc-linux-gnu
 326   EXPECT_EQ("arm-none--eabi", Triple::normalize("arm-none-eabi")); // arm-none-eabi
 327 }
 328
 329 TEST(TripleTest, MutateName) {
 330   Triple T;
 331   EXPECT_EQ(Triple::UnknownArch, T.getArch());
 332   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 333   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 334   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 335
 336   T.setArchName("i386");
 337   EXPECT_EQ(Triple::x86, T.getArch());
 338   EXPECT_EQ("i386--", T.getTriple());
 339
 340   T.setVendorName("pc");
 341   EXPECT_EQ(Triple::x86, T.getArch());
 342   EXPECT_EQ(Triple::PC, T.getVendor());
 343   EXPECT_EQ("i386-pc-", T.getTriple());
 344
 345   T.setOSName("linux");
 346   EXPECT_EQ(Triple::x86, T.getArch());
 347   EXPECT_EQ(Triple::PC, T.getVendor());
 348   EXPECT_EQ(Triple::Linux, T.getOS());
 349   EXPECT_EQ("i386-pc-linux", T.getTriple());
 350
 351   T.setEnvironmentName("gnu");
 352   EXPECT_EQ(Triple::x86, T.getArch());
 353   EXPECT_EQ(Triple::PC, T.getVendor());
 354   EXPECT_EQ(Triple::Linux, T.getOS());
 355   EXPECT_EQ("i386-pc-linux-gnu", T.getTriple());
 356
 357   T.setOSName("freebsd");
 358   EXPECT_EQ(Triple::x86, T.getArch());
 359   EXPECT_EQ(Triple::PC, T.getVendor());
 360   EXPECT_EQ(Triple::FreeBSD, T.getOS());
 361   EXPECT_EQ("i386-pc-freebsd-gnu", T.getTriple());
 362
 363   T.setOSAndEnvironmentName("darwin");
 364   EXPECT_EQ(Triple::x86, T.getArch());
 365   EXPECT_EQ(Triple::PC, T.getVendor());
 366   EXPECT_EQ(Triple::Darwin, T.getOS());
 367   EXPECT_EQ("i386-pc-darwin", T.getTriple());
 368
 369   T.setEnvironmentName("amdopencl");
 370   EXPECT_EQ(Triple::AMDOpenCL, T.getEnvironment());
 371 }
 372
 373 TEST(TripleTest, BitWidthPredicates) {
 374   Triple T;
 375   EXPECT_FALSE(T.isArch16Bit());
 376   EXPECT_FALSE(T.isArch32Bit());
 377   EXPECT_FALSE(T.isArch64Bit());
 378
 379   T.setArch(Triple::arm);
 380   EXPECT_FALSE(T.isArch16Bit());
 381   EXPECT_TRUE(T.isArch32Bit());
 382   EXPECT_FALSE(T.isArch64Bit());
 383
 384   T.setArch(Triple::hexagon);
 385   EXPECT_FALSE(T.isArch16Bit());
 386   EXPECT_TRUE(T.isArch32Bit());
 387   EXPECT_FALSE(T.isArch64Bit());
 388
 389   T.setArch(Triple::mips);
 390   EXPECT_FALSE(T.isArch16Bit());
 391   EXPECT_TRUE(T.isArch32Bit());
 392   EXPECT_FALSE(T.isArch64Bit());
 393
 394   T.setArch(Triple::mips64);
 395   EXPECT_FALSE(T.isArch16Bit());
 396   EXPECT_FALSE(T.isArch32Bit());
 397   EXPECT_TRUE(T.isArch64Bit());
 398
 399   T.setArch(Triple::msp430);
 400   EXPECT_TRUE(T.isArch16Bit());
 401   EXPECT_FALSE(T.isArch32Bit());
 402   EXPECT_FALSE(T.isArch64Bit());
 403
 404   T.setArch(Triple::ppc);
 405   EXPECT_FALSE(T.isArch16Bit());
 406   EXPECT_TRUE(T.isArch32Bit());
 407   EXPECT_FALSE(T.isArch64Bit());
 408
 409   T.setArch(Triple::ppc64);
 410   EXPECT_FALSE(T.isArch16Bit());
 411   EXPECT_FALSE(T.isArch32Bit());
 412   EXPECT_TRUE(T.isArch64Bit());
 413
 414   T.setArch(Triple::x86);
 415   EXPECT_FALSE(T.isArch16Bit());
 416   EXPECT_TRUE(T.isArch32Bit());
 417   EXPECT_FALSE(T.isArch64Bit());
 418
 419   T.setArch(Triple::x86_64);
 420   EXPECT_FALSE(T.isArch16Bit());
 421   EXPECT_FALSE(T.isArch32Bit());
 422   EXPECT_TRUE(T.isArch64Bit());
 423
 424   T.setArch(Triple::amdil);
 425   EXPECT_FALSE(T.isArch16Bit());
 426   EXPECT_TRUE(T.isArch32Bit());
 427   EXPECT_FALSE(T.isArch64Bit());
 428
 429   T.setArch(Triple::amdil64);
 430   EXPECT_FALSE(T.isArch16Bit());
 431   EXPECT_FALSE(T.isArch32Bit());
 432   EXPECT_TRUE(T.isArch64Bit());
 433
 434   T.setArch(Triple::hsail);
 435   EXPECT_FALSE(T.isArch16Bit());
 436   EXPECT_TRUE(T.isArch32Bit());
 437   EXPECT_FALSE(T.isArch64Bit());
 438
 439   T.setArch(Triple::hsail64);
 440   EXPECT_FALSE(T.isArch16Bit());
 441   EXPECT_FALSE(T.isArch32Bit());
 442   EXPECT_TRUE(T.isArch64Bit());
 443
 444   T.setArch(Triple::spir);
 445   EXPECT_FALSE(T.isArch16Bit());
 446   EXPECT_TRUE(T.isArch32Bit());
 447   EXPECT_FALSE(T.isArch64Bit());
 448
 449   T.setArch(Triple::spir64);
 450   EXPECT_FALSE(T.isArch16Bit());
 451   EXPECT_FALSE(T.isArch32Bit());
 452   EXPECT_TRUE(T.isArch64Bit());
 453
 454   T.setArch(Triple::sparc);
 455   EXPECT_FALSE(T.isArch16Bit());
 456   EXPECT_TRUE(T.isArch32Bit());
 457   EXPECT_FALSE(T.isArch64Bit());
 458
 459   T.setArch(Triple::sparcel);
 460   EXPECT_FALSE(T.isArch16Bit());
 461   EXPECT_TRUE(T.isArch32Bit());
 462   EXPECT_FALSE(T.isArch64Bit());
 463
 464   T.setArch(Triple::sparcv9);
 465   EXPECT_FALSE(T.isArch16Bit());
 466   EXPECT_FALSE(T.isArch32Bit());
 467   EXPECT_TRUE(T.isArch64Bit());
 468
 469   T.setArch(Triple::wasm32);
 470   EXPECT_FALSE(T.isArch16Bit());
 471   EXPECT_TRUE(T.isArch32Bit());
 472   EXPECT_FALSE(T.isArch64Bit());
 473
 474   T.setArch(Triple::wasm64);
 475   EXPECT_FALSE(T.isArch16Bit());
 476   EXPECT_FALSE(T.isArch32Bit());
 477   EXPECT_TRUE(T.isArch64Bit());
 478
 479   T.setArch(Triple::avr);
 480   EXPECT_TRUE(T.isArch16Bit());
 481   EXPECT_FALSE(T.isArch32Bit());
 482   EXPECT_FALSE(T.isArch64Bit());
 483 }
 484
 485 TEST(TripleTest, BitWidthArchVariants) {
 486   Triple T;
 487   EXPECT_EQ(Triple::UnknownArch, T.get32BitArchVariant().getArch());
 488   EXPECT_EQ(Triple::UnknownArch, T.get64BitArchVariant().getArch());
 489
 490   T.setArch(Triple::UnknownArch);
 491   EXPECT_EQ(Triple::UnknownArch, T.get32BitArchVariant().getArch());
 492   EXPECT_EQ(Triple::UnknownArch, T.get64BitArchVariant().getArch());
 493
 494   T.setArch(Triple::mips);
 495   EXPECT_EQ(Triple::mips, T.get32BitArchVariant().getArch());
 496   EXPECT_EQ(Triple::mips64, T.get64BitArchVariant().getArch());
 497
 498   T.setArch(Triple::mipsel);
 499   EXPECT_EQ(Triple::mipsel, T.get32BitArchVariant().getArch());
 500   EXPECT_EQ(Triple::mips64el, T.get64BitArchVariant().getArch());
 501
 502   T.setArch(Triple::ppc);
 503   EXPECT_EQ(Triple::ppc, T.get32BitArchVariant().getArch());
 504   EXPECT_EQ(Triple::ppc64, T.get64BitArchVariant().getArch());
 505
 506   T.setArch(Triple::nvptx);
 507   EXPECT_EQ(Triple::nvptx, T.get32BitArchVariant().getArch());
 508   EXPECT_EQ(Triple::nvptx64, T.get64BitArchVariant().getArch());
 509
 510   T.setArch(Triple::sparc);
 511   EXPECT_EQ(Triple::sparc, T.get32BitArchVariant().getArch());
 512   EXPECT_EQ(Triple::sparcv9, T.get64BitArchVariant().getArch());
 513
 514   T.setArch(Triple::x86);
 515   EXPECT_EQ(Triple::x86, T.get32BitArchVariant().getArch());
 516   EXPECT_EQ(Triple::x86_64, T.get64BitArchVariant().getArch());
 517
 518   T.setArch(Triple::mips64);
 519   EXPECT_EQ(Triple::mips, T.get32BitArchVariant().getArch());
 520   EXPECT_EQ(Triple::mips64, T.get64BitArchVariant().getArch());
 521
 522   T.setArch(Triple::mips64el);
 523   EXPECT_EQ(Triple::mipsel, T.get32BitArchVariant().getArch());
 524   EXPECT_EQ(Triple::mips64el, T.get64BitArchVariant().getArch());
 525
 526   T.setArch(Triple::ppc64);
 527   EXPECT_EQ(Triple::ppc, T.get32BitArchVariant().getArch());
 528   EXPECT_EQ(Triple::ppc64, T.get64BitArchVariant().getArch());
 529
 530   T.setArch(Triple::nvptx64);
 531   EXPECT_EQ(Triple::nvptx, T.get32BitArchVariant().getArch());
 532   EXPECT_EQ(Triple::nvptx64, T.get64BitArchVariant().getArch());
 533
 534   T.setArch(Triple::sparcv9);
 535   EXPECT_EQ(Triple::sparc, T.get32BitArchVariant().getArch());
 536   EXPECT_EQ(Triple::sparcv9, T.get64BitArchVariant().getArch());
 537
 538   T.setArch(Triple::x86_64);
 539   EXPECT_EQ(Triple::x86, T.get32BitArchVariant().getArch());
 540   EXPECT_EQ(Triple::x86_64, T.get64BitArchVariant().getArch());
 541
 542   T.setArch(Triple::amdil);
 543   EXPECT_EQ(Triple::amdil, T.get32BitArchVariant().getArch());
 544   EXPECT_EQ(Triple::amdil64, T.get64BitArchVariant().getArch());
 545
 546   T.setArch(Triple::amdil64);
 547   EXPECT_EQ(Triple::amdil, T.get32BitArchVariant().getArch());
 548   EXPECT_EQ(Triple::amdil64, T.get64BitArchVariant().getArch());
 549
 550   T.setArch(Triple::hsail);
 551   EXPECT_EQ(Triple::hsail, T.get32BitArchVariant().getArch());
 552   EXPECT_EQ(Triple::hsail64, T.get64BitArchVariant().getArch());
 553
 554   T.setArch(Triple::hsail64);
 555   EXPECT_EQ(Triple::hsail, T.get32BitArchVariant().getArch());
 556   EXPECT_EQ(Triple::hsail64, T.get64BitArchVariant().getArch());
 557
 558   T.setArch(Triple::spir);
 559   EXPECT_EQ(Triple::spir, T.get32BitArchVariant().getArch());
 560   EXPECT_EQ(Triple::spir64, T.get64BitArchVariant().getArch());
 561
 562   T.setArch(Triple::spir64);
 563   EXPECT_EQ(Triple::spir, T.get32BitArchVariant().getArch());
 564   EXPECT_EQ(Triple::spir64, T.get64BitArchVariant().getArch());
 565
 566   T.setArch(Triple::wasm32);
 567   EXPECT_EQ(Triple::wasm32, T.get32BitArchVariant().getArch());
 568   EXPECT_EQ(Triple::wasm64, T.get64BitArchVariant().getArch());
 569
 570   T.setArch(Triple::wasm64);
 571   EXPECT_EQ(Triple::wasm32, T.get32BitArchVariant().getArch());
 572   EXPECT_EQ(Triple::wasm64, T.get64BitArchVariant().getArch());
 573 }
 574
 575 TEST(TripleTest, EndianArchVariants) {
 576   Triple T;
 577   EXPECT_EQ(Triple::UnknownArch, T.getBigEndianArchVariant().getArch());
 578   EXPECT_EQ(Triple::UnknownArch, T.getLittleEndianArchVariant().getArch());
 579
 580   T.setArch(Triple::UnknownArch);
 581   EXPECT_EQ(Triple::UnknownArch, T.getBigEndianArchVariant().getArch());
 582   EXPECT_EQ(Triple::UnknownArch, T.getLittleEndianArchVariant().getArch());
 583
 584   T.setArch(Triple::aarch64_be);
 585   EXPECT_EQ(Triple::aarch64_be, T.getBigEndianArchVariant().getArch());
 586   EXPECT_EQ(Triple::aarch64, T.getLittleEndianArchVariant().getArch());
 587
 588   T.setArch(Triple::aarch64);
 589   EXPECT_EQ(Triple::aarch64_be, T.getBigEndianArchVariant().getArch());
 590   EXPECT_EQ(Triple::aarch64, T.getLittleEndianArchVariant().getArch());
 591
 592   T.setArch(Triple::armeb);
 593   EXPECT_EQ(Triple::armeb, T.getBigEndianArchVariant().getArch());
 594   EXPECT_EQ(Triple::UnknownArch, T.getLittleEndianArchVariant().getArch());
 595
 596   T.setArch(Triple::arm);
 597   EXPECT_EQ(Triple::UnknownArch, T.getBigEndianArchVariant().getArch());
 598   EXPECT_EQ(Triple::arm, T.getLittleEndianArchVariant().getArch());
 599
 600   T.setArch(Triple::bpfeb);
 601   EXPECT_EQ(Triple::bpfeb, T.getBigEndianArchVariant().getArch());
 602   EXPECT_EQ(Triple::bpfel, T.getLittleEndianArchVariant().getArch());
 603
 604   T.setArch(Triple::bpfel);
 605   EXPECT_EQ(Triple::bpfeb, T.getBigEndianArchVariant().getArch());
 606   EXPECT_EQ(Triple::bpfel, T.getLittleEndianArchVariant().getArch());
 607
 608   T.setArch(Triple::mips64);
 609   EXPECT_EQ(Triple::mips64, T.getBigEndianArchVariant().getArch());
 610   EXPECT_EQ(Triple::mips64el, T.getLittleEndianArchVariant().getArch());
 611
 612   T.setArch(Triple::mips64el);
 613   EXPECT_EQ(Triple::mips64, T.getBigEndianArchVariant().getArch());
 614   EXPECT_EQ(Triple::mips64el, T.getLittleEndianArchVariant().getArch());
 615
 616   T.setArch(Triple::mips);
 617   EXPECT_EQ(Triple::mips, T.getBigEndianArchVariant().getArch());
 618   EXPECT_EQ(Triple::mipsel, T.getLittleEndianArchVariant().getArch());
 619
 620   T.setArch(Triple::mipsel);
 621   EXPECT_EQ(Triple::mips, T.getBigEndianArchVariant().getArch());
 622   EXPECT_EQ(Triple::mipsel, T.getLittleEndianArchVariant().getArch());
 623
 624   T.setArch(Triple::ppc);
 625   EXPECT_EQ(Triple::ppc, T.getBigEndianArchVariant().getArch());
 626   EXPECT_EQ(Triple::UnknownArch, T.getLittleEndianArchVariant().getArch());
 627
 628   T.setArch(Triple::ppc64);
 629   EXPECT_EQ(Triple::ppc64, T.getBigEndianArchVariant().getArch());
 630   EXPECT_EQ(Triple::ppc64le, T.getLittleEndianArchVariant().getArch());
 631
 632   T.setArch(Triple::ppc64le);
 633   EXPECT_EQ(Triple::ppc64, T.getBigEndianArchVariant().getArch());
 634   EXPECT_EQ(Triple::ppc64le, T.getLittleEndianArchVariant().getArch());
 635
 636   T.setArch(Triple::sparc);
 637   EXPECT_EQ(Triple::sparc, T.getBigEndianArchVariant().getArch());
 638   EXPECT_EQ(Triple::sparcel, T.getLittleEndianArchVariant().getArch());
 639
 640   T.setArch(Triple::sparcel);
 641   EXPECT_EQ(Triple::sparc, T.getBigEndianArchVariant().getArch());
 642   EXPECT_EQ(Triple::sparcel, T.getLittleEndianArchVariant().getArch());
 643
 644   T.setArch(Triple::thumb);
 645   EXPECT_EQ(Triple::UnknownArch, T.getBigEndianArchVariant().getArch());
 646   EXPECT_EQ(Triple::thumb, T.getLittleEndianArchVariant().getArch());
 647
 648   T.setArch(Triple::thumbeb);
 649   EXPECT_EQ(Triple::thumbeb, T.getBigEndianArchVariant().getArch());
 650   EXPECT_EQ(Triple::UnknownArch, T.getLittleEndianArchVariant().getArch());
 651 }
 652
 653 TEST(TripleTest, getOSVersion) {
 654   Triple T;
 655   unsigned Major, Minor, Micro;
 656
 657   T = Triple("i386-apple-darwin9");
 658   EXPECT_TRUE(T.isMacOSX());
 659   EXPECT_FALSE(T.isiOS());
 660   EXPECT_FALSE(T.isArch16Bit());
 661   EXPECT_TRUE(T.isArch32Bit());
 662   EXPECT_FALSE(T.isArch64Bit());
 663   T.getMacOSXVersion(Major, Minor, Micro);
 664   EXPECT_EQ((unsigned)10, Major);
 665   EXPECT_EQ((unsigned)5, Minor);
 666   EXPECT_EQ((unsigned)0, Micro);
 667   T.getiOSVersion(Major, Minor, Micro);
 668   EXPECT_EQ((unsigned)5, Major);
 669   EXPECT_EQ((unsigned)0, Minor);
 670   EXPECT_EQ((unsigned)0, Micro);
 671
 672   T = Triple("x86_64-apple-darwin9");
 673   EXPECT_TRUE(T.isMacOSX());
 674   EXPECT_FALSE(T.isiOS());
 675   EXPECT_FALSE(T.isArch16Bit());
 676   EXPECT_FALSE(T.isArch32Bit());
 677   EXPECT_TRUE(T.isArch64Bit());
 678   T.getMacOSXVersion(Major, Minor, Micro);
 679   EXPECT_EQ((unsigned)10, Major);
 680   EXPECT_EQ((unsigned)5, Minor);
 681   EXPECT_EQ((unsigned)0, Micro);
 682   T.getiOSVersion(Major, Minor, Micro);
 683   EXPECT_EQ((unsigned)5, Major);
 684   EXPECT_EQ((unsigned)0, Minor);
 685   EXPECT_EQ((unsigned)0, Micro);
 686
 687   T = Triple("x86_64-apple-macosx");
 688   EXPECT_TRUE(T.isMacOSX());
 689   EXPECT_FALSE(T.isiOS());
 690   EXPECT_FALSE(T.isArch16Bit());
 691   EXPECT_FALSE(T.isArch32Bit());
 692   EXPECT_TRUE(T.isArch64Bit());
 693   T.getMacOSXVersion(Major, Minor, Micro);
 694   EXPECT_EQ((unsigned)10, Major);
 695   EXPECT_EQ((unsigned)4, Minor);
 696   EXPECT_EQ((unsigned)0, Micro);
 697   T.getiOSVersion(Major, Minor, Micro);
 698   EXPECT_EQ((unsigned)5, Major);
 699   EXPECT_EQ((unsigned)0, Minor);
 700   EXPECT_EQ((unsigned)0, Micro);
 701
 702   T = Triple("x86_64-apple-macosx10.7");
 703   EXPECT_TRUE(T.isMacOSX());
 704   EXPECT_FALSE(T.isiOS());
 705   EXPECT_FALSE(T.isArch16Bit());
 706   EXPECT_FALSE(T.isArch32Bit());
 707   EXPECT_TRUE(T.isArch64Bit());
 708   T.getMacOSXVersion(Major, Minor, Micro);
 709   EXPECT_EQ((unsigned)10, Major);
 710   EXPECT_EQ((unsigned)7, Minor);
 711   EXPECT_EQ((unsigned)0, Micro);
 712   T.getiOSVersion(Major, Minor, Micro);
 713   EXPECT_EQ((unsigned)5, Major);
 714   EXPECT_EQ((unsigned)0, Minor);
 715   EXPECT_EQ((unsigned)0, Micro);
 716
 717   T = Triple("armv7-apple-ios");
 718   EXPECT_FALSE(T.isMacOSX());
 719   EXPECT_TRUE(T.isiOS());
 720   EXPECT_FALSE(T.isArch16Bit());
 721   EXPECT_TRUE(T.isArch32Bit());
 722   EXPECT_FALSE(T.isArch64Bit());
 723   T.getMacOSXVersion(Major, Minor, Micro);
 724   EXPECT_EQ((unsigned)10, Major);
 725   EXPECT_EQ((unsigned)4, Minor);
 726   EXPECT_EQ((unsigned)0, Micro);
 727   T.getiOSVersion(Major, Minor, Micro);
 728   EXPECT_EQ((unsigned)5, Major);
 729   EXPECT_EQ((unsigned)0, Minor);
 730   EXPECT_EQ((unsigned)0, Micro);
 731
 732   T = Triple("armv7-apple-ios7.0");
 733   EXPECT_FALSE(T.isMacOSX());
 734   EXPECT_TRUE(T.isiOS());
 735   EXPECT_FALSE(T.isArch16Bit());
 736   EXPECT_TRUE(T.isArch32Bit());
 737   EXPECT_FALSE(T.isArch64Bit());
 738   T.getMacOSXVersion(Major, Minor, Micro);
 739   EXPECT_EQ((unsigned)10, Major);
 740   EXPECT_EQ((unsigned)4, Minor);
 741   EXPECT_EQ((unsigned)0, Micro);
 742   T.getiOSVersion(Major, Minor, Micro);
 743   EXPECT_EQ((unsigned)7, Major);
 744   EXPECT_EQ((unsigned)0, Minor);
 745   EXPECT_EQ((unsigned)0, Micro);
 746 }
 747
 748 TEST(TripleTest, FileFormat) {
 749   EXPECT_EQ(Triple::ELF, Triple("i686-unknown-linux-gnu").getObjectFormat());
 750   EXPECT_EQ(Triple::ELF, Triple("i686-unknown-freebsd").getObjectFormat());
 751   EXPECT_EQ(Triple::ELF, Triple("i686-unknown-netbsd").getObjectFormat());
 752   EXPECT_EQ(Triple::ELF, Triple("i686--win32-elf").getObjectFormat());
 753   EXPECT_EQ(Triple::ELF, Triple("i686---elf").getObjectFormat());
 754
 755   EXPECT_EQ(Triple::MachO, Triple("i686-apple-macosx").getObjectFormat());
 756   EXPECT_EQ(Triple::MachO, Triple("i686-apple-ios").getObjectFormat());
 757   EXPECT_EQ(Triple::MachO, Triple("i686---macho").getObjectFormat());
 758
 759   EXPECT_EQ(Triple::COFF, Triple("i686--win32").getObjectFormat());
 760
 761   EXPECT_EQ(Triple::ELF, Triple("i686-pc-windows-msvc-elf").getObjectFormat());
 762   EXPECT_EQ(Triple::ELF, Triple("i686-pc-cygwin-elf").getObjectFormat());
 763
 764   Triple MSVCNormalized(Triple::normalize("i686-pc-windows-msvc-elf"));
 765   EXPECT_EQ(Triple::ELF, MSVCNormalized.getObjectFormat());
 766
 767   Triple GNUWindowsNormalized(Triple::normalize("i686-pc-windows-gnu-elf"));
 768   EXPECT_EQ(Triple::ELF, GNUWindowsNormalized.getObjectFormat());
 769
 770   Triple CygnusNormalised(Triple::normalize("i686-pc-windows-cygnus-elf"));
 771   EXPECT_EQ(Triple::ELF, CygnusNormalised.getObjectFormat());
 772
 773   Triple CygwinNormalized(Triple::normalize("i686-pc-cygwin-elf"));
 774   EXPECT_EQ(Triple::ELF, CygwinNormalized.getObjectFormat());
 775
 776   Triple T = Triple("");
 777   T.setObjectFormat(Triple::ELF);
 778   EXPECT_EQ(Triple::ELF, T.getObjectFormat());
 779 }
 780
 781 TEST(TripleTest, NormalizeWindows) {
 782   EXPECT_EQ("i686-pc-windows-msvc", Triple::normalize("i686-pc-win32"));
 783   EXPECT_EQ("i686--windows-msvc", Triple::normalize("i686-win32"));
 784   EXPECT_EQ("i686-pc-windows-gnu", Triple::normalize("i686-pc-mingw32"));
 785   EXPECT_EQ("i686--windows-gnu", Triple::normalize("i686-mingw32"));
 786   EXPECT_EQ("i686-pc-windows-gnu", Triple::normalize("i686-pc-mingw32-w64"));
 787   EXPECT_EQ("i686--windows-gnu", Triple::normalize("i686-mingw32-w64"));
 788   EXPECT_EQ("i686-pc-windows-cygnus", Triple::normalize("i686-pc-cygwin"));
 789   EXPECT_EQ("i686--windows-cygnus", Triple::normalize("i686-cygwin"));
 790
 791   EXPECT_EQ("x86_64-pc-windows-msvc", Triple::normalize("x86_64-pc-win32"));
 792   EXPECT_EQ("x86_64--windows-msvc", Triple::normalize("x86_64-win32"));
 793   EXPECT_EQ("x86_64-pc-windows-gnu", Triple::normalize("x86_64-pc-mingw32"));
 794   EXPECT_EQ("x86_64--windows-gnu", Triple::normalize("x86_64-mingw32"));
 795   EXPECT_EQ("x86_64-pc-windows-gnu", Triple::normalize("x86_64-pc-mingw32-w64"));
 796   EXPECT_EQ("x86_64--windows-gnu", Triple::normalize("x86_64-mingw32-w64"));
 797
 798   EXPECT_EQ("i686-pc-windows-elf", Triple::normalize("i686-pc-win32-elf"));
 799   EXPECT_EQ("i686--windows-elf", Triple::normalize("i686-win32-elf"));
 800   EXPECT_EQ("i686-pc-windows-macho", Triple::normalize("i686-pc-win32-macho"));
 801   EXPECT_EQ("i686--windows-macho", Triple::normalize("i686-win32-macho"));
 802
 803   EXPECT_EQ("x86_64-pc-windows-elf", Triple::normalize("x86_64-pc-win32-elf"));
 804   EXPECT_EQ("x86_64--windows-elf", Triple::normalize("x86_64-win32-elf"));
 805   EXPECT_EQ("x86_64-pc-windows-macho", Triple::normalize("x86_64-pc-win32-macho"));
 806   EXPECT_EQ("x86_64--windows-macho", Triple::normalize("x86_64-win32-macho"));
 807
 808   EXPECT_EQ("i686-pc-windows-cygnus",
 809             Triple::normalize("i686-pc-windows-cygnus"));
 810   EXPECT_EQ("i686-pc-windows-gnu", Triple::normalize("i686-pc-windows-gnu"));
 811   EXPECT_EQ("i686-pc-windows-itanium", Triple::normalize("i686-pc-windows-itanium"));
 812   EXPECT_EQ("i686-pc-windows-msvc", Triple::normalize("i686-pc-windows-msvc"));
 813
 814   EXPECT_EQ("i686-pc-windows-elf", Triple::normalize("i686-pc-windows-elf-elf"));
 815 }
 816
 817 TEST(TripleTest, getARMCPUForArch) {
 818   // Standard ARM Architectures.
 819   {
 820     llvm::Triple Triple("armv4-unknown-eabi");
 821     EXPECT_EQ("strongarm", Triple.getARMCPUForArch());
 822   }
 823   {
 824     llvm::Triple Triple("armv4t-unknown-eabi");
 825     EXPECT_EQ("arm7tdmi", Triple.getARMCPUForArch());
 826   }
 827   {
 828     llvm::Triple Triple("armv5-unknown-eabi");
 829     EXPECT_EQ("arm10tdmi", Triple.getARMCPUForArch());
 830   }
 831   {
 832     llvm::Triple Triple("armv5t-unknown-eabi");
 833     EXPECT_EQ("arm10tdmi", Triple.getARMCPUForArch());
 834   }
 835   {
 836     llvm::Triple Triple("armv5e-unknown-eabi");
 837     EXPECT_EQ("arm1022e", Triple.getARMCPUForArch());
 838   }
 839   {
 840     llvm::Triple Triple("armv5tej-unknown-eabi");
 841     EXPECT_EQ("arm926ej-s", Triple.getARMCPUForArch());
 842   }
 843   {
 844     llvm::Triple Triple("armv6-unknown-eabi");
 845     EXPECT_EQ("arm1136jf-s", Triple.getARMCPUForArch());
 846   }
 847   {
 848     llvm::Triple Triple("armv6j-unknown-eabi");
 849     EXPECT_EQ("arm1136j-s", Triple.getARMCPUForArch());
 850   }
 851   {
 852     llvm::Triple Triple("armv6k-unknown-eabi");
 853     EXPECT_EQ("arm1176jzf-s", Triple.getARMCPUForArch());
 854   }
 855   {
 856     llvm::Triple Triple("armv6zk-unknown-eabi");
 857     EXPECT_EQ("arm1176jzf-s", Triple.getARMCPUForArch());
 858   }
 859   {
 860     llvm::Triple Triple("armv6t2-unknown-eabi");
 861     EXPECT_EQ("arm1156t2-s", Triple.getARMCPUForArch());
 862   }
 863   {
 864     llvm::Triple Triple("armv6m-unknown-eabi");
 865     EXPECT_EQ("cortex-m0", Triple.getARMCPUForArch());
 866   }
 867   {
 868     llvm::Triple Triple("armv7-unknown-eabi");
 869     EXPECT_EQ("cortex-a8", Triple.getARMCPUForArch());
 870   }
 871   {
 872     llvm::Triple Triple("armv7a-unknown-eabi");
 873     EXPECT_EQ("cortex-a8", Triple.getARMCPUForArch());
 874   }
 875   {
 876     llvm::Triple Triple("armv7m-unknown-eabi");
 877     EXPECT_EQ("cortex-m3", Triple.getARMCPUForArch());
 878   }
 879   {
 880     llvm::Triple Triple("armv7r-unknown-eabi");
 881     EXPECT_EQ("cortex-r4", Triple.getARMCPUForArch());
 882   }
 883   {
 884     llvm::Triple Triple("armv7r-unknown-eabi");
 885     EXPECT_EQ("cortex-r4", Triple.getARMCPUForArch());
 886   }
 887   {
 888     llvm::Triple Triple("armv7r-unknown-eabi");
 889     EXPECT_EQ("cortex-r4", Triple.getARMCPUForArch());
 890   }
 891   {
 892     llvm::Triple Triple("armv7r-unknown-eabi");
 893     EXPECT_EQ("cortex-r4", Triple.getARMCPUForArch());
 894   }
 895   {
 896     llvm::Triple Triple("armv8a-unknown-eabi");
 897     EXPECT_EQ("cortex-a53", Triple.getARMCPUForArch());
 898   }
 899   {
 900     llvm::Triple Triple("armv8.1a-unknown-eabi");
 901     EXPECT_EQ("generic", Triple.getARMCPUForArch());
 902   }
 903   // Non-synonym names, using -march style, not default arch.
 904   {
 905     llvm::Triple Triple("arm");
 906     EXPECT_EQ("cortex-a8", Triple.getARMCPUForArch("armv7-a"));
 907   }
 908   {
 909     llvm::Triple Triple("arm");
 910     EXPECT_EQ("cortex-m3", Triple.getARMCPUForArch("armv7-m"));
 911   }
 912   {
 913     llvm::Triple Triple("arm");
 914     EXPECT_EQ("cortex-a53", Triple.getARMCPUForArch("armv8"));
 915   }
 916   {
 917     llvm::Triple Triple("arm");
 918     EXPECT_EQ("cortex-a53", Triple.getARMCPUForArch("armv8-a"));
 919   }
 920   // Platform specific defaults.
 921   {
 922     llvm::Triple Triple("arm--nacl");
 923     EXPECT_EQ("cortex-a8", Triple.getARMCPUForArch());
 924   }
 925   {
 926     llvm::Triple Triple("armv6-unknown-freebsd");
 927     EXPECT_EQ("arm1176jzf-s", Triple.getARMCPUForArch());
 928   }
 929   {
 930     llvm::Triple Triple("thumbv6-unknown-freebsd");
 931     EXPECT_EQ("arm1176jzf-s", Triple.getARMCPUForArch());
 932   }
 933   {
 934     llvm::Triple Triple("armebv6-unknown-freebsd");
 935     EXPECT_EQ("arm1176jzf-s", Triple.getARMCPUForArch());
 936   }
 937   {
 938     llvm::Triple Triple("arm--win32");
 939     EXPECT_EQ("cortex-a9", Triple.getARMCPUForArch());
 940   }
 941   // Some alternative architectures
 942   {
 943     llvm::Triple Triple("xscale-unknown-eabi");
 944     EXPECT_EQ("xscale", Triple.getARMCPUForArch());
 945   }
 946   {
 947     llvm::Triple Triple("iwmmxt-unknown-eabi");
 948     EXPECT_EQ("iwmmxt", Triple.getARMCPUForArch());
 949   }
 950   {
 951     llvm::Triple Triple("armv7s-apple-ios7");
 952     EXPECT_EQ("swift", Triple.getARMCPUForArch());
 953   }
 954   {
 955     llvm::Triple Triple("armv7em-apple-ios7");
 956     EXPECT_EQ("cortex-m4", Triple.getARMCPUForArch());
 957   }
 958   {
 959     llvm::Triple Triple("armv7l-linux-gnueabihf");
 960     EXPECT_EQ("cortex-a8", Triple.getARMCPUForArch());
 961   }
 962   {
 963     llvm::Triple Triple("armv6sm-apple-ios7");
 964     EXPECT_EQ("cortex-m0", Triple.getARMCPUForArch());
 965   }
 966   // armeb is permitted, but armebeb is not
 967   {
 968     llvm::Triple Triple("armeb-none-eabi");
 969     EXPECT_EQ("arm7tdmi", Triple.getARMCPUForArch());
 970   }
 971   {
 972     llvm::Triple Triple("armebeb-none-eabi");
 973     EXPECT_EQ("", Triple.getARMCPUForArch());
 974   }
 975   {
 976     llvm::Triple Triple("armebv6eb-none-eabi");
 977     EXPECT_EQ("", Triple.getARMCPUForArch());
 978   }
 979   // armebv6 and armv6eb are permitted, but armebv6eb is not
 980   {
 981     llvm::Triple Triple("armebv6-non-eabi");
 982     EXPECT_EQ("arm1136jf-s", Triple.getARMCPUForArch());
 983   }
 984   {
 985     llvm::Triple Triple("armv6eb-none-eabi");
 986     EXPECT_EQ("arm1136jf-s", Triple.getARMCPUForArch());
 987   }
 988   // xscaleeb is permitted, but armebxscale is not
 989   {
 990     llvm::Triple Triple("xscaleeb-none-eabi");
 991     EXPECT_EQ("xscale", Triple.getARMCPUForArch());
 992   }
 993   {
 994     llvm::Triple Triple("armebxscale-none-eabi");
 995     EXPECT_EQ("", Triple.getARMCPUForArch());
 996   }
 997 }
 998
 999 TEST(TripleTest, NormalizeARM) {
1000   EXPECT_EQ("armv6--netbsd-eabi", Triple::normalize("armv6-netbsd-eabi"));
1001   EXPECT_EQ("armv7--netbsd-eabi", Triple::normalize("armv7-netbsd-eabi"));
1002   EXPECT_EQ("armv6eb--netbsd-eabi", Triple::normalize("armv6eb-netbsd-eabi"));
1003   EXPECT_EQ("armv7eb--netbsd-eabi", Triple::normalize("armv7eb-netbsd-eabi"));
1004   EXPECT_EQ("armv6--netbsd-eabihf", Triple::normalize("armv6-netbsd-eabihf"));
1005   EXPECT_EQ("armv7--netbsd-eabihf", Triple::normalize("armv7-netbsd-eabihf"));
1006   EXPECT_EQ("armv6eb--netbsd-eabihf", Triple::normalize("armv6eb-netbsd-eabihf"));
1007   EXPECT_EQ("armv7eb--netbsd-eabihf", Triple::normalize("armv7eb-netbsd-eabihf"));
1008
1009   Triple T;
1010   T = Triple("armv6--netbsd-eabi");
1011   EXPECT_EQ(Triple::arm, T.getArch());
1012   T = Triple("armv6eb--netbsd-eabi");
1013   EXPECT_EQ(Triple::armeb, T.getArch());
1014 }
1015
1016 TEST(TripleTest, ParseARMArch) {
1017   // ARM
1018   {
1019     Triple T = Triple("arm");
1020     EXPECT_EQ(Triple::arm, T.getArch());
1021   }
1022   {
1023     Triple T = Triple("armv6t2");
1024     EXPECT_EQ(Triple::arm, T.getArch());
1025   }
1026   {
1027     Triple T = Triple("armv8");
1028     EXPECT_EQ(Triple::arm, T.getArch());
1029   }
1030   {
1031     Triple T = Triple("armeb");
1032     EXPECT_EQ(Triple::armeb, T.getArch());
1033   }
1034   {
1035     Triple T = Triple("armv5eb");
1036     EXPECT_EQ(Triple::armeb, T.getArch());
1037   }
1038   {
1039     Triple T = Triple("armebv7m");
1040     EXPECT_EQ(Triple::armeb, T.getArch());
1041   }
1042   {
1043     Triple T = Triple("armv7eb");
1044     EXPECT_EQ(Triple::armeb, T.getArch());
1045   }
1046   // THUMB
1047   {
1048     Triple T = Triple("thumb");
1049     EXPECT_EQ(Triple::thumb, T.getArch());
1050   }
1051   {
1052     Triple T = Triple("thumbv7a");
1053     EXPECT_EQ(Triple::thumb, T.getArch());
1054   }
1055   {
1056     Triple T = Triple("thumbeb");
1057     EXPECT_EQ(Triple::thumbeb, T.getArch());
1058   }
1059   {
1060     Triple T = Triple("thumbv4teb");
1061     EXPECT_EQ(Triple::thumbeb, T.getArch());
1062   }
1063   {
1064     Triple T = Triple("thumbebv7");
1065     EXPECT_EQ(Triple::thumbeb, T.getArch());
1066   }
1067   {
1068     Triple T = Triple("armv6m");
1069     EXPECT_EQ(Triple::thumb, T.getArch());
1070   }
1071   {
1072     Triple T = Triple("thumbv2");
1073     EXPECT_EQ(Triple::UnknownArch, T.getArch());
1074   }
1075   {
1076     Triple T = Triple("thumbebv6eb");
1077     EXPECT_EQ(Triple::UnknownArch, T.getArch());
1078   }
1079   // AARCH64
1080   {
1081     Triple T = Triple("arm64");
1082     EXPECT_EQ(Triple::aarch64, T.getArch());
1083   }
1084   {
1085     Triple T = Triple("aarch64");
1086     EXPECT_EQ(Triple::aarch64, T.getArch());
1087   }
1088   {
1089     Triple T = Triple("aarch64_be");
1090     EXPECT_EQ(Triple::aarch64_be, T.getArch());
1091   }
1092   {
1093     Triple T = Triple("aarch64be");
1094     EXPECT_EQ(Triple::UnknownArch, T.getArch());
1095   }
1096   {
1097     Triple T = Triple("arm64be");
1098     EXPECT_EQ(Triple::UnknownArch, T.getArch());
1099   }
1100 }
1101 } // end anonymous namespace