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 "llvm/ADT/Triple.h"
  11 #include "gtest/gtest.h"
  12
  13 using namespace llvm;
  14
  15 namespace {
  16
  17 TEST(TripleTest, BasicParsing) {
  18   Triple T;
  19
  20   T = Triple("");
  21   EXPECT_EQ("", T.getArchName().str());
  22   EXPECT_EQ("", T.getVendorName().str());
  23   EXPECT_EQ("", T.getOSName().str());
  24   EXPECT_EQ("", T.getEnvironmentName().str());
  25
  26   T = Triple("-");
  27   EXPECT_EQ("", T.getArchName().str());
  28   EXPECT_EQ("", T.getVendorName().str());
  29   EXPECT_EQ("", T.getOSName().str());
  30   EXPECT_EQ("", T.getEnvironmentName().str());
  31
  32   T = Triple("--");
  33   EXPECT_EQ("", T.getArchName().str());
  34   EXPECT_EQ("", T.getVendorName().str());
  35   EXPECT_EQ("", T.getOSName().str());
  36   EXPECT_EQ("", T.getEnvironmentName().str());
  37
  38   T = Triple("---");
  39   EXPECT_EQ("", T.getArchName().str());
  40   EXPECT_EQ("", T.getVendorName().str());
  41   EXPECT_EQ("", T.getOSName().str());
  42   EXPECT_EQ("", T.getEnvironmentName().str());
  43
  44   T = Triple("----");
  45   EXPECT_EQ("", T.getArchName().str());
  46   EXPECT_EQ("", T.getVendorName().str());
  47   EXPECT_EQ("", T.getOSName().str());
  48   EXPECT_EQ("-", T.getEnvironmentName().str());
  49
  50   T = Triple("a");
  51   EXPECT_EQ("a", T.getArchName().str());
  52   EXPECT_EQ("", T.getVendorName().str());
  53   EXPECT_EQ("", T.getOSName().str());
  54   EXPECT_EQ("", T.getEnvironmentName().str());
  55
  56   T = Triple("a-b");
  57   EXPECT_EQ("a", T.getArchName().str());
  58   EXPECT_EQ("b", T.getVendorName().str());
  59   EXPECT_EQ("", T.getOSName().str());
  60   EXPECT_EQ("", T.getEnvironmentName().str());
  61
  62   T = Triple("a-b-c");
  63   EXPECT_EQ("a", T.getArchName().str());
  64   EXPECT_EQ("b", T.getVendorName().str());
  65   EXPECT_EQ("c", T.getOSName().str());
  66   EXPECT_EQ("", T.getEnvironmentName().str());
  67
  68   T = Triple("a-b-c-d");
  69   EXPECT_EQ("a", T.getArchName().str());
  70   EXPECT_EQ("b", T.getVendorName().str());
  71   EXPECT_EQ("c", T.getOSName().str());
  72   EXPECT_EQ("d", T.getEnvironmentName().str());
  73 }
  74
  75 TEST(TripleTest, ParsedIDs) {
  76   Triple T;
  77
  78   T = Triple("i386-apple-darwin");
  79   EXPECT_EQ(Triple::x86, T.getArch());
  80   EXPECT_EQ(Triple::Apple, T.getVendor());
  81   EXPECT_EQ(Triple::Darwin, T.getOS());
  82   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
  83
  84   T = Triple("i386-pc-elfiamcu");
  85   EXPECT_EQ(Triple::x86, T.getArch());
  86   EXPECT_EQ(Triple::PC, T.getVendor());
  87   EXPECT_EQ(Triple::ELFIAMCU, T.getOS());
  88   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
  89
  90   T = Triple("i386-pc-contiki-unknown");
  91   EXPECT_EQ(Triple::x86, T.getArch());
  92   EXPECT_EQ(Triple::PC, T.getVendor());
  93   EXPECT_EQ(Triple::Contiki, T.getOS());
  94   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
  95
  96   T = Triple("x86_64-pc-linux-gnu");
  97   EXPECT_EQ(Triple::x86_64, T.getArch());
  98   EXPECT_EQ(Triple::PC, T.getVendor());
  99   EXPECT_EQ(Triple::Linux, T.getOS());
 100   EXPECT_EQ(Triple::GNU, T.getEnvironment());
 101
 102   T = Triple("x86_64-pc-linux-musl");
 103   EXPECT_EQ(Triple::x86_64, T.getArch());
 104   EXPECT_EQ(Triple::PC, T.getVendor());
 105   EXPECT_EQ(Triple::Linux, T.getOS());
 106   EXPECT_EQ(Triple::Musl, T.getEnvironment());
 107
 108   T = Triple("powerpc-bgp-linux");
 109   EXPECT_EQ(Triple::ppc, T.getArch());
 110   EXPECT_EQ(Triple::BGP, T.getVendor());
 111   EXPECT_EQ(Triple::Linux, T.getOS());
 112   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 113
 114   T = Triple("powerpc-bgp-cnk");
 115   EXPECT_EQ(Triple::ppc, T.getArch());
 116   EXPECT_EQ(Triple::BGP, T.getVendor());
 117   EXPECT_EQ(Triple::CNK, T.getOS());
 118   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 119
 120   T = Triple("powerpc64-bgq-linux");
 121   EXPECT_EQ(Triple::ppc64, T.getArch());
 122   EXPECT_EQ(Triple::BGQ, T.getVendor());
 123   EXPECT_EQ(Triple::Linux, T.getOS());
 124   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 125
 126   T = Triple("powerpc-ibm-aix");
 127   EXPECT_EQ(Triple::ppc, T.getArch());
 128   EXPECT_EQ(Triple::IBM, T.getVendor());
 129   EXPECT_EQ(Triple::AIX, T.getOS());
 130   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 131
 132   T = Triple("powerpc64-ibm-aix");
 133   EXPECT_EQ(Triple::ppc64, T.getArch());
 134   EXPECT_EQ(Triple::IBM, T.getVendor());
 135   EXPECT_EQ(Triple::AIX, T.getOS());
 136   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 137
 138   T = Triple("powerpc-dunno-notsure");
 139   EXPECT_EQ(Triple::ppc, T.getArch());
 140   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 141   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 142   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 143
 144   T = Triple("arm-none-none-eabi");
 145   EXPECT_EQ(Triple::arm, T.getArch());
 146   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 147   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 148   EXPECT_EQ(Triple::EABI, T.getEnvironment());
 149
 150   T = Triple("arm-none-linux-musleabi");
 151   EXPECT_EQ(Triple::arm, T.getArch());
 152   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 153   EXPECT_EQ(Triple::Linux, T.getOS());
 154   EXPECT_EQ(Triple::MuslEABI, T.getEnvironment());
 155
 156   T = Triple("armv6hl-none-linux-gnueabi");
 157   EXPECT_EQ(Triple::arm, T.getArch());
 158   EXPECT_EQ(Triple::Linux, T.getOS());
 159   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 160   EXPECT_EQ(Triple::GNUEABI, T.getEnvironment());
 161
 162   T = Triple("armv7hl-none-linux-gnueabi");
 163   EXPECT_EQ(Triple::arm, T.getArch());
 164   EXPECT_EQ(Triple::Linux, T.getOS());
 165   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 166   EXPECT_EQ(Triple::GNUEABI, T.getEnvironment());
 167
 168   T = Triple("amdil-unknown-unknown");
 169   EXPECT_EQ(Triple::amdil, T.getArch());
 170   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 171   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 172
 173   T = Triple("amdil64-unknown-unknown");
 174   EXPECT_EQ(Triple::amdil64, T.getArch());
 175   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 176   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 177
 178   T = Triple("hsail-unknown-unknown");
 179   EXPECT_EQ(Triple::hsail, T.getArch());
 180   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 181   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 182
 183   T = Triple("hsail64-unknown-unknown");
 184   EXPECT_EQ(Triple::hsail64, T.getArch());
 185   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 186   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 187
 188   T = Triple("sparcel-unknown-unknown");
 189   EXPECT_EQ(Triple::sparcel, T.getArch());
 190   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 191   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 192
 193   T = Triple("spir-unknown-unknown");
 194   EXPECT_EQ(Triple::spir, T.getArch());
 195   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 196   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 197
 198   T = Triple("spir64-unknown-unknown");
 199   EXPECT_EQ(Triple::spir64, T.getArch());
 200   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 201   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 202
 203   T = Triple("x86_64-unknown-ananas");
 204   EXPECT_EQ(Triple::x86_64, T.getArch());
 205   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 206   EXPECT_EQ(Triple::Ananas, T.getOS());
 207   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 208
 209   T = Triple("x86_64-unknown-cloudabi");
 210   EXPECT_EQ(Triple::x86_64, T.getArch());
 211   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 212   EXPECT_EQ(Triple::CloudABI, T.getOS());
 213   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 214
 215   T = Triple("x86_64-unknown-fuchsia");
 216   EXPECT_EQ(Triple::x86_64, T.getArch());
 217   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 218   EXPECT_EQ(Triple::Fuchsia, T.getOS());
 219   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 220
 221   T = Triple("wasm32-unknown-unknown");
 222   EXPECT_EQ(Triple::wasm32, T.getArch());
 223   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 224   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 225   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 226
 227   T = Triple("wasm64-unknown-unknown");
 228   EXPECT_EQ(Triple::wasm64, T.getArch());
 229   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 230   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 231   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 232
 233   T = Triple("avr-unknown-unknown");
 234   EXPECT_EQ(Triple::avr, T.getArch());
 235   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 236   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 237   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 238
 239   T = Triple("avr");
 240   EXPECT_EQ(Triple::avr, T.getArch());
 241   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 242   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 243   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 244
 245   T = Triple("lanai-unknown-unknown");
 246   EXPECT_EQ(Triple::lanai, T.getArch());
 247   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 248   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 249   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 250
 251   T = Triple("lanai");
 252   EXPECT_EQ(Triple::lanai, T.getArch());
 253   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 254   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 255   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 256
 257   T = Triple("amdgcn-mesa-mesa3d");
 258   EXPECT_EQ(Triple::amdgcn, T.getArch());
 259   EXPECT_EQ(Triple::Mesa, T.getVendor());
 260   EXPECT_EQ(Triple::Mesa3D, T.getOS());
 261   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 262
 263   T = Triple("amdgcn-amd-amdhsa");
 264   EXPECT_EQ(Triple::amdgcn, T.getArch());
 265   EXPECT_EQ(Triple::AMD, T.getVendor());
 266   EXPECT_EQ(Triple::AMDHSA, T.getOS());
 267   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 268
 269   T = Triple("amdgcn-amd-amdhsa-opencl");
 270   EXPECT_EQ(Triple::amdgcn, T.getArch());
 271   EXPECT_EQ(Triple::AMD, T.getVendor());
 272   EXPECT_EQ(Triple::AMDHSA, T.getOS());
 273   EXPECT_EQ(Triple::OpenCL, T.getEnvironment());
 274
 275   T = Triple("amdgcn-amd-amdpal");
 276   EXPECT_EQ(Triple::amdgcn, T.getArch());
 277   EXPECT_EQ(Triple::AMD, T.getVendor());
 278   EXPECT_EQ(Triple::AMDPAL, T.getOS());
 279   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 280
 281   T = Triple("riscv32-unknown-unknown");
 282   EXPECT_EQ(Triple::riscv32, T.getArch());
 283   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 284   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 285   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 286
 287   T = Triple("riscv64-unknown-linux");
 288   EXPECT_EQ(Triple::riscv64, T.getArch());
 289   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 290   EXPECT_EQ(Triple::Linux, T.getOS());
 291   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 292
 293   T = Triple("riscv64-unknown-freebsd");
 294   EXPECT_EQ(Triple::riscv64, T.getArch());
 295   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 296   EXPECT_EQ(Triple::FreeBSD, T.getOS());
 297   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 298
 299   T = Triple("armv7hl-suse-linux-gnueabi");
 300   EXPECT_EQ(Triple::arm, T.getArch());
 301   EXPECT_EQ(Triple::SUSE, T.getVendor());
 302   EXPECT_EQ(Triple::Linux, T.getOS());
 303   EXPECT_EQ(Triple::GNUEABI, T.getEnvironment());
 304
 305   T = Triple("i586-pc-haiku");
 306   EXPECT_EQ(Triple::x86, T.getArch());
 307   EXPECT_EQ(Triple::PC, T.getVendor());
 308   EXPECT_EQ(Triple::Haiku, T.getOS());
 309   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 310
 311   T = Triple("x86_64-unknown-haiku");
 312   EXPECT_EQ(Triple::x86_64, T.getArch());
 313   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 314   EXPECT_EQ(Triple::Haiku, T.getOS());
 315   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 316
 317   T = Triple("mips-mti-linux-gnu");
 318   EXPECT_EQ(Triple::mips, T.getArch());
 319   EXPECT_EQ(Triple::MipsTechnologies, T.getVendor());
 320   EXPECT_EQ(Triple::Linux, T.getOS());
 321   EXPECT_EQ(Triple::GNU, T.getEnvironment());
 322
 323   T = Triple("mipsel-img-linux-gnu");
 324   EXPECT_EQ(Triple::mipsel, T.getArch());
 325   EXPECT_EQ(Triple::ImaginationTechnologies, T.getVendor());
 326   EXPECT_EQ(Triple::Linux, T.getOS());
 327   EXPECT_EQ(Triple::GNU, T.getEnvironment());
 328
 329   T = Triple("mips64-mti-linux-gnu");
 330   EXPECT_EQ(Triple::mips64, T.getArch());
 331   EXPECT_EQ(Triple::MipsTechnologies, T.getVendor());
 332   EXPECT_EQ(Triple::Linux, T.getOS());
 333   EXPECT_EQ(Triple::GNU, T.getEnvironment());
 334
 335   T = Triple("mips64el-img-linux-gnu");
 336   EXPECT_EQ(Triple::mips64el, T.getArch());
 337   EXPECT_EQ(Triple::ImaginationTechnologies, T.getVendor());
 338   EXPECT_EQ(Triple::Linux, T.getOS());
 339   EXPECT_EQ(Triple::GNU, T.getEnvironment());
 340
 341   T = Triple("mips64el-img-linux-gnuabin32");
 342   EXPECT_EQ(Triple::mips64el, T.getArch());
 343   EXPECT_EQ(Triple::ImaginationTechnologies, T.getVendor());
 344   EXPECT_EQ(Triple::Linux, T.getOS());
 345   EXPECT_EQ(Triple::GNUABIN32, T.getEnvironment());
 346
 347   T = Triple("mips64el-unknown-linux-gnuabi64");
 348   EXPECT_EQ(Triple::mips64el, T.getArch());
 349   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 350   EXPECT_EQ(Triple::Linux, T.getOS());
 351   EXPECT_EQ(Triple::GNUABI64, T.getEnvironment());
 352
 353   T = Triple("huh");
 354   EXPECT_EQ(Triple::UnknownArch, T.getArch());
 355 }
 356
 357 static std::string Join(StringRef A, StringRef B, StringRef C) {
 358   std::string Str = A; Str += '-'; Str += B; Str += '-'; Str += C;
 359   return Str;
 360 }
 361
 362 static std::string Join(StringRef A, StringRef B, StringRef C, StringRef D) {
 363   std::string Str = A; Str += '-'; Str += B; Str += '-'; Str += C; Str += '-';
 364   Str += D; return Str;
 365 }
 366
 367 TEST(TripleTest, Normalization) {
 368
 369   EXPECT_EQ("", Triple::normalize(""));
 370   EXPECT_EQ("-", Triple::normalize("-"));
 371   EXPECT_EQ("--", Triple::normalize("--"));
 372   EXPECT_EQ("---", Triple::normalize("---"));
 373   EXPECT_EQ("----", Triple::normalize("----"));
 374
 375   EXPECT_EQ("a", Triple::normalize("a"));
 376   EXPECT_EQ("a-b", Triple::normalize("a-b"));
 377   EXPECT_EQ("a-b-c", Triple::normalize("a-b-c"));
 378   EXPECT_EQ("a-b-c-d", Triple::normalize("a-b-c-d"));
 379
 380   EXPECT_EQ("i386-b-c", Triple::normalize("i386-b-c"));
 381   EXPECT_EQ("i386-a-c", Triple::normalize("a-i386-c"));
 382   EXPECT_EQ("i386-a-b", Triple::normalize("a-b-i386"));
 383   EXPECT_EQ("i386-a-b-c", Triple::normalize("a-b-c-i386"));
 384
 385   EXPECT_EQ("a-pc-c", Triple::normalize("a-pc-c"));
 386   EXPECT_EQ("-pc-b-c", Triple::normalize("pc-b-c"));
 387   EXPECT_EQ("a-pc-b", Triple::normalize("a-b-pc"));
 388   EXPECT_EQ("a-pc-b-c", Triple::normalize("a-b-c-pc"));
 389
 390   EXPECT_EQ("a-b-linux", Triple::normalize("a-b-linux"));
 391   EXPECT_EQ("--linux-b-c", Triple::normalize("linux-b-c"));
 392   EXPECT_EQ("a--linux-c", Triple::normalize("a-linux-c"));
 393
 394   EXPECT_EQ("i386-pc-a", Triple::normalize("a-pc-i386"));
 395   EXPECT_EQ("i386-pc-", Triple::normalize("-pc-i386"));
 396   EXPECT_EQ("-pc-linux-c", Triple::normalize("linux-pc-c"));
 397   EXPECT_EQ("-pc-linux", Triple::normalize("linux-pc-"));
 398
 399   EXPECT_EQ("i386", Triple::normalize("i386"));
 400   EXPECT_EQ("-pc", Triple::normalize("pc"));
 401   EXPECT_EQ("--linux", Triple::normalize("linux"));
 402
 403   EXPECT_EQ("x86_64--linux-gnu", Triple::normalize("x86_64-gnu-linux"));
 404
 405   // Check that normalizing a permutated set of valid components returns a
 406   // triple with the unpermuted components.
 407   //
 408   // We don't check every possible combination. For the set of architectures A,
 409   // vendors V, operating systems O, and environments E, that would require |A|
 410   // * |V| * |O| * |E| * 4! tests. Instead we check every option for any given
 411   // slot and make sure it gets normalized to the correct position from every
 412   // permutation. This should cover the core logic while being a tractable
 413   // number of tests at (|A| + |V| + |O| + |E|) * 4!.
 414   auto FirstArchType = Triple::ArchType(Triple::UnknownArch + 1);
 415   auto FirstVendorType = Triple::VendorType(Triple::UnknownVendor + 1);
 416   auto FirstOSType = Triple::OSType(Triple::UnknownOS + 1);
 417   auto FirstEnvType = Triple::EnvironmentType(Triple::UnknownEnvironment + 1);
 418   StringRef InitialC[] = {Triple::getArchTypeName(FirstArchType),
 419                           Triple::getVendorTypeName(FirstVendorType),
 420                           Triple::getOSTypeName(FirstOSType),
 421                           Triple::getEnvironmentTypeName(FirstEnvType)};
 422   for (int Arch = FirstArchType; Arch <= Triple::LastArchType; ++Arch) {
 423     StringRef C[] = {InitialC[0], InitialC[1], InitialC[2], InitialC[3]};
 424     C[0] = Triple::getArchTypeName(Triple::ArchType(Arch));
 425     std::string E = Join(C[0], C[1], C[2]);
 426     int I[] = {0, 1, 2};
 427     do {
 428       EXPECT_EQ(E, Triple::normalize(Join(C[I[0]], C[I[1]], C[I[2]])));
 429     } while (std::next_permutation(std::begin(I), std::end(I)));
 430     std::string F = Join(C[0], C[1], C[2], C[3]);
 431     int J[] = {0, 1, 2, 3};
 432     do {
 433       EXPECT_EQ(F, Triple::normalize(Join(C[J[0]], C[J[1]], C[J[2]], C[J[3]])));
 434     } while (std::next_permutation(std::begin(J), std::end(J)));
 435   }
 436   for (int Vendor = FirstVendorType; Vendor <= Triple::LastVendorType;
 437        ++Vendor) {
 438     StringRef C[] = {InitialC[0], InitialC[1], InitialC[2], InitialC[3]};
 439     C[1] = Triple::getVendorTypeName(Triple::VendorType(Vendor));
 440     std::string E = Join(C[0], C[1], C[2]);
 441     int I[] = {0, 1, 2};
 442     do {
 443       EXPECT_EQ(E, Triple::normalize(Join(C[I[0]], C[I[1]], C[I[2]])));
 444     } while (std::next_permutation(std::begin(I), std::end(I)));
 445     std::string F = Join(C[0], C[1], C[2], C[3]);
 446     int J[] = {0, 1, 2, 3};
 447     do {
 448       EXPECT_EQ(F, Triple::normalize(Join(C[J[0]], C[J[1]], C[J[2]], C[J[3]])));
 449     } while (std::next_permutation(std::begin(J), std::end(J)));
 450   }
 451   for (int OS = FirstOSType; OS <= Triple::LastOSType; ++OS) {
 452     if (OS == Triple::Win32)
 453       continue;
 454     StringRef C[] = {InitialC[0], InitialC[1], InitialC[2], InitialC[3]};
 455     C[2] = Triple::getOSTypeName(Triple::OSType(OS));
 456     std::string E = Join(C[0], C[1], C[2]);
 457     int I[] = {0, 1, 2};
 458     do {
 459       EXPECT_EQ(E, Triple::normalize(Join(C[I[0]], C[I[1]], C[I[2]])));
 460     } while (std::next_permutation(std::begin(I), std::end(I)));
 461     std::string F = Join(C[0], C[1], C[2], C[3]);
 462     int J[] = {0, 1, 2, 3};
 463     do {
 464       EXPECT_EQ(F, Triple::normalize(Join(C[J[0]], C[J[1]], C[J[2]], C[J[3]])));
 465     } while (std::next_permutation(std::begin(J), std::end(J)));
 466   }
 467   for (int Env = FirstEnvType; Env <= Triple::LastEnvironmentType; ++Env) {
 468     StringRef C[] = {InitialC[0], InitialC[1], InitialC[2], InitialC[3]};
 469     C[3] = Triple::getEnvironmentTypeName(Triple::EnvironmentType(Env));
 470     std::string F = Join(C[0], C[1], C[2], C[3]);
 471     int J[] = {0, 1, 2, 3};
 472     do {
 473       EXPECT_EQ(F, Triple::normalize(Join(C[J[0]], C[J[1]], C[J[2]], C[J[3]])));
 474     } while (std::next_permutation(std::begin(J), std::end(J)));
 475   }
 476
 477   // Various real-world funky triples.  The value returned by GCC's config.sub
 478   // is given in the comment.
 479   EXPECT_EQ("i386--windows-gnu", Triple::normalize("i386-mingw32")); // i386-pc-mingw32
 480   EXPECT_EQ("x86_64--linux-gnu", Triple::normalize("x86_64-linux-gnu")); // x86_64-pc-linux-gnu
 481   EXPECT_EQ("i486--linux-gnu", Triple::normalize("i486-linux-gnu")); // i486-pc-linux-gnu
 482   EXPECT_EQ("i386-redhat-linux", Triple::normalize("i386-redhat-linux")); // i386-redhat-linux-gnu
 483   EXPECT_EQ("i686--linux", Triple::normalize("i686-linux")); // i686-pc-linux-gnu
 484   EXPECT_EQ("arm-none--eabi", Triple::normalize("arm-none-eabi")); // arm-none-eabi
 485 }
 486
 487 TEST(TripleTest, MutateName) {
 488   Triple T;
 489   EXPECT_EQ(Triple::UnknownArch, T.getArch());
 490   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 491   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 492   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 493
 494   T.setArchName("i386");
 495   EXPECT_EQ(Triple::x86, T.getArch());
 496   EXPECT_EQ("i386--", T.getTriple());
 497
 498   T.setVendorName("pc");
 499   EXPECT_EQ(Triple::x86, T.getArch());
 500   EXPECT_EQ(Triple::PC, T.getVendor());
 501   EXPECT_EQ("i386-pc-", T.getTriple());
 502
 503   T.setOSName("linux");
 504   EXPECT_EQ(Triple::x86, T.getArch());
 505   EXPECT_EQ(Triple::PC, T.getVendor());
 506   EXPECT_EQ(Triple::Linux, T.getOS());
 507   EXPECT_EQ("i386-pc-linux", T.getTriple());
 508
 509   T.setEnvironmentName("gnu");
 510   EXPECT_EQ(Triple::x86, T.getArch());
 511   EXPECT_EQ(Triple::PC, T.getVendor());
 512   EXPECT_EQ(Triple::Linux, T.getOS());
 513   EXPECT_EQ("i386-pc-linux-gnu", T.getTriple());
 514
 515   T.setOSName("freebsd");
 516   EXPECT_EQ(Triple::x86, T.getArch());
 517   EXPECT_EQ(Triple::PC, T.getVendor());
 518   EXPECT_EQ(Triple::FreeBSD, T.getOS());
 519   EXPECT_EQ("i386-pc-freebsd-gnu", T.getTriple());
 520
 521   T.setOSAndEnvironmentName("darwin");
 522   EXPECT_EQ(Triple::x86, T.getArch());
 523   EXPECT_EQ(Triple::PC, T.getVendor());
 524   EXPECT_EQ(Triple::Darwin, T.getOS());
 525   EXPECT_EQ("i386-pc-darwin", T.getTriple());
 526
 527   T.setEnvironmentName("amdopencl");
 528   EXPECT_EQ(Triple::AMDOpenCL, T.getEnvironment());
 529 }
 530
 531 TEST(TripleTest, BitWidthPredicates) {
 532   Triple T;
 533   EXPECT_FALSE(T.isArch16Bit());
 534   EXPECT_FALSE(T.isArch32Bit());
 535   EXPECT_FALSE(T.isArch64Bit());
 536
 537   T.setArch(Triple::arm);
 538   EXPECT_FALSE(T.isArch16Bit());
 539   EXPECT_TRUE(T.isArch32Bit());
 540   EXPECT_FALSE(T.isArch64Bit());
 541
 542   T.setArch(Triple::hexagon);
 543   EXPECT_FALSE(T.isArch16Bit());
 544   EXPECT_TRUE(T.isArch32Bit());
 545   EXPECT_FALSE(T.isArch64Bit());
 546
 547   T.setArch(Triple::mips);
 548   EXPECT_FALSE(T.isArch16Bit());
 549   EXPECT_TRUE(T.isArch32Bit());
 550   EXPECT_FALSE(T.isArch64Bit());
 551
 552   T.setArch(Triple::mips64);
 553   EXPECT_FALSE(T.isArch16Bit());
 554   EXPECT_FALSE(T.isArch32Bit());
 555   EXPECT_TRUE(T.isArch64Bit());
 556
 557   T.setArch(Triple::msp430);
 558   EXPECT_TRUE(T.isArch16Bit());
 559   EXPECT_FALSE(T.isArch32Bit());
 560   EXPECT_FALSE(T.isArch64Bit());
 561
 562   T.setArch(Triple::ppc);
 563   EXPECT_FALSE(T.isArch16Bit());
 564   EXPECT_TRUE(T.isArch32Bit());
 565   EXPECT_FALSE(T.isArch64Bit());
 566
 567   T.setArch(Triple::ppc64);
 568   EXPECT_FALSE(T.isArch16Bit());
 569   EXPECT_FALSE(T.isArch32Bit());
 570   EXPECT_TRUE(T.isArch64Bit());
 571
 572   T.setArch(Triple::x86);
 573   EXPECT_FALSE(T.isArch16Bit());
 574   EXPECT_TRUE(T.isArch32Bit());
 575   EXPECT_FALSE(T.isArch64Bit());
 576
 577   T.setArch(Triple::x86_64);
 578   EXPECT_FALSE(T.isArch16Bit());
 579   EXPECT_FALSE(T.isArch32Bit());
 580   EXPECT_TRUE(T.isArch64Bit());
 581
 582   T.setArch(Triple::amdil);
 583   EXPECT_FALSE(T.isArch16Bit());
 584   EXPECT_TRUE(T.isArch32Bit());
 585   EXPECT_FALSE(T.isArch64Bit());
 586
 587   T.setArch(Triple::amdil64);
 588   EXPECT_FALSE(T.isArch16Bit());
 589   EXPECT_FALSE(T.isArch32Bit());
 590   EXPECT_TRUE(T.isArch64Bit());
 591
 592   T.setArch(Triple::hsail);
 593   EXPECT_FALSE(T.isArch16Bit());
 594   EXPECT_TRUE(T.isArch32Bit());
 595   EXPECT_FALSE(T.isArch64Bit());
 596
 597   T.setArch(Triple::hsail64);
 598   EXPECT_FALSE(T.isArch16Bit());
 599   EXPECT_FALSE(T.isArch32Bit());
 600   EXPECT_TRUE(T.isArch64Bit());
 601
 602   T.setArch(Triple::spir);
 603   EXPECT_FALSE(T.isArch16Bit());
 604   EXPECT_TRUE(T.isArch32Bit());
 605   EXPECT_FALSE(T.isArch64Bit());
 606
 607   T.setArch(Triple::spir64);
 608   EXPECT_FALSE(T.isArch16Bit());
 609   EXPECT_FALSE(T.isArch32Bit());
 610   EXPECT_TRUE(T.isArch64Bit());
 611
 612   T.setArch(Triple::sparc);
 613   EXPECT_FALSE(T.isArch16Bit());
 614   EXPECT_TRUE(T.isArch32Bit());
 615   EXPECT_FALSE(T.isArch64Bit());
 616
 617   T.setArch(Triple::sparcel);
 618   EXPECT_FALSE(T.isArch16Bit());
 619   EXPECT_TRUE(T.isArch32Bit());
 620   EXPECT_FALSE(T.isArch64Bit());
 621
 622   T.setArch(Triple::sparcv9);
 623   EXPECT_FALSE(T.isArch16Bit());
 624   EXPECT_FALSE(T.isArch32Bit());
 625   EXPECT_TRUE(T.isArch64Bit());
 626
 627   T.setArch(Triple::wasm32);
 628   EXPECT_FALSE(T.isArch16Bit());
 629   EXPECT_TRUE(T.isArch32Bit());
 630   EXPECT_FALSE(T.isArch64Bit());
 631
 632   T.setArch(Triple::wasm64);
 633   EXPECT_FALSE(T.isArch16Bit());
 634   EXPECT_FALSE(T.isArch32Bit());
 635   EXPECT_TRUE(T.isArch64Bit());
 636
 637   T.setArch(Triple::avr);
 638   EXPECT_TRUE(T.isArch16Bit());
 639   EXPECT_FALSE(T.isArch32Bit());
 640   EXPECT_FALSE(T.isArch64Bit());
 641
 642   T.setArch(Triple::lanai);
 643   EXPECT_FALSE(T.isArch16Bit());
 644   EXPECT_TRUE(T.isArch32Bit());
 645   EXPECT_FALSE(T.isArch64Bit());
 646
 647   T.setArch(Triple::riscv32);
 648   EXPECT_FALSE(T.isArch16Bit());
 649   EXPECT_TRUE(T.isArch32Bit());
 650   EXPECT_FALSE(T.isArch64Bit());
 651
 652   T.setArch(Triple::riscv64);
 653   EXPECT_FALSE(T.isArch16Bit());
 654   EXPECT_FALSE(T.isArch32Bit());
 655   EXPECT_TRUE(T.isArch64Bit());
 656 }
 657
 658 TEST(TripleTest, BitWidthArchVariants) {
 659   Triple T;
 660   EXPECT_EQ(Triple::UnknownArch, T.get32BitArchVariant().getArch());
 661   EXPECT_EQ(Triple::UnknownArch, T.get64BitArchVariant().getArch());
 662
 663   T.setArch(Triple::UnknownArch);
 664   EXPECT_EQ(Triple::UnknownArch, T.get32BitArchVariant().getArch());
 665   EXPECT_EQ(Triple::UnknownArch, T.get64BitArchVariant().getArch());
 666
 667   T.setArch(Triple::mips);
 668   EXPECT_EQ(Triple::mips, T.get32BitArchVariant().getArch());
 669   EXPECT_EQ(Triple::mips64, T.get64BitArchVariant().getArch());
 670
 671   T.setArch(Triple::mipsel);
 672   EXPECT_EQ(Triple::mipsel, T.get32BitArchVariant().getArch());
 673   EXPECT_EQ(Triple::mips64el, T.get64BitArchVariant().getArch());
 674
 675   T.setArch(Triple::ppc);
 676   EXPECT_EQ(Triple::ppc, T.get32BitArchVariant().getArch());
 677   EXPECT_EQ(Triple::ppc64, T.get64BitArchVariant().getArch());
 678
 679   T.setArch(Triple::nvptx);
 680   EXPECT_EQ(Triple::nvptx, T.get32BitArchVariant().getArch());
 681   EXPECT_EQ(Triple::nvptx64, T.get64BitArchVariant().getArch());
 682
 683   T.setArch(Triple::sparc);
 684   EXPECT_EQ(Triple::sparc, T.get32BitArchVariant().getArch());
 685   EXPECT_EQ(Triple::sparcv9, T.get64BitArchVariant().getArch());
 686
 687   T.setArch(Triple::x86);
 688   EXPECT_EQ(Triple::x86, T.get32BitArchVariant().getArch());
 689   EXPECT_EQ(Triple::x86_64, T.get64BitArchVariant().getArch());
 690
 691   T.setArch(Triple::mips64);
 692   EXPECT_EQ(Triple::mips, T.get32BitArchVariant().getArch());
 693   EXPECT_EQ(Triple::mips64, T.get64BitArchVariant().getArch());
 694
 695   T.setArch(Triple::mips64el);
 696   EXPECT_EQ(Triple::mipsel, T.get32BitArchVariant().getArch());
 697   EXPECT_EQ(Triple::mips64el, T.get64BitArchVariant().getArch());
 698
 699   T.setArch(Triple::ppc64);
 700   EXPECT_EQ(Triple::ppc, T.get32BitArchVariant().getArch());
 701   EXPECT_EQ(Triple::ppc64, T.get64BitArchVariant().getArch());
 702
 703   T.setArch(Triple::nvptx64);
 704   EXPECT_EQ(Triple::nvptx, T.get32BitArchVariant().getArch());
 705   EXPECT_EQ(Triple::nvptx64, T.get64BitArchVariant().getArch());
 706
 707   T.setArch(Triple::sparcv9);
 708   EXPECT_EQ(Triple::sparc, T.get32BitArchVariant().getArch());
 709   EXPECT_EQ(Triple::sparcv9, T.get64BitArchVariant().getArch());
 710
 711   T.setArch(Triple::x86_64);
 712   EXPECT_EQ(Triple::x86, T.get32BitArchVariant().getArch());
 713   EXPECT_EQ(Triple::x86_64, T.get64BitArchVariant().getArch());
 714
 715   T.setArch(Triple::amdil);
 716   EXPECT_EQ(Triple::amdil, T.get32BitArchVariant().getArch());
 717   EXPECT_EQ(Triple::amdil64, T.get64BitArchVariant().getArch());
 718
 719   T.setArch(Triple::amdil64);
 720   EXPECT_EQ(Triple::amdil, T.get32BitArchVariant().getArch());
 721   EXPECT_EQ(Triple::amdil64, T.get64BitArchVariant().getArch());
 722
 723   T.setArch(Triple::hsail);
 724   EXPECT_EQ(Triple::hsail, T.get32BitArchVariant().getArch());
 725   EXPECT_EQ(Triple::hsail64, T.get64BitArchVariant().getArch());
 726
 727   T.setArch(Triple::hsail64);
 728   EXPECT_EQ(Triple::hsail, T.get32BitArchVariant().getArch());
 729   EXPECT_EQ(Triple::hsail64, T.get64BitArchVariant().getArch());
 730
 731   T.setArch(Triple::spir);
 732   EXPECT_EQ(Triple::spir, T.get32BitArchVariant().getArch());
 733   EXPECT_EQ(Triple::spir64, T.get64BitArchVariant().getArch());
 734
 735   T.setArch(Triple::spir64);
 736   EXPECT_EQ(Triple::spir, T.get32BitArchVariant().getArch());
 737   EXPECT_EQ(Triple::spir64, T.get64BitArchVariant().getArch());
 738
 739   T.setArch(Triple::wasm32);
 740   EXPECT_EQ(Triple::wasm32, T.get32BitArchVariant().getArch());
 741   EXPECT_EQ(Triple::wasm64, T.get64BitArchVariant().getArch());
 742
 743   T.setArch(Triple::wasm64);
 744   EXPECT_EQ(Triple::wasm32, T.get32BitArchVariant().getArch());
 745   EXPECT_EQ(Triple::wasm64, T.get64BitArchVariant().getArch());
 746
 747   T.setArch(Triple::riscv32);
 748   EXPECT_EQ(Triple::riscv32, T.get32BitArchVariant().getArch());
 749   EXPECT_EQ(Triple::riscv64, T.get64BitArchVariant().getArch());
 750
 751   T.setArch(Triple::riscv64);
 752   EXPECT_EQ(Triple::riscv32, T.get32BitArchVariant().getArch());
 753   EXPECT_EQ(Triple::riscv64, T.get64BitArchVariant().getArch());
 754
 755   T.setArch(Triple::thumbeb);
 756   EXPECT_EQ(Triple::thumbeb, T.get32BitArchVariant().getArch());
 757   EXPECT_EQ(Triple::aarch64_be, T.get64BitArchVariant().getArch());
 758
 759   T.setArch(Triple::thumb);
 760   EXPECT_EQ(Triple::thumb, T.get32BitArchVariant().getArch());
 761   EXPECT_EQ(Triple::aarch64, T.get64BitArchVariant().getArch());
 762
 763   T.setArch(Triple::aarch64);
 764   EXPECT_EQ(Triple::arm, T.get32BitArchVariant().getArch());
 765   EXPECT_EQ(Triple::aarch64, T.get64BitArchVariant().getArch());
 766
 767   T.setArch(Triple::aarch64_be);
 768   EXPECT_EQ(Triple::armeb, T.get32BitArchVariant().getArch());
 769   EXPECT_EQ(Triple::aarch64_be, T.get64BitArchVariant().getArch());
 770
 771   T.setArch(Triple::renderscript32);
 772   EXPECT_EQ(Triple::renderscript32, T.get32BitArchVariant().getArch());
 773   EXPECT_EQ(Triple::renderscript64, T.get64BitArchVariant().getArch());
 774
 775   T.setArch(Triple::renderscript64);
 776   EXPECT_EQ(Triple::renderscript32, T.get32BitArchVariant().getArch());
 777   EXPECT_EQ(Triple::renderscript64, T.get64BitArchVariant().getArch());
 778
 779   T.setArch(Triple::le32);
 780   EXPECT_EQ(Triple::le32, T.get32BitArchVariant().getArch());
 781   EXPECT_EQ(Triple::le64, T.get64BitArchVariant().getArch());
 782
 783   T.setArch(Triple::le64);
 784   EXPECT_EQ(Triple::le32, T.get32BitArchVariant().getArch());
 785   EXPECT_EQ(Triple::le64, T.get64BitArchVariant().getArch());
 786
 787   T.setArch(Triple::armeb);
 788   EXPECT_EQ(Triple::armeb, T.get32BitArchVariant().getArch());
 789   EXPECT_EQ(Triple::aarch64_be, T.get64BitArchVariant().getArch());
 790
 791   T.setArch(Triple::arm);
 792   EXPECT_EQ(Triple::arm, T.get32BitArchVariant().getArch());
 793   EXPECT_EQ(Triple::aarch64, T.get64BitArchVariant().getArch());
 794
 795   T.setArch(Triple::systemz);
 796   EXPECT_EQ(Triple::UnknownArch, T.get32BitArchVariant().getArch());
 797   EXPECT_EQ(Triple::systemz, T.get64BitArchVariant().getArch());
 798
 799   T.setArch(Triple::xcore);
 800   EXPECT_EQ(Triple::xcore, T.get32BitArchVariant().getArch());
 801   EXPECT_EQ(Triple::UnknownArch, T.get64BitArchVariant().getArch());
 802 }
 803
 804 TEST(TripleTest, EndianArchVariants) {
 805   Triple T;
 806   EXPECT_EQ(Triple::UnknownArch, T.getBigEndianArchVariant().getArch());
 807   EXPECT_EQ(Triple::UnknownArch, T.getLittleEndianArchVariant().getArch());
 808
 809   T.setArch(Triple::UnknownArch);
 810   EXPECT_EQ(Triple::UnknownArch, T.getBigEndianArchVariant().getArch());
 811   EXPECT_EQ(Triple::UnknownArch, T.getLittleEndianArchVariant().getArch());
 812
 813   T.setArch(Triple::aarch64_be);
 814   EXPECT_EQ(Triple::aarch64_be, T.getBigEndianArchVariant().getArch());
 815   EXPECT_EQ(Triple::aarch64, T.getLittleEndianArchVariant().getArch());
 816
 817   T.setArch(Triple::aarch64);
 818   EXPECT_EQ(Triple::aarch64_be, T.getBigEndianArchVariant().getArch());
 819   EXPECT_EQ(Triple::aarch64, T.getLittleEndianArchVariant().getArch());
 820
 821   T.setArch(Triple::armeb);
 822   EXPECT_EQ(Triple::armeb, T.getBigEndianArchVariant().getArch());
 823   EXPECT_EQ(Triple::UnknownArch, T.getLittleEndianArchVariant().getArch());
 824
 825   T.setArch(Triple::arm);
 826   EXPECT_EQ(Triple::UnknownArch, T.getBigEndianArchVariant().getArch());
 827   EXPECT_EQ(Triple::arm, T.getLittleEndianArchVariant().getArch());
 828   T = Triple("arm");
 829   EXPECT_TRUE(T.isLittleEndian());
 830   T = Triple("thumb");
 831   EXPECT_TRUE(T.isLittleEndian());
 832   T = Triple("armeb");
 833   EXPECT_FALSE(T.isLittleEndian());
 834   T = Triple("thumbeb");
 835   EXPECT_FALSE(T.isLittleEndian());
 836
 837   T.setArch(Triple::bpfeb);
 838   EXPECT_EQ(Triple::bpfeb, T.getBigEndianArchVariant().getArch());
 839   EXPECT_EQ(Triple::bpfel, T.getLittleEndianArchVariant().getArch());
 840
 841   T.setArch(Triple::bpfel);
 842   EXPECT_EQ(Triple::bpfeb, T.getBigEndianArchVariant().getArch());
 843   EXPECT_EQ(Triple::bpfel, T.getLittleEndianArchVariant().getArch());
 844
 845   T.setArch(Triple::mips64);
 846   EXPECT_EQ(Triple::mips64, T.getBigEndianArchVariant().getArch());
 847   EXPECT_EQ(Triple::mips64el, T.getLittleEndianArchVariant().getArch());
 848
 849   T.setArch(Triple::mips64el);
 850   EXPECT_EQ(Triple::mips64, T.getBigEndianArchVariant().getArch());
 851   EXPECT_EQ(Triple::mips64el, T.getLittleEndianArchVariant().getArch());
 852
 853   T.setArch(Triple::mips);
 854   EXPECT_EQ(Triple::mips, T.getBigEndianArchVariant().getArch());
 855   EXPECT_EQ(Triple::mipsel, T.getLittleEndianArchVariant().getArch());
 856
 857   T.setArch(Triple::mipsel);
 858   EXPECT_EQ(Triple::mips, T.getBigEndianArchVariant().getArch());
 859   EXPECT_EQ(Triple::mipsel, T.getLittleEndianArchVariant().getArch());
 860
 861   T.setArch(Triple::ppc);
 862   EXPECT_EQ(Triple::ppc, T.getBigEndianArchVariant().getArch());
 863   EXPECT_EQ(Triple::UnknownArch, T.getLittleEndianArchVariant().getArch());
 864
 865   T.setArch(Triple::ppc64);
 866   EXPECT_EQ(Triple::ppc64, T.getBigEndianArchVariant().getArch());
 867   EXPECT_EQ(Triple::ppc64le, T.getLittleEndianArchVariant().getArch());
 868
 869   T.setArch(Triple::ppc64le);
 870   EXPECT_EQ(Triple::ppc64, T.getBigEndianArchVariant().getArch());
 871   EXPECT_EQ(Triple::ppc64le, T.getLittleEndianArchVariant().getArch());
 872
 873   T.setArch(Triple::sparc);
 874   EXPECT_EQ(Triple::sparc, T.getBigEndianArchVariant().getArch());
 875   EXPECT_EQ(Triple::sparcel, T.getLittleEndianArchVariant().getArch());
 876
 877   T.setArch(Triple::sparcel);
 878   EXPECT_EQ(Triple::sparc, T.getBigEndianArchVariant().getArch());
 879   EXPECT_EQ(Triple::sparcel, T.getLittleEndianArchVariant().getArch());
 880
 881   T.setArch(Triple::thumb);
 882   EXPECT_EQ(Triple::UnknownArch, T.getBigEndianArchVariant().getArch());
 883   EXPECT_EQ(Triple::thumb, T.getLittleEndianArchVariant().getArch());
 884
 885   T.setArch(Triple::thumbeb);
 886   EXPECT_EQ(Triple::thumbeb, T.getBigEndianArchVariant().getArch());
 887   EXPECT_EQ(Triple::UnknownArch, T.getLittleEndianArchVariant().getArch());
 888
 889   T.setArch(Triple::lanai);
 890   EXPECT_EQ(Triple::lanai, T.getBigEndianArchVariant().getArch());
 891   EXPECT_EQ(Triple::UnknownArch, T.getLittleEndianArchVariant().getArch());
 892
 893   T.setArch(Triple::tcele);
 894   EXPECT_EQ(Triple::tce, T.getBigEndianArchVariant().getArch());
 895   EXPECT_EQ(Triple::tcele, T.getLittleEndianArchVariant().getArch());
 896
 897   T.setArch(Triple::tce);
 898   EXPECT_EQ(Triple::tce, T.getBigEndianArchVariant().getArch());
 899   EXPECT_EQ(Triple::tcele, T.getLittleEndianArchVariant().getArch());
 900
 901   T.setArch(Triple::le32);
 902   EXPECT_EQ(Triple::UnknownArch, T.getBigEndianArchVariant().getArch());
 903   EXPECT_EQ(Triple::le32, T.getLittleEndianArchVariant().getArch());
 904
 905   T.setArch(Triple::le64);
 906   EXPECT_EQ(Triple::UnknownArch, T.getBigEndianArchVariant().getArch());
 907   EXPECT_EQ(Triple::le64, T.getLittleEndianArchVariant().getArch());
 908 }
 909
 910 TEST(TripleTest, getOSVersion) {
 911   Triple T;
 912   unsigned Major, Minor, Micro;
 913
 914   T = Triple("i386-apple-darwin9");
 915   EXPECT_TRUE(T.isMacOSX());
 916   EXPECT_FALSE(T.isiOS());
 917   EXPECT_FALSE(T.isArch16Bit());
 918   EXPECT_TRUE(T.isArch32Bit());
 919   EXPECT_FALSE(T.isArch64Bit());
 920   T.getMacOSXVersion(Major, Minor, Micro);
 921   EXPECT_EQ((unsigned)10, Major);
 922   EXPECT_EQ((unsigned)5, Minor);
 923   EXPECT_EQ((unsigned)0, Micro);
 924   T.getiOSVersion(Major, Minor, Micro);
 925   EXPECT_EQ((unsigned)5, Major);
 926   EXPECT_EQ((unsigned)0, Minor);
 927   EXPECT_EQ((unsigned)0, Micro);
 928
 929   T = Triple("x86_64-apple-darwin9");
 930   EXPECT_TRUE(T.isMacOSX());
 931   EXPECT_FALSE(T.isiOS());
 932   EXPECT_FALSE(T.isArch16Bit());
 933   EXPECT_FALSE(T.isArch32Bit());
 934   EXPECT_TRUE(T.isArch64Bit());
 935   T.getMacOSXVersion(Major, Minor, Micro);
 936   EXPECT_EQ((unsigned)10, Major);
 937   EXPECT_EQ((unsigned)5, Minor);
 938   EXPECT_EQ((unsigned)0, Micro);
 939   T.getiOSVersion(Major, Minor, Micro);
 940   EXPECT_EQ((unsigned)5, Major);
 941   EXPECT_EQ((unsigned)0, Minor);
 942   EXPECT_EQ((unsigned)0, Micro);
 943
 944   T = Triple("x86_64-apple-macosx");
 945   EXPECT_TRUE(T.isMacOSX());
 946   EXPECT_FALSE(T.isiOS());
 947   EXPECT_FALSE(T.isArch16Bit());
 948   EXPECT_FALSE(T.isArch32Bit());
 949   EXPECT_TRUE(T.isArch64Bit());
 950   T.getMacOSXVersion(Major, Minor, Micro);
 951   EXPECT_EQ((unsigned)10, Major);
 952   EXPECT_EQ((unsigned)4, Minor);
 953   EXPECT_EQ((unsigned)0, Micro);
 954   T.getiOSVersion(Major, Minor, Micro);
 955   EXPECT_EQ((unsigned)5, Major);
 956   EXPECT_EQ((unsigned)0, Minor);
 957   EXPECT_EQ((unsigned)0, Micro);
 958
 959   T = Triple("x86_64-apple-macosx10.7");
 960   EXPECT_TRUE(T.isMacOSX());
 961   EXPECT_FALSE(T.isiOS());
 962   EXPECT_FALSE(T.isArch16Bit());
 963   EXPECT_FALSE(T.isArch32Bit());
 964   EXPECT_TRUE(T.isArch64Bit());
 965   T.getMacOSXVersion(Major, Minor, Micro);
 966   EXPECT_EQ((unsigned)10, Major);
 967   EXPECT_EQ((unsigned)7, Minor);
 968   EXPECT_EQ((unsigned)0, Micro);
 969   T.getiOSVersion(Major, Minor, Micro);
 970   EXPECT_EQ((unsigned)5, Major);
 971   EXPECT_EQ((unsigned)0, Minor);
 972   EXPECT_EQ((unsigned)0, Micro);
 973
 974   T = Triple("armv7-apple-ios");
 975   EXPECT_FALSE(T.isMacOSX());
 976   EXPECT_TRUE(T.isiOS());
 977   EXPECT_FALSE(T.isArch16Bit());
 978   EXPECT_TRUE(T.isArch32Bit());
 979   EXPECT_FALSE(T.isArch64Bit());
 980   T.getMacOSXVersion(Major, Minor, Micro);
 981   EXPECT_EQ((unsigned)10, Major);
 982   EXPECT_EQ((unsigned)4, Minor);
 983   EXPECT_EQ((unsigned)0, Micro);
 984   T.getiOSVersion(Major, Minor, Micro);
 985   EXPECT_EQ((unsigned)5, Major);
 986   EXPECT_EQ((unsigned)0, Minor);
 987   EXPECT_EQ((unsigned)0, Micro);
 988
 989   T = Triple("armv7-apple-ios7.0");
 990   EXPECT_FALSE(T.isMacOSX());
 991   EXPECT_TRUE(T.isiOS());
 992   EXPECT_FALSE(T.isArch16Bit());
 993   EXPECT_TRUE(T.isArch32Bit());
 994   EXPECT_FALSE(T.isArch64Bit());
 995   T.getMacOSXVersion(Major, Minor, Micro);
 996   EXPECT_EQ((unsigned)10, Major);
 997   EXPECT_EQ((unsigned)4, Minor);
 998   EXPECT_EQ((unsigned)0, Micro);
 999   T.getiOSVersion(Major, Minor, Micro);
1000   EXPECT_EQ((unsigned)7, Major);
1001   EXPECT_EQ((unsigned)0, Minor);
1002   EXPECT_EQ((unsigned)0, Micro);
1003 }
1004
1005 TEST(TripleTest, FileFormat) {
1006   EXPECT_EQ(Triple::ELF, Triple("i686-unknown-linux-gnu").getObjectFormat());
1007   EXPECT_EQ(Triple::ELF, Triple("i686-unknown-freebsd").getObjectFormat());
1008   EXPECT_EQ(Triple::ELF, Triple("i686-unknown-netbsd").getObjectFormat());
1009   EXPECT_EQ(Triple::ELF, Triple("i686--win32-elf").getObjectFormat());
1010   EXPECT_EQ(Triple::ELF, Triple("i686---elf").getObjectFormat());
1011
1012   EXPECT_EQ(Triple::MachO, Triple("i686-apple-macosx").getObjectFormat());
1013   EXPECT_EQ(Triple::MachO, Triple("i686-apple-ios").getObjectFormat());
1014   EXPECT_EQ(Triple::MachO, Triple("i686---macho").getObjectFormat());
1015
1016   EXPECT_EQ(Triple::COFF, Triple("i686--win32").getObjectFormat());
1017
1018   EXPECT_EQ(Triple::ELF, Triple("i686-pc-windows-msvc-elf").getObjectFormat());
1019   EXPECT_EQ(Triple::ELF, Triple("i686-pc-cygwin-elf").getObjectFormat());
1020
1021   EXPECT_EQ(Triple::Wasm, Triple("wasm32-unknown-unknown-wasm").getObjectFormat());
1022   EXPECT_EQ(Triple::Wasm, Triple("wasm64-unknown-unknown-wasm").getObjectFormat());
1023
1024   Triple MSVCNormalized(Triple::normalize("i686-pc-windows-msvc-elf"));
1025   EXPECT_EQ(Triple::ELF, MSVCNormalized.getObjectFormat());
1026
1027   Triple GNUWindowsNormalized(Triple::normalize("i686-pc-windows-gnu-elf"));
1028   EXPECT_EQ(Triple::ELF, GNUWindowsNormalized.getObjectFormat());
1029
1030   Triple CygnusNormalised(Triple::normalize("i686-pc-windows-cygnus-elf"));
1031   EXPECT_EQ(Triple::ELF, CygnusNormalised.getObjectFormat());
1032
1033   Triple CygwinNormalized(Triple::normalize("i686-pc-cygwin-elf"));
1034   EXPECT_EQ(Triple::ELF, CygwinNormalized.getObjectFormat());
1035
1036   Triple T = Triple("");
1037   T.setObjectFormat(Triple::ELF);
1038   EXPECT_EQ(Triple::ELF, T.getObjectFormat());
1039
1040   T.setObjectFormat(Triple::MachO);
1041   EXPECT_EQ(Triple::MachO, T.getObjectFormat());
1042 }
1043
1044 TEST(TripleTest, NormalizeWindows) {
1045   EXPECT_EQ("i686-pc-windows-msvc", Triple::normalize("i686-pc-win32"));
1046   EXPECT_EQ("i686--windows-msvc", Triple::normalize("i686-win32"));
1047   EXPECT_EQ("i686-pc-windows-gnu", Triple::normalize("i686-pc-mingw32"));
1048   EXPECT_EQ("i686--windows-gnu", Triple::normalize("i686-mingw32"));
1049   EXPECT_EQ("i686-pc-windows-gnu", Triple::normalize("i686-pc-mingw32-w64"));
1050   EXPECT_EQ("i686--windows-gnu", Triple::normalize("i686-mingw32-w64"));
1051   EXPECT_EQ("i686-pc-windows-cygnus", Triple::normalize("i686-pc-cygwin"));
1052   EXPECT_EQ("i686--windows-cygnus", Triple::normalize("i686-cygwin"));
1053
1054   EXPECT_EQ("x86_64-pc-windows-msvc", Triple::normalize("x86_64-pc-win32"));
1055   EXPECT_EQ("x86_64--windows-msvc", Triple::normalize("x86_64-win32"));
1056   EXPECT_EQ("x86_64-pc-windows-gnu", Triple::normalize("x86_64-pc-mingw32"));
1057   EXPECT_EQ("x86_64--windows-gnu", Triple::normalize("x86_64-mingw32"));
1058   EXPECT_EQ("x86_64-pc-windows-gnu", Triple::normalize("x86_64-pc-mingw32-w64"));
1059   EXPECT_EQ("x86_64--windows-gnu", Triple::normalize("x86_64-mingw32-w64"));
1060
1061   EXPECT_EQ("i686-pc-windows-elf", Triple::normalize("i686-pc-win32-elf"));
1062   EXPECT_EQ("i686--windows-elf", Triple::normalize("i686-win32-elf"));
1063   EXPECT_EQ("i686-pc-windows-macho", Triple::normalize("i686-pc-win32-macho"));
1064   EXPECT_EQ("i686--windows-macho", Triple::normalize("i686-win32-macho"));
1065
1066   EXPECT_EQ("x86_64-pc-windows-elf", Triple::normalize("x86_64-pc-win32-elf"));
1067   EXPECT_EQ("x86_64--windows-elf", Triple::normalize("x86_64-win32-elf"));
1068   EXPECT_EQ("x86_64-pc-windows-macho", Triple::normalize("x86_64-pc-win32-macho"));
1069   EXPECT_EQ("x86_64--windows-macho", Triple::normalize("x86_64-win32-macho"));
1070
1071   EXPECT_EQ("i686-pc-windows-cygnus",
1072             Triple::normalize("i686-pc-windows-cygnus"));
1073   EXPECT_EQ("i686-pc-windows-gnu", Triple::normalize("i686-pc-windows-gnu"));
1074   EXPECT_EQ("i686-pc-windows-itanium", Triple::normalize("i686-pc-windows-itanium"));
1075   EXPECT_EQ("i686-pc-windows-msvc", Triple::normalize("i686-pc-windows-msvc"));
1076
1077   EXPECT_EQ("i686-pc-windows-elf", Triple::normalize("i686-pc-windows-elf-elf"));
1078 }
1079
1080 TEST(TripleTest, getARMCPUForArch) {
1081   // Platform specific defaults.
1082   {
1083     llvm::Triple Triple("arm--nacl");
1084     EXPECT_EQ("cortex-a8", Triple.getARMCPUForArch());
1085   }
1086   {
1087     llvm::Triple Triple("arm--openbsd");
1088     EXPECT_EQ("cortex-a8", Triple.getARMCPUForArch());
1089   }
1090   {
1091     llvm::Triple Triple("armv6-unknown-freebsd");
1092     EXPECT_EQ("arm1176jzf-s", Triple.getARMCPUForArch());
1093   }
1094   {
1095     llvm::Triple Triple("thumbv6-unknown-freebsd");
1096     EXPECT_EQ("arm1176jzf-s", Triple.getARMCPUForArch());
1097   }
1098   {
1099     llvm::Triple Triple("armebv6-unknown-freebsd");
1100     EXPECT_EQ("arm1176jzf-s", Triple.getARMCPUForArch());
1101   }
1102   {
1103     llvm::Triple Triple("arm--win32");
1104     EXPECT_EQ("cortex-a9", Triple.getARMCPUForArch());
1105   }
1106   // Some alternative architectures
1107   {
1108     llvm::Triple Triple("armv7k-apple-ios9");
1109     EXPECT_EQ("cortex-a7", Triple.getARMCPUForArch());
1110   }
1111   {
1112     llvm::Triple Triple("armv7k-apple-watchos3");
1113     EXPECT_EQ("cortex-a7", Triple.getARMCPUForArch());
1114   }
1115   {
1116     llvm::Triple Triple("armv7k-apple-tvos9");
1117     EXPECT_EQ("cortex-a7", Triple.getARMCPUForArch());
1118   }
1119   // armeb is permitted, but armebeb is not
1120   {
1121     llvm::Triple Triple("armeb-none-eabi");
1122     EXPECT_EQ("arm7tdmi", Triple.getARMCPUForArch());
1123   }
1124   {
1125     llvm::Triple Triple("armebeb-none-eabi");
1126     EXPECT_EQ("", Triple.getARMCPUForArch());
1127   }
1128   {
1129     llvm::Triple Triple("armebv6eb-none-eabi");
1130     EXPECT_EQ("", Triple.getARMCPUForArch());
1131   }
1132   // xscaleeb is permitted, but armebxscale is not
1133   {
1134     llvm::Triple Triple("xscaleeb-none-eabi");
1135     EXPECT_EQ("xscale", Triple.getARMCPUForArch());
1136   }
1137   {
1138     llvm::Triple Triple("armebxscale-none-eabi");
1139     EXPECT_EQ("", Triple.getARMCPUForArch());
1140   }
1141 }
1142
1143 TEST(TripleTest, NormalizeARM) {
1144   EXPECT_EQ("armv6--netbsd-eabi", Triple::normalize("armv6-netbsd-eabi"));
1145   EXPECT_EQ("armv7--netbsd-eabi", Triple::normalize("armv7-netbsd-eabi"));
1146   EXPECT_EQ("armv6eb--netbsd-eabi", Triple::normalize("armv6eb-netbsd-eabi"));
1147   EXPECT_EQ("armv7eb--netbsd-eabi", Triple::normalize("armv7eb-netbsd-eabi"));
1148   EXPECT_EQ("armv6--netbsd-eabihf", Triple::normalize("armv6-netbsd-eabihf"));
1149   EXPECT_EQ("armv7--netbsd-eabihf", Triple::normalize("armv7-netbsd-eabihf"));
1150   EXPECT_EQ("armv6eb--netbsd-eabihf", Triple::normalize("armv6eb-netbsd-eabihf"));
1151   EXPECT_EQ("armv7eb--netbsd-eabihf", Triple::normalize("armv7eb-netbsd-eabihf"));
1152
1153   EXPECT_EQ("armv7-suse-linux-gnueabihf",
1154             Triple::normalize("armv7-suse-linux-gnueabi"));
1155
1156   Triple T;
1157   T = Triple("armv6--netbsd-eabi");
1158   EXPECT_EQ(Triple::arm, T.getArch());
1159   T = Triple("armv6eb--netbsd-eabi");
1160   EXPECT_EQ(Triple::armeb, T.getArch());
1161   T = Triple("armv7-suse-linux-gnueabihf");
1162   EXPECT_EQ(Triple::GNUEABIHF, T.getEnvironment());
1163 }
1164
1165 TEST(TripleTest, ParseARMArch) {
1166   // ARM
1167   {
1168     Triple T = Triple("arm");
1169     EXPECT_EQ(Triple::arm, T.getArch());
1170   }
1171   {
1172     Triple T = Triple("armeb");
1173     EXPECT_EQ(Triple::armeb, T.getArch());
1174   }
1175   // THUMB
1176   {
1177     Triple T = Triple("thumb");
1178     EXPECT_EQ(Triple::thumb, T.getArch());
1179   }
1180   {
1181     Triple T = Triple("thumbeb");
1182     EXPECT_EQ(Triple::thumbeb, T.getArch());
1183   }
1184   // AARCH64
1185   {
1186     Triple T = Triple("arm64");
1187     EXPECT_EQ(Triple::aarch64, T.getArch());
1188   }
1189   {
1190     Triple T = Triple("aarch64");
1191     EXPECT_EQ(Triple::aarch64, T.getArch());
1192   }
1193   {
1194     Triple T = Triple("aarch64_be");
1195     EXPECT_EQ(Triple::aarch64_be, T.getArch());
1196   }
1197 }
1198 } // end anonymous namespace