llvm/unittests/TargetParser/TripleTest.cpp

   1 //===----------- Triple.cpp - Triple unit tests ---------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "llvm/TargetParser/Triple.h"
  10 #include "llvm/Support/FormatVariadic.h"
  11 #include "llvm/Support/VersionTuple.h"
  12 #include "gtest/gtest.h"
  13
  14 using namespace llvm;
  15
  16 namespace {
  17
  18 TEST(TripleTest, BasicParsing) {
  19   Triple T;
  20
  21   T = Triple("");
  22   EXPECT_EQ("", T.getArchName().str());
  23   EXPECT_EQ("", T.getVendorName().str());
  24   EXPECT_EQ("", T.getOSName().str());
  25   EXPECT_EQ("", T.getEnvironmentName().str());
  26
  27   T = Triple("-");
  28   EXPECT_EQ("", T.getArchName().str());
  29   EXPECT_EQ("", T.getVendorName().str());
  30   EXPECT_EQ("", T.getOSName().str());
  31   EXPECT_EQ("", T.getEnvironmentName().str());
  32
  33   T = Triple("--");
  34   EXPECT_EQ("", T.getArchName().str());
  35   EXPECT_EQ("", T.getVendorName().str());
  36   EXPECT_EQ("", T.getOSName().str());
  37   EXPECT_EQ("", T.getEnvironmentName().str());
  38
  39   T = Triple("---");
  40   EXPECT_EQ("", T.getArchName().str());
  41   EXPECT_EQ("", T.getVendorName().str());
  42   EXPECT_EQ("", T.getOSName().str());
  43   EXPECT_EQ("", T.getEnvironmentName().str());
  44
  45   T = Triple("----");
  46   EXPECT_EQ("", T.getArchName().str());
  47   EXPECT_EQ("", T.getVendorName().str());
  48   EXPECT_EQ("", T.getOSName().str());
  49   EXPECT_EQ("-", T.getEnvironmentName().str());
  50
  51   T = Triple("a");
  52   EXPECT_EQ("a", T.getArchName().str());
  53   EXPECT_EQ("", T.getVendorName().str());
  54   EXPECT_EQ("", T.getOSName().str());
  55   EXPECT_EQ("", T.getEnvironmentName().str());
  56
  57   T = Triple("a-b");
  58   EXPECT_EQ("a", T.getArchName().str());
  59   EXPECT_EQ("b", T.getVendorName().str());
  60   EXPECT_EQ("", T.getOSName().str());
  61   EXPECT_EQ("", T.getEnvironmentName().str());
  62
  63   T = Triple("a-b-c");
  64   EXPECT_EQ("a", T.getArchName().str());
  65   EXPECT_EQ("b", T.getVendorName().str());
  66   EXPECT_EQ("c", T.getOSName().str());
  67   EXPECT_EQ("", T.getEnvironmentName().str());
  68
  69   T = Triple("a-b-c-d");
  70   EXPECT_EQ("a", T.getArchName().str());
  71   EXPECT_EQ("b", T.getVendorName().str());
  72   EXPECT_EQ("c", T.getOSName().str());
  73   EXPECT_EQ("d", T.getEnvironmentName().str());
  74 }
  75
  76 TEST(TripleTest, ParsedIDs) {
  77   Triple T;
  78
  79   T = Triple("i386-apple-darwin");
  80   EXPECT_EQ(Triple::x86, T.getArch());
  81   EXPECT_EQ(Triple::Apple, T.getVendor());
  82   EXPECT_EQ(Triple::Darwin, T.getOS());
  83   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
  84
  85   T = Triple("i386-pc-elfiamcu");
  86   EXPECT_EQ(Triple::x86, T.getArch());
  87   EXPECT_EQ(Triple::PC, T.getVendor());
  88   EXPECT_EQ(Triple::ELFIAMCU, T.getOS());
  89   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
  90
  91   T = Triple("i386-pc-hurd-gnu");
  92   EXPECT_EQ(Triple::x86, T.getArch());
  93   EXPECT_EQ(Triple::PC, T.getVendor());
  94   EXPECT_EQ(Triple::Hurd, T.getOS());
  95   EXPECT_EQ(Triple::GNU, T.getEnvironment());
  96
  97   T = Triple("i686-pc-linux-gnu");
  98   EXPECT_EQ(Triple::x86, T.getArch());
  99   EXPECT_EQ(Triple::PC, T.getVendor());
 100   EXPECT_EQ(Triple::Linux, T.getOS());
 101   EXPECT_EQ(Triple::GNU, T.getEnvironment());
 102   EXPECT_FALSE(T.isTime64ABI());
 103
 104   T = Triple("x86_64-pc-linux-gnu");
 105   EXPECT_EQ(Triple::x86_64, T.getArch());
 106   EXPECT_EQ(Triple::PC, T.getVendor());
 107   EXPECT_EQ(Triple::Linux, T.getOS());
 108   EXPECT_EQ(Triple::GNU, T.getEnvironment());
 109
 110   T = Triple("x86_64-pc-linux-musl");
 111   EXPECT_EQ(Triple::x86_64, T.getArch());
 112   EXPECT_EQ(Triple::PC, T.getVendor());
 113   EXPECT_EQ(Triple::Linux, T.getOS());
 114   EXPECT_EQ(Triple::Musl, T.getEnvironment());
 115
 116   T = Triple("x86_64-pc-linux-muslx32");
 117   EXPECT_EQ(Triple::x86_64, T.getArch());
 118   EXPECT_EQ(Triple::PC, T.getVendor());
 119   EXPECT_EQ(Triple::Linux, T.getOS());
 120   EXPECT_EQ(Triple::MuslX32, T.getEnvironment());
 121
 122   T = Triple("x86_64-pc-hurd-gnu");
 123   EXPECT_EQ(Triple::x86_64, T.getArch());
 124   EXPECT_EQ(Triple::PC, T.getVendor());
 125   EXPECT_EQ(Triple::Hurd, T.getOS());
 126   EXPECT_EQ(Triple::GNU, T.getEnvironment());
 127
 128   T = Triple("arm-unknown-linux-android16");
 129   EXPECT_EQ(Triple::arm, T.getArch());
 130   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 131   EXPECT_EQ(Triple::Linux, T.getOS());
 132   EXPECT_EQ(Triple::Android, T.getEnvironment());
 133
 134   T = Triple("aarch64-unknown-linux-android21");
 135   EXPECT_EQ(Triple::aarch64, T.getArch());
 136   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 137   EXPECT_EQ(Triple::Linux, T.getOS());
 138   EXPECT_EQ(Triple::Android, T.getEnvironment());
 139
 140   // PS4 has two spellings for the vendor.
 141   T = Triple("x86_64-scei-ps4");
 142   EXPECT_EQ(Triple::x86_64, T.getArch());
 143   EXPECT_EQ(Triple::SCEI, T.getVendor());
 144   EXPECT_EQ(Triple::PS4, T.getOS());
 145
 146   T = Triple("x86_64-sie-ps4");
 147   EXPECT_EQ(Triple::x86_64, T.getArch());
 148   EXPECT_EQ(Triple::SCEI, T.getVendor());
 149   EXPECT_EQ(Triple::PS4, T.getOS());
 150
 151   T = Triple("x86_64-sie-ps5");
 152   EXPECT_EQ(Triple::x86_64, T.getArch());
 153   EXPECT_EQ(Triple::SCEI, T.getVendor());
 154   EXPECT_EQ(Triple::PS5, T.getOS());
 155
 156   T = Triple("powerpc-ibm-aix");
 157   EXPECT_EQ(Triple::ppc, T.getArch());
 158   EXPECT_EQ(Triple::IBM, T.getVendor());
 159   EXPECT_EQ(Triple::AIX, T.getOS());
 160   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 161
 162   T = Triple("powerpc64-ibm-aix");
 163   EXPECT_EQ(Triple::ppc64, T.getArch());
 164   EXPECT_EQ(Triple::IBM, T.getVendor());
 165   EXPECT_EQ(Triple::AIX, T.getOS());
 166   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 167
 168   T = Triple("powerpc-dunno-notsure");
 169   EXPECT_EQ(Triple::ppc, T.getArch());
 170   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 171   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 172   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 173
 174   T = Triple("powerpcspe-unknown-freebsd");
 175   EXPECT_EQ(Triple::ppc, T.getArch());
 176   EXPECT_EQ(Triple::PPCSubArch_spe, T.getSubArch());
 177   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 178   EXPECT_EQ(Triple::FreeBSD, T.getOS());
 179   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 180
 181   T = Triple("s390x-ibm-zos");
 182   EXPECT_EQ(Triple::systemz, T.getArch());
 183   EXPECT_EQ(Triple::IBM, T.getVendor());
 184   EXPECT_EQ(Triple::ZOS, T.getOS());
 185   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 186
 187   T = Triple("systemz-ibm-zos");
 188   EXPECT_EQ(Triple::systemz, T.getArch());
 189   EXPECT_EQ(Triple::IBM, T.getVendor());
 190   EXPECT_EQ(Triple::ZOS, T.getOS());
 191   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 192
 193   T = Triple("arm-none-none-eabi");
 194   EXPECT_EQ(Triple::arm, T.getArch());
 195   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 196   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 197   EXPECT_EQ(Triple::EABI, T.getEnvironment());
 198   EXPECT_FALSE(T.isHardFloatABI());
 199
 200   T = Triple("arm-none-none-eabihf");
 201   EXPECT_EQ(Triple::arm, T.getArch());
 202   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 203   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 204   EXPECT_EQ(Triple::EABIHF, T.getEnvironment());
 205   EXPECT_TRUE(T.isHardFloatABI());
 206
 207   T = Triple("arm-none-linux-musleabi");
 208   EXPECT_EQ(Triple::arm, T.getArch());
 209   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 210   EXPECT_EQ(Triple::Linux, T.getOS());
 211   EXPECT_EQ(Triple::MuslEABI, T.getEnvironment());
 212   EXPECT_FALSE(T.isHardFloatABI());
 213
 214   T = Triple("arm-none-linux-musleabihf");
 215   EXPECT_EQ(Triple::arm, T.getArch());
 216   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 217   EXPECT_EQ(Triple::Linux, T.getOS());
 218   EXPECT_EQ(Triple::MuslEABIHF, T.getEnvironment());
 219   EXPECT_TRUE(T.isHardFloatABI());
 220
 221   T = Triple("armv6hl-none-linux-gnueabi");
 222   EXPECT_EQ(Triple::arm, T.getArch());
 223   EXPECT_EQ(Triple::Linux, T.getOS());
 224   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 225   EXPECT_EQ(Triple::GNUEABI, T.getEnvironment());
 226   EXPECT_FALSE(T.isTime64ABI());
 227   EXPECT_FALSE(T.isHardFloatABI());
 228
 229   T = Triple("armv7hl-none-linux-gnueabi");
 230   EXPECT_EQ(Triple::arm, T.getArch());
 231   EXPECT_EQ(Triple::Linux, T.getOS());
 232   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 233   EXPECT_EQ(Triple::GNUEABI, T.getEnvironment());
 234   EXPECT_FALSE(T.isTime64ABI());
 235   EXPECT_FALSE(T.isHardFloatABI());
 236
 237   T = Triple("armv7hl-none-linux-gnueabihf");
 238   EXPECT_EQ(Triple::arm, T.getArch());
 239   EXPECT_EQ(Triple::Linux, T.getOS());
 240   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 241   EXPECT_EQ(Triple::GNUEABIHF, T.getEnvironment());
 242   EXPECT_FALSE(T.isTime64ABI());
 243   EXPECT_TRUE(T.isHardFloatABI());
 244
 245   T = Triple("amdil-unknown-unknown");
 246   EXPECT_EQ(Triple::amdil, T.getArch());
 247   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 248   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 249
 250   T = Triple("amdil64-unknown-unknown");
 251   EXPECT_EQ(Triple::amdil64, T.getArch());
 252   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 253   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 254
 255   T = Triple("hsail-unknown-unknown");
 256   EXPECT_EQ(Triple::hsail, T.getArch());
 257   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 258   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 259
 260   T = Triple("hsail64-unknown-unknown");
 261   EXPECT_EQ(Triple::hsail64, T.getArch());
 262   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 263   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 264
 265   T = Triple("sparcel-unknown-unknown");
 266   EXPECT_EQ(Triple::sparcel, T.getArch());
 267   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 268   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 269
 270   T = Triple("spir-unknown-unknown");
 271   EXPECT_EQ(Triple::spir, T.getArch());
 272   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 273   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 274
 275   T = Triple("spir64-unknown-unknown");
 276   EXPECT_EQ(Triple::spir64, T.getArch());
 277   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 278   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 279
 280   T = Triple("spirv32-unknown-unknown");
 281   EXPECT_EQ(Triple::spirv32, T.getArch());
 282   EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
 283   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 284   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 285
 286   T = Triple("spirv32v1.0-unknown-unknown");
 287   EXPECT_EQ(Triple::spirv32, T.getArch());
 288   EXPECT_EQ(Triple::SPIRVSubArch_v10, T.getSubArch());
 289   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 290   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 291
 292   T = Triple("spirv32v1.1-unknown-unknown");
 293   EXPECT_EQ(Triple::spirv32, T.getArch());
 294   EXPECT_EQ(Triple::SPIRVSubArch_v11, T.getSubArch());
 295   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 296   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 297
 298   T = Triple("spirv32v1.2-unknown-unknown");
 299   EXPECT_EQ(Triple::spirv32, T.getArch());
 300   EXPECT_EQ(Triple::SPIRVSubArch_v12, T.getSubArch());
 301   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 302   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 303
 304   T = Triple("spirv32v1.3-unknown-unknown");
 305   EXPECT_EQ(Triple::spirv32, T.getArch());
 306   EXPECT_EQ(Triple::SPIRVSubArch_v13, T.getSubArch());
 307   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 308   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 309
 310   T = Triple("spirv32v1.4-unknown-unknown");
 311   EXPECT_EQ(Triple::spirv32, T.getArch());
 312   EXPECT_EQ(Triple::SPIRVSubArch_v14, T.getSubArch());
 313   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 314   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 315
 316   T = Triple("spirv32v1.5-unknown-unknown");
 317   EXPECT_EQ(Triple::spirv32, T.getArch());
 318   EXPECT_EQ(Triple::SPIRVSubArch_v15, T.getSubArch());
 319   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 320   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 321
 322   T = Triple("spirv64-unknown-unknown");
 323   EXPECT_EQ(Triple::spirv64, T.getArch());
 324   EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
 325   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 326   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 327
 328   T = Triple("spirv64v1.0-unknown-unknown");
 329   EXPECT_EQ(Triple::spirv64, T.getArch());
 330   EXPECT_EQ(Triple::SPIRVSubArch_v10, T.getSubArch());
 331   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 332   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 333
 334   T = Triple("spirv64v1.1-unknown-unknown");
 335   EXPECT_EQ(Triple::spirv64, T.getArch());
 336   EXPECT_EQ(Triple::SPIRVSubArch_v11, T.getSubArch());
 337   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 338   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 339
 340   T = Triple("spirv64v1.2-unknown-unknown");
 341   EXPECT_EQ(Triple::spirv64, T.getArch());
 342   EXPECT_EQ(Triple::SPIRVSubArch_v12, T.getSubArch());
 343   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 344   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 345
 346   T = Triple("spirv64v1.3-unknown-unknown");
 347   EXPECT_EQ(Triple::spirv64, T.getArch());
 348   EXPECT_EQ(Triple::SPIRVSubArch_v13, T.getSubArch());
 349   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 350   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 351
 352   T = Triple("spirv64v1.4-unknown-unknown");
 353   EXPECT_EQ(Triple::spirv64, T.getArch());
 354   EXPECT_EQ(Triple::SPIRVSubArch_v14, T.getSubArch());
 355   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 356   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 357
 358   T = Triple("spirv64v1.5-unknown-unknown");
 359   EXPECT_EQ(Triple::spirv64, T.getArch());
 360   EXPECT_EQ(Triple::SPIRVSubArch_v15, T.getSubArch());
 361   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 362   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 363
 364   T = Triple("spirv-unknown-vulkan-pixel");
 365   EXPECT_EQ(Triple::spirv, T.getArch());
 366   EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
 367   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 368   EXPECT_EQ(Triple::Vulkan, T.getOS());
 369   EXPECT_EQ(VersionTuple(1, 2), T.getVulkanVersion());
 370   EXPECT_EQ(Triple::Pixel, T.getEnvironment());
 371
 372   T = Triple("spirv-unknown-vulkan-vertex");
 373   EXPECT_EQ(Triple::spirv, T.getArch());
 374   EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
 375   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 376   EXPECT_EQ(Triple::Vulkan, T.getOS());
 377   EXPECT_EQ(VersionTuple(1, 2), T.getVulkanVersion());
 378   EXPECT_EQ(Triple::Vertex, T.getEnvironment());
 379
 380   T = Triple("spirv-unknown-vulkan-geometry");
 381   EXPECT_EQ(Triple::spirv, T.getArch());
 382   EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
 383   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 384   EXPECT_EQ(Triple::Vulkan, T.getOS());
 385   EXPECT_EQ(VersionTuple(1, 2), T.getVulkanVersion());
 386   EXPECT_EQ(Triple::Geometry, T.getEnvironment());
 387
 388   T = Triple("spirv-unknown-vulkan-library");
 389   EXPECT_EQ(Triple::spirv, T.getArch());
 390   EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
 391   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 392   EXPECT_EQ(Triple::Vulkan, T.getOS());
 393   EXPECT_EQ(VersionTuple(1, 2), T.getVulkanVersion());
 394   EXPECT_EQ(Triple::Library, T.getEnvironment());
 395
 396   T = Triple("spirv-unknown-vulkan-raygeneration");
 397   EXPECT_EQ(Triple::spirv, T.getArch());
 398   EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
 399   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 400   EXPECT_EQ(Triple::Vulkan, T.getOS());
 401   EXPECT_EQ(VersionTuple(1, 2), T.getVulkanVersion());
 402   EXPECT_EQ(Triple::RayGeneration, T.getEnvironment());
 403
 404   T = Triple("spirv-unknown-vulkan-intersection");
 405   EXPECT_EQ(Triple::spirv, T.getArch());
 406   EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
 407   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 408   EXPECT_EQ(Triple::Vulkan, T.getOS());
 409   EXPECT_EQ(VersionTuple(1, 2), T.getVulkanVersion());
 410   EXPECT_EQ(Triple::Intersection, T.getEnvironment());
 411
 412   T = Triple("spirv-unknown-vulkan-anyhit");
 413   EXPECT_EQ(Triple::spirv, T.getArch());
 414   EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
 415   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 416   EXPECT_EQ(Triple::Vulkan, T.getOS());
 417   EXPECT_EQ(VersionTuple(1, 2), T.getVulkanVersion());
 418   EXPECT_EQ(Triple::AnyHit, T.getEnvironment());
 419
 420   T = Triple("spirv-unknown-vulkan-closesthit");
 421   EXPECT_EQ(Triple::spirv, T.getArch());
 422   EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
 423   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 424   EXPECT_EQ(Triple::Vulkan, T.getOS());
 425   EXPECT_EQ(VersionTuple(1, 2), T.getVulkanVersion());
 426   EXPECT_EQ(Triple::ClosestHit, T.getEnvironment());
 427
 428   T = Triple("spirv-unknown-vulkan-miss");
 429   EXPECT_EQ(Triple::spirv, T.getArch());
 430   EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
 431   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 432   EXPECT_EQ(Triple::Vulkan, T.getOS());
 433   EXPECT_EQ(VersionTuple(1, 2), T.getVulkanVersion());
 434   EXPECT_EQ(Triple::Miss, T.getEnvironment());
 435
 436   T = Triple("spirv-unknown-vulkan-callable");
 437   EXPECT_EQ(Triple::spirv, T.getArch());
 438   EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
 439   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 440   EXPECT_EQ(Triple::Vulkan, T.getOS());
 441   EXPECT_EQ(VersionTuple(1, 2), T.getVulkanVersion());
 442   EXPECT_EQ(Triple::Callable, T.getEnvironment());
 443
 444   T = Triple("spirv-unknown-vulkan-mesh");
 445   EXPECT_EQ(Triple::spirv, T.getArch());
 446   EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
 447   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 448   EXPECT_EQ(Triple::Vulkan, T.getOS());
 449   EXPECT_EQ(VersionTuple(1, 2), T.getVulkanVersion());
 450   EXPECT_EQ(Triple::Mesh, T.getEnvironment());
 451
 452   T = Triple("spirv-unknown-vulkan-amplification");
 453   EXPECT_EQ(Triple::spirv, T.getArch());
 454   EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
 455   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 456   EXPECT_EQ(Triple::Vulkan, T.getOS());
 457   EXPECT_EQ(VersionTuple(1, 2), T.getVulkanVersion());
 458   EXPECT_EQ(Triple::Amplification, T.getEnvironment());
 459
 460   T = Triple("spirv1.5-unknown-vulkan1.2-compute");
 461   EXPECT_EQ(Triple::spirv, T.getArch());
 462   EXPECT_EQ(Triple::SPIRVSubArch_v15, T.getSubArch());
 463   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 464   EXPECT_EQ(Triple::Vulkan, T.getOS());
 465   EXPECT_EQ(VersionTuple(1, 2), T.getVulkanVersion());
 466   EXPECT_EQ(Triple::Compute, T.getEnvironment());
 467
 468   T = Triple("spirv1.6-unknown-vulkan1.3-compute");
 469   EXPECT_EQ(Triple::spirv, T.getArch());
 470   EXPECT_EQ(Triple::SPIRVSubArch_v16, T.getSubArch());
 471   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 472   EXPECT_EQ(Triple::Vulkan, T.getOS());
 473   EXPECT_EQ(VersionTuple(1, 3), T.getVulkanVersion());
 474   EXPECT_EQ(Triple::Compute, T.getEnvironment());
 475
 476   T = Triple("dxilv1.0--shadermodel6.0-pixel");
 477   EXPECT_EQ(Triple::dxil, T.getArch());
 478   EXPECT_EQ(Triple::DXILSubArch_v1_0, T.getSubArch());
 479   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 480   EXPECT_EQ(Triple::ShaderModel, T.getOS());
 481   EXPECT_EQ(VersionTuple(1, 0), T.getDXILVersion());
 482   EXPECT_EQ(Triple::Pixel, T.getEnvironment());
 483
 484   T = Triple("dxilv1.1--shadermodel6.1-vertex");
 485   EXPECT_EQ(Triple::dxil, T.getArch());
 486   EXPECT_EQ(Triple::DXILSubArch_v1_1, T.getSubArch());
 487   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 488   EXPECT_EQ(Triple::ShaderModel, T.getOS());
 489   EXPECT_EQ(VersionTuple(1, 1), T.getDXILVersion());
 490   EXPECT_EQ(Triple::Vertex, T.getEnvironment());
 491
 492   T = Triple("dxilv1.2--shadermodel6.2-geometry");
 493   EXPECT_EQ(Triple::dxil, T.getArch());
 494   EXPECT_EQ(Triple::DXILSubArch_v1_2, T.getSubArch());
 495   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 496   EXPECT_EQ(Triple::ShaderModel, T.getOS());
 497   EXPECT_EQ(VersionTuple(1, 2), T.getDXILVersion());
 498   EXPECT_EQ(Triple::Geometry, T.getEnvironment());
 499
 500   T = Triple("dxilv1.3--shadermodel6.3-library");
 501   EXPECT_EQ(Triple::dxil, T.getArch());
 502   EXPECT_EQ(Triple::DXILSubArch_v1_3, T.getSubArch());
 503   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 504   EXPECT_EQ(Triple::ShaderModel, T.getOS());
 505   EXPECT_EQ(VersionTuple(1, 3), T.getDXILVersion());
 506   EXPECT_EQ(Triple::Library, T.getEnvironment());
 507
 508   T = Triple("dxilv1.4--shadermodel6.4-hull");
 509   EXPECT_EQ(Triple::dxil, T.getArch());
 510   EXPECT_EQ(Triple::DXILSubArch_v1_4, T.getSubArch());
 511   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 512   EXPECT_EQ(Triple::ShaderModel, T.getOS());
 513   EXPECT_EQ(VersionTuple(1, 4), T.getDXILVersion());
 514   EXPECT_EQ(Triple::Hull, T.getEnvironment());
 515
 516   T = Triple("dxilv1.5--shadermodel6.5-domain");
 517   EXPECT_EQ(Triple::dxil, T.getArch());
 518   EXPECT_EQ(Triple::DXILSubArch_v1_5, T.getSubArch());
 519   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 520   EXPECT_EQ(Triple::ShaderModel, T.getOS());
 521   EXPECT_EQ(VersionTuple(1, 5), T.getDXILVersion());
 522   EXPECT_EQ(Triple::Domain, T.getEnvironment());
 523
 524   T = Triple("dxilv1.6--shadermodel6.6-compute");
 525   EXPECT_EQ(Triple::dxil, T.getArch());
 526   EXPECT_EQ(Triple::DXILSubArch_v1_6, T.getSubArch());
 527   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 528   EXPECT_EQ(Triple::ShaderModel, T.getOS());
 529   EXPECT_EQ(VersionTuple(1, 6), T.getDXILVersion());
 530   EXPECT_EQ(Triple::Compute, T.getEnvironment());
 531
 532   T = Triple("dxilv1.7-unknown-shadermodel6.7-mesh");
 533   EXPECT_EQ(Triple::dxil, T.getArch());
 534   EXPECT_EQ(Triple::DXILSubArch_v1_7, T.getSubArch());
 535   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 536   EXPECT_EQ(Triple::ShaderModel, T.getOS());
 537   EXPECT_EQ(VersionTuple(1, 7), T.getDXILVersion());
 538   EXPECT_EQ(Triple::Mesh, T.getEnvironment());
 539
 540   T = Triple("dxilv1.8-unknown-shadermodel6.8-amplification");
 541   EXPECT_EQ(Triple::dxil, T.getArch());
 542   EXPECT_EQ(Triple::DXILSubArch_v1_8, T.getSubArch());
 543   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 544   EXPECT_EQ(Triple::ShaderModel, T.getOS());
 545   EXPECT_EQ(VersionTuple(1, 8), T.getDXILVersion());
 546   EXPECT_EQ(Triple::Amplification, T.getEnvironment());
 547
 548   T = Triple("dxilv1.8-unknown-shadermodel6.15-library");
 549   EXPECT_EQ(Triple::dxil, T.getArch());
 550   EXPECT_EQ(Triple::DXILSubArch_v1_8, T.getSubArch());
 551   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 552   EXPECT_EQ(Triple::ShaderModel, T.getOS());
 553   EXPECT_EQ(VersionTuple(1, 8), T.getDXILVersion());
 554
 555   T = Triple("x86_64-unknown-fuchsia");
 556   EXPECT_EQ(Triple::x86_64, T.getArch());
 557   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 558   EXPECT_EQ(Triple::Fuchsia, T.getOS());
 559   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 560
 561   T = Triple("x86_64-unknown-hermit");
 562   EXPECT_EQ(Triple::x86_64, T.getArch());
 563   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 564   EXPECT_EQ(Triple::HermitCore, T.getOS());
 565   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 566
 567   T = Triple("x86_64-unknown-uefi");
 568   EXPECT_EQ(Triple::x86_64, T.getArch());
 569   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 570   EXPECT_EQ(Triple::UEFI, T.getOS());
 571   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 572   EXPECT_EQ(Triple::COFF, T.getObjectFormat());
 573
 574   T = Triple("wasm32-unknown-unknown");
 575   EXPECT_EQ(Triple::wasm32, T.getArch());
 576   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 577   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 578   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 579
 580   T = Triple("wasm32-unknown-wasi");
 581   EXPECT_EQ(Triple::wasm32, T.getArch());
 582   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 583   EXPECT_EQ(Triple::WASI, T.getOS());
 584   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 585
 586   T = Triple("wasm64-unknown-unknown");
 587   EXPECT_EQ(Triple::wasm64, T.getArch());
 588   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 589   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 590   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 591
 592   T = Triple("wasm64-unknown-wasi");
 593   EXPECT_EQ(Triple::wasm64, T.getArch());
 594   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 595   EXPECT_EQ(Triple::WASI, T.getOS());
 596   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 597
 598   T = Triple("avr-unknown-unknown");
 599   EXPECT_EQ(Triple::avr, T.getArch());
 600   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 601   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 602   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 603
 604   T = Triple("avr");
 605   EXPECT_EQ(Triple::avr, T.getArch());
 606   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 607   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 608   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 609
 610   T = Triple("lanai-unknown-unknown");
 611   EXPECT_EQ(Triple::lanai, T.getArch());
 612   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 613   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 614   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 615
 616   T = Triple("lanai");
 617   EXPECT_EQ(Triple::lanai, T.getArch());
 618   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 619   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 620   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 621
 622   T = Triple("amdgcn-mesa-mesa3d");
 623   EXPECT_EQ(Triple::amdgcn, T.getArch());
 624   EXPECT_EQ(Triple::Mesa, T.getVendor());
 625   EXPECT_EQ(Triple::Mesa3D, T.getOS());
 626   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 627
 628   T = Triple("amdgcn-amd-amdhsa");
 629   EXPECT_EQ(Triple::amdgcn, T.getArch());
 630   EXPECT_EQ(Triple::AMD, T.getVendor());
 631   EXPECT_EQ(Triple::AMDHSA, T.getOS());
 632   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 633
 634   T = Triple("amdgcn-amd-amdpal");
 635   EXPECT_EQ(Triple::amdgcn, T.getArch());
 636   EXPECT_EQ(Triple::AMD, T.getVendor());
 637   EXPECT_EQ(Triple::AMDPAL, T.getOS());
 638   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 639
 640   T = Triple("ve-unknown-linux");
 641   EXPECT_EQ(Triple::ve, T.getArch());
 642   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 643   EXPECT_EQ(Triple::Linux, T.getOS());
 644   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 645
 646   T = Triple("csky-unknown-unknown");
 647   EXPECT_EQ(Triple::csky, T.getArch());
 648   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 649   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 650   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 651
 652   T = Triple("csky-unknown-linux");
 653   EXPECT_EQ(Triple::csky, T.getArch());
 654   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 655   EXPECT_EQ(Triple::Linux, T.getOS());
 656   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 657
 658   T = Triple("loongarch32-unknown-unknown");
 659   EXPECT_EQ(Triple::loongarch32, T.getArch());
 660   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 661   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 662   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 663
 664   T = Triple("loongarch32-unknown-linux-gnu");
 665   EXPECT_EQ(Triple::loongarch32, T.getArch());
 666   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 667   EXPECT_EQ(Triple::Linux, T.getOS());
 668   EXPECT_EQ(Triple::GNU, T.getEnvironment());
 669
 670   T = Triple("loongarch32-unknown-linux-gnuf32");
 671   EXPECT_EQ(Triple::loongarch32, T.getArch());
 672   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 673   EXPECT_EQ(Triple::Linux, T.getOS());
 674   EXPECT_EQ(Triple::GNUF32, T.getEnvironment());
 675
 676   T = Triple("loongarch32-unknown-linux-gnuf64");
 677   EXPECT_EQ(Triple::loongarch32, T.getArch());
 678   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 679   EXPECT_EQ(Triple::Linux, T.getOS());
 680   EXPECT_EQ(Triple::GNUF64, T.getEnvironment());
 681
 682   T = Triple("loongarch32-unknown-linux-gnusf");
 683   EXPECT_EQ(Triple::loongarch32, T.getArch());
 684   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 685   EXPECT_EQ(Triple::Linux, T.getOS());
 686   EXPECT_EQ(Triple::GNUSF, T.getEnvironment());
 687
 688   T = Triple("loongarch32-unknown-linux-musl");
 689   EXPECT_EQ(Triple::loongarch32, T.getArch());
 690   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 691   EXPECT_EQ(Triple::Linux, T.getOS());
 692   EXPECT_EQ(Triple::Musl, T.getEnvironment());
 693
 694   T = Triple("loongarch32-unknown-linux-muslf32");
 695   EXPECT_EQ(Triple::loongarch32, T.getArch());
 696   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 697   EXPECT_EQ(Triple::Linux, T.getOS());
 698   EXPECT_EQ(Triple::MuslF32, T.getEnvironment());
 699
 700   T = Triple("loongarch32-unknown-linux-muslsf");
 701   EXPECT_EQ(Triple::loongarch32, T.getArch());
 702   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 703   EXPECT_EQ(Triple::Linux, T.getOS());
 704   EXPECT_EQ(Triple::MuslSF, T.getEnvironment());
 705
 706   T = Triple("loongarch64-unknown-linux");
 707   EXPECT_EQ(Triple::loongarch64, T.getArch());
 708   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 709   EXPECT_EQ(Triple::Linux, T.getOS());
 710   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 711
 712   T = Triple("loongarch64-unknown-linux-gnu");
 713   EXPECT_EQ(Triple::loongarch64, T.getArch());
 714   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 715   EXPECT_EQ(Triple::Linux, T.getOS());
 716   EXPECT_EQ(Triple::GNU, T.getEnvironment());
 717
 718   T = Triple("loongarch64-unknown-linux-gnuf32");
 719   EXPECT_EQ(Triple::loongarch64, T.getArch());
 720   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 721   EXPECT_EQ(Triple::Linux, T.getOS());
 722   EXPECT_EQ(Triple::GNUF32, T.getEnvironment());
 723
 724   T = Triple("loongarch64-unknown-linux-gnuf64");
 725   EXPECT_EQ(Triple::loongarch64, T.getArch());
 726   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 727   EXPECT_EQ(Triple::Linux, T.getOS());
 728   EXPECT_EQ(Triple::GNUF64, T.getEnvironment());
 729
 730   T = Triple("loongarch64-unknown-linux-gnusf");
 731   EXPECT_EQ(Triple::loongarch64, T.getArch());
 732   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 733   EXPECT_EQ(Triple::Linux, T.getOS());
 734   EXPECT_EQ(Triple::GNUSF, T.getEnvironment());
 735
 736   T = Triple("loongarch64-unknown-linux-musl");
 737   EXPECT_EQ(Triple::loongarch64, T.getArch());
 738   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 739   EXPECT_EQ(Triple::Linux, T.getOS());
 740   EXPECT_EQ(Triple::Musl, T.getEnvironment());
 741
 742   T = Triple("loongarch64-unknown-linux-muslf32");
 743   EXPECT_EQ(Triple::loongarch64, T.getArch());
 744   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 745   EXPECT_EQ(Triple::Linux, T.getOS());
 746   EXPECT_EQ(Triple::MuslF32, T.getEnvironment());
 747
 748   T = Triple("loongarch64-unknown-linux-muslsf");
 749   EXPECT_EQ(Triple::loongarch64, T.getArch());
 750   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 751   EXPECT_EQ(Triple::Linux, T.getOS());
 752   EXPECT_EQ(Triple::MuslSF, T.getEnvironment());
 753
 754   T = Triple("riscv32-unknown-unknown");
 755   EXPECT_EQ(Triple::riscv32, T.getArch());
 756   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 757   EXPECT_EQ(Triple::UnknownOS, T.getOS());
 758   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 759
 760   T = Triple("riscv64-unknown-linux");
 761   EXPECT_EQ(Triple::riscv64, T.getArch());
 762   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 763   EXPECT_EQ(Triple::Linux, T.getOS());
 764   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 765
 766   T = Triple("riscv64-unknown-freebsd");
 767   EXPECT_EQ(Triple::riscv64, T.getArch());
 768   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 769   EXPECT_EQ(Triple::FreeBSD, T.getOS());
 770   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 771
 772   T = Triple("riscv64-suse-linux");
 773   EXPECT_EQ(Triple::riscv64, T.getArch());
 774   EXPECT_EQ(Triple::SUSE, T.getVendor());
 775   EXPECT_EQ(Triple::Linux, T.getOS());
 776   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 777
 778   T = Triple("armv7hl-suse-linux-gnueabi");
 779   EXPECT_EQ(Triple::arm, T.getArch());
 780   EXPECT_EQ(Triple::SUSE, T.getVendor());
 781   EXPECT_EQ(Triple::Linux, T.getOS());
 782   EXPECT_EQ(Triple::GNUEABI, T.getEnvironment());
 783
 784   T = Triple("i586-pc-haiku");
 785   EXPECT_EQ(Triple::x86, T.getArch());
 786   EXPECT_EQ(Triple::PC, T.getVendor());
 787   EXPECT_EQ(Triple::Haiku, T.getOS());
 788   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 789
 790   T = Triple("x86_64-unknown-haiku");
 791   EXPECT_EQ(Triple::x86_64, T.getArch());
 792   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 793   EXPECT_EQ(Triple::Haiku, T.getOS());
 794   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 795
 796   T = Triple("mips-mti-linux-gnu");
 797   EXPECT_EQ(Triple::mips, T.getArch());
 798   EXPECT_EQ(Triple::MipsTechnologies, T.getVendor());
 799   EXPECT_EQ(Triple::Linux, T.getOS());
 800   EXPECT_EQ(Triple::GNU, T.getEnvironment());
 801
 802   T = Triple("mipsel-img-linux-gnu");
 803   EXPECT_EQ(Triple::mipsel, T.getArch());
 804   EXPECT_EQ(Triple::ImaginationTechnologies, T.getVendor());
 805   EXPECT_EQ(Triple::Linux, T.getOS());
 806   EXPECT_EQ(Triple::GNU, T.getEnvironment());
 807
 808   T = Triple("mips64-mti-linux-gnu");
 809   EXPECT_EQ(Triple::mips64, T.getArch());
 810   EXPECT_EQ(Triple::MipsTechnologies, T.getVendor());
 811   EXPECT_EQ(Triple::Linux, T.getOS());
 812   EXPECT_EQ(Triple::GNU, T.getEnvironment());
 813
 814   T = Triple("mips64el-img-linux-gnu");
 815   EXPECT_EQ(Triple::mips64el, T.getArch());
 816   EXPECT_EQ(Triple::ImaginationTechnologies, T.getVendor());
 817   EXPECT_EQ(Triple::Linux, T.getOS());
 818   EXPECT_EQ(Triple::GNU, T.getEnvironment());
 819
 820   T = Triple("mips64el-img-linux-gnuabin32");
 821   EXPECT_EQ(Triple::mips64el, T.getArch());
 822   EXPECT_EQ(Triple::ImaginationTechnologies, T.getVendor());
 823   EXPECT_EQ(Triple::Linux, T.getOS());
 824   EXPECT_EQ(Triple::GNUABIN32, T.getEnvironment());
 825
 826   T = Triple("mips64el-unknown-linux-gnuabi64");
 827   EXPECT_EQ(Triple::mips64el, T.getArch());
 828   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 829   EXPECT_EQ(Triple::Linux, T.getOS());
 830   EXPECT_EQ(Triple::GNUABI64, T.getEnvironment());
 831   EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
 832   T = Triple("mips64el");
 833   EXPECT_EQ(Triple::mips64el, T.getArch());
 834   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 835   EXPECT_EQ(Triple::GNUABI64, T.getEnvironment());
 836   EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
 837
 838   T = Triple("mips64-unknown-linux-gnuabi64");
 839   EXPECT_EQ(Triple::mips64, T.getArch());
 840   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 841   EXPECT_EQ(Triple::Linux, T.getOS());
 842   EXPECT_EQ(Triple::GNUABI64, T.getEnvironment());
 843   EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
 844   T = Triple("mips64");
 845   EXPECT_EQ(Triple::mips64, T.getArch());
 846   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 847   EXPECT_EQ(Triple::GNUABI64, T.getEnvironment());
 848   EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
 849
 850   T = Triple("mipsisa64r6el-unknown-linux-gnuabi64");
 851   EXPECT_EQ(Triple::mips64el, T.getArch());
 852   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 853   EXPECT_EQ(Triple::Linux, T.getOS());
 854   EXPECT_EQ(Triple::GNUABI64, T.getEnvironment());
 855   EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch());
 856   T = Triple("mips64r6el");
 857   EXPECT_EQ(Triple::mips64el, T.getArch());
 858   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 859   EXPECT_EQ(Triple::GNUABI64, T.getEnvironment());
 860   EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch());
 861   T = Triple("mipsisa64r6el");
 862   EXPECT_EQ(Triple::mips64el, T.getArch());
 863   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 864   EXPECT_EQ(Triple::GNUABI64, T.getEnvironment());
 865   EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch());
 866
 867   T = Triple("mipsisa64r6-unknown-linux-gnuabi64");
 868   EXPECT_EQ(Triple::mips64, T.getArch());
 869   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 870   EXPECT_EQ(Triple::Linux, T.getOS());
 871   EXPECT_EQ(Triple::GNUABI64, T.getEnvironment());
 872   EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch());
 873   T = Triple("mips64r6");
 874   EXPECT_EQ(Triple::mips64, T.getArch());
 875   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 876   EXPECT_EQ(Triple::GNUABI64, T.getEnvironment());
 877   EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch());
 878   T = Triple("mipsisa64r6");
 879   EXPECT_EQ(Triple::mips64, T.getArch());
 880   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 881   EXPECT_EQ(Triple::GNUABI64, T.getEnvironment());
 882   EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch());
 883
 884   T = Triple("mips64el-unknown-linux-gnuabin32");
 885   EXPECT_EQ(Triple::mips64el, T.getArch());
 886   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 887   EXPECT_EQ(Triple::Linux, T.getOS());
 888   EXPECT_EQ(Triple::GNUABIN32, T.getEnvironment());
 889   EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
 890   T = Triple("mipsn32el");
 891   EXPECT_EQ(Triple::mips64el, T.getArch());
 892   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 893   EXPECT_EQ(Triple::GNUABIN32, T.getEnvironment());
 894   EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
 895
 896   T = Triple("mips64-unknown-linux-gnuabin32");
 897   EXPECT_EQ(Triple::mips64, T.getArch());
 898   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 899   EXPECT_EQ(Triple::Linux, T.getOS());
 900   EXPECT_EQ(Triple::GNUABIN32, T.getEnvironment());
 901   EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
 902   T = Triple("mipsn32");
 903   EXPECT_EQ(Triple::mips64, T.getArch());
 904   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 905   EXPECT_EQ(Triple::GNUABIN32, T.getEnvironment());
 906   EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
 907
 908   T = Triple("mipsisa64r6el-unknown-linux-gnuabin32");
 909   EXPECT_EQ(Triple::mips64el, T.getArch());
 910   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 911   EXPECT_EQ(Triple::Linux, T.getOS());
 912   EXPECT_EQ(Triple::GNUABIN32, T.getEnvironment());
 913   EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch());
 914   T = Triple("mipsn32r6el");
 915   EXPECT_EQ(Triple::mips64el, T.getArch());
 916   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 917   EXPECT_EQ(Triple::GNUABIN32, T.getEnvironment());
 918   EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch());
 919
 920   T = Triple("mipsisa64r6-unknown-linux-gnuabin32");
 921   EXPECT_EQ(Triple::mips64, T.getArch());
 922   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 923   EXPECT_EQ(Triple::Linux, T.getOS());
 924   EXPECT_EQ(Triple::GNUABIN32, T.getEnvironment());
 925   EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch());
 926   T = Triple("mipsn32r6");
 927   EXPECT_EQ(Triple::mips64, T.getArch());
 928   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 929   EXPECT_EQ(Triple::GNUABIN32, T.getEnvironment());
 930   EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch());
 931
 932   T = Triple("mipsel-unknown-linux-gnu");
 933   EXPECT_EQ(Triple::mipsel, T.getArch());
 934   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 935   EXPECT_EQ(Triple::Linux, T.getOS());
 936   EXPECT_EQ(Triple::GNU, T.getEnvironment());
 937   EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
 938   T = Triple("mipsel");
 939   EXPECT_EQ(Triple::mipsel, T.getArch());
 940   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 941   EXPECT_EQ(Triple::GNU, T.getEnvironment());
 942   EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
 943
 944   T = Triple("mips-unknown-linux-gnu");
 945   EXPECT_EQ(Triple::mips, T.getArch());
 946   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 947   EXPECT_EQ(Triple::Linux, T.getOS());
 948   EXPECT_EQ(Triple::GNU, T.getEnvironment());
 949   EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
 950   T = Triple("mips");
 951   EXPECT_EQ(Triple::mips, T.getArch());
 952   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 953   EXPECT_EQ(Triple::GNU, T.getEnvironment());
 954   EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
 955
 956   T = Triple("mipsisa32r6el-unknown-linux-gnu");
 957   EXPECT_EQ(Triple::mipsel, T.getArch());
 958   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 959   EXPECT_EQ(Triple::Linux, T.getOS());
 960   EXPECT_EQ(Triple::GNU, T.getEnvironment());
 961   EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch());
 962   T = Triple("mipsr6el");
 963   EXPECT_EQ(Triple::mipsel, T.getArch());
 964   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 965   EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch());
 966   T = Triple("mipsisa32r6el");
 967   EXPECT_EQ(Triple::mipsel, T.getArch());
 968   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 969   EXPECT_EQ(Triple::GNU, T.getEnvironment());
 970   EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch());
 971
 972   T = Triple("mipsisa32r6-unknown-linux-gnu");
 973   EXPECT_EQ(Triple::mips, T.getArch());
 974   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 975   EXPECT_EQ(Triple::Linux, T.getOS());
 976   EXPECT_EQ(Triple::GNU, T.getEnvironment());
 977   EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch());
 978   T = Triple("mipsr6");
 979   EXPECT_EQ(Triple::mips, T.getArch());
 980   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 981   EXPECT_EQ(Triple::GNU, T.getEnvironment());
 982   EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch());
 983   T = Triple("mipsisa32r6");
 984   EXPECT_EQ(Triple::mips, T.getArch());
 985   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 986   EXPECT_EQ(Triple::GNU, T.getEnvironment());
 987   EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch());
 988
 989   T = Triple("mips64el-unknown-linux-muslabi64");
 990   EXPECT_EQ(Triple::mips64el, T.getArch());
 991   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 992   EXPECT_EQ(Triple::Linux, T.getOS());
 993   EXPECT_EQ(Triple::MuslABI64, T.getEnvironment());
 994   EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
 995
 996   T = Triple("mips64-unknown-linux-muslabi64");
 997   EXPECT_EQ(Triple::mips64, T.getArch());
 998   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
 999   EXPECT_EQ(Triple::Linux, T.getOS());
1000   EXPECT_EQ(Triple::MuslABI64, T.getEnvironment());
1001   EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
1002
1003   T = Triple("mipsisa64r6el-unknown-linux-muslabi64");
1004   EXPECT_EQ(Triple::mips64el, T.getArch());
1005   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
1006   EXPECT_EQ(Triple::Linux, T.getOS());
1007   EXPECT_EQ(Triple::MuslABI64, T.getEnvironment());
1008   EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch());
1009
1010   T = Triple("mipsisa64r6-unknown-linux-muslabi64");
1011   EXPECT_EQ(Triple::mips64, T.getArch());
1012   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
1013   EXPECT_EQ(Triple::Linux, T.getOS());
1014   EXPECT_EQ(Triple::MuslABI64, T.getEnvironment());
1015   EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch());
1016
1017   T = Triple("mips64el-unknown-linux-muslabin32");
1018   EXPECT_EQ(Triple::mips64el, T.getArch());
1019   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
1020   EXPECT_EQ(Triple::Linux, T.getOS());
1021   EXPECT_EQ(Triple::MuslABIN32, T.getEnvironment());
1022   EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
1023
1024   T = Triple("mips64-unknown-linux-muslabin32");
1025   EXPECT_EQ(Triple::mips64, T.getArch());
1026   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
1027   EXPECT_EQ(Triple::Linux, T.getOS());
1028   EXPECT_EQ(Triple::MuslABIN32, T.getEnvironment());
1029   EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
1030
1031   T = Triple("mipsisa64r6el-unknown-linux-muslabin32");
1032   EXPECT_EQ(Triple::mips64el, T.getArch());
1033   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
1034   EXPECT_EQ(Triple::Linux, T.getOS());
1035   EXPECT_EQ(Triple::MuslABIN32, T.getEnvironment());
1036   EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch());
1037
1038   T = Triple("mipsisa64r6-unknown-linux-muslabin32");
1039   EXPECT_EQ(Triple::mips64, T.getArch());
1040   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
1041   EXPECT_EQ(Triple::Linux, T.getOS());
1042   EXPECT_EQ(Triple::MuslABIN32, T.getEnvironment());
1043   EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch());
1044
1045   T = Triple("mipsel-unknown-linux-musl");
1046   EXPECT_EQ(Triple::mipsel, T.getArch());
1047   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
1048   EXPECT_EQ(Triple::Linux, T.getOS());
1049   EXPECT_EQ(Triple::Musl, T.getEnvironment());
1050   EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
1051
1052   T = Triple("mips-unknown-linux-musl");
1053   EXPECT_EQ(Triple::mips, T.getArch());
1054   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
1055   EXPECT_EQ(Triple::Linux, T.getOS());
1056   EXPECT_EQ(Triple::Musl, T.getEnvironment());
1057   EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
1058
1059   T = Triple("mipsisa32r6el-unknown-linux-musl");
1060   EXPECT_EQ(Triple::mipsel, T.getArch());
1061   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
1062   EXPECT_EQ(Triple::Linux, T.getOS());
1063   EXPECT_EQ(Triple::Musl, T.getEnvironment());
1064   EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch());
1065
1066   T = Triple("mipsisa32r6-unknown-linux-musl");
1067   EXPECT_EQ(Triple::mips, T.getArch());
1068   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
1069   EXPECT_EQ(Triple::Linux, T.getOS());
1070   EXPECT_EQ(Triple::Musl, T.getEnvironment());
1071   EXPECT_EQ(Triple::MipsSubArch_r6, T.getSubArch());
1072
1073   T = Triple("arm-oe-linux-gnueabi");
1074   EXPECT_EQ(Triple::arm, T.getArch());
1075   EXPECT_EQ(Triple::OpenEmbedded, T.getVendor());
1076   EXPECT_EQ(Triple::Linux, T.getOS());
1077   EXPECT_EQ(Triple::GNUEABI, T.getEnvironment());
1078
1079   T = Triple("aarch64-oe-linux");
1080   EXPECT_EQ(Triple::aarch64, T.getArch());
1081   EXPECT_EQ(Triple::OpenEmbedded, T.getVendor());
1082   EXPECT_EQ(Triple::Linux, T.getOS());
1083   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
1084   EXPECT_TRUE(T.isArch64Bit());
1085
1086   T = Triple("arm64_32-apple-ios");
1087   EXPECT_EQ(Triple::aarch64_32, T.getArch());
1088   EXPECT_EQ(Triple::IOS, T.getOS());
1089   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
1090   EXPECT_TRUE(T.isArch32Bit());
1091
1092   T = Triple("dxil-unknown-shadermodel-pixel");
1093   EXPECT_EQ(Triple::dxil, T.getArch());
1094   EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
1095   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
1096   EXPECT_EQ(Triple::ShaderModel, T.getOS());
1097   EXPECT_EQ(Triple::Pixel, T.getEnvironment());
1098   EXPECT_FALSE(T.supportsCOMDAT());
1099
1100   T = Triple("dxil-unknown-shadermodel-vertex");
1101   EXPECT_EQ(Triple::dxil, T.getArch());
1102   EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
1103   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
1104   EXPECT_EQ(Triple::ShaderModel, T.getOS());
1105   EXPECT_EQ(Triple::Vertex, T.getEnvironment());
1106   EXPECT_FALSE(T.supportsCOMDAT());
1107
1108   T = Triple("dxil-unknown-shadermodel-geometry");
1109   EXPECT_EQ(Triple::dxil, T.getArch());
1110   EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
1111   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
1112   EXPECT_EQ(Triple::ShaderModel, T.getOS());
1113   EXPECT_EQ(Triple::Geometry, T.getEnvironment());
1114   EXPECT_FALSE(T.supportsCOMDAT());
1115
1116   T = Triple("dxil-unknown-shadermodel-hull");
1117   EXPECT_EQ(Triple::dxil, T.getArch());
1118   EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
1119   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
1120   EXPECT_EQ(Triple::ShaderModel, T.getOS());
1121   EXPECT_EQ(Triple::Hull, T.getEnvironment());
1122   EXPECT_FALSE(T.supportsCOMDAT());
1123
1124   T = Triple("dxil-unknown-shadermodel-domain");
1125   EXPECT_EQ(Triple::dxil, T.getArch());
1126   EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
1127   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
1128   EXPECT_EQ(Triple::ShaderModel, T.getOS());
1129   EXPECT_EQ(Triple::Domain, T.getEnvironment());
1130   EXPECT_FALSE(T.supportsCOMDAT());
1131
1132   T = Triple("dxil-unknown-shadermodel-compute");
1133   EXPECT_EQ(Triple::dxil, T.getArch());
1134   EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
1135   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
1136   EXPECT_EQ(Triple::ShaderModel, T.getOS());
1137   EXPECT_EQ(Triple::Compute, T.getEnvironment());
1138   EXPECT_FALSE(T.supportsCOMDAT());
1139
1140   T = Triple("dxil-unknown-shadermodel-library");
1141   EXPECT_EQ(Triple::dxil, T.getArch());
1142   EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
1143   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
1144   EXPECT_EQ(Triple::ShaderModel, T.getOS());
1145   EXPECT_EQ(Triple::Library, T.getEnvironment());
1146   EXPECT_FALSE(T.supportsCOMDAT());
1147
1148   T = Triple("dxil-unknown-shadermodel-raygeneration");
1149   EXPECT_EQ(Triple::dxil, T.getArch());
1150   EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
1151   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
1152   EXPECT_EQ(Triple::ShaderModel, T.getOS());
1153   EXPECT_EQ(Triple::RayGeneration, T.getEnvironment());
1154   EXPECT_FALSE(T.supportsCOMDAT());
1155
1156   T = Triple("dxil-unknown-shadermodel-intersection");
1157   EXPECT_EQ(Triple::dxil, T.getArch());
1158   EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
1159   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
1160   EXPECT_EQ(Triple::ShaderModel, T.getOS());
1161   EXPECT_EQ(Triple::Intersection, T.getEnvironment());
1162   EXPECT_FALSE(T.supportsCOMDAT());
1163
1164   T = Triple("dxil-unknown-shadermodel-anyhit");
1165   EXPECT_EQ(Triple::dxil, T.getArch());
1166   EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
1167   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
1168   EXPECT_EQ(Triple::ShaderModel, T.getOS());
1169   EXPECT_EQ(Triple::AnyHit, T.getEnvironment());
1170   EXPECT_FALSE(T.supportsCOMDAT());
1171
1172   T = Triple("dxil-unknown-shadermodel-closesthit");
1173   EXPECT_EQ(Triple::dxil, T.getArch());
1174   EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
1175   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
1176   EXPECT_EQ(Triple::ShaderModel, T.getOS());
1177   EXPECT_EQ(Triple::ClosestHit, T.getEnvironment());
1178   EXPECT_FALSE(T.supportsCOMDAT());
1179
1180   T = Triple("dxil-unknown-shadermodel-miss");
1181   EXPECT_EQ(Triple::dxil, T.getArch());
1182   EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
1183   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
1184   EXPECT_EQ(Triple::ShaderModel, T.getOS());
1185   EXPECT_EQ(Triple::Miss, T.getEnvironment());
1186   EXPECT_FALSE(T.supportsCOMDAT());
1187
1188   T = Triple("dxil-unknown-shadermodel-callable");
1189   EXPECT_EQ(Triple::dxil, T.getArch());
1190   EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
1191   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
1192   EXPECT_EQ(Triple::ShaderModel, T.getOS());
1193   EXPECT_EQ(Triple::Callable, T.getEnvironment());
1194   EXPECT_FALSE(T.supportsCOMDAT());
1195
1196   T = Triple("dxil-unknown-shadermodel-mesh");
1197   EXPECT_EQ(Triple::dxil, T.getArch());
1198   EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
1199   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
1200   EXPECT_EQ(Triple::ShaderModel, T.getOS());
1201   EXPECT_EQ(Triple::Mesh, T.getEnvironment());
1202   EXPECT_FALSE(T.supportsCOMDAT());
1203
1204   T = Triple("dxil-unknown-shadermodel-amplification");
1205   EXPECT_EQ(Triple::dxil, T.getArch());
1206   EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
1207   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
1208   EXPECT_EQ(Triple::ShaderModel, T.getOS());
1209   EXPECT_EQ(Triple::Amplification, T.getEnvironment());
1210   EXPECT_FALSE(T.supportsCOMDAT());
1211
1212   T = Triple("dxilv1.0-unknown-unknown");
1213   EXPECT_EQ(Triple::dxil, T.getArch());
1214   EXPECT_EQ(Triple::DXILSubArch_v1_0, T.getSubArch());
1215   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
1216   EXPECT_EQ(Triple::UnknownOS, T.getOS());
1217
1218   T = Triple("dxilv1.1-unknown-unknown");
1219   EXPECT_EQ(Triple::dxil, T.getArch());
1220   EXPECT_EQ(Triple::DXILSubArch_v1_1, T.getSubArch());
1221   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
1222   EXPECT_EQ(Triple::UnknownOS, T.getOS());
1223
1224   T = Triple("dxilv1.2-unknown-unknown");
1225   EXPECT_EQ(Triple::dxil, T.getArch());
1226   EXPECT_EQ(Triple::DXILSubArch_v1_2, T.getSubArch());
1227   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
1228   EXPECT_EQ(Triple::UnknownOS, T.getOS());
1229
1230   T = Triple("dxilv1.3-unknown-unknown");
1231   EXPECT_EQ(Triple::dxil, T.getArch());
1232   EXPECT_EQ(Triple::DXILSubArch_v1_3, T.getSubArch());
1233   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
1234   EXPECT_EQ(Triple::UnknownOS, T.getOS());
1235
1236   T = Triple("dxilv1.4-unknown-unknown");
1237   EXPECT_EQ(Triple::dxil, T.getArch());
1238   EXPECT_EQ(Triple::DXILSubArch_v1_4, T.getSubArch());
1239   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
1240   EXPECT_EQ(Triple::UnknownOS, T.getOS());
1241
1242   T = Triple("dxilv1.5-unknown-unknown");
1243   EXPECT_EQ(Triple::dxil, T.getArch());
1244   EXPECT_EQ(Triple::DXILSubArch_v1_5, T.getSubArch());
1245   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
1246   EXPECT_EQ(Triple::UnknownOS, T.getOS());
1247
1248   T = Triple("dxilv1.6-unknown-unknown");
1249   EXPECT_EQ(Triple::dxil, T.getArch());
1250   EXPECT_EQ(Triple::DXILSubArch_v1_6, T.getSubArch());
1251   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
1252   EXPECT_EQ(Triple::UnknownOS, T.getOS());
1253
1254   T = Triple("dxilv1.7-unknown-unknown");
1255   EXPECT_EQ(Triple::dxil, T.getArch());
1256   EXPECT_EQ(Triple::DXILSubArch_v1_7, T.getSubArch());
1257   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
1258   EXPECT_EQ(Triple::UnknownOS, T.getOS());
1259
1260   T = Triple("dxilv1.8-unknown-unknown");
1261   EXPECT_EQ(Triple::dxil, T.getArch());
1262   EXPECT_EQ(Triple::DXILSubArch_v1_8, T.getSubArch());
1263   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
1264   EXPECT_EQ(Triple::UnknownOS, T.getOS());
1265
1266   // Check specification of unknown SubArch results in
1267   // unknown architecture.
1268   T = Triple("dxilv1.999-unknown-unknown");
1269   EXPECT_EQ(Triple::UnknownArch, T.getArch());
1270   EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
1271   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
1272   EXPECT_EQ(Triple::UnknownOS, T.getOS());
1273
1274   T = Triple("dxil-unknown-unknown");
1275   EXPECT_EQ(Triple::dxil, T.getArch());
1276   EXPECT_EQ(Triple::NoSubArch, T.getSubArch());
1277   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
1278   EXPECT_EQ(Triple::UnknownOS, T.getOS());
1279
1280   T = Triple("xtensa");
1281   EXPECT_EQ(Triple::xtensa, T.getArch());
1282   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
1283   EXPECT_EQ(Triple::UnknownOS, T.getOS());
1284   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
1285
1286   T = Triple("xtensa-unknown-unknown");
1287   EXPECT_EQ(Triple::xtensa, T.getArch());
1288   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
1289   EXPECT_EQ(Triple::UnknownOS, T.getOS());
1290   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
1291
1292   T = Triple("arm-unknown-linux-ohos");
1293   EXPECT_EQ(Triple::arm, T.getArch());
1294   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
1295   EXPECT_EQ(Triple::Linux, T.getOS());
1296   EXPECT_EQ(Triple::OpenHOS, T.getEnvironment());
1297
1298   T = Triple("arm-unknown-liteos");
1299   EXPECT_EQ(Triple::arm, T.getArch());
1300   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
1301   EXPECT_EQ(Triple::LiteOS, T.getOS());
1302   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
1303
1304   T = Triple("x86_64-pc-serenity");
1305   EXPECT_EQ(Triple::x86_64, T.getArch());
1306   EXPECT_EQ(Triple::PC, T.getVendor());
1307   EXPECT_EQ(Triple::Serenity, T.getOS());
1308   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
1309
1310   T = Triple("aarch64-pc-serenity");
1311   EXPECT_EQ(Triple::aarch64, T.getArch());
1312   EXPECT_EQ(Triple::PC, T.getVendor());
1313   EXPECT_EQ(Triple::Serenity, T.getOS());
1314   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
1315
1316   T = Triple("aarch64-unknown-linux-pauthtest");
1317   EXPECT_EQ(Triple::aarch64, T.getArch());
1318   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
1319   EXPECT_EQ(Triple::Linux, T.getOS());
1320   EXPECT_EQ(Triple::PAuthTest, T.getEnvironment());
1321
1322   // Gentoo time64 triples
1323   T = Triple("i686-pc-linux-gnut64");
1324   EXPECT_EQ(Triple::x86, T.getArch());
1325   EXPECT_EQ(Triple::PC, T.getVendor());
1326   EXPECT_EQ(Triple::Linux, T.getOS());
1327   EXPECT_EQ(Triple::GNUT64, T.getEnvironment());
1328   EXPECT_TRUE(T.isTime64ABI());
1329
1330   T = Triple("armv5tel-softfloat-linux-gnueabit64");
1331   EXPECT_EQ(Triple::arm, T.getArch());
1332   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
1333   EXPECT_EQ(Triple::Linux, T.getOS());
1334   EXPECT_EQ(Triple::GNUEABIT64, T.getEnvironment());
1335   EXPECT_TRUE(T.isTime64ABI());
1336
1337   T = Triple("armv7a-unknown-linux-gnueabihft64");
1338   EXPECT_EQ(Triple::arm, T.getArch());
1339   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
1340   EXPECT_EQ(Triple::Linux, T.getOS());
1341   EXPECT_EQ(Triple::GNUEABIHFT64, T.getEnvironment());
1342   EXPECT_TRUE(T.isTime64ABI());
1343   EXPECT_TRUE(T.isHardFloatABI());
1344
1345   T = Triple("x86_64-pc-linux-llvm");
1346   EXPECT_EQ(Triple::x86_64, T.getArch());
1347   EXPECT_EQ(Triple::PC, T.getVendor());
1348   EXPECT_EQ(Triple::Linux, T.getOS());
1349   EXPECT_EQ(Triple::LLVM, T.getEnvironment());
1350
1351   T = Triple("spirv64-intel-unknown");
1352   EXPECT_EQ(Triple::spirv64, T.getArch());
1353   EXPECT_EQ(Triple::Intel, T.getVendor());
1354   EXPECT_EQ(Triple::UnknownOS, T.getOS());
1355   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
1356
1357   T = Triple("huh");
1358   EXPECT_EQ(Triple::UnknownArch, T.getArch());
1359 }
1360
1361 static std::string Join(StringRef A, StringRef B, StringRef C) {
1362   std::string Str = std::string(A);
1363   Str += '-';
1364   Str += B;
1365   Str += '-';
1366   Str += C;
1367   return Str;
1368 }
1369
1370 static std::string Join(StringRef A, StringRef B, StringRef C, StringRef D) {
1371   std::string Str = std::string(A);
1372   Str += '-';
1373   Str += B;
1374   Str += '-';
1375   Str += C;
1376   Str += '-';
1377   Str += D;
1378   return Str;
1379 }
1380
1381 TEST(TripleTest, Normalization) {
1382
1383   EXPECT_EQ("unknown", Triple::normalize(""));
1384   EXPECT_EQ("unknown-unknown", Triple::normalize("-"));
1385   EXPECT_EQ("unknown-unknown-unknown", Triple::normalize("--"));
1386   EXPECT_EQ("unknown-unknown-unknown-unknown", Triple::normalize("---"));
1387   EXPECT_EQ("unknown-unknown-unknown-unknown-unknown",
1388             Triple::normalize("----"));
1389
1390   EXPECT_EQ("a", Triple::normalize("a"));
1391   EXPECT_EQ("a-b", Triple::normalize("a-b"));
1392   EXPECT_EQ("a-b-c", Triple::normalize("a-b-c"));
1393   EXPECT_EQ("a-b-c-d", Triple::normalize("a-b-c-d"));
1394
1395   EXPECT_EQ("i386-b-c", Triple::normalize("i386-b-c"));
1396   EXPECT_EQ("i386-a-c", Triple::normalize("a-i386-c"));
1397   EXPECT_EQ("i386-a-b", Triple::normalize("a-b-i386"));
1398   EXPECT_EQ("i386-a-b-c", Triple::normalize("a-b-c-i386"));
1399
1400   EXPECT_EQ("a-pc-c", Triple::normalize("a-pc-c"));
1401   EXPECT_EQ("unknown-pc-b-c", Triple::normalize("pc-b-c"));
1402   EXPECT_EQ("a-pc-b", Triple::normalize("a-b-pc"));
1403   EXPECT_EQ("a-pc-b-c", Triple::normalize("a-b-c-pc"));
1404
1405   EXPECT_EQ("a-b-linux", Triple::normalize("a-b-linux"));
1406   EXPECT_EQ("unknown-unknown-linux-b-c", Triple::normalize("linux-b-c"));
1407   EXPECT_EQ("a-unknown-linux-c", Triple::normalize("a-linux-c"));
1408
1409   EXPECT_EQ("i386-pc-a", Triple::normalize("a-pc-i386"));
1410   EXPECT_EQ("i386-pc-unknown", Triple::normalize("-pc-i386"));
1411   EXPECT_EQ("unknown-pc-linux-c", Triple::normalize("linux-pc-c"));
1412   EXPECT_EQ("unknown-pc-linux", Triple::normalize("linux-pc-"));
1413
1414   EXPECT_EQ("i386", Triple::normalize("i386"));
1415   EXPECT_EQ("unknown-pc", Triple::normalize("pc"));
1416   EXPECT_EQ("unknown-unknown-linux", Triple::normalize("linux"));
1417
1418   EXPECT_EQ("x86_64-unknown-linux-gnu", Triple::normalize("x86_64-gnu-linux"));
1419
1420   EXPECT_EQ("a-unknown-unknown",
1421             Triple::normalize("a", Triple::CanonicalForm::THREE_IDENT));
1422   EXPECT_EQ("a-b-unknown",
1423             Triple::normalize("a-b", Triple::CanonicalForm::THREE_IDENT));
1424   EXPECT_EQ("a-b-c",
1425             Triple::normalize("a-b-c", Triple::CanonicalForm::THREE_IDENT));
1426   EXPECT_EQ("a-b-c",
1427             Triple::normalize("a-b-c-d", Triple::CanonicalForm::THREE_IDENT));
1428   EXPECT_EQ("a-b-c",
1429             Triple::normalize("a-b-c-d-e", Triple::CanonicalForm::THREE_IDENT));
1430
1431   EXPECT_EQ("a-unknown-unknown-unknown",
1432             Triple::normalize("a", Triple::CanonicalForm::FOUR_IDENT));
1433   EXPECT_EQ("a-b-unknown-unknown",
1434             Triple::normalize("a-b", Triple::CanonicalForm::FOUR_IDENT));
1435   EXPECT_EQ("a-b-c-unknown",
1436             Triple::normalize("a-b-c", Triple::CanonicalForm::FOUR_IDENT));
1437   EXPECT_EQ("a-b-c-d",
1438             Triple::normalize("a-b-c-d", Triple::CanonicalForm::FOUR_IDENT));
1439   EXPECT_EQ("a-b-c-d",
1440             Triple::normalize("a-b-c-d-e", Triple::CanonicalForm::FOUR_IDENT));
1441
1442   EXPECT_EQ("a-unknown-unknown-unknown-unknown",
1443             Triple::normalize("a", Triple::CanonicalForm::FIVE_IDENT));
1444   EXPECT_EQ("a-b-unknown-unknown-unknown",
1445             Triple::normalize("a-b", Triple::CanonicalForm::FIVE_IDENT));
1446   EXPECT_EQ("a-b-c-unknown-unknown",
1447             Triple::normalize("a-b-c", Triple::CanonicalForm::FIVE_IDENT));
1448   EXPECT_EQ("a-b-c-d-unknown",
1449             Triple::normalize("a-b-c-d", Triple::CanonicalForm::FIVE_IDENT));
1450   EXPECT_EQ("a-b-c-d-e",
1451             Triple::normalize("a-b-c-d-e", Triple::CanonicalForm::FIVE_IDENT));
1452
1453   EXPECT_EQ("i386-b-c-unknown",
1454             Triple::normalize("i386-b-c", Triple::CanonicalForm::FOUR_IDENT));
1455   EXPECT_EQ("i386-b-c-unknown-unknown",
1456             Triple::normalize("i386-b-c", Triple::CanonicalForm::FIVE_IDENT));
1457
1458   EXPECT_EQ("i386-a-c-unknown",
1459             Triple::normalize("a-i386-c", Triple::CanonicalForm::FOUR_IDENT));
1460   EXPECT_EQ("i386-a-c-unknown-unknown",
1461             Triple::normalize("a-i386-c", Triple::CanonicalForm::FIVE_IDENT));
1462
1463   EXPECT_EQ("i386-a-b-unknown",
1464             Triple::normalize("a-b-i386", Triple::CanonicalForm::FOUR_IDENT));
1465   EXPECT_EQ("i386-a-b-c",
1466             Triple::normalize("a-b-c-i386", Triple::CanonicalForm::FOUR_IDENT));
1467
1468   EXPECT_EQ("a-pc-c-unknown",
1469             Triple::normalize("a-pc-c", Triple::CanonicalForm::FOUR_IDENT));
1470   EXPECT_EQ("unknown-pc-b-c",
1471             Triple::normalize("pc-b-c", Triple::CanonicalForm::FOUR_IDENT));
1472   EXPECT_EQ("a-pc-b-unknown",
1473             Triple::normalize("a-b-pc", Triple::CanonicalForm::FOUR_IDENT));
1474   EXPECT_EQ("a-pc-b-c",
1475             Triple::normalize("a-b-c-pc", Triple::CanonicalForm::FOUR_IDENT));
1476
1477   EXPECT_EQ("a-b-linux-unknown",
1478             Triple::normalize("a-b-linux", Triple::CanonicalForm::FOUR_IDENT));
1479   // We lose `-c` here as expected.
1480   EXPECT_EQ("unknown-unknown-linux-b",
1481             Triple::normalize("linux-b-c", Triple::CanonicalForm::FOUR_IDENT));
1482   EXPECT_EQ("a-unknown-linux-c",
1483             Triple::normalize("a-linux-c", Triple::CanonicalForm::FOUR_IDENT));
1484
1485   EXPECT_EQ("i386-pc-a-unknown",
1486             Triple::normalize("a-pc-i386", Triple::CanonicalForm::FOUR_IDENT));
1487   EXPECT_EQ("i386-pc-unknown-unknown",
1488             Triple::normalize("-pc-i386", Triple::CanonicalForm::FOUR_IDENT));
1489   EXPECT_EQ("unknown-pc-linux-c",
1490             Triple::normalize("linux-pc-c", Triple::CanonicalForm::FOUR_IDENT));
1491   EXPECT_EQ("unknown-pc-linux-unknown",
1492             Triple::normalize("linux-pc-", Triple::CanonicalForm::FOUR_IDENT));
1493
1494   EXPECT_EQ("i386-unknown-unknown-unknown",
1495             Triple::normalize("i386", Triple::CanonicalForm::FOUR_IDENT));
1496   EXPECT_EQ("unknown-pc-unknown-unknown",
1497             Triple::normalize("pc", Triple::CanonicalForm::FOUR_IDENT));
1498   EXPECT_EQ("unknown-unknown-linux-unknown",
1499             Triple::normalize("linux", Triple::CanonicalForm::FOUR_IDENT));
1500
1501   EXPECT_EQ(
1502       "x86_64-unknown-linux-gnu",
1503       Triple::normalize("x86_64-gnu-linux", Triple::CanonicalForm::FOUR_IDENT));
1504
1505   EXPECT_EQ("i386-a-b-unknown-unknown",
1506             Triple::normalize("a-b-i386", Triple::CanonicalForm::FIVE_IDENT));
1507   EXPECT_EQ("i386-a-b-c-unknown",
1508             Triple::normalize("a-b-c-i386", Triple::CanonicalForm::FIVE_IDENT));
1509
1510   EXPECT_EQ("a-pc-c-unknown-unknown",
1511             Triple::normalize("a-pc-c", Triple::CanonicalForm::FIVE_IDENT));
1512   EXPECT_EQ("unknown-pc-b-c-unknown",
1513             Triple::normalize("pc-b-c", Triple::CanonicalForm::FIVE_IDENT));
1514   EXPECT_EQ("a-pc-b-unknown-unknown",
1515             Triple::normalize("a-b-pc", Triple::CanonicalForm::FIVE_IDENT));
1516   EXPECT_EQ("a-pc-b-c-unknown",
1517             Triple::normalize("a-b-c-pc", Triple::CanonicalForm::FIVE_IDENT));
1518
1519   EXPECT_EQ("a-b-linux-unknown-unknown",
1520             Triple::normalize("a-b-linux", Triple::CanonicalForm::FIVE_IDENT));
1521   EXPECT_EQ("unknown-unknown-linux-b-c",
1522             Triple::normalize("linux-b-c", Triple::CanonicalForm::FIVE_IDENT));
1523   EXPECT_EQ("a-unknown-linux-c-unknown",
1524             Triple::normalize("a-linux-c", Triple::CanonicalForm::FIVE_IDENT));
1525
1526   EXPECT_EQ("i386-pc-a-unknown-unknown",
1527             Triple::normalize("a-pc-i386", Triple::CanonicalForm::FIVE_IDENT));
1528   EXPECT_EQ("i386-pc-unknown-unknown-unknown",
1529             Triple::normalize("-pc-i386", Triple::CanonicalForm::FIVE_IDENT));
1530   EXPECT_EQ("unknown-pc-linux-c-unknown",
1531             Triple::normalize("linux-pc-c", Triple::CanonicalForm::FIVE_IDENT));
1532   EXPECT_EQ("unknown-pc-linux-unknown-unknown",
1533             Triple::normalize("linux-pc-", Triple::CanonicalForm::FIVE_IDENT));
1534
1535   EXPECT_EQ("i386-unknown-unknown-unknown-unknown",
1536             Triple::normalize("i386", Triple::CanonicalForm::FIVE_IDENT));
1537   EXPECT_EQ("unknown-pc-unknown-unknown-unknown",
1538             Triple::normalize("pc", Triple::CanonicalForm::FIVE_IDENT));
1539   EXPECT_EQ("unknown-unknown-linux-unknown-unknown",
1540             Triple::normalize("linux", Triple::CanonicalForm::FIVE_IDENT));
1541
1542   EXPECT_EQ(
1543       "x86_64-unknown-linux-gnu-unknown",
1544       Triple::normalize("x86_64-gnu-linux", Triple::CanonicalForm::FIVE_IDENT));
1545
1546   // Check that normalizing a permutated set of valid components returns a
1547   // triple with the unpermuted components.
1548   //
1549   // We don't check every possible combination. For the set of architectures A,
1550   // vendors V, operating systems O, and environments E, that would require |A|
1551   // * |V| * |O| * |E| * 4! tests. Instead we check every option for any given
1552   // slot and make sure it gets normalized to the correct position from every
1553   // permutation. This should cover the core logic while being a tractable
1554   // number of tests at (|A| + |V| + |O| + |E|) * 4!.
1555   auto FirstArchType = Triple::ArchType(Triple::UnknownArch + 1);
1556   auto FirstVendorType = Triple::VendorType(Triple::UnknownVendor + 1);
1557   auto FirstOSType = Triple::OSType(Triple::UnknownOS + 1);
1558   auto FirstEnvType = Triple::EnvironmentType(Triple::UnknownEnvironment + 1);
1559   StringRef InitialC[] = {Triple::getArchTypeName(FirstArchType),
1560                           Triple::getVendorTypeName(FirstVendorType),
1561                           Triple::getOSTypeName(FirstOSType),
1562                           Triple::getEnvironmentTypeName(FirstEnvType)};
1563   for (int Arch = FirstArchType; Arch <= Triple::LastArchType; ++Arch) {
1564     StringRef C[] = {InitialC[0], InitialC[1], InitialC[2], InitialC[3]};
1565     C[0] = Triple::getArchTypeName(Triple::ArchType(Arch));
1566     std::string E = Join(C[0], C[1], C[2]);
1567     int I[] = {0, 1, 2};
1568     do {
1569       EXPECT_EQ(E, Triple::normalize(Join(C[I[0]], C[I[1]], C[I[2]])));
1570     } while (std::next_permutation(std::begin(I), std::end(I)));
1571     std::string F = Join(C[0], C[1], C[2], C[3]);
1572     int J[] = {0, 1, 2, 3};
1573     do {
1574       EXPECT_EQ(F, Triple::normalize(Join(C[J[0]], C[J[1]], C[J[2]], C[J[3]])));
1575     } while (std::next_permutation(std::begin(J), std::end(J)));
1576   }
1577   for (int Vendor = FirstVendorType; Vendor <= Triple::LastVendorType;
1578        ++Vendor) {
1579     StringRef C[] = {InitialC[0], InitialC[1], InitialC[2], InitialC[3]};
1580     C[1] = Triple::getVendorTypeName(Triple::VendorType(Vendor));
1581     std::string E = Join(C[0], C[1], C[2]);
1582     int I[] = {0, 1, 2};
1583     do {
1584       EXPECT_EQ(E, Triple::normalize(Join(C[I[0]], C[I[1]], C[I[2]])));
1585     } while (std::next_permutation(std::begin(I), std::end(I)));
1586     std::string F = Join(C[0], C[1], C[2], C[3]);
1587     int J[] = {0, 1, 2, 3};
1588     do {
1589       EXPECT_EQ(F, Triple::normalize(Join(C[J[0]], C[J[1]], C[J[2]], C[J[3]])));
1590     } while (std::next_permutation(std::begin(J), std::end(J)));
1591   }
1592   for (int OS = FirstOSType; OS <= Triple::LastOSType; ++OS) {
1593     if (OS == Triple::Win32)
1594       continue;
1595     StringRef C[] = {InitialC[0], InitialC[1], InitialC[2], InitialC[3]};
1596     C[2] = Triple::getOSTypeName(Triple::OSType(OS));
1597     std::string E = Join(C[0], C[1], C[2]);
1598     int I[] = {0, 1, 2};
1599     do {
1600       EXPECT_EQ(E, Triple::normalize(Join(C[I[0]], C[I[1]], C[I[2]])));
1601     } while (std::next_permutation(std::begin(I), std::end(I)));
1602     std::string F = Join(C[0], C[1], C[2], C[3]);
1603     int J[] = {0, 1, 2, 3};
1604     do {
1605       EXPECT_EQ(F, Triple::normalize(Join(C[J[0]], C[J[1]], C[J[2]], C[J[3]])));
1606     } while (std::next_permutation(std::begin(J), std::end(J)));
1607   }
1608   for (int Env = FirstEnvType; Env <= Triple::LastEnvironmentType; ++Env) {
1609     StringRef C[] = {InitialC[0], InitialC[1], InitialC[2], InitialC[3]};
1610     C[3] = Triple::getEnvironmentTypeName(Triple::EnvironmentType(Env));
1611     std::string F = Join(C[0], C[1], C[2], C[3]);
1612     int J[] = {0, 1, 2, 3};
1613     do {
1614       EXPECT_EQ(F, Triple::normalize(Join(C[J[0]], C[J[1]], C[J[2]], C[J[3]])));
1615     } while (std::next_permutation(std::begin(J), std::end(J)));
1616   }
1617
1618   // Various real-world funky triples.  The value returned by GCC's config.sub
1619   // is given in the comment.
1620   EXPECT_EQ("i386-unknown-windows-gnu",
1621             Triple::normalize("i386-mingw32")); // i386-pc-mingw32
1622   EXPECT_EQ("x86_64-unknown-linux-gnu",
1623             Triple::normalize("x86_64-linux-gnu")); // x86_64-pc-linux-gnu
1624   EXPECT_EQ("i486-unknown-linux-gnu",
1625             Triple::normalize("i486-linux-gnu")); // i486-pc-linux-gnu
1626   EXPECT_EQ("i386-redhat-linux",
1627             Triple::normalize("i386-redhat-linux")); // i386-redhat-linux-gnu
1628   EXPECT_EQ("i686-unknown-linux",
1629             Triple::normalize("i686-linux")); // i686-pc-linux-gnu
1630   EXPECT_EQ("arm-unknown-none-eabi",
1631             Triple::normalize("arm-none-eabi")); // arm-none-eabi
1632   EXPECT_EQ("ve-unknown-linux",
1633             Triple::normalize("ve-linux")); // ve-linux
1634   EXPECT_EQ("wasm32-unknown-wasi",
1635             Triple::normalize("wasm32-wasi")); // wasm32-unknown-wasi
1636   EXPECT_EQ("wasm64-unknown-wasi",
1637             Triple::normalize("wasm64-wasi")); // wasm64-unknown-wasi
1638 }
1639
1640 TEST(TripleTest, MutateName) {
1641   Triple T;
1642   EXPECT_EQ(Triple::UnknownArch, T.getArch());
1643   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
1644   EXPECT_EQ(Triple::UnknownOS, T.getOS());
1645   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
1646
1647   T.setArchName("i386");
1648   EXPECT_EQ(Triple::x86, T.getArch());
1649   EXPECT_EQ("i386--", T.getTriple());
1650
1651   T.setVendorName("pc");
1652   EXPECT_EQ(Triple::x86, T.getArch());
1653   EXPECT_EQ(Triple::PC, T.getVendor());
1654   EXPECT_EQ("i386-pc-", T.getTriple());
1655
1656   T.setOSName("linux");
1657   EXPECT_EQ(Triple::x86, T.getArch());
1658   EXPECT_EQ(Triple::PC, T.getVendor());
1659   EXPECT_EQ(Triple::Linux, T.getOS());
1660   EXPECT_EQ("i386-pc-linux", T.getTriple());
1661
1662   T.setEnvironmentName("gnu");
1663   EXPECT_EQ(Triple::x86, T.getArch());
1664   EXPECT_EQ(Triple::PC, T.getVendor());
1665   EXPECT_EQ(Triple::Linux, T.getOS());
1666   EXPECT_EQ("i386-pc-linux-gnu", T.getTriple());
1667
1668   T.setOSName("freebsd");
1669   EXPECT_EQ(Triple::x86, T.getArch());
1670   EXPECT_EQ(Triple::PC, T.getVendor());
1671   EXPECT_EQ(Triple::FreeBSD, T.getOS());
1672   EXPECT_EQ("i386-pc-freebsd-gnu", T.getTriple());
1673
1674   T.setOSAndEnvironmentName("darwin");
1675   EXPECT_EQ(Triple::x86, T.getArch());
1676   EXPECT_EQ(Triple::PC, T.getVendor());
1677   EXPECT_EQ(Triple::Darwin, T.getOS());
1678   EXPECT_EQ("i386-pc-darwin", T.getTriple());
1679 }
1680
1681 TEST(TripleTest, BitWidthChecks) {
1682   Triple T;
1683   EXPECT_FALSE(T.isArch16Bit());
1684   EXPECT_FALSE(T.isArch32Bit());
1685   EXPECT_FALSE(T.isArch64Bit());
1686   EXPECT_EQ(T.getArchPointerBitWidth(), 0U);
1687
1688   T.setArch(Triple::arm);
1689   EXPECT_FALSE(T.isArch16Bit());
1690   EXPECT_TRUE(T.isArch32Bit());
1691   EXPECT_FALSE(T.isArch64Bit());
1692   EXPECT_EQ(T.getArchPointerBitWidth(), 32U);
1693
1694   T.setArch(Triple::hexagon);
1695   EXPECT_FALSE(T.isArch16Bit());
1696   EXPECT_TRUE(T.isArch32Bit());
1697   EXPECT_FALSE(T.isArch64Bit());
1698   EXPECT_EQ(T.getArchPointerBitWidth(), 32U);
1699
1700   T.setArch(Triple::mips);
1701   EXPECT_FALSE(T.isArch16Bit());
1702   EXPECT_TRUE(T.isArch32Bit());
1703   EXPECT_FALSE(T.isArch64Bit());
1704   EXPECT_EQ(T.getArchPointerBitWidth(), 32U);
1705
1706   T.setArch(Triple::mips64);
1707   EXPECT_FALSE(T.isArch16Bit());
1708   EXPECT_FALSE(T.isArch32Bit());
1709   EXPECT_TRUE(T.isArch64Bit());
1710   EXPECT_EQ(T.getArchPointerBitWidth(), 64U);
1711
1712   T.setArch(Triple::msp430);
1713   EXPECT_TRUE(T.isArch16Bit());
1714   EXPECT_FALSE(T.isArch32Bit());
1715   EXPECT_FALSE(T.isArch64Bit());
1716   EXPECT_EQ(T.getArchPointerBitWidth(), 16U);
1717
1718   T.setArch(Triple::ppc);
1719   EXPECT_FALSE(T.isArch16Bit());
1720   EXPECT_TRUE(T.isArch32Bit());
1721   EXPECT_FALSE(T.isArch64Bit());
1722   EXPECT_EQ(T.getArchPointerBitWidth(), 32U);
1723
1724   T.setArch(Triple::ppc64);
1725   EXPECT_FALSE(T.isArch16Bit());
1726   EXPECT_FALSE(T.isArch32Bit());
1727   EXPECT_TRUE(T.isArch64Bit());
1728   EXPECT_EQ(T.getArchPointerBitWidth(), 64U);
1729
1730   T.setArch(Triple::x86);
1731   EXPECT_FALSE(T.isArch16Bit());
1732   EXPECT_TRUE(T.isArch32Bit());
1733   EXPECT_FALSE(T.isArch64Bit());
1734   EXPECT_EQ(T.getArchPointerBitWidth(), 32U);
1735
1736   T.setArch(Triple::x86_64);
1737   EXPECT_FALSE(T.isArch16Bit());
1738   EXPECT_FALSE(T.isArch32Bit());
1739   EXPECT_TRUE(T.isArch64Bit());
1740   EXPECT_EQ(T.getArchPointerBitWidth(), 64U);
1741
1742   T.setArch(Triple::amdil);
1743   EXPECT_FALSE(T.isArch16Bit());
1744   EXPECT_TRUE(T.isArch32Bit());
1745   EXPECT_FALSE(T.isArch64Bit());
1746   EXPECT_EQ(T.getArchPointerBitWidth(), 32U);
1747
1748   T.setArch(Triple::amdil64);
1749   EXPECT_FALSE(T.isArch16Bit());
1750   EXPECT_FALSE(T.isArch32Bit());
1751   EXPECT_TRUE(T.isArch64Bit());
1752   EXPECT_EQ(T.getArchPointerBitWidth(), 64U);
1753
1754   T.setArch(Triple::hsail);
1755   EXPECT_FALSE(T.isArch16Bit());
1756   EXPECT_TRUE(T.isArch32Bit());
1757   EXPECT_FALSE(T.isArch64Bit());
1758   EXPECT_EQ(T.getArchPointerBitWidth(), 32U);
1759
1760   T.setArch(Triple::hsail64);
1761   EXPECT_FALSE(T.isArch16Bit());
1762   EXPECT_FALSE(T.isArch32Bit());
1763   EXPECT_TRUE(T.isArch64Bit());
1764   EXPECT_EQ(T.getArchPointerBitWidth(), 64U);
1765
1766   T.setArch(Triple::spir);
1767   EXPECT_FALSE(T.isArch16Bit());
1768   EXPECT_TRUE(T.isArch32Bit());
1769   EXPECT_FALSE(T.isArch64Bit());
1770   EXPECT_EQ(T.getArchPointerBitWidth(), 32U);
1771
1772   T.setArch(Triple::spir64);
1773   EXPECT_FALSE(T.isArch16Bit());
1774   EXPECT_FALSE(T.isArch32Bit());
1775   EXPECT_TRUE(T.isArch64Bit());
1776   EXPECT_EQ(T.getArchPointerBitWidth(), 64U);
1777
1778   T.setArch(Triple::spirv);
1779   EXPECT_FALSE(T.isArch16Bit());
1780   EXPECT_FALSE(T.isArch32Bit());
1781   EXPECT_TRUE(T.isArch64Bit());
1782   EXPECT_TRUE(T.isSPIRV());
1783
1784   T.setArch(Triple::spirv32);
1785   EXPECT_FALSE(T.isArch16Bit());
1786   EXPECT_TRUE(T.isArch32Bit());
1787   EXPECT_FALSE(T.isArch64Bit());
1788   EXPECT_TRUE(T.isSPIRV());
1789
1790   T.setArch(Triple::spirv64);
1791   EXPECT_FALSE(T.isArch16Bit());
1792   EXPECT_FALSE(T.isArch32Bit());
1793   EXPECT_TRUE(T.isArch64Bit());
1794   EXPECT_TRUE(T.isSPIRV());
1795
1796   T.setArch(Triple::sparc);
1797   EXPECT_FALSE(T.isArch16Bit());
1798   EXPECT_TRUE(T.isArch32Bit());
1799   EXPECT_FALSE(T.isArch64Bit());
1800
1801   T.setArch(Triple::sparcel);
1802   EXPECT_FALSE(T.isArch16Bit());
1803   EXPECT_TRUE(T.isArch32Bit());
1804   EXPECT_FALSE(T.isArch64Bit());
1805
1806   T.setArch(Triple::sparcv9);
1807   EXPECT_FALSE(T.isArch16Bit());
1808   EXPECT_FALSE(T.isArch32Bit());
1809   EXPECT_TRUE(T.isArch64Bit());
1810
1811   T.setArch(Triple::wasm32);
1812   EXPECT_FALSE(T.isArch16Bit());
1813   EXPECT_TRUE(T.isArch32Bit());
1814   EXPECT_FALSE(T.isArch64Bit());
1815
1816   T.setArch(Triple::wasm64);
1817   EXPECT_FALSE(T.isArch16Bit());
1818   EXPECT_FALSE(T.isArch32Bit());
1819   EXPECT_TRUE(T.isArch64Bit());
1820
1821   T.setArch(Triple::avr);
1822   EXPECT_TRUE(T.isArch16Bit());
1823   EXPECT_FALSE(T.isArch32Bit());
1824   EXPECT_FALSE(T.isArch64Bit());
1825
1826   T.setArch(Triple::lanai);
1827   EXPECT_FALSE(T.isArch16Bit());
1828   EXPECT_TRUE(T.isArch32Bit());
1829   EXPECT_FALSE(T.isArch64Bit());
1830
1831   T.setArch(Triple::riscv32);
1832   EXPECT_FALSE(T.isArch16Bit());
1833   EXPECT_TRUE(T.isArch32Bit());
1834   EXPECT_FALSE(T.isArch64Bit());
1835   EXPECT_TRUE(T.isRISCV());
1836
1837   T.setArch(Triple::riscv64);
1838   EXPECT_FALSE(T.isArch16Bit());
1839   EXPECT_FALSE(T.isArch32Bit());
1840   EXPECT_TRUE(T.isArch64Bit());
1841   EXPECT_TRUE(T.isRISCV());
1842
1843   T.setArch(Triple::csky);
1844   EXPECT_FALSE(T.isArch16Bit());
1845   EXPECT_TRUE(T.isArch32Bit());
1846   EXPECT_FALSE(T.isArch64Bit());
1847   EXPECT_TRUE(T.isCSKY());
1848
1849   T.setArch(Triple::loongarch32);
1850   EXPECT_FALSE(T.isArch16Bit());
1851   EXPECT_TRUE(T.isArch32Bit());
1852   EXPECT_FALSE(T.isArch64Bit());
1853   EXPECT_TRUE(T.isLoongArch());
1854   EXPECT_TRUE(T.isLoongArch32());
1855
1856   T.setArch(Triple::loongarch64);
1857   EXPECT_FALSE(T.isArch16Bit());
1858   EXPECT_FALSE(T.isArch32Bit());
1859   EXPECT_TRUE(T.isArch64Bit());
1860   EXPECT_TRUE(T.isLoongArch());
1861   EXPECT_TRUE(T.isLoongArch64());
1862
1863   T.setArch(Triple::dxil);
1864   EXPECT_FALSE(T.isArch16Bit());
1865   EXPECT_TRUE(T.isArch32Bit());
1866   EXPECT_FALSE(T.isArch64Bit());
1867   EXPECT_TRUE(T.isDXIL());
1868
1869   T.setArch(Triple::xtensa);
1870   EXPECT_FALSE(T.isArch16Bit());
1871   EXPECT_TRUE(T.isArch32Bit());
1872   EXPECT_FALSE(T.isArch64Bit());
1873 }
1874
1875 TEST(TripleTest, BitWidthArchVariants) {
1876   Triple T;
1877   EXPECT_EQ(Triple::UnknownArch, T.get32BitArchVariant().getArch());
1878   EXPECT_EQ(Triple::UnknownArch, T.get64BitArchVariant().getArch());
1879
1880   T.setArch(Triple::UnknownArch);
1881   EXPECT_EQ(Triple::UnknownArch, T.get32BitArchVariant().getArch());
1882   EXPECT_EQ(Triple::UnknownArch, T.get64BitArchVariant().getArch());
1883
1884   T.setArch(Triple::mips);
1885   EXPECT_EQ(Triple::mips, T.get32BitArchVariant().getArch());
1886   EXPECT_EQ(Triple::NoSubArch, T.get32BitArchVariant().getSubArch());
1887   EXPECT_EQ(Triple::mips64, T.get64BitArchVariant().getArch());
1888   EXPECT_EQ(Triple::NoSubArch, T.get64BitArchVariant().getSubArch());
1889
1890   T.setArch(Triple::mips, Triple::MipsSubArch_r6);
1891   EXPECT_EQ(Triple::mips, T.get32BitArchVariant().getArch());
1892   EXPECT_EQ(Triple::MipsSubArch_r6, T.get32BitArchVariant().getSubArch());
1893   EXPECT_EQ(Triple::mips64, T.get64BitArchVariant().getArch());
1894   EXPECT_EQ(Triple::MipsSubArch_r6, T.get64BitArchVariant().getSubArch());
1895
1896   T.setArch(Triple::mipsel);
1897   EXPECT_EQ(Triple::mipsel, T.get32BitArchVariant().getArch());
1898   EXPECT_EQ(Triple::NoSubArch, T.get32BitArchVariant().getSubArch());
1899   EXPECT_EQ(Triple::mips64el, T.get64BitArchVariant().getArch());
1900   EXPECT_EQ(Triple::NoSubArch, T.get64BitArchVariant().getSubArch());
1901
1902   T.setArch(Triple::mipsel, Triple::MipsSubArch_r6);
1903   EXPECT_EQ(Triple::mipsel, T.get32BitArchVariant().getArch());
1904   EXPECT_EQ(Triple::MipsSubArch_r6, T.get32BitArchVariant().getSubArch());
1905   EXPECT_EQ(Triple::mips64el, T.get64BitArchVariant().getArch());
1906   EXPECT_EQ(Triple::MipsSubArch_r6, T.get64BitArchVariant().getSubArch());
1907
1908   T.setArch(Triple::ppc);
1909   EXPECT_EQ(Triple::ppc, T.get32BitArchVariant().getArch());
1910   EXPECT_EQ(Triple::ppc64, T.get64BitArchVariant().getArch());
1911
1912   T.setArch(Triple::nvptx);
1913   EXPECT_EQ(Triple::nvptx, T.get32BitArchVariant().getArch());
1914   EXPECT_EQ(Triple::nvptx64, T.get64BitArchVariant().getArch());
1915
1916   T.setArch(Triple::sparc);
1917   EXPECT_EQ(Triple::sparc, T.get32BitArchVariant().getArch());
1918   EXPECT_EQ(Triple::sparcv9, T.get64BitArchVariant().getArch());
1919
1920   T.setArch(Triple::x86);
1921   EXPECT_EQ(Triple::x86, T.get32BitArchVariant().getArch());
1922   EXPECT_EQ(Triple::x86_64, T.get64BitArchVariant().getArch());
1923
1924   T.setArch(Triple::mips64);
1925   EXPECT_EQ(Triple::mips, T.get32BitArchVariant().getArch());
1926   EXPECT_EQ(Triple::NoSubArch, T.get32BitArchVariant().getSubArch());
1927   EXPECT_EQ(Triple::mips64, T.get64BitArchVariant().getArch());
1928   EXPECT_EQ(Triple::NoSubArch, T.get64BitArchVariant().getSubArch());
1929
1930   T.setArch(Triple::mips64, Triple::MipsSubArch_r6);
1931   EXPECT_EQ(Triple::mips, T.get32BitArchVariant().getArch());
1932   EXPECT_EQ(Triple::MipsSubArch_r6, T.get32BitArchVariant().getSubArch());
1933   EXPECT_EQ(Triple::mips64, T.get64BitArchVariant().getArch());
1934   EXPECT_EQ(Triple::MipsSubArch_r6, T.get64BitArchVariant().getSubArch());
1935
1936   T.setArch(Triple::mips64el);
1937   EXPECT_EQ(Triple::mipsel, T.get32BitArchVariant().getArch());
1938   EXPECT_EQ(Triple::NoSubArch, T.get32BitArchVariant().getSubArch());
1939   EXPECT_EQ(Triple::mips64el, T.get64BitArchVariant().getArch());
1940   EXPECT_EQ(Triple::NoSubArch, T.get64BitArchVariant().getSubArch());
1941
1942   T.setArch(Triple::mips64el, Triple::MipsSubArch_r6);
1943   EXPECT_EQ(Triple::mipsel, T.get32BitArchVariant().getArch());
1944   EXPECT_EQ(Triple::MipsSubArch_r6, T.get32BitArchVariant().getSubArch());
1945   EXPECT_EQ(Triple::mips64el, T.get64BitArchVariant().getArch());
1946   EXPECT_EQ(Triple::MipsSubArch_r6, T.get64BitArchVariant().getSubArch());
1947
1948   T.setArch(Triple::ppc64);
1949   EXPECT_EQ(Triple::ppc, T.get32BitArchVariant().getArch());
1950   EXPECT_EQ(Triple::ppc64, T.get64BitArchVariant().getArch());
1951
1952   T.setArch(Triple::nvptx64);
1953   EXPECT_EQ(Triple::nvptx, T.get32BitArchVariant().getArch());
1954   EXPECT_EQ(Triple::nvptx64, T.get64BitArchVariant().getArch());
1955
1956   T.setArch(Triple::sparcv9);
1957   EXPECT_EQ(Triple::sparc, T.get32BitArchVariant().getArch());
1958   EXPECT_EQ(Triple::sparcv9, T.get64BitArchVariant().getArch());
1959
1960   T.setArch(Triple::x86_64);
1961   EXPECT_EQ(Triple::x86, T.get32BitArchVariant().getArch());
1962   EXPECT_EQ(Triple::x86_64, T.get64BitArchVariant().getArch());
1963
1964   T.setArch(Triple::amdil);
1965   EXPECT_EQ(Triple::amdil, T.get32BitArchVariant().getArch());
1966   EXPECT_EQ(Triple::amdil64, T.get64BitArchVariant().getArch());
1967
1968   T.setArch(Triple::amdil64);
1969   EXPECT_EQ(Triple::amdil, T.get32BitArchVariant().getArch());
1970   EXPECT_EQ(Triple::amdil64, T.get64BitArchVariant().getArch());
1971
1972   T.setArch(Triple::hsail);
1973   EXPECT_EQ(Triple::hsail, T.get32BitArchVariant().getArch());
1974   EXPECT_EQ(Triple::hsail64, T.get64BitArchVariant().getArch());
1975
1976   T.setArch(Triple::hsail64);
1977   EXPECT_EQ(Triple::hsail, T.get32BitArchVariant().getArch());
1978   EXPECT_EQ(Triple::hsail64, T.get64BitArchVariant().getArch());
1979
1980   T.setArch(Triple::spir);
1981   EXPECT_EQ(Triple::spir, T.get32BitArchVariant().getArch());
1982   EXPECT_EQ(Triple::spir64, T.get64BitArchVariant().getArch());
1983
1984   T.setArch(Triple::spir64);
1985   EXPECT_EQ(Triple::spir, T.get32BitArchVariant().getArch());
1986   EXPECT_EQ(Triple::spir64, T.get64BitArchVariant().getArch());
1987
1988   T.setArch(Triple::spirv);
1989   EXPECT_EQ(Triple::spirv32, T.get32BitArchVariant().getArch());
1990   EXPECT_EQ(Triple::spirv64, T.get64BitArchVariant().getArch());
1991
1992   T.setArch(Triple::spirv32);
1993   EXPECT_EQ(Triple::spirv32, T.get32BitArchVariant().getArch());
1994   EXPECT_EQ(Triple::spirv64, T.get64BitArchVariant().getArch());
1995
1996   T.setArch(Triple::spirv64);
1997   EXPECT_EQ(Triple::spirv32, T.get32BitArchVariant().getArch());
1998   EXPECT_EQ(Triple::spirv64, T.get64BitArchVariant().getArch());
1999
2000   T.setArch(Triple::wasm32);
2001   EXPECT_EQ(Triple::wasm32, T.get32BitArchVariant().getArch());
2002   EXPECT_EQ(Triple::wasm64, T.get64BitArchVariant().getArch());
2003
2004   T.setArch(Triple::wasm64);
2005   EXPECT_EQ(Triple::wasm32, T.get32BitArchVariant().getArch());
2006   EXPECT_EQ(Triple::wasm64, T.get64BitArchVariant().getArch());
2007
2008   T.setArch(Triple::riscv32);
2009   EXPECT_EQ(Triple::riscv32, T.get32BitArchVariant().getArch());
2010   EXPECT_EQ(Triple::riscv64, T.get64BitArchVariant().getArch());
2011
2012   T.setArch(Triple::riscv64);
2013   EXPECT_EQ(Triple::riscv32, T.get32BitArchVariant().getArch());
2014   EXPECT_EQ(Triple::riscv64, T.get64BitArchVariant().getArch());
2015
2016   T.setArch(Triple::csky);
2017   EXPECT_EQ(Triple::csky, T.get32BitArchVariant().getArch());
2018   EXPECT_EQ(Triple::UnknownArch, T.get64BitArchVariant().getArch());
2019
2020   T.setArch(Triple::loongarch32);
2021   EXPECT_EQ(Triple::loongarch32, T.get32BitArchVariant().getArch());
2022   EXPECT_EQ(Triple::loongarch64, T.get64BitArchVariant().getArch());
2023
2024   T.setArch(Triple::loongarch64);
2025   EXPECT_EQ(Triple::loongarch32, T.get32BitArchVariant().getArch());
2026   EXPECT_EQ(Triple::loongarch64, T.get64BitArchVariant().getArch());
2027
2028   T.setArch(Triple::thumbeb);
2029   EXPECT_EQ(Triple::thumbeb, T.get32BitArchVariant().getArch());
2030   EXPECT_EQ(Triple::aarch64_be, T.get64BitArchVariant().getArch());
2031
2032   T.setArch(Triple::thumb);
2033   EXPECT_EQ(Triple::thumb, T.get32BitArchVariant().getArch());
2034   EXPECT_EQ(Triple::aarch64, T.get64BitArchVariant().getArch());
2035
2036   T.setArch(Triple::aarch64);
2037   EXPECT_EQ(Triple::arm, T.get32BitArchVariant().getArch());
2038   EXPECT_EQ(Triple::aarch64, T.get64BitArchVariant().getArch());
2039
2040   T.setArch(Triple::aarch64_be);
2041   EXPECT_EQ(Triple::armeb, T.get32BitArchVariant().getArch());
2042   EXPECT_EQ(Triple::aarch64_be, T.get64BitArchVariant().getArch());
2043
2044   T.setArch(Triple::renderscript32);
2045   EXPECT_EQ(Triple::renderscript32, T.get32BitArchVariant().getArch());
2046   EXPECT_EQ(Triple::renderscript64, T.get64BitArchVariant().getArch());
2047
2048   T.setArch(Triple::renderscript64);
2049   EXPECT_EQ(Triple::renderscript32, T.get32BitArchVariant().getArch());
2050   EXPECT_EQ(Triple::renderscript64, T.get64BitArchVariant().getArch());
2051
2052   T.setArch(Triple::armeb);
2053   EXPECT_EQ(Triple::armeb, T.get32BitArchVariant().getArch());
2054   EXPECT_EQ(Triple::aarch64_be, T.get64BitArchVariant().getArch());
2055
2056   T.setArch(Triple::arm);
2057   EXPECT_EQ(Triple::arm, T.get32BitArchVariant().getArch());
2058   EXPECT_EQ(Triple::aarch64, T.get64BitArchVariant().getArch());
2059
2060   T.setArch(Triple::systemz);
2061   EXPECT_EQ(Triple::UnknownArch, T.get32BitArchVariant().getArch());
2062   EXPECT_EQ(Triple::systemz, T.get64BitArchVariant().getArch());
2063
2064   T.setArch(Triple::xcore);
2065   EXPECT_EQ(Triple::xcore, T.get32BitArchVariant().getArch());
2066   EXPECT_EQ(Triple::UnknownArch, T.get64BitArchVariant().getArch());
2067
2068   T.setArch(Triple::dxil);
2069   EXPECT_EQ(Triple::dxil, T.get32BitArchVariant().getArch());
2070   EXPECT_EQ(Triple::UnknownArch, T.get64BitArchVariant().getArch());
2071
2072   T.setArch(Triple::xtensa);
2073   EXPECT_EQ(Triple::xtensa, T.get32BitArchVariant().getArch());
2074   EXPECT_EQ(Triple::UnknownArch, T.get64BitArchVariant().getArch());
2075 }
2076
2077 TEST(TripleTest, EndianArchVariants) {
2078   Triple T;
2079   EXPECT_EQ(Triple::UnknownArch, T.getBigEndianArchVariant().getArch());
2080   EXPECT_EQ(Triple::UnknownArch, T.getLittleEndianArchVariant().getArch());
2081
2082   T.setArch(Triple::UnknownArch);
2083   EXPECT_EQ(Triple::UnknownArch, T.getBigEndianArchVariant().getArch());
2084   EXPECT_EQ(Triple::UnknownArch, T.getLittleEndianArchVariant().getArch());
2085
2086   T.setArch(Triple::aarch64_be);
2087   EXPECT_EQ(Triple::aarch64_be, T.getBigEndianArchVariant().getArch());
2088   EXPECT_EQ(Triple::aarch64, T.getLittleEndianArchVariant().getArch());
2089
2090   T.setArch(Triple::aarch64);
2091   EXPECT_EQ(Triple::aarch64_be, T.getBigEndianArchVariant().getArch());
2092   EXPECT_EQ(Triple::aarch64, T.getLittleEndianArchVariant().getArch());
2093
2094   T.setArch(Triple::armeb);
2095   EXPECT_EQ(Triple::armeb, T.getBigEndianArchVariant().getArch());
2096   EXPECT_EQ(Triple::UnknownArch, T.getLittleEndianArchVariant().getArch());
2097
2098   T.setArch(Triple::arm);
2099   EXPECT_EQ(Triple::UnknownArch, T.getBigEndianArchVariant().getArch());
2100   EXPECT_EQ(Triple::arm, T.getLittleEndianArchVariant().getArch());
2101   T = Triple("arm");
2102   EXPECT_TRUE(T.isLittleEndian());
2103   T = Triple("thumb");
2104   EXPECT_TRUE(T.isLittleEndian());
2105   T = Triple("armeb");
2106   EXPECT_FALSE(T.isLittleEndian());
2107   T = Triple("thumbeb");
2108   EXPECT_FALSE(T.isLittleEndian());
2109
2110   T.setArch(Triple::bpfeb);
2111   EXPECT_EQ(Triple::bpfeb, T.getBigEndianArchVariant().getArch());
2112   EXPECT_EQ(Triple::bpfel, T.getLittleEndianArchVariant().getArch());
2113
2114   T.setArch(Triple::bpfel);
2115   EXPECT_EQ(Triple::bpfeb, T.getBigEndianArchVariant().getArch());
2116   EXPECT_EQ(Triple::bpfel, T.getLittleEndianArchVariant().getArch());
2117
2118   T.setArch(Triple::mips64);
2119   EXPECT_EQ(Triple::mips64, T.getBigEndianArchVariant().getArch());
2120   EXPECT_EQ(Triple::NoSubArch, T.getBigEndianArchVariant().getSubArch());
2121   EXPECT_EQ(Triple::mips64el, T.getLittleEndianArchVariant().getArch());
2122   EXPECT_EQ(Triple::NoSubArch, T.getLittleEndianArchVariant().getSubArch());
2123
2124   T.setArch(Triple::mips64, Triple::MipsSubArch_r6);
2125   EXPECT_EQ(Triple::mips64, T.getBigEndianArchVariant().getArch());
2126   EXPECT_EQ(Triple::MipsSubArch_r6, T.getBigEndianArchVariant().getSubArch());
2127   EXPECT_EQ(Triple::mips64el, T.getLittleEndianArchVariant().getArch());
2128   EXPECT_EQ(Triple::MipsSubArch_r6,
2129             T.getLittleEndianArchVariant().getSubArch());
2130
2131   T.setArch(Triple::mips64el);
2132   EXPECT_EQ(Triple::mips64, T.getBigEndianArchVariant().getArch());
2133   EXPECT_EQ(Triple::NoSubArch, T.getBigEndianArchVariant().getSubArch());
2134   EXPECT_EQ(Triple::mips64el, T.getLittleEndianArchVariant().getArch());
2135   EXPECT_EQ(Triple::NoSubArch, T.getLittleEndianArchVariant().getSubArch());
2136
2137   T.setArch(Triple::mips64el, Triple::MipsSubArch_r6);
2138   EXPECT_EQ(Triple::mips64, T.getBigEndianArchVariant().getArch());
2139   EXPECT_EQ(Triple::MipsSubArch_r6, T.getBigEndianArchVariant().getSubArch());
2140   EXPECT_EQ(Triple::mips64el, T.getLittleEndianArchVariant().getArch());
2141   EXPECT_EQ(Triple::MipsSubArch_r6,
2142             T.getLittleEndianArchVariant().getSubArch());
2143
2144   T.setArch(Triple::mips);
2145   EXPECT_EQ(Triple::mips, T.getBigEndianArchVariant().getArch());
2146   EXPECT_EQ(Triple::NoSubArch, T.getBigEndianArchVariant().getSubArch());
2147   EXPECT_EQ(Triple::mipsel, T.getLittleEndianArchVariant().getArch());
2148   EXPECT_EQ(Triple::NoSubArch, T.getLittleEndianArchVariant().getSubArch());
2149
2150   T.setArch(Triple::mips, Triple::MipsSubArch_r6);
2151   EXPECT_EQ(Triple::mips, T.getBigEndianArchVariant().getArch());
2152   EXPECT_EQ(Triple::MipsSubArch_r6, T.getBigEndianArchVariant().getSubArch());
2153   EXPECT_EQ(Triple::mipsel, T.getLittleEndianArchVariant().getArch());
2154   EXPECT_EQ(Triple::MipsSubArch_r6,
2155             T.getLittleEndianArchVariant().getSubArch());
2156
2157   T.setArch(Triple::mipsel);
2158   EXPECT_EQ(Triple::mips, T.getBigEndianArchVariant().getArch());
2159   EXPECT_EQ(Triple::NoSubArch, T.getBigEndianArchVariant().getSubArch());
2160   EXPECT_EQ(Triple::mipsel, T.getLittleEndianArchVariant().getArch());
2161   EXPECT_EQ(Triple::NoSubArch, T.getLittleEndianArchVariant().getSubArch());
2162
2163   T.setArch(Triple::mipsel, Triple::MipsSubArch_r6);
2164   EXPECT_EQ(Triple::mips, T.getBigEndianArchVariant().getArch());
2165   EXPECT_EQ(Triple::MipsSubArch_r6, T.getBigEndianArchVariant().getSubArch());
2166   EXPECT_EQ(Triple::mipsel, T.getLittleEndianArchVariant().getArch());
2167   EXPECT_EQ(Triple::MipsSubArch_r6,
2168             T.getLittleEndianArchVariant().getSubArch());
2169
2170   T.setArch(Triple::ppc);
2171   EXPECT_EQ(Triple::ppc, T.getBigEndianArchVariant().getArch());
2172   EXPECT_EQ(Triple::ppcle, T.getLittleEndianArchVariant().getArch());
2173
2174   T.setArch(Triple::ppc64);
2175   EXPECT_EQ(Triple::ppc64, T.getBigEndianArchVariant().getArch());
2176   EXPECT_EQ(Triple::ppc64le, T.getLittleEndianArchVariant().getArch());
2177
2178   T.setArch(Triple::ppc64le);
2179   EXPECT_EQ(Triple::ppc64, T.getBigEndianArchVariant().getArch());
2180   EXPECT_EQ(Triple::ppc64le, T.getLittleEndianArchVariant().getArch());
2181
2182   T.setArch(Triple::sparc);
2183   EXPECT_EQ(Triple::sparc, T.getBigEndianArchVariant().getArch());
2184   EXPECT_EQ(Triple::sparcel, T.getLittleEndianArchVariant().getArch());
2185
2186   T.setArch(Triple::sparcel);
2187   EXPECT_EQ(Triple::sparc, T.getBigEndianArchVariant().getArch());
2188   EXPECT_EQ(Triple::sparcel, T.getLittleEndianArchVariant().getArch());
2189
2190   T.setArch(Triple::thumb);
2191   EXPECT_EQ(Triple::UnknownArch, T.getBigEndianArchVariant().getArch());
2192   EXPECT_EQ(Triple::thumb, T.getLittleEndianArchVariant().getArch());
2193
2194   T.setArch(Triple::thumbeb);
2195   EXPECT_EQ(Triple::thumbeb, T.getBigEndianArchVariant().getArch());
2196   EXPECT_EQ(Triple::UnknownArch, T.getLittleEndianArchVariant().getArch());
2197
2198   T.setArch(Triple::lanai);
2199   EXPECT_EQ(Triple::lanai, T.getBigEndianArchVariant().getArch());
2200   EXPECT_EQ(Triple::UnknownArch, T.getLittleEndianArchVariant().getArch());
2201
2202   T.setArch(Triple::tcele);
2203   EXPECT_EQ(Triple::tce, T.getBigEndianArchVariant().getArch());
2204   EXPECT_EQ(Triple::tcele, T.getLittleEndianArchVariant().getArch());
2205
2206   T.setArch(Triple::tce);
2207   EXPECT_EQ(Triple::tce, T.getBigEndianArchVariant().getArch());
2208   EXPECT_EQ(Triple::tcele, T.getLittleEndianArchVariant().getArch());
2209
2210   T.setArch(Triple::csky);
2211   EXPECT_EQ(Triple::UnknownArch, T.getBigEndianArchVariant().getArch());
2212   EXPECT_EQ(Triple::csky, T.getLittleEndianArchVariant().getArch());
2213
2214   T.setArch(Triple::loongarch32);
2215   EXPECT_TRUE(T.isLittleEndian());
2216   EXPECT_EQ(Triple::UnknownArch, T.getBigEndianArchVariant().getArch());
2217   EXPECT_EQ(Triple::loongarch32, T.getLittleEndianArchVariant().getArch());
2218
2219   T.setArch(Triple::loongarch64);
2220   EXPECT_TRUE(T.isLittleEndian());
2221   EXPECT_EQ(Triple::UnknownArch, T.getBigEndianArchVariant().getArch());
2222   EXPECT_EQ(Triple::loongarch64, T.getLittleEndianArchVariant().getArch());
2223
2224   T.setArch(Triple::dxil);
2225   EXPECT_TRUE(T.isLittleEndian());
2226   EXPECT_EQ(Triple::UnknownArch, T.getBigEndianArchVariant().getArch());
2227   EXPECT_EQ(Triple::dxil, T.getLittleEndianArchVariant().getArch());
2228 }
2229
2230 TEST(TripleTest, XROS) {
2231   Triple T;
2232   VersionTuple Version;
2233
2234   T = Triple("arm64-apple-xros");
2235   EXPECT_TRUE(T.isXROS());
2236   EXPECT_TRUE(T.isOSDarwin());
2237   EXPECT_FALSE(T.isiOS());
2238   EXPECT_FALSE(T.isMacOSX());
2239   EXPECT_FALSE(T.isSimulatorEnvironment());
2240   EXPECT_EQ(T.getOSName(), "xros");
2241   Version = T.getOSVersion();
2242   EXPECT_EQ(VersionTuple(0), Version);
2243
2244   T = Triple("arm64-apple-visionos1.2");
2245   EXPECT_TRUE(T.isXROS());
2246   EXPECT_TRUE(T.isOSDarwin());
2247   EXPECT_FALSE(T.isiOS());
2248   EXPECT_FALSE(T.isMacOSX());
2249   EXPECT_FALSE(T.isSimulatorEnvironment());
2250   EXPECT_EQ(T.getOSName(), "visionos1.2");
2251   Version = T.getOSVersion();
2252   EXPECT_EQ(VersionTuple(1, 2), Version);
2253
2254   T = Triple("arm64-apple-xros1-simulator");
2255   EXPECT_TRUE(T.isXROS());
2256   EXPECT_TRUE(T.isOSDarwin());
2257   EXPECT_FALSE(T.isiOS());
2258   EXPECT_FALSE(T.isMacOSX());
2259   EXPECT_TRUE(T.isSimulatorEnvironment());
2260   Version = T.getOSVersion();
2261   EXPECT_EQ(VersionTuple(1), Version);
2262   Version = T.getiOSVersion();
2263   EXPECT_EQ(VersionTuple(17), Version);
2264 }
2265
2266 TEST(TripleTest, getOSVersion) {
2267   Triple T;
2268   VersionTuple Version;
2269
2270   T = Triple("i386-apple-darwin9");
2271   EXPECT_TRUE(T.isMacOSX());
2272   EXPECT_FALSE(T.isiOS());
2273   EXPECT_FALSE(T.isArch16Bit());
2274   EXPECT_TRUE(T.isArch32Bit());
2275   EXPECT_FALSE(T.isArch64Bit());
2276   T.getMacOSXVersion(Version);
2277   EXPECT_EQ(VersionTuple(10, 5), Version);
2278   Version = T.getiOSVersion();
2279   EXPECT_EQ(VersionTuple(5), Version);
2280
2281   T = Triple("x86_64-apple-darwin9");
2282   EXPECT_TRUE(T.isMacOSX());
2283   EXPECT_FALSE(T.isiOS());
2284   EXPECT_FALSE(T.isArch16Bit());
2285   EXPECT_FALSE(T.isArch32Bit());
2286   EXPECT_TRUE(T.isArch64Bit());
2287   T.getMacOSXVersion(Version);
2288   EXPECT_EQ(VersionTuple(10, 5), Version);
2289   Version = T.getiOSVersion();
2290   EXPECT_EQ(VersionTuple(5), Version);
2291
2292   T = Triple("x86_64-apple-macosx");
2293   EXPECT_TRUE(T.isMacOSX());
2294   EXPECT_FALSE(T.isiOS());
2295   EXPECT_FALSE(T.isArch16Bit());
2296   EXPECT_FALSE(T.isArch32Bit());
2297   EXPECT_TRUE(T.isArch64Bit());
2298   T.getMacOSXVersion(Version);
2299   EXPECT_EQ(VersionTuple(10, 4), Version);
2300   Version = T.getiOSVersion();
2301   EXPECT_EQ(VersionTuple(5), Version);
2302
2303   T = Triple("x86_64-apple-macosx10.7");
2304   EXPECT_TRUE(T.isMacOSX());
2305   EXPECT_FALSE(T.isiOS());
2306   EXPECT_FALSE(T.isArch16Bit());
2307   EXPECT_FALSE(T.isArch32Bit());
2308   EXPECT_TRUE(T.isArch64Bit());
2309   T.getMacOSXVersion(Version);
2310   EXPECT_EQ(VersionTuple(10, 7), Version);
2311   Version = T.getiOSVersion();
2312   EXPECT_EQ(VersionTuple(5), Version);
2313
2314   T = Triple("x86_64-apple-macos11.0");
2315   EXPECT_TRUE(T.isMacOSX());
2316   EXPECT_FALSE(T.isiOS());
2317   EXPECT_FALSE(T.isArch16Bit());
2318   EXPECT_FALSE(T.isArch32Bit());
2319   EXPECT_TRUE(T.isArch64Bit());
2320   T.getMacOSXVersion(Version);
2321   EXPECT_EQ(VersionTuple(11, 0), Version);
2322
2323   T = Triple("arm64-apple-macosx11.5.8");
2324   EXPECT_TRUE(T.isMacOSX());
2325   EXPECT_FALSE(T.isiOS());
2326   EXPECT_FALSE(T.isArch16Bit());
2327   EXPECT_FALSE(T.isArch32Bit());
2328   EXPECT_TRUE(T.isArch64Bit());
2329   T.getMacOSXVersion(Version);
2330   EXPECT_EQ(VersionTuple(11, 5, 8), Version);
2331
2332   // 10.16 forms a valid triple, even though it's not
2333   // a version of a macOS.
2334   T = Triple("x86_64-apple-macos10.16");
2335   EXPECT_TRUE(T.isMacOSX());
2336   T.getMacOSXVersion(Version);
2337   EXPECT_EQ(VersionTuple(10, 16), Version);
2338
2339   T = Triple("x86_64-apple-darwin20");
2340   EXPECT_TRUE(T.isMacOSX());
2341   T.getMacOSXVersion(Version);
2342   EXPECT_EQ(VersionTuple(11), Version);
2343
2344   // For darwin triples on macOS 11, only compare the major version.
2345   T = Triple("x86_64-apple-darwin20.2");
2346   EXPECT_TRUE(T.isMacOSX());
2347   T.getMacOSXVersion(Version);
2348   EXPECT_EQ(VersionTuple(11), Version);
2349
2350   T = Triple("armv7-apple-ios");
2351   EXPECT_FALSE(T.isMacOSX());
2352   EXPECT_TRUE(T.isiOS());
2353   EXPECT_FALSE(T.isArch16Bit());
2354   EXPECT_TRUE(T.isArch32Bit());
2355   EXPECT_FALSE(T.isArch64Bit());
2356   T.getMacOSXVersion(Version);
2357   EXPECT_EQ(VersionTuple(10, 4), Version);
2358   Version = T.getiOSVersion();
2359   EXPECT_EQ(VersionTuple(5), Version);
2360
2361   T = Triple("armv7-apple-ios7.0");
2362   EXPECT_FALSE(T.isMacOSX());
2363   EXPECT_TRUE(T.isiOS());
2364   EXPECT_FALSE(T.isArch16Bit());
2365   EXPECT_TRUE(T.isArch32Bit());
2366   EXPECT_FALSE(T.isArch64Bit());
2367   T.getMacOSXVersion(Version);
2368   EXPECT_EQ(VersionTuple(10, 4), Version);
2369   Version = T.getiOSVersion();
2370   EXPECT_EQ(VersionTuple(7, 0), Version);
2371   EXPECT_FALSE(T.isSimulatorEnvironment());
2372
2373   T = Triple("x86_64-apple-ios10.3-simulator");
2374   EXPECT_TRUE(T.isiOS());
2375   Version = T.getiOSVersion();
2376   EXPECT_EQ(VersionTuple(10, 3), Version);
2377   EXPECT_TRUE(T.isSimulatorEnvironment());
2378   EXPECT_FALSE(T.isMacCatalystEnvironment());
2379
2380   T = Triple("x86_64-apple-ios13.0-macabi");
2381   EXPECT_TRUE(T.isiOS());
2382   Version = T.getiOSVersion();
2383   EXPECT_EQ(VersionTuple(13, 0), Version);
2384   EXPECT_TRUE(T.getEnvironment() == Triple::MacABI);
2385   EXPECT_TRUE(T.isMacCatalystEnvironment());
2386   EXPECT_FALSE(T.isSimulatorEnvironment());
2387
2388   T = Triple("x86_64-apple-driverkit20.1.0");
2389   EXPECT_TRUE(T.isDriverKit());
2390   EXPECT_TRUE(T.isOSDarwin());
2391   EXPECT_FALSE(T.isMacOSX());
2392   EXPECT_FALSE(T.isiOS());
2393   Version = T.getDriverKitVersion();
2394   EXPECT_EQ(VersionTuple(20, 1), Version);
2395
2396   T = Triple("x86_64-apple-driverkit20");
2397   Version = T.getDriverKitVersion();
2398   EXPECT_EQ(VersionTuple(20, 0), Version);
2399
2400   // DriverKit version should default to 19.0.
2401   T = Triple("x86_64-apple-driverkit");
2402   Version = T.getDriverKitVersion();
2403   EXPECT_EQ(VersionTuple(19, 0), Version);
2404
2405   T = Triple("dxil-unknown-shadermodel6.6-pixel");
2406   EXPECT_EQ(Triple::dxil, T.getArch());
2407   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
2408   EXPECT_EQ(Triple::ShaderModel, T.getOS());
2409   Version = T.getOSVersion();
2410   EXPECT_EQ(VersionTuple(6, 6), Version);
2411   EXPECT_EQ(Triple::Pixel, T.getEnvironment());
2412
2413   T = Triple("dxil-unknown-shadermodel6.0-pixel");
2414   EXPECT_EQ(Triple::dxil, T.getArch());
2415   EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
2416   EXPECT_EQ(Triple::ShaderModel, T.getOS());
2417   Version = T.getOSVersion();
2418   EXPECT_EQ(VersionTuple(6, 0), Version);
2419   EXPECT_EQ(Triple::Pixel, T.getEnvironment());
2420 }
2421
2422 TEST(TripleTest, getEnvironmentVersion) {
2423   Triple T;
2424   VersionTuple Version;
2425
2426   T = Triple("arm-unknown-linux-android16");
2427   EXPECT_TRUE(T.isAndroid());
2428   Version = T.getEnvironmentVersion();
2429   EXPECT_EQ(VersionTuple(16), Version);
2430   EXPECT_EQ(Triple::Android, T.getEnvironment());
2431
2432   T = Triple("aarch64-unknown-linux-android21");
2433   EXPECT_TRUE(T.isAndroid());
2434   Version = T.getEnvironmentVersion();
2435   EXPECT_EQ(VersionTuple(21), Version);
2436   EXPECT_EQ(Triple::Android, T.getEnvironment());
2437 }
2438
2439 TEST(TripleTest, isMacOSVersionLT) {
2440   Triple T = Triple("x86_64-apple-macos11");
2441   EXPECT_TRUE(T.isMacOSXVersionLT(11, 1, 0));
2442   EXPECT_FALSE(T.isMacOSXVersionLT(10, 15, 0));
2443
2444   T = Triple("x86_64-apple-darwin20");
2445   EXPECT_TRUE(T.isMacOSXVersionLT(11, 1, 0));
2446   EXPECT_FALSE(T.isMacOSXVersionLT(11, 0, 0));
2447   EXPECT_FALSE(T.isMacOSXVersionLT(10, 15, 0));
2448 }
2449
2450 TEST(TripleTest, CanonicalizeOSVersion) {
2451   EXPECT_EQ(VersionTuple(10, 15, 4),
2452             Triple::getCanonicalVersionForOS(Triple::MacOSX,
2453                                              VersionTuple(10, 15, 4)));
2454   EXPECT_EQ(VersionTuple(11, 0), Triple::getCanonicalVersionForOS(
2455                                      Triple::MacOSX, VersionTuple(10, 16)));
2456   EXPECT_EQ(VersionTuple(20),
2457             Triple::getCanonicalVersionForOS(Triple::Darwin, VersionTuple(20)));
2458 }
2459
2460 TEST(TripleTest, FileFormat) {
2461   EXPECT_EQ(Triple::ELF, Triple("i686-unknown-linux-gnu").getObjectFormat());
2462   EXPECT_EQ(Triple::ELF, Triple("i686-unknown-freebsd").getObjectFormat());
2463   EXPECT_EQ(Triple::ELF, Triple("i686-unknown-netbsd").getObjectFormat());
2464   EXPECT_EQ(Triple::ELF, Triple("i686--win32-elf").getObjectFormat());
2465   EXPECT_EQ(Triple::ELF, Triple("i686---elf").getObjectFormat());
2466
2467   EXPECT_EQ(Triple::MachO, Triple("i686-apple-macosx").getObjectFormat());
2468   EXPECT_EQ(Triple::MachO, Triple("i686-apple-ios").getObjectFormat());
2469   EXPECT_EQ(Triple::MachO, Triple("i686---macho").getObjectFormat());
2470   EXPECT_EQ(Triple::MachO, Triple("powerpc-apple-macosx").getObjectFormat());
2471
2472   EXPECT_EQ(Triple::COFF, Triple("i686--win32").getObjectFormat());
2473
2474   EXPECT_EQ(Triple::ELF, Triple("i686-pc-windows-msvc-elf").getObjectFormat());
2475   EXPECT_EQ(Triple::ELF, Triple("i686-pc-cygwin-elf").getObjectFormat());
2476
2477   EXPECT_EQ(Triple::ELF, Triple("systemz-ibm-linux").getObjectFormat());
2478   EXPECT_EQ(Triple::ELF, Triple("systemz-ibm-unknown").getObjectFormat());
2479
2480   EXPECT_EQ(Triple::GOFF, Triple("s390x-ibm-zos").getObjectFormat());
2481   EXPECT_EQ(Triple::GOFF, Triple("systemz-ibm-zos").getObjectFormat());
2482   EXPECT_EQ(Triple::GOFF, Triple("s390x-ibm-zos-goff").getObjectFormat());
2483   EXPECT_EQ(Triple::GOFF, Triple("s390x-unknown-zos-goff").getObjectFormat());
2484   EXPECT_EQ(Triple::GOFF, Triple("s390x---goff").getObjectFormat());
2485
2486   EXPECT_EQ(Triple::Wasm, Triple("wasm32-unknown-unknown").getObjectFormat());
2487   EXPECT_EQ(Triple::Wasm, Triple("wasm64-unknown-unknown").getObjectFormat());
2488   EXPECT_EQ(Triple::Wasm, Triple("wasm32-wasi").getObjectFormat());
2489   EXPECT_EQ(Triple::Wasm, Triple("wasm64-wasi").getObjectFormat());
2490   EXPECT_EQ(Triple::Wasm, Triple("wasm32-unknown-wasi").getObjectFormat());
2491   EXPECT_EQ(Triple::Wasm, Triple("wasm64-unknown-wasi").getObjectFormat());
2492
2493   EXPECT_EQ(Triple::Wasm,
2494             Triple("wasm32-unknown-unknown-wasm").getObjectFormat());
2495   EXPECT_EQ(Triple::Wasm,
2496             Triple("wasm64-unknown-unknown-wasm").getObjectFormat());
2497   EXPECT_EQ(Triple::Wasm,
2498             Triple("wasm32-wasi-wasm").getObjectFormat());
2499   EXPECT_EQ(Triple::Wasm,
2500             Triple("wasm64-wasi-wasm").getObjectFormat());
2501   EXPECT_EQ(Triple::Wasm,
2502             Triple("wasm32-unknown-wasi-wasm").getObjectFormat());
2503   EXPECT_EQ(Triple::Wasm,
2504             Triple("wasm64-unknown-wasi-wasm").getObjectFormat());
2505
2506   EXPECT_EQ(Triple::XCOFF, Triple("powerpc-ibm-aix").getObjectFormat());
2507   EXPECT_EQ(Triple::XCOFF, Triple("powerpc64-ibm-aix").getObjectFormat());
2508   EXPECT_EQ(Triple::XCOFF, Triple("powerpc---xcoff").getObjectFormat());
2509   EXPECT_EQ(Triple::XCOFF, Triple("powerpc64---xcoff").getObjectFormat());
2510
2511   EXPECT_EQ(Triple::ELF, Triple("csky-unknown-unknown").getObjectFormat());
2512   EXPECT_EQ(Triple::ELF, Triple("csky-unknown-linux").getObjectFormat());
2513
2514   EXPECT_EQ(Triple::SPIRV, Triple("spirv-unknown-unknown").getObjectFormat());
2515   EXPECT_EQ(Triple::SPIRV, Triple("spirv32-unknown-unknown").getObjectFormat());
2516   EXPECT_EQ(Triple::SPIRV, Triple("spirv64-unknown-unknown").getObjectFormat());
2517
2518   EXPECT_EQ(Triple::ELF,
2519             Triple("loongarch32-unknown-unknown").getObjectFormat());
2520   EXPECT_EQ(Triple::ELF, Triple("loongarch64-unknown-linux").getObjectFormat());
2521
2522   Triple MSVCNormalized(Triple::normalize("i686-pc-windows-msvc-elf"));
2523   EXPECT_EQ(Triple::ELF, MSVCNormalized.getObjectFormat());
2524
2525   Triple GNUWindowsNormalized(Triple::normalize("i686-pc-windows-gnu-elf"));
2526   EXPECT_EQ(Triple::ELF, GNUWindowsNormalized.getObjectFormat());
2527
2528   Triple CygnusNormalised(Triple::normalize("i686-pc-windows-cygnus-elf"));
2529   EXPECT_EQ(Triple::ELF, CygnusNormalised.getObjectFormat());
2530
2531   Triple CygwinNormalized(Triple::normalize("i686-pc-cygwin-elf"));
2532   EXPECT_EQ(Triple::ELF, CygwinNormalized.getObjectFormat());
2533
2534   EXPECT_EQ(Triple::DXContainer,
2535             Triple("dxil-unknown-shadermodel").getObjectFormat());
2536
2537   Triple T = Triple("");
2538   T.setObjectFormat(Triple::ELF);
2539   EXPECT_EQ(Triple::ELF, T.getObjectFormat());
2540   EXPECT_EQ("elf", Triple::getObjectFormatTypeName(T.getObjectFormat()));
2541
2542   T.setObjectFormat(Triple::MachO);
2543   EXPECT_EQ(Triple::MachO, T.getObjectFormat());
2544   EXPECT_EQ("macho", Triple::getObjectFormatTypeName(T.getObjectFormat()));
2545
2546   T.setObjectFormat(Triple::XCOFF);
2547   EXPECT_EQ(Triple::XCOFF, T.getObjectFormat());
2548   EXPECT_EQ("xcoff", Triple::getObjectFormatTypeName(T.getObjectFormat()));
2549
2550   T.setObjectFormat(Triple::GOFF);
2551   EXPECT_EQ(Triple::GOFF, T.getObjectFormat());
2552   EXPECT_EQ("goff", Triple::getObjectFormatTypeName(T.getObjectFormat()));
2553
2554   T.setObjectFormat(Triple::SPIRV);
2555   EXPECT_EQ(Triple::SPIRV, T.getObjectFormat());
2556   EXPECT_EQ("spirv", Triple::getObjectFormatTypeName(T.getObjectFormat()));
2557
2558   EXPECT_EQ(Triple::ELF, Triple("amdgcn-apple-macosx").getObjectFormat());
2559   EXPECT_EQ(Triple::ELF, Triple("r600-apple-macosx").getObjectFormat());
2560   EXPECT_EQ(Triple::SPIRV, Triple("spirv-apple-macosx").getObjectFormat());
2561   EXPECT_EQ(Triple::SPIRV, Triple("spirv32-apple-macosx").getObjectFormat());
2562   EXPECT_EQ(Triple::SPIRV, Triple("spirv64-apple-macosx").getObjectFormat());
2563   EXPECT_EQ(Triple::DXContainer, Triple("dxil-apple-macosx").getObjectFormat());
2564 }
2565
2566 TEST(TripleTest, NormalizeWindows) {
2567   EXPECT_EQ("i686-pc-windows-msvc", Triple::normalize("i686-pc-win32"));
2568   EXPECT_EQ("i686-unknown-windows-msvc", Triple::normalize("i686-win32"));
2569   EXPECT_EQ("i686-pc-windows-gnu", Triple::normalize("i686-pc-mingw32"));
2570   EXPECT_EQ("i686-unknown-windows-gnu", Triple::normalize("i686-mingw32"));
2571   EXPECT_EQ("i686-pc-windows-gnu", Triple::normalize("i686-pc-mingw32-w64"));
2572   EXPECT_EQ("i686-unknown-windows-gnu", Triple::normalize("i686-mingw32-w64"));
2573   EXPECT_EQ("i686-pc-windows-cygnus", Triple::normalize("i686-pc-cygwin"));
2574   EXPECT_EQ("i686-unknown-windows-cygnus", Triple::normalize("i686-cygwin"));
2575
2576   EXPECT_EQ("x86_64-pc-windows-msvc", Triple::normalize("x86_64-pc-win32"));
2577   EXPECT_EQ("x86_64-unknown-windows-msvc", Triple::normalize("x86_64-win32"));
2578   EXPECT_EQ("x86_64-pc-windows-gnu", Triple::normalize("x86_64-pc-mingw32"));
2579   EXPECT_EQ("x86_64-unknown-windows-gnu", Triple::normalize("x86_64-mingw32"));
2580   EXPECT_EQ("x86_64-pc-windows-gnu",
2581             Triple::normalize("x86_64-pc-mingw32-w64"));
2582   EXPECT_EQ("x86_64-unknown-windows-gnu",
2583             Triple::normalize("x86_64-mingw32-w64"));
2584
2585   EXPECT_EQ("i686-pc-windows-elf", Triple::normalize("i686-pc-win32-elf"));
2586   EXPECT_EQ("i686-unknown-windows-elf", Triple::normalize("i686-win32-elf"));
2587   EXPECT_EQ("i686-pc-windows-macho", Triple::normalize("i686-pc-win32-macho"));
2588   EXPECT_EQ("i686-unknown-windows-macho",
2589             Triple::normalize("i686-win32-macho"));
2590
2591   EXPECT_EQ("x86_64-pc-windows-elf", Triple::normalize("x86_64-pc-win32-elf"));
2592   EXPECT_EQ("x86_64-unknown-windows-elf",
2593             Triple::normalize("x86_64-win32-elf"));
2594   EXPECT_EQ("x86_64-pc-windows-macho",
2595             Triple::normalize("x86_64-pc-win32-macho"));
2596   EXPECT_EQ("x86_64-unknown-windows-macho",
2597             Triple::normalize("x86_64-win32-macho"));
2598
2599   EXPECT_EQ("i686-pc-windows-cygnus",
2600             Triple::normalize("i686-pc-windows-cygnus"));
2601   EXPECT_EQ("i686-pc-windows-gnu", Triple::normalize("i686-pc-windows-gnu"));
2602   EXPECT_EQ("i686-pc-windows-itanium",
2603             Triple::normalize("i686-pc-windows-itanium"));
2604   EXPECT_EQ("i686-pc-windows-msvc", Triple::normalize("i686-pc-windows-msvc"));
2605
2606   EXPECT_EQ("i686-pc-windows-elf",
2607             Triple::normalize("i686-pc-windows-elf-elf"));
2608
2609   EXPECT_TRUE(Triple("x86_64-pc-win32").isWindowsMSVCEnvironment());
2610
2611   EXPECT_TRUE(Triple(Triple::normalize("mipsel-windows-msvccoff")).isOSBinFormatCOFF());
2612   EXPECT_TRUE(Triple(Triple::normalize("mipsel-windows-msvc")).isOSBinFormatCOFF());
2613   EXPECT_TRUE(Triple(Triple::normalize("mipsel-windows-gnu")).isOSBinFormatCOFF());
2614 }
2615
2616 TEST(TripleTest, NormalizeAndroid) {
2617   EXPECT_EQ("arm-unknown-linux-android16",
2618             Triple::normalize("arm-linux-androideabi16"));
2619   EXPECT_EQ("armv7a-unknown-linux-android",
2620             Triple::normalize("armv7a-linux-androideabi"));
2621   EXPECT_EQ("aarch64-unknown-linux-android21",
2622             Triple::normalize("aarch64-linux-android21"));
2623 }
2624
2625 TEST(TripleTest, NormalizeARM) {
2626   EXPECT_EQ("armv6-unknown-netbsd-eabi",
2627             Triple::normalize("armv6-netbsd-eabi"));
2628   EXPECT_EQ("armv7-unknown-netbsd-eabi",
2629             Triple::normalize("armv7-netbsd-eabi"));
2630   EXPECT_EQ("armv6eb-unknown-netbsd-eabi",
2631             Triple::normalize("armv6eb-netbsd-eabi"));
2632   EXPECT_EQ("armv7eb-unknown-netbsd-eabi",
2633             Triple::normalize("armv7eb-netbsd-eabi"));
2634   EXPECT_EQ("armv6-unknown-netbsd-eabihf",
2635             Triple::normalize("armv6-netbsd-eabihf"));
2636   EXPECT_EQ("armv7-unknown-netbsd-eabihf",
2637             Triple::normalize("armv7-netbsd-eabihf"));
2638   EXPECT_EQ("armv6eb-unknown-netbsd-eabihf",
2639             Triple::normalize("armv6eb-netbsd-eabihf"));
2640   EXPECT_EQ("armv7eb-unknown-netbsd-eabihf",
2641             Triple::normalize("armv7eb-netbsd-eabihf"));
2642
2643   EXPECT_EQ("armv7-suse-linux-gnueabihf",
2644             Triple::normalize("armv7-suse-linux-gnueabi"));
2645
2646   Triple T;
2647   T = Triple("armv6--netbsd-eabi");
2648   EXPECT_EQ(Triple::arm, T.getArch());
2649   T = Triple("armv6eb--netbsd-eabi");
2650   EXPECT_EQ(Triple::armeb, T.getArch());
2651   T = Triple("armv7-suse-linux-gnueabihf");
2652   EXPECT_EQ(Triple::GNUEABIHF, T.getEnvironment());
2653 }
2654
2655 TEST(TripleTest, ParseARMArch) {
2656   // ARM
2657   {
2658     Triple T = Triple("arm");
2659     EXPECT_EQ(Triple::arm, T.getArch());
2660   }
2661   {
2662     Triple T = Triple("armeb");
2663     EXPECT_EQ(Triple::armeb, T.getArch());
2664   }
2665   // THUMB
2666   {
2667     Triple T = Triple("thumb");
2668     EXPECT_EQ(Triple::thumb, T.getArch());
2669   }
2670   {
2671     Triple T = Triple("thumbeb");
2672     EXPECT_EQ(Triple::thumbeb, T.getArch());
2673   }
2674   // AARCH64
2675   {
2676     Triple T = Triple("arm64");
2677     EXPECT_EQ(Triple::aarch64, T.getArch());
2678   }
2679   {
2680     Triple T = Triple("arm64_32");
2681     EXPECT_EQ(Triple::aarch64_32, T.getArch());
2682   }
2683   {
2684     Triple T = Triple("aarch64");
2685     EXPECT_EQ(Triple::aarch64, T.getArch());
2686   }
2687   {
2688     Triple T = Triple("aarch64_be");
2689     EXPECT_EQ(Triple::aarch64_be, T.getArch());
2690   }
2691   {
2692     Triple T = Triple("arm64e");
2693     EXPECT_EQ(Triple::aarch64, T.getArch());
2694     EXPECT_EQ(Triple::AArch64SubArch_arm64e, T.getSubArch());
2695   }
2696   {
2697     Triple T = Triple("arm64ec");
2698     EXPECT_EQ(Triple::aarch64, T.getArch());
2699     EXPECT_EQ(Triple::AArch64SubArch_arm64ec, T.getSubArch());
2700   }
2701   {
2702     Triple T;
2703     T.setArch(Triple::aarch64, Triple::AArch64SubArch_arm64ec);
2704     EXPECT_EQ("arm64ec", T.getArchName());
2705   }
2706 }
2707
2708 TEST(TripleTest, isArmT32) {
2709   // Not isArmT32
2710   {
2711     Triple T = Triple("thumbv6m");
2712     EXPECT_FALSE(T.isArmT32());
2713   }
2714   {
2715     Triple T = Triple("armv8m.base");
2716     EXPECT_FALSE(T.isArmT32());
2717   }
2718   {
2719     Triple T = Triple("armv7s");
2720     EXPECT_FALSE(T.isArmT32());
2721   }
2722   {
2723     Triple T = Triple("armv7k");
2724     EXPECT_FALSE(T.isArmT32());
2725   }
2726   {
2727     Triple T = Triple("armv7ve");
2728     EXPECT_FALSE(T.isArmT32());
2729   }
2730   {
2731     Triple T = Triple("armv6");
2732     EXPECT_FALSE(T.isArmT32());
2733   }
2734   {
2735     Triple T = Triple("armv6m");
2736     EXPECT_FALSE(T.isArmT32());
2737   }
2738   {
2739     Triple T = Triple("armv6k");
2740     EXPECT_FALSE(T.isArmT32());
2741   }
2742   {
2743     Triple T = Triple("armv6t2");
2744     EXPECT_FALSE(T.isArmT32());
2745   }
2746   {
2747     Triple T = Triple("armv5");
2748     EXPECT_FALSE(T.isArmT32());
2749   }
2750   {
2751     Triple T = Triple("armv5te");
2752     EXPECT_FALSE(T.isArmT32());
2753   }
2754   {
2755     Triple T = Triple("armv4t");
2756     EXPECT_FALSE(T.isArmT32());
2757   }
2758
2759   // isArmT32
2760   {
2761     Triple T = Triple("arm");
2762     EXPECT_TRUE(T.isArmT32());
2763   }
2764   {
2765     Triple T = Triple("armv7m");
2766     EXPECT_TRUE(T.isArmT32());
2767   }
2768   {
2769     Triple T = Triple("armv7em");
2770     EXPECT_TRUE(T.isArmT32());
2771   }
2772   {
2773     Triple T = Triple("armv8m.main");
2774     EXPECT_TRUE(T.isArmT32());
2775   }
2776   {
2777     Triple T = Triple("armv8.1m.main");
2778     EXPECT_TRUE(T.isArmT32());
2779   }
2780 }
2781
2782 TEST(TripleTest, isArmMClass) {
2783   // not M-class
2784   {
2785     Triple T = Triple("armv7s");
2786     EXPECT_FALSE(T.isArmMClass());
2787   }
2788   {
2789     Triple T = Triple("armv7k");
2790     EXPECT_FALSE(T.isArmMClass());
2791   }
2792   {
2793     Triple T = Triple("armv7ve");
2794     EXPECT_FALSE(T.isArmMClass());
2795   }
2796   {
2797     Triple T = Triple("armv6");
2798     EXPECT_FALSE(T.isArmMClass());
2799   }
2800   {
2801     Triple T = Triple("armv6k");
2802     EXPECT_FALSE(T.isArmMClass());
2803   }
2804   {
2805     Triple T = Triple("armv6t2");
2806     EXPECT_FALSE(T.isArmMClass());
2807   }
2808   {
2809     Triple T = Triple("armv5");
2810     EXPECT_FALSE(T.isArmMClass());
2811   }
2812   {
2813     Triple T = Triple("armv5te");
2814     EXPECT_FALSE(T.isArmMClass());
2815   }
2816   {
2817     Triple T = Triple("armv4t");
2818     EXPECT_FALSE(T.isArmMClass());
2819   }
2820   {
2821     Triple T = Triple("arm");
2822     EXPECT_FALSE(T.isArmMClass());
2823   }
2824
2825   // is M-class
2826   {
2827     Triple T = Triple("armv6m");
2828     EXPECT_TRUE(T.isArmMClass());
2829   }
2830   {
2831     Triple T = Triple("armv7m");
2832     EXPECT_TRUE(T.isArmMClass());
2833   }
2834   {
2835     Triple T = Triple("armv7em");
2836     EXPECT_TRUE(T.isArmMClass());
2837   }
2838   {
2839     Triple T = Triple("armv8m.base");
2840     EXPECT_TRUE(T.isArmMClass());
2841   }
2842   {
2843     Triple T = Triple("armv8m.main");
2844     EXPECT_TRUE(T.isArmMClass());
2845   }
2846   {
2847     Triple T = Triple("armv8.1m.main");
2848     EXPECT_TRUE(T.isArmMClass());
2849   }
2850 }
2851
2852 TEST(TripleTest, DXILNormaizeWithVersion) {
2853   EXPECT_EQ("dxilv1.0-unknown-shadermodel6.0",
2854             Triple::normalize("dxilv1.0--shadermodel6.0"));
2855   EXPECT_EQ("dxilv1.0-unknown-shadermodel6.0",
2856             Triple::normalize("dxil--shadermodel6.0"));
2857   EXPECT_EQ("dxilv1.1-unknown-shadermodel6.1-library",
2858             Triple::normalize("dxil-shadermodel6.1-unknown-library"));
2859   EXPECT_EQ("dxilv1.8-unknown-shadermodel6.x-unknown",
2860             Triple::normalize("dxil-unknown-shadermodel6.x-unknown"));
2861   EXPECT_EQ("dxilv1.8-unknown-shadermodel6.x-unknown",
2862             Triple::normalize("dxil-unknown-shadermodel6.x-unknown"));
2863   EXPECT_EQ("dxil-unknown-unknown-unknown", Triple::normalize("dxil---"));
2864   EXPECT_EQ("dxilv1.0-pc-shadermodel5.0-compute",
2865             Triple::normalize("dxil-shadermodel5.0-pc-compute"));
2866 }
2867
2868 TEST(TripleTest, isCompatibleWith) {
2869   struct {
2870     const char *A;
2871     const char *B;
2872     bool Result;
2873   } Cases[] = {
2874       {"armv7-linux-gnueabihf", "thumbv7-linux-gnueabihf", true},
2875       {"armv4-none-unknown-eabi", "thumbv6-unknown-linux-gnueabihf", false},
2876       {"x86_64-apple-macosx10.9.0", "x86_64-apple-macosx10.10.0", true},
2877       {"x86_64-apple-macosx10.9.0", "i386-apple-macosx10.9.0", false},
2878       {"x86_64-apple-macosx10.9.0", "x86_64h-apple-macosx10.9.0", true},
2879       {"x86_64-unknown-linux-gnu", "x86_64-unknown-linux-gnu", true},
2880       {"x86_64-unknown-linux-gnu", "i386-unknown-linux-gnu", false},
2881       {"x86_64-unknown-linux-gnu", "x86_64h-unknown-linux-gnu", true},
2882       {"x86_64-pc-windows-gnu", "x86_64-pc-windows-msvc", false},
2883       {"x86_64-pc-windows-msvc", "x86_64-pc-windows-msvc-elf", false},
2884       {"i686-w64-windows-gnu", "i386-w64-windows-gnu", true},
2885       {"x86_64-w64-windows-gnu", "x86_64-pc-windows-gnu", true},
2886       {"armv7-w64-windows-gnu", "thumbv7-pc-windows-gnu", true},
2887   };
2888
2889   auto DoTest = [](const char *A, const char *B,
2890                    bool Result) -> testing::AssertionResult {
2891     if (Triple(A).isCompatibleWith(Triple(B)) != Result) {
2892       return testing::AssertionFailure()
2893              << llvm::formatv("Triple {0} and {1} were expected to be {2}", A,
2894                               B, Result ? "compatible" : "incompatible");
2895     }
2896     return testing::AssertionSuccess();
2897   };
2898   for (const auto &C : Cases) {
2899     EXPECT_TRUE(DoTest(C.A, C.B, C.Result));
2900     // Test that the comparison is commutative.
2901     EXPECT_TRUE(DoTest(C.B, C.A, C.Result));
2902   }
2903 }
2904 } // end anonymous namespace