lib/Support/Triple.cpp

   1 //===--- Triple.cpp - Target triple helper class --------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "llvm/ADT/Triple.h"
  11 #include "llvm/ADT/STLExtras.h"
  12 #include "llvm/ADT/SmallString.h"
  13 #include "llvm/ADT/StringSwitch.h"
  14 #include "llvm/Support/ErrorHandling.h"
  15 #include "llvm/Support/TargetParser.h"
  16 #include "llvm/Support/Host.h"
  17 #include <cstring>
  18 using namespace llvm;
  19
  20 StringRef Triple::getArchTypeName(ArchType Kind) {
  21   switch (Kind) {
  22   case UnknownArch:    return "unknown";
  23
  24   case aarch64:        return "aarch64";
  25   case aarch64_be:     return "aarch64_be";
  26   case arm:            return "arm";
  27   case armeb:          return "armeb";
  28   case avr:            return "avr";
  29   case bpfel:          return "bpfel";
  30   case bpfeb:          return "bpfeb";
  31   case hexagon:        return "hexagon";
  32   case mips:           return "mips";
  33   case mipsel:         return "mipsel";
  34   case mips64:         return "mips64";
  35   case mips64el:       return "mips64el";
  36   case msp430:         return "msp430";
  37   case nios2:          return "nios2";
  38   case ppc64:          return "powerpc64";
  39   case ppc64le:        return "powerpc64le";
  40   case ppc:            return "powerpc";
  41   case r600:           return "r600";
  42   case amdgcn:         return "amdgcn";
  43   case riscv32:        return "riscv32";
  44   case riscv64:        return "riscv64";
  45   case sparc:          return "sparc";
  46   case sparcv9:        return "sparcv9";
  47   case sparcel:        return "sparcel";
  48   case systemz:        return "s390x";
  49   case tce:            return "tce";
  50   case tcele:          return "tcele";
  51   case thumb:          return "thumb";
  52   case thumbeb:        return "thumbeb";
  53   case x86:            return "i386";
  54   case x86_64:         return "x86_64";
  55   case xcore:          return "xcore";
  56   case nvptx:          return "nvptx";
  57   case nvptx64:        return "nvptx64";
  58   case le32:           return "le32";
  59   case le64:           return "le64";
  60   case amdil:          return "amdil";
  61   case amdil64:        return "amdil64";
  62   case hsail:          return "hsail";
  63   case hsail64:        return "hsail64";
  64   case spir:           return "spir";
  65   case spir64:         return "spir64";
  66   case kalimba:        return "kalimba";
  67   case lanai:          return "lanai";
  68   case shave:          return "shave";
  69   case wasm32:         return "wasm32";
  70   case wasm64:         return "wasm64";
  71   case renderscript32: return "renderscript32";
  72   case renderscript64: return "renderscript64";
  73   }
  74
  75   llvm_unreachable("Invalid ArchType!");
  76 }
  77
  78 StringRef Triple::getArchTypePrefix(ArchType Kind) {
  79   switch (Kind) {
  80   default:
  81     return StringRef();
  82
  83   case aarch64:
  84   case aarch64_be:  return "aarch64";
  85
  86   case arm:
  87   case armeb:
  88   case thumb:
  89   case thumbeb:     return "arm";
  90
  91   case avr:         return "avr";
  92
  93   case ppc64:
  94   case ppc64le:
  95   case ppc:         return "ppc";
  96
  97   case mips:
  98   case mipsel:
  99   case mips64:
 100   case mips64el:    return "mips";
 101
 102   case nios2:       return "nios2";
 103
 104   case hexagon:     return "hexagon";
 105
 106   case amdgcn:      return "amdgcn";
 107   case r600:        return "r600";
 108
 109   case bpfel:
 110   case bpfeb:       return "bpf";
 111
 112   case sparcv9:
 113   case sparcel:
 114   case sparc:       return "sparc";
 115
 116   case systemz:     return "s390";
 117
 118   case x86:
 119   case x86_64:      return "x86";
 120
 121   case xcore:       return "xcore";
 122
 123   // NVPTX intrinsics are namespaced under nvvm.
 124   case nvptx:       return "nvvm";
 125   case nvptx64:     return "nvvm";
 126
 127   case le32:        return "le32";
 128   case le64:        return "le64";
 129
 130   case amdil:
 131   case amdil64:     return "amdil";
 132
 133   case hsail:
 134   case hsail64:     return "hsail";
 135
 136   case spir:
 137   case spir64:      return "spir";
 138   case kalimba:     return "kalimba";
 139   case lanai:       return "lanai";
 140   case shave:       return "shave";
 141   case wasm32:
 142   case wasm64:      return "wasm";
 143
 144   case riscv32:
 145   case riscv64:     return "riscv";
 146   }
 147 }
 148
 149 StringRef Triple::getVendorTypeName(VendorType Kind) {
 150   switch (Kind) {
 151   case UnknownVendor: return "unknown";
 152
 153   case Apple: return "apple";
 154   case PC: return "pc";
 155   case SCEI: return "scei";
 156   case BGP: return "bgp";
 157   case BGQ: return "bgq";
 158   case Freescale: return "fsl";
 159   case IBM: return "ibm";
 160   case ImaginationTechnologies: return "img";
 161   case MipsTechnologies: return "mti";
 162   case NVIDIA: return "nvidia";
 163   case CSR: return "csr";
 164   case Myriad: return "myriad";
 165   case AMD: return "amd";
 166   case Mesa: return "mesa";
 167   case SUSE: return "suse";
 168   }
 169
 170   llvm_unreachable("Invalid VendorType!");
 171 }
 172
 173 StringRef Triple::getOSTypeName(OSType Kind) {
 174   switch (Kind) {
 175   case UnknownOS: return "unknown";
 176
 177   case CloudABI: return "cloudabi";
 178   case Darwin: return "darwin";
 179   case DragonFly: return "dragonfly";
 180   case FreeBSD: return "freebsd";
 181   case Fuchsia: return "fuchsia";
 182   case IOS: return "ios";
 183   case KFreeBSD: return "kfreebsd";
 184   case Linux: return "linux";
 185   case Lv2: return "lv2";
 186   case MacOSX: return "macosx";
 187   case NetBSD: return "netbsd";
 188   case OpenBSD: return "openbsd";
 189   case Solaris: return "solaris";
 190   case Win32: return "windows";
 191   case Haiku: return "haiku";
 192   case Minix: return "minix";
 193   case RTEMS: return "rtems";
 194   case NaCl: return "nacl";
 195   case CNK: return "cnk";
 196   case Bitrig: return "bitrig";
 197   case AIX: return "aix";
 198   case CUDA: return "cuda";
 199   case NVCL: return "nvcl";
 200   case AMDHSA: return "amdhsa";
 201   case PS4: return "ps4";
 202   case ELFIAMCU: return "elfiamcu";
 203   case TvOS: return "tvos";
 204   case WatchOS: return "watchos";
 205   case Mesa3D: return "mesa3d";
 206   case Contiki: return "contiki";
 207   }
 208
 209   llvm_unreachable("Invalid OSType");
 210 }
 211
 212 StringRef Triple::getEnvironmentTypeName(EnvironmentType Kind) {
 213   switch (Kind) {
 214   case UnknownEnvironment: return "unknown";
 215   case GNU: return "gnu";
 216   case GNUABI64: return "gnuabi64";
 217   case GNUEABIHF: return "gnueabihf";
 218   case GNUEABI: return "gnueabi";
 219   case GNUX32: return "gnux32";
 220   case CODE16: return "code16";
 221   case EABI: return "eabi";
 222   case EABIHF: return "eabihf";
 223   case Android: return "android";
 224   case Musl: return "musl";
 225   case MuslEABI: return "musleabi";
 226   case MuslEABIHF: return "musleabihf";
 227   case MSVC: return "msvc";
 228   case Itanium: return "itanium";
 229   case Cygnus: return "cygnus";
 230   case AMDOpenCL: return "amdopencl";
 231   case CoreCLR: return "coreclr";
 232   case OpenCL: return "opencl";
 233   }
 234
 235   llvm_unreachable("Invalid EnvironmentType!");
 236 }
 237
 238 static Triple::ArchType parseBPFArch(StringRef ArchName) {
 239   if (ArchName.equals("bpf")) {
 240     if (sys::IsLittleEndianHost)
 241       return Triple::bpfel;
 242     else
 243       return Triple::bpfeb;
 244   } else if (ArchName.equals("bpf_be") || ArchName.equals("bpfeb")) {
 245     return Triple::bpfeb;
 246   } else if (ArchName.equals("bpf_le") || ArchName.equals("bpfel")) {
 247     return Triple::bpfel;
 248   } else {
 249     return Triple::UnknownArch;
 250   }
 251 }
 252
 253 Triple::ArchType Triple::getArchTypeForLLVMName(StringRef Name) {
 254   Triple::ArchType BPFArch(parseBPFArch(Name));
 255   return StringSwitch<Triple::ArchType>(Name)
 256     .Case("aarch64", aarch64)
 257     .Case("aarch64_be", aarch64_be)
 258     .Case("arm64", aarch64) // "arm64" is an alias for "aarch64"
 259     .Case("arm", arm)
 260     .Case("armeb", armeb)
 261     .Case("avr", avr)
 262     .StartsWith("bpf", BPFArch)
 263     .Case("mips", mips)
 264     .Case("mipsel", mipsel)
 265     .Case("mips64", mips64)
 266     .Case("mips64el", mips64el)
 267     .Case("msp430", msp430)
 268     .Case("nios2", nios2)
 269     .Case("ppc64", ppc64)
 270     .Case("ppc32", ppc)
 271     .Case("ppc", ppc)
 272     .Case("ppc64le", ppc64le)
 273     .Case("r600", r600)
 274     .Case("amdgcn", amdgcn)
 275     .Case("riscv32", riscv32)
 276     .Case("riscv64", riscv64)
 277     .Case("hexagon", hexagon)
 278     .Case("sparc", sparc)
 279     .Case("sparcel", sparcel)
 280     .Case("sparcv9", sparcv9)
 281     .Case("systemz", systemz)
 282     .Case("tce", tce)
 283     .Case("tcele", tcele)
 284     .Case("thumb", thumb)
 285     .Case("thumbeb", thumbeb)
 286     .Case("x86", x86)
 287     .Case("x86-64", x86_64)
 288     .Case("xcore", xcore)
 289     .Case("nvptx", nvptx)
 290     .Case("nvptx64", nvptx64)
 291     .Case("le32", le32)
 292     .Case("le64", le64)
 293     .Case("amdil", amdil)
 294     .Case("amdil64", amdil64)
 295     .Case("hsail", hsail)
 296     .Case("hsail64", hsail64)
 297     .Case("spir", spir)
 298     .Case("spir64", spir64)
 299     .Case("kalimba", kalimba)
 300     .Case("lanai", lanai)
 301     .Case("shave", shave)
 302     .Case("wasm32", wasm32)
 303     .Case("wasm64", wasm64)
 304     .Case("renderscript32", renderscript32)
 305     .Case("renderscript64", renderscript64)
 306     .Default(UnknownArch);
 307 }
 308
 309 static Triple::ArchType parseARMArch(StringRef ArchName) {
 310   unsigned ISA = ARM::parseArchISA(ArchName);
 311   unsigned ENDIAN = ARM::parseArchEndian(ArchName);
 312
 313   Triple::ArchType arch = Triple::UnknownArch;
 314   switch (ENDIAN) {
 315   case ARM::EK_LITTLE: {
 316     switch (ISA) {
 317     case ARM::IK_ARM:
 318       arch = Triple::arm;
 319       break;
 320     case ARM::IK_THUMB:
 321       arch = Triple::thumb;
 322       break;
 323     case ARM::IK_AARCH64:
 324       arch = Triple::aarch64;
 325       break;
 326     }
 327     break;
 328   }
 329   case ARM::EK_BIG: {
 330     switch (ISA) {
 331     case ARM::IK_ARM:
 332       arch = Triple::armeb;
 333       break;
 334     case ARM::IK_THUMB:
 335       arch = Triple::thumbeb;
 336       break;
 337     case ARM::IK_AARCH64:
 338       arch = Triple::aarch64_be;
 339       break;
 340     }
 341     break;
 342   }
 343   }
 344
 345   ArchName = ARM::getCanonicalArchName(ArchName);
 346   if (ArchName.empty())
 347     return Triple::UnknownArch;
 348
 349   // Thumb only exists in v4+
 350   if (ISA == ARM::IK_THUMB &&
 351       (ArchName.startswith("v2") || ArchName.startswith("v3")))
 352     return Triple::UnknownArch;
 353
 354   // Thumb only for v6m
 355   unsigned Profile = ARM::parseArchProfile(ArchName);
 356   unsigned Version = ARM::parseArchVersion(ArchName);
 357   if (Profile == ARM::PK_M && Version == 6) {
 358     if (ENDIAN == ARM::EK_BIG)
 359       return Triple::thumbeb;
 360     else
 361       return Triple::thumb;
 362   }
 363
 364   return arch;
 365 }
 366
 367 static Triple::ArchType parseArch(StringRef ArchName) {
 368   auto AT = StringSwitch<Triple::ArchType>(ArchName)
 369     .Cases("i386", "i486", "i586", "i686", Triple::x86)
 370     // FIXME: Do we need to support these?
 371     .Cases("i786", "i886", "i986", Triple::x86)
 372     .Cases("amd64", "x86_64", "x86_64h", Triple::x86_64)
 373     .Cases("powerpc", "ppc32", Triple::ppc)
 374     .Cases("powerpc64", "ppu", "ppc64", Triple::ppc64)
 375     .Cases("powerpc64le", "ppc64le", Triple::ppc64le)
 376     .Case("xscale", Triple::arm)
 377     .Case("xscaleeb", Triple::armeb)
 378     .Case("aarch64", Triple::aarch64)
 379     .Case("aarch64_be", Triple::aarch64_be)
 380     .Case("arm64", Triple::aarch64)
 381     .Case("arm", Triple::arm)
 382     .Case("armeb", Triple::armeb)
 383     .Case("thumb", Triple::thumb)
 384     .Case("thumbeb", Triple::thumbeb)
 385     .Case("avr", Triple::avr)
 386     .Case("msp430", Triple::msp430)
 387     .Cases("mips", "mipseb", "mipsallegrex", Triple::mips)
 388     .Cases("mipsel", "mipsallegrexel", Triple::mipsel)
 389     .Cases("mips64", "mips64eb", Triple::mips64)
 390     .Case("mips64el", Triple::mips64el)
 391     .Case("nios2", Triple::nios2)
 392     .Case("r600", Triple::r600)
 393     .Case("amdgcn", Triple::amdgcn)
 394     .Case("riscv32", Triple::riscv32)
 395     .Case("riscv64", Triple::riscv64)
 396     .Case("hexagon", Triple::hexagon)
 397     .Cases("s390x", "systemz", Triple::systemz)
 398     .Case("sparc", Triple::sparc)
 399     .Case("sparcel", Triple::sparcel)
 400     .Cases("sparcv9", "sparc64", Triple::sparcv9)
 401     .Case("tce", Triple::tce)
 402     .Case("tcele", Triple::tcele)
 403     .Case("xcore", Triple::xcore)
 404     .Case("nvptx", Triple::nvptx)
 405     .Case("nvptx64", Triple::nvptx64)
 406     .Case("le32", Triple::le32)
 407     .Case("le64", Triple::le64)
 408     .Case("amdil", Triple::amdil)
 409     .Case("amdil64", Triple::amdil64)
 410     .Case("hsail", Triple::hsail)
 411     .Case("hsail64", Triple::hsail64)
 412     .Case("spir", Triple::spir)
 413     .Case("spir64", Triple::spir64)
 414     .StartsWith("kalimba", Triple::kalimba)
 415     .Case("lanai", Triple::lanai)
 416     .Case("shave", Triple::shave)
 417     .Case("wasm32", Triple::wasm32)
 418     .Case("wasm64", Triple::wasm64)
 419     .Case("renderscript32", Triple::renderscript32)
 420     .Case("renderscript64", Triple::renderscript64)
 421     .Default(Triple::UnknownArch);
 422
 423   // Some architectures require special parsing logic just to compute the
 424   // ArchType result.
 425   if (AT == Triple::UnknownArch) {
 426     if (ArchName.startswith("arm") || ArchName.startswith("thumb") ||
 427         ArchName.startswith("aarch64"))
 428       return parseARMArch(ArchName);
 429     if (ArchName.startswith("bpf"))
 430       return parseBPFArch(ArchName);
 431   }
 432
 433   return AT;
 434 }
 435
 436 static Triple::VendorType parseVendor(StringRef VendorName) {
 437   return StringSwitch<Triple::VendorType>(VendorName)
 438     .Case("apple", Triple::Apple)
 439     .Case("pc", Triple::PC)
 440     .Case("scei", Triple::SCEI)
 441     .Case("bgp", Triple::BGP)
 442     .Case("bgq", Triple::BGQ)
 443     .Case("fsl", Triple::Freescale)
 444     .Case("ibm", Triple::IBM)
 445     .Case("img", Triple::ImaginationTechnologies)
 446     .Case("mti", Triple::MipsTechnologies)
 447     .Case("nvidia", Triple::NVIDIA)
 448     .Case("csr", Triple::CSR)
 449     .Case("myriad", Triple::Myriad)
 450     .Case("amd", Triple::AMD)
 451     .Case("mesa", Triple::Mesa)
 452     .Case("suse", Triple::SUSE)
 453     .Default(Triple::UnknownVendor);
 454 }
 455
 456 static Triple::OSType parseOS(StringRef OSName) {
 457   return StringSwitch<Triple::OSType>(OSName)
 458     .StartsWith("cloudabi", Triple::CloudABI)
 459     .StartsWith("darwin", Triple::Darwin)
 460     .StartsWith("dragonfly", Triple::DragonFly)
 461     .StartsWith("freebsd", Triple::FreeBSD)
 462     .StartsWith("fuchsia", Triple::Fuchsia)
 463     .StartsWith("ios", Triple::IOS)
 464     .StartsWith("kfreebsd", Triple::KFreeBSD)
 465     .StartsWith("linux", Triple::Linux)
 466     .StartsWith("lv2", Triple::Lv2)
 467     .StartsWith("macos", Triple::MacOSX)
 468     .StartsWith("netbsd", Triple::NetBSD)
 469     .StartsWith("openbsd", Triple::OpenBSD)
 470     .StartsWith("solaris", Triple::Solaris)
 471     .StartsWith("win32", Triple::Win32)
 472     .StartsWith("windows", Triple::Win32)
 473     .StartsWith("haiku", Triple::Haiku)
 474     .StartsWith("minix", Triple::Minix)
 475     .StartsWith("rtems", Triple::RTEMS)
 476     .StartsWith("nacl", Triple::NaCl)
 477     .StartsWith("cnk", Triple::CNK)
 478     .StartsWith("bitrig", Triple::Bitrig)
 479     .StartsWith("aix", Triple::AIX)
 480     .StartsWith("cuda", Triple::CUDA)
 481     .StartsWith("nvcl", Triple::NVCL)
 482     .StartsWith("amdhsa", Triple::AMDHSA)
 483     .StartsWith("ps4", Triple::PS4)
 484     .StartsWith("elfiamcu", Triple::ELFIAMCU)
 485     .StartsWith("tvos", Triple::TvOS)
 486     .StartsWith("watchos", Triple::WatchOS)
 487     .StartsWith("mesa3d", Triple::Mesa3D)
 488     .StartsWith("contiki", Triple::Contiki)
 489     .Default(Triple::UnknownOS);
 490 }
 491
 492 static Triple::EnvironmentType parseEnvironment(StringRef EnvironmentName) {
 493   return StringSwitch<Triple::EnvironmentType>(EnvironmentName)
 494     .StartsWith("eabihf", Triple::EABIHF)
 495     .StartsWith("eabi", Triple::EABI)
 496     .StartsWith("gnuabi64", Triple::GNUABI64)
 497     .StartsWith("gnueabihf", Triple::GNUEABIHF)
 498     .StartsWith("gnueabi", Triple::GNUEABI)
 499     .StartsWith("gnux32", Triple::GNUX32)
 500     .StartsWith("code16", Triple::CODE16)
 501     .StartsWith("gnu", Triple::GNU)
 502     .StartsWith("android", Triple::Android)
 503     .StartsWith("musleabihf", Triple::MuslEABIHF)
 504     .StartsWith("musleabi", Triple::MuslEABI)
 505     .StartsWith("musl", Triple::Musl)
 506     .StartsWith("msvc", Triple::MSVC)
 507     .StartsWith("itanium", Triple::Itanium)
 508     .StartsWith("cygnus", Triple::Cygnus)
 509     .StartsWith("amdopencl", Triple::AMDOpenCL)
 510     .StartsWith("coreclr", Triple::CoreCLR)
 511     .StartsWith("opencl", Triple::OpenCL)
 512     .Default(Triple::UnknownEnvironment);
 513 }
 514
 515 static Triple::ObjectFormatType parseFormat(StringRef EnvironmentName) {
 516   return StringSwitch<Triple::ObjectFormatType>(EnvironmentName)
 517     .EndsWith("coff", Triple::COFF)
 518     .EndsWith("elf", Triple::ELF)
 519     .EndsWith("macho", Triple::MachO)
 520     .EndsWith("wasm", Triple::Wasm)
 521     .Default(Triple::UnknownObjectFormat);
 522 }
 523
 524 static Triple::SubArchType parseSubArch(StringRef SubArchName) {
 525   StringRef ARMSubArch = ARM::getCanonicalArchName(SubArchName);
 526
 527   // For now, this is the small part. Early return.
 528   if (ARMSubArch.empty())
 529     return StringSwitch<Triple::SubArchType>(SubArchName)
 530       .EndsWith("kalimba3", Triple::KalimbaSubArch_v3)
 531       .EndsWith("kalimba4", Triple::KalimbaSubArch_v4)
 532       .EndsWith("kalimba5", Triple::KalimbaSubArch_v5)
 533       .Default(Triple::NoSubArch);
 534
 535   // ARM sub arch.
 536   switch(ARM::parseArch(ARMSubArch)) {
 537   case ARM::AK_ARMV4:
 538     return Triple::NoSubArch;
 539   case ARM::AK_ARMV4T:
 540     return Triple::ARMSubArch_v4t;
 541   case ARM::AK_ARMV5T:
 542     return Triple::ARMSubArch_v5;
 543   case ARM::AK_ARMV5TE:
 544   case ARM::AK_IWMMXT:
 545   case ARM::AK_IWMMXT2:
 546   case ARM::AK_XSCALE:
 547   case ARM::AK_ARMV5TEJ:
 548     return Triple::ARMSubArch_v5te;
 549   case ARM::AK_ARMV6:
 550     return Triple::ARMSubArch_v6;
 551   case ARM::AK_ARMV6K:
 552   case ARM::AK_ARMV6KZ:
 553     return Triple::ARMSubArch_v6k;
 554   case ARM::AK_ARMV6T2:
 555     return Triple::ARMSubArch_v6t2;
 556   case ARM::AK_ARMV6M:
 557     return Triple::ARMSubArch_v6m;
 558   case ARM::AK_ARMV7A:
 559   case ARM::AK_ARMV7R:
 560     return Triple::ARMSubArch_v7;
 561   case ARM::AK_ARMV7VE:
 562     return Triple::ARMSubArch_v7ve;
 563   case ARM::AK_ARMV7K:
 564     return Triple::ARMSubArch_v7k;
 565   case ARM::AK_ARMV7M:
 566     return Triple::ARMSubArch_v7m;
 567   case ARM::AK_ARMV7S:
 568     return Triple::ARMSubArch_v7s;
 569   case ARM::AK_ARMV7EM:
 570     return Triple::ARMSubArch_v7em;
 571   case ARM::AK_ARMV8A:
 572     return Triple::ARMSubArch_v8;
 573   case ARM::AK_ARMV8_1A:
 574     return Triple::ARMSubArch_v8_1a;
 575   case ARM::AK_ARMV8_2A:
 576     return Triple::ARMSubArch_v8_2a;
 577   case ARM::AK_ARMV8R:
 578     return Triple::ARMSubArch_v8r;
 579   case ARM::AK_ARMV8MBaseline:
 580     return Triple::ARMSubArch_v8m_baseline;
 581   case ARM::AK_ARMV8MMainline:
 582     return Triple::ARMSubArch_v8m_mainline;
 583   default:
 584     return Triple::NoSubArch;
 585   }
 586 }
 587
 588 static StringRef getObjectFormatTypeName(Triple::ObjectFormatType Kind) {
 589   switch (Kind) {
 590   case Triple::UnknownObjectFormat: return "";
 591   case Triple::COFF: return "coff";
 592   case Triple::ELF: return "elf";
 593   case Triple::MachO: return "macho";
 594   case Triple::Wasm: return "wasm";
 595   }
 596   llvm_unreachable("unknown object format type");
 597 }
 598
 599 static Triple::ObjectFormatType getDefaultFormat(const Triple &T) {
 600   switch (T.getArch()) {
 601   case Triple::UnknownArch:
 602   case Triple::aarch64:
 603   case Triple::arm:
 604   case Triple::thumb:
 605   case Triple::x86:
 606   case Triple::x86_64:
 607     if (T.isOSDarwin())
 608       return Triple::MachO;
 609     else if (T.isOSWindows())
 610       return Triple::COFF;
 611     return Triple::ELF;
 612
 613   case Triple::aarch64_be:
 614   case Triple::amdgcn:
 615   case Triple::amdil:
 616   case Triple::amdil64:
 617   case Triple::armeb:
 618   case Triple::avr:
 619   case Triple::bpfeb:
 620   case Triple::bpfel:
 621   case Triple::hexagon:
 622   case Triple::lanai:
 623   case Triple::hsail:
 624   case Triple::hsail64:
 625   case Triple::kalimba:
 626   case Triple::le32:
 627   case Triple::le64:
 628   case Triple::mips:
 629   case Triple::mips64:
 630   case Triple::mips64el:
 631   case Triple::mipsel:
 632   case Triple::msp430:
 633   case Triple::nios2:
 634   case Triple::nvptx:
 635   case Triple::nvptx64:
 636   case Triple::ppc64le:
 637   case Triple::r600:
 638   case Triple::renderscript32:
 639   case Triple::renderscript64:
 640   case Triple::riscv32:
 641   case Triple::riscv64:
 642   case Triple::shave:
 643   case Triple::sparc:
 644   case Triple::sparcel:
 645   case Triple::sparcv9:
 646   case Triple::spir:
 647   case Triple::spir64:
 648   case Triple::systemz:
 649   case Triple::tce:
 650   case Triple::tcele:
 651   case Triple::thumbeb:
 652   case Triple::wasm32:
 653   case Triple::wasm64:
 654   case Triple::xcore:
 655     return Triple::ELF;
 656
 657   case Triple::ppc:
 658   case Triple::ppc64:
 659     if (T.isOSDarwin())
 660       return Triple::MachO;
 661     return Triple::ELF;
 662   }
 663   llvm_unreachable("unknown architecture");
 664 }
 665
 666 /// \brief Construct a triple from the string representation provided.
 667 ///
 668 /// This stores the string representation and parses the various pieces into
 669 /// enum members.
 670 Triple::Triple(const Twine &Str)
 671     : Data(Str.str()), Arch(UnknownArch), SubArch(NoSubArch),
 672       Vendor(UnknownVendor), OS(UnknownOS), Environment(UnknownEnvironment),
 673       ObjectFormat(UnknownObjectFormat) {
 674   // Do minimal parsing by hand here.
 675   SmallVector<StringRef, 4> Components;
 676   StringRef(Data).split(Components, '-', /*MaxSplit*/ 3);
 677   if (Components.size() > 0) {
 678     Arch = parseArch(Components[0]);
 679     SubArch = parseSubArch(Components[0]);
 680     if (Components.size() > 1) {
 681       Vendor = parseVendor(Components[1]);
 682       if (Components.size() > 2) {
 683         OS = parseOS(Components[2]);
 684         if (Components.size() > 3) {
 685           Environment = parseEnvironment(Components[3]);
 686           ObjectFormat = parseFormat(Components[3]);
 687         }
 688       }
 689     }
 690   }
 691   if (ObjectFormat == UnknownObjectFormat)
 692     ObjectFormat = getDefaultFormat(*this);
 693 }
 694
 695 /// \brief Construct a triple from string representations of the architecture,
 696 /// vendor, and OS.
 697 ///
 698 /// This joins each argument into a canonical string representation and parses
 699 /// them into enum members. It leaves the environment unknown and omits it from
 700 /// the string representation.
 701 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr)
 702     : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr).str()),
 703       Arch(parseArch(ArchStr.str())),
 704       SubArch(parseSubArch(ArchStr.str())),
 705       Vendor(parseVendor(VendorStr.str())),
 706       OS(parseOS(OSStr.str())),
 707       Environment(), ObjectFormat(Triple::UnknownObjectFormat) {
 708   ObjectFormat = getDefaultFormat(*this);
 709 }
 710
 711 /// \brief Construct a triple from string representations of the architecture,
 712 /// vendor, OS, and environment.
 713 ///
 714 /// This joins each argument into a canonical string representation and parses
 715 /// them into enum members.
 716 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr,
 717                const Twine &EnvironmentStr)
 718     : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr + Twine('-') +
 719             EnvironmentStr).str()),
 720       Arch(parseArch(ArchStr.str())),
 721       SubArch(parseSubArch(ArchStr.str())),
 722       Vendor(parseVendor(VendorStr.str())),
 723       OS(parseOS(OSStr.str())),
 724       Environment(parseEnvironment(EnvironmentStr.str())),
 725       ObjectFormat(parseFormat(EnvironmentStr.str())) {
 726   if (ObjectFormat == Triple::UnknownObjectFormat)
 727     ObjectFormat = getDefaultFormat(*this);
 728 }
 729
 730 std::string Triple::normalize(StringRef Str) {
 731   bool IsMinGW32 = false;
 732   bool IsCygwin = false;
 733
 734   // Parse into components.
 735   SmallVector<StringRef, 4> Components;
 736   Str.split(Components, '-');
 737
 738   // If the first component corresponds to a known architecture, preferentially
 739   // use it for the architecture.  If the second component corresponds to a
 740   // known vendor, preferentially use it for the vendor, etc.  This avoids silly
 741   // component movement when a component parses as (eg) both a valid arch and a
 742   // valid os.
 743   ArchType Arch = UnknownArch;
 744   if (Components.size() > 0)
 745     Arch = parseArch(Components[0]);
 746   VendorType Vendor = UnknownVendor;
 747   if (Components.size() > 1)
 748     Vendor = parseVendor(Components[1]);
 749   OSType OS = UnknownOS;
 750   if (Components.size() > 2) {
 751     OS = parseOS(Components[2]);
 752     IsCygwin = Components[2].startswith("cygwin");
 753     IsMinGW32 = Components[2].startswith("mingw");
 754   }
 755   EnvironmentType Environment = UnknownEnvironment;
 756   if (Components.size() > 3)
 757     Environment = parseEnvironment(Components[3]);
 758   ObjectFormatType ObjectFormat = UnknownObjectFormat;
 759   if (Components.size() > 4)
 760     ObjectFormat = parseFormat(Components[4]);
 761
 762   // Note which components are already in their final position.  These will not
 763   // be moved.
 764   bool Found[4];
 765   Found[0] = Arch != UnknownArch;
 766   Found[1] = Vendor != UnknownVendor;
 767   Found[2] = OS != UnknownOS;
 768   Found[3] = Environment != UnknownEnvironment;
 769
 770   // If they are not there already, permute the components into their canonical
 771   // positions by seeing if they parse as a valid architecture, and if so moving
 772   // the component to the architecture position etc.
 773   for (unsigned Pos = 0; Pos != array_lengthof(Found); ++Pos) {
 774     if (Found[Pos])
 775       continue; // Already in the canonical position.
 776
 777     for (unsigned Idx = 0; Idx != Components.size(); ++Idx) {
 778       // Do not reparse any components that already matched.
 779       if (Idx < array_lengthof(Found) && Found[Idx])
 780         continue;
 781
 782       // Does this component parse as valid for the target position?
 783       bool Valid = false;
 784       StringRef Comp = Components[Idx];
 785       switch (Pos) {
 786       default: llvm_unreachable("unexpected component type!");
 787       case 0:
 788         Arch = parseArch(Comp);
 789         Valid = Arch != UnknownArch;
 790         break;
 791       case 1:
 792         Vendor = parseVendor(Comp);
 793         Valid = Vendor != UnknownVendor;
 794         break;
 795       case 2:
 796         OS = parseOS(Comp);
 797         IsCygwin = Comp.startswith("cygwin");
 798         IsMinGW32 = Comp.startswith("mingw");
 799         Valid = OS != UnknownOS || IsCygwin || IsMinGW32;
 800         break;
 801       case 3:
 802         Environment = parseEnvironment(Comp);
 803         Valid = Environment != UnknownEnvironment;
 804         if (!Valid) {
 805           ObjectFormat = parseFormat(Comp);
 806           Valid = ObjectFormat != UnknownObjectFormat;
 807         }
 808         break;
 809       }
 810       if (!Valid)
 811         continue; // Nope, try the next component.
 812
 813       // Move the component to the target position, pushing any non-fixed
 814       // components that are in the way to the right.  This tends to give
 815       // good results in the common cases of a forgotten vendor component
 816       // or a wrongly positioned environment.
 817       if (Pos < Idx) {
 818         // Insert left, pushing the existing components to the right.  For
 819         // example, a-b-i386 -> i386-a-b when moving i386 to the front.
 820         StringRef CurrentComponent(""); // The empty component.
 821         // Replace the component we are moving with an empty component.
 822         std::swap(CurrentComponent, Components[Idx]);
 823         // Insert the component being moved at Pos, displacing any existing
 824         // components to the right.
 825         for (unsigned i = Pos; !CurrentComponent.empty(); ++i) {
 826           // Skip over any fixed components.
 827           while (i < array_lengthof(Found) && Found[i])
 828             ++i;
 829           // Place the component at the new position, getting the component
 830           // that was at this position - it will be moved right.
 831           std::swap(CurrentComponent, Components[i]);
 832         }
 833       } else if (Pos > Idx) {
 834         // Push right by inserting empty components until the component at Idx
 835         // reaches the target position Pos.  For example, pc-a -> -pc-a when
 836         // moving pc to the second position.
 837         do {
 838           // Insert one empty component at Idx.
 839           StringRef CurrentComponent(""); // The empty component.
 840           for (unsigned i = Idx; i < Components.size();) {
 841             // Place the component at the new position, getting the component
 842             // that was at this position - it will be moved right.
 843             std::swap(CurrentComponent, Components[i]);
 844             // If it was placed on top of an empty component then we are done.
 845             if (CurrentComponent.empty())
 846               break;
 847             // Advance to the next component, skipping any fixed components.
 848             while (++i < array_lengthof(Found) && Found[i])
 849               ;
 850           }
 851           // The last component was pushed off the end - append it.
 852           if (!CurrentComponent.empty())
 853             Components.push_back(CurrentComponent);
 854
 855           // Advance Idx to the component's new position.
 856           while (++Idx < array_lengthof(Found) && Found[Idx])
 857             ;
 858         } while (Idx < Pos); // Add more until the final position is reached.
 859       }
 860       assert(Pos < Components.size() && Components[Pos] == Comp &&
 861              "Component moved wrong!");
 862       Found[Pos] = true;
 863       break;
 864     }
 865   }
 866
 867   // Special case logic goes here.  At this point Arch, Vendor and OS have the
 868   // correct values for the computed components.
 869   std::string NormalizedEnvironment;
 870   if (Environment == Triple::Android && Components[3].startswith("androideabi")) {
 871     StringRef AndroidVersion = Components[3].drop_front(strlen("androideabi"));
 872     if (AndroidVersion.empty()) {
 873       Components[3] = "android";
 874     } else {
 875       NormalizedEnvironment = Twine("android", AndroidVersion).str();
 876       Components[3] = NormalizedEnvironment;
 877     }
 878   }
 879
 880   // SUSE uses "gnueabi" to mean "gnueabihf"
 881   if (Vendor == Triple::SUSE && Environment == llvm::Triple::GNUEABI)
 882     Components[3] = "gnueabihf";
 883
 884   if (OS == Triple::Win32) {
 885     Components.resize(4);
 886     Components[2] = "windows";
 887     if (Environment == UnknownEnvironment) {
 888       if (ObjectFormat == UnknownObjectFormat || ObjectFormat == Triple::COFF)
 889         Components[3] = "msvc";
 890       else
 891         Components[3] = getObjectFormatTypeName(ObjectFormat);
 892     }
 893   } else if (IsMinGW32) {
 894     Components.resize(4);
 895     Components[2] = "windows";
 896     Components[3] = "gnu";
 897   } else if (IsCygwin) {
 898     Components.resize(4);
 899     Components[2] = "windows";
 900     Components[3] = "cygnus";
 901   }
 902   if (IsMinGW32 || IsCygwin ||
 903       (OS == Triple::Win32 && Environment != UnknownEnvironment)) {
 904     if (ObjectFormat != UnknownObjectFormat && ObjectFormat != Triple::COFF) {
 905       Components.resize(5);
 906       Components[4] = getObjectFormatTypeName(ObjectFormat);
 907     }
 908   }
 909
 910   // Stick the corrected components back together to form the normalized string.
 911   std::string Normalized;
 912   for (unsigned i = 0, e = Components.size(); i != e; ++i) {
 913     if (i) Normalized += '-';
 914     Normalized += Components[i];
 915   }
 916   return Normalized;
 917 }
 918
 919 StringRef Triple::getArchName() const {
 920   return StringRef(Data).split('-').first;           // Isolate first component
 921 }
 922
 923 StringRef Triple::getVendorName() const {
 924   StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
 925   return Tmp.split('-').first;                       // Isolate second component
 926 }
 927
 928 StringRef Triple::getOSName() const {
 929   StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
 930   Tmp = Tmp.split('-').second;                       // Strip second component
 931   return Tmp.split('-').first;                       // Isolate third component
 932 }
 933
 934 StringRef Triple::getEnvironmentName() const {
 935   StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
 936   Tmp = Tmp.split('-').second;                       // Strip second component
 937   return Tmp.split('-').second;                      // Strip third component
 938 }
 939
 940 StringRef Triple::getOSAndEnvironmentName() const {
 941   StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
 942   return Tmp.split('-').second;                      // Strip second component
 943 }
 944
 945 static unsigned EatNumber(StringRef &Str) {
 946   assert(!Str.empty() && Str[0] >= '0' && Str[0] <= '9' && "Not a number");
 947   unsigned Result = 0;
 948
 949   do {
 950     // Consume the leading digit.
 951     Result = Result*10 + (Str[0] - '0');
 952
 953     // Eat the digit.
 954     Str = Str.substr(1);
 955   } while (!Str.empty() && Str[0] >= '0' && Str[0] <= '9');
 956
 957   return Result;
 958 }
 959
 960 static void parseVersionFromName(StringRef Name, unsigned &Major,
 961                                  unsigned &Minor, unsigned &Micro) {
 962   // Any unset version defaults to 0.
 963   Major = Minor = Micro = 0;
 964
 965   // Parse up to three components.
 966   unsigned *Components[3] = {&Major, &Minor, &Micro};
 967   for (unsigned i = 0; i != 3; ++i) {
 968     if (Name.empty() || Name[0] < '0' || Name[0] > '9')
 969       break;
 970
 971     // Consume the leading number.
 972     *Components[i] = EatNumber(Name);
 973
 974     // Consume the separator, if present.
 975     if (Name.startswith("."))
 976       Name = Name.substr(1);
 977   }
 978 }
 979
 980 void Triple::getEnvironmentVersion(unsigned &Major, unsigned &Minor,
 981                                    unsigned &Micro) const {
 982   StringRef EnvironmentName = getEnvironmentName();
 983   StringRef EnvironmentTypeName = getEnvironmentTypeName(getEnvironment());
 984   if (EnvironmentName.startswith(EnvironmentTypeName))
 985     EnvironmentName = EnvironmentName.substr(EnvironmentTypeName.size());
 986
 987   parseVersionFromName(EnvironmentName, Major, Minor, Micro);
 988 }
 989
 990 void Triple::getOSVersion(unsigned &Major, unsigned &Minor,
 991                           unsigned &Micro) const {
 992   StringRef OSName = getOSName();
 993   // Assume that the OS portion of the triple starts with the canonical name.
 994   StringRef OSTypeName = getOSTypeName(getOS());
 995   if (OSName.startswith(OSTypeName))
 996     OSName = OSName.substr(OSTypeName.size());
 997   else if (getOS() == MacOSX)
 998     OSName.consume_front("macos");
 999
1000   parseVersionFromName(OSName, Major, Minor, Micro);
1001 }
1002
1003 bool Triple::getMacOSXVersion(unsigned &Major, unsigned &Minor,
1004                               unsigned &Micro) const {
1005   getOSVersion(Major, Minor, Micro);
1006
1007   switch (getOS()) {
1008   default: llvm_unreachable("unexpected OS for Darwin triple");
1009   case Darwin:
1010     // Default to darwin8, i.e., MacOSX 10.4.
1011     if (Major == 0)
1012       Major = 8;
1013     // Darwin version numbers are skewed from OS X versions.
1014     if (Major < 4)
1015       return false;
1016     Micro = 0;
1017     Minor = Major - 4;
1018     Major = 10;
1019     break;
1020   case MacOSX:
1021     // Default to 10.4.
1022     if (Major == 0) {
1023       Major = 10;
1024       Minor = 4;
1025     }
1026     if (Major != 10)
1027       return false;
1028     break;
1029   case IOS:
1030   case TvOS:
1031   case WatchOS:
1032     // Ignore the version from the triple.  This is only handled because the
1033     // the clang driver combines OS X and IOS support into a common Darwin
1034     // toolchain that wants to know the OS X version number even when targeting
1035     // IOS.
1036     Major = 10;
1037     Minor = 4;
1038     Micro = 0;
1039     break;
1040   }
1041   return true;
1042 }
1043
1044 void Triple::getiOSVersion(unsigned &Major, unsigned &Minor,
1045                            unsigned &Micro) const {
1046   switch (getOS()) {
1047   default: llvm_unreachable("unexpected OS for Darwin triple");
1048   case Darwin:
1049   case MacOSX:
1050     // Ignore the version from the triple.  This is only handled because the
1051     // the clang driver combines OS X and IOS support into a common Darwin
1052     // toolchain that wants to know the iOS version number even when targeting
1053     // OS X.
1054     Major = 5;
1055     Minor = 0;
1056     Micro = 0;
1057     break;
1058   case IOS:
1059   case TvOS:
1060     getOSVersion(Major, Minor, Micro);
1061     // Default to 5.0 (or 7.0 for arm64).
1062     if (Major == 0)
1063       Major = (getArch() == aarch64) ? 7 : 5;
1064     break;
1065   case WatchOS:
1066     llvm_unreachable("conflicting triple info");
1067   }
1068 }
1069
1070 void Triple::getWatchOSVersion(unsigned &Major, unsigned &Minor,
1071                                unsigned &Micro) const {
1072   switch (getOS()) {
1073   default: llvm_unreachable("unexpected OS for Darwin triple");
1074   case Darwin:
1075   case MacOSX:
1076     // Ignore the version from the triple.  This is only handled because the
1077     // the clang driver combines OS X and IOS support into a common Darwin
1078     // toolchain that wants to know the iOS version number even when targeting
1079     // OS X.
1080     Major = 2;
1081     Minor = 0;
1082     Micro = 0;
1083     break;
1084   case WatchOS:
1085     getOSVersion(Major, Minor, Micro);
1086     if (Major == 0)
1087       Major = 2;
1088     break;
1089   case IOS:
1090     llvm_unreachable("conflicting triple info");
1091   }
1092 }
1093
1094 void Triple::setTriple(const Twine &Str) {
1095   *this = Triple(Str);
1096 }
1097
1098 void Triple::setArch(ArchType Kind) {
1099   setArchName(getArchTypeName(Kind));
1100 }
1101
1102 void Triple::setVendor(VendorType Kind) {
1103   setVendorName(getVendorTypeName(Kind));
1104 }
1105
1106 void Triple::setOS(OSType Kind) {
1107   setOSName(getOSTypeName(Kind));
1108 }
1109
1110 void Triple::setEnvironment(EnvironmentType Kind) {
1111   if (ObjectFormat == getDefaultFormat(*this))
1112     return setEnvironmentName(getEnvironmentTypeName(Kind));
1113
1114   setEnvironmentName((getEnvironmentTypeName(Kind) + Twine("-") +
1115                       getObjectFormatTypeName(ObjectFormat)).str());
1116 }
1117
1118 void Triple::setObjectFormat(ObjectFormatType Kind) {
1119   if (Environment == UnknownEnvironment)
1120     return setEnvironmentName(getObjectFormatTypeName(Kind));
1121
1122   setEnvironmentName((getEnvironmentTypeName(Environment) + Twine("-") +
1123                       getObjectFormatTypeName(Kind)).str());
1124 }
1125
1126 void Triple::setArchName(StringRef Str) {
1127   // Work around a miscompilation bug for Twines in gcc 4.0.3.
1128   SmallString<64> Triple;
1129   Triple += Str;
1130   Triple += "-";
1131   Triple += getVendorName();
1132   Triple += "-";
1133   Triple += getOSAndEnvironmentName();
1134   setTriple(Triple);
1135 }
1136
1137 void Triple::setVendorName(StringRef Str) {
1138   setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName());
1139 }
1140
1141 void Triple::setOSName(StringRef Str) {
1142   if (hasEnvironment())
1143     setTriple(getArchName() + "-" + getVendorName() + "-" + Str +
1144               "-" + getEnvironmentName());
1145   else
1146     setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
1147 }
1148
1149 void Triple::setEnvironmentName(StringRef Str) {
1150   setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() +
1151             "-" + Str);
1152 }
1153
1154 void Triple::setOSAndEnvironmentName(StringRef Str) {
1155   setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
1156 }
1157
1158 static unsigned getArchPointerBitWidth(llvm::Triple::ArchType Arch) {
1159   switch (Arch) {
1160   case llvm::Triple::UnknownArch:
1161     return 0;
1162
1163   case llvm::Triple::avr:
1164   case llvm::Triple::msp430:
1165     return 16;
1166
1167   case llvm::Triple::arm:
1168   case llvm::Triple::armeb:
1169   case llvm::Triple::hexagon:
1170   case llvm::Triple::le32:
1171   case llvm::Triple::mips:
1172   case llvm::Triple::mipsel:
1173   case llvm::Triple::nios2:
1174   case llvm::Triple::nvptx:
1175   case llvm::Triple::ppc:
1176   case llvm::Triple::r600:
1177   case llvm::Triple::riscv32:
1178   case llvm::Triple::sparc:
1179   case llvm::Triple::sparcel:
1180   case llvm::Triple::tce:
1181   case llvm::Triple::tcele:
1182   case llvm::Triple::thumb:
1183   case llvm::Triple::thumbeb:
1184   case llvm::Triple::x86:
1185   case llvm::Triple::xcore:
1186   case llvm::Triple::amdil:
1187   case llvm::Triple::hsail:
1188   case llvm::Triple::spir:
1189   case llvm::Triple::kalimba:
1190   case llvm::Triple::lanai:
1191   case llvm::Triple::shave:
1192   case llvm::Triple::wasm32:
1193   case llvm::Triple::renderscript32:
1194     return 32;
1195
1196   case llvm::Triple::aarch64:
1197   case llvm::Triple::aarch64_be:
1198   case llvm::Triple::amdgcn:
1199   case llvm::Triple::bpfel:
1200   case llvm::Triple::bpfeb:
1201   case llvm::Triple::le64:
1202   case llvm::Triple::mips64:
1203   case llvm::Triple::mips64el:
1204   case llvm::Triple::nvptx64:
1205   case llvm::Triple::ppc64:
1206   case llvm::Triple::ppc64le:
1207   case llvm::Triple::riscv64:
1208   case llvm::Triple::sparcv9:
1209   case llvm::Triple::systemz:
1210   case llvm::Triple::x86_64:
1211   case llvm::Triple::amdil64:
1212   case llvm::Triple::hsail64:
1213   case llvm::Triple::spir64:
1214   case llvm::Triple::wasm64:
1215   case llvm::Triple::renderscript64:
1216     return 64;
1217   }
1218   llvm_unreachable("Invalid architecture value");
1219 }
1220
1221 bool Triple::isArch64Bit() const {
1222   return getArchPointerBitWidth(getArch()) == 64;
1223 }
1224
1225 bool Triple::isArch32Bit() const {
1226   return getArchPointerBitWidth(getArch()) == 32;
1227 }
1228
1229 bool Triple::isArch16Bit() const {
1230   return getArchPointerBitWidth(getArch()) == 16;
1231 }
1232
1233 Triple Triple::get32BitArchVariant() const {
1234   Triple T(*this);
1235   switch (getArch()) {
1236   case Triple::UnknownArch:
1237   case Triple::amdgcn:
1238   case Triple::avr:
1239   case Triple::bpfel:
1240   case Triple::bpfeb:
1241   case Triple::msp430:
1242   case Triple::systemz:
1243   case Triple::ppc64le:
1244     T.setArch(UnknownArch);
1245     break;
1246
1247   case Triple::amdil:
1248   case Triple::hsail:
1249   case Triple::spir:
1250   case Triple::arm:
1251   case Triple::armeb:
1252   case Triple::hexagon:
1253   case Triple::kalimba:
1254   case Triple::le32:
1255   case Triple::mips:
1256   case Triple::mipsel:
1257   case Triple::nios2:
1258   case Triple::nvptx:
1259   case Triple::ppc:
1260   case Triple::r600:
1261   case Triple::riscv32:
1262   case Triple::sparc:
1263   case Triple::sparcel:
1264   case Triple::tce:
1265   case Triple::tcele:
1266   case Triple::thumb:
1267   case Triple::thumbeb:
1268   case Triple::x86:
1269   case Triple::xcore:
1270   case Triple::lanai:
1271   case Triple::shave:
1272   case Triple::wasm32:
1273   case Triple::renderscript32:
1274     // Already 32-bit.
1275     break;
1276
1277   case Triple::aarch64:        T.setArch(Triple::arm);     break;
1278   case Triple::aarch64_be:     T.setArch(Triple::armeb);   break;
1279   case Triple::le64:           T.setArch(Triple::le32);    break;
1280   case Triple::mips64:         T.setArch(Triple::mips);    break;
1281   case Triple::mips64el:       T.setArch(Triple::mipsel);  break;
1282   case Triple::nvptx64:        T.setArch(Triple::nvptx);   break;
1283   case Triple::ppc64:          T.setArch(Triple::ppc);     break;
1284   case Triple::sparcv9:        T.setArch(Triple::sparc);   break;
1285   case Triple::riscv64:        T.setArch(Triple::riscv32); break;
1286   case Triple::x86_64:         T.setArch(Triple::x86);     break;
1287   case Triple::amdil64:        T.setArch(Triple::amdil);   break;
1288   case Triple::hsail64:        T.setArch(Triple::hsail);   break;
1289   case Triple::spir64:         T.setArch(Triple::spir);    break;
1290   case Triple::wasm64:         T.setArch(Triple::wasm32);  break;
1291   case Triple::renderscript64: T.setArch(Triple::renderscript32); break;
1292   }
1293   return T;
1294 }
1295
1296 Triple Triple::get64BitArchVariant() const {
1297   Triple T(*this);
1298   switch (getArch()) {
1299   case Triple::UnknownArch:
1300   case Triple::avr:
1301   case Triple::hexagon:
1302   case Triple::kalimba:
1303   case Triple::lanai:
1304   case Triple::msp430:
1305   case Triple::nios2:
1306   case Triple::r600:
1307   case Triple::tce:
1308   case Triple::tcele:
1309   case Triple::xcore:
1310   case Triple::sparcel:
1311   case Triple::shave:
1312     T.setArch(UnknownArch);
1313     break;
1314
1315   case Triple::aarch64:
1316   case Triple::aarch64_be:
1317   case Triple::bpfel:
1318   case Triple::bpfeb:
1319   case Triple::le64:
1320   case Triple::amdil64:
1321   case Triple::amdgcn:
1322   case Triple::hsail64:
1323   case Triple::spir64:
1324   case Triple::mips64:
1325   case Triple::mips64el:
1326   case Triple::nvptx64:
1327   case Triple::ppc64:
1328   case Triple::ppc64le:
1329   case Triple::riscv64:
1330   case Triple::sparcv9:
1331   case Triple::systemz:
1332   case Triple::x86_64:
1333   case Triple::wasm64:
1334   case Triple::renderscript64:
1335     // Already 64-bit.
1336     break;
1337
1338   case Triple::arm:             T.setArch(Triple::aarch64);    break;
1339   case Triple::armeb:           T.setArch(Triple::aarch64_be); break;
1340   case Triple::le32:            T.setArch(Triple::le64);       break;
1341   case Triple::mips:            T.setArch(Triple::mips64);     break;
1342   case Triple::mipsel:          T.setArch(Triple::mips64el);   break;
1343   case Triple::nvptx:           T.setArch(Triple::nvptx64);    break;
1344   case Triple::ppc:             T.setArch(Triple::ppc64);      break;
1345   case Triple::sparc:           T.setArch(Triple::sparcv9);    break;
1346   case Triple::riscv32:         T.setArch(Triple::riscv64);    break;
1347   case Triple::x86:             T.setArch(Triple::x86_64);     break;
1348   case Triple::amdil:           T.setArch(Triple::amdil64);    break;
1349   case Triple::hsail:           T.setArch(Triple::hsail64);    break;
1350   case Triple::spir:            T.setArch(Triple::spir64);     break;
1351   case Triple::thumb:           T.setArch(Triple::aarch64);    break;
1352   case Triple::thumbeb:         T.setArch(Triple::aarch64_be); break;
1353   case Triple::wasm32:          T.setArch(Triple::wasm64);     break;
1354   case Triple::renderscript32:  T.setArch(Triple::renderscript64);     break;
1355   }
1356   return T;
1357 }
1358
1359 Triple Triple::getBigEndianArchVariant() const {
1360   Triple T(*this);
1361   // Already big endian.
1362   if (!isLittleEndian())
1363     return T;
1364   switch (getArch()) {
1365   case Triple::UnknownArch:
1366   case Triple::amdgcn:
1367   case Triple::amdil64:
1368   case Triple::amdil:
1369   case Triple::avr:
1370   case Triple::hexagon:
1371   case Triple::hsail64:
1372   case Triple::hsail:
1373   case Triple::kalimba:
1374   case Triple::le32:
1375   case Triple::le64:
1376   case Triple::msp430:
1377   case Triple::nios2:
1378   case Triple::nvptx64:
1379   case Triple::nvptx:
1380   case Triple::r600:
1381   case Triple::riscv32:
1382   case Triple::riscv64:
1383   case Triple::shave:
1384   case Triple::spir64:
1385   case Triple::spir:
1386   case Triple::wasm32:
1387   case Triple::wasm64:
1388   case Triple::x86:
1389   case Triple::x86_64:
1390   case Triple::xcore:
1391   case Triple::renderscript32:
1392   case Triple::renderscript64:
1393
1394   // ARM is intentionally unsupported here, changing the architecture would
1395   // drop any arch suffixes.
1396   case Triple::arm:
1397   case Triple::thumb:
1398     T.setArch(UnknownArch);
1399     break;
1400
1401   case Triple::tcele:   T.setArch(Triple::tce);        break;
1402   case Triple::aarch64: T.setArch(Triple::aarch64_be); break;
1403   case Triple::bpfel:   T.setArch(Triple::bpfeb);      break;
1404   case Triple::mips64el:T.setArch(Triple::mips64);     break;
1405   case Triple::mipsel:  T.setArch(Triple::mips);       break;
1406   case Triple::ppc64le: T.setArch(Triple::ppc64);      break;
1407   case Triple::sparcel: T.setArch(Triple::sparc);      break;
1408   default:
1409     llvm_unreachable("getBigEndianArchVariant: unknown triple.");
1410   }
1411   return T;
1412 }
1413
1414 Triple Triple::getLittleEndianArchVariant() const {
1415   Triple T(*this);
1416   if (isLittleEndian())
1417     return T;
1418
1419   switch (getArch()) {
1420   case Triple::UnknownArch:
1421   case Triple::lanai:
1422   case Triple::ppc:
1423   case Triple::sparcv9:
1424   case Triple::systemz:
1425
1426   // ARM is intentionally unsupported here, changing the architecture would
1427   // drop any arch suffixes.
1428   case Triple::armeb:
1429   case Triple::thumbeb:
1430     T.setArch(UnknownArch);
1431     break;
1432
1433   case Triple::tce:        T.setArch(Triple::tcele);    break;
1434   case Triple::aarch64_be: T.setArch(Triple::aarch64);  break;
1435   case Triple::bpfeb:      T.setArch(Triple::bpfel);    break;
1436   case Triple::mips64:     T.setArch(Triple::mips64el); break;
1437   case Triple::mips:       T.setArch(Triple::mipsel);   break;
1438   case Triple::ppc64:      T.setArch(Triple::ppc64le);  break;
1439   case Triple::sparc:      T.setArch(Triple::sparcel);  break;
1440   default:
1441     llvm_unreachable("getLittleEndianArchVariant: unknown triple.");
1442   }
1443   return T;
1444 }
1445
1446 bool Triple::isLittleEndian() const {
1447   switch (getArch()) {
1448   case Triple::aarch64:
1449   case Triple::amdgcn:
1450   case Triple::amdil64:
1451   case Triple::amdil:
1452   case Triple::arm:
1453   case Triple::avr:
1454   case Triple::bpfel:
1455   case Triple::hexagon:
1456   case Triple::hsail64:
1457   case Triple::hsail:
1458   case Triple::kalimba:
1459   case Triple::le32:
1460   case Triple::le64:
1461   case Triple::mips64el:
1462   case Triple::mipsel:
1463   case Triple::msp430:
1464   case Triple::nios2:
1465   case Triple::nvptx64:
1466   case Triple::nvptx:
1467   case Triple::ppc64le:
1468   case Triple::r600:
1469   case Triple::riscv32:
1470   case Triple::riscv64:
1471   case Triple::shave:
1472   case Triple::sparcel:
1473   case Triple::spir64:
1474   case Triple::spir:
1475   case Triple::thumb:
1476   case Triple::wasm32:
1477   case Triple::wasm64:
1478   case Triple::x86:
1479   case Triple::x86_64:
1480   case Triple::xcore:
1481   case Triple::tcele:
1482   case Triple::renderscript32:
1483   case Triple::renderscript64:
1484     return true;
1485   default:
1486     return false;
1487   }
1488 }
1489
1490 bool Triple::isCompatibleWith(const Triple &Other) const {
1491   // If vendor is apple, ignore the version number.
1492   if (getVendor() == Triple::Apple)
1493     return getArch() == Other.getArch() && getSubArch() == Other.getSubArch() &&
1494            getVendor() == Other.getVendor() && getOS() == Other.getOS();
1495
1496   return *this == Other;
1497 }
1498
1499 std::string Triple::merge(const Triple &Other) const {
1500   // If vendor is apple, pick the triple with the larger version number.
1501   if (getVendor() == Triple::Apple)
1502     if (Other.isOSVersionLT(*this))
1503       return str();
1504
1505   return Other.str();
1506 }
1507
1508 StringRef Triple::getARMCPUForArch(StringRef MArch) const {
1509   if (MArch.empty())
1510     MArch = getArchName();
1511   MArch = ARM::getCanonicalArchName(MArch);
1512
1513   // Some defaults are forced.
1514   switch (getOS()) {
1515   case llvm::Triple::FreeBSD:
1516   case llvm::Triple::NetBSD:
1517     if (!MArch.empty() && MArch == "v6")
1518       return "arm1176jzf-s";
1519     break;
1520   case llvm::Triple::Win32:
1521     // FIXME: this is invalid for WindowsCE
1522     return "cortex-a9";
1523   case llvm::Triple::MacOSX:
1524   case llvm::Triple::IOS:
1525   case llvm::Triple::WatchOS:
1526   case llvm::Triple::TvOS:
1527     if (MArch == "v7k")
1528       return "cortex-a7";
1529     break;
1530   default:
1531     break;
1532   }
1533
1534   if (MArch.empty())
1535     return StringRef();
1536
1537   StringRef CPU = ARM::getDefaultCPU(MArch);
1538   if (!CPU.empty())
1539     return CPU;
1540
1541   // If no specific architecture version is requested, return the minimum CPU
1542   // required by the OS and environment.
1543   switch (getOS()) {
1544   case llvm::Triple::NetBSD:
1545     switch (getEnvironment()) {
1546     case llvm::Triple::GNUEABIHF:
1547     case llvm::Triple::GNUEABI:
1548     case llvm::Triple::EABIHF:
1549     case llvm::Triple::EABI:
1550       return "arm926ej-s";
1551     default:
1552       return "strongarm";
1553     }
1554   case llvm::Triple::NaCl:
1555   case llvm::Triple::OpenBSD:
1556     return "cortex-a8";
1557   default:
1558     switch (getEnvironment()) {
1559     case llvm::Triple::EABIHF:
1560     case llvm::Triple::GNUEABIHF:
1561     case llvm::Triple::MuslEABIHF:
1562       return "arm1176jzf-s";
1563     default:
1564       return "arm7tdmi";
1565     }
1566   }
1567
1568   llvm_unreachable("invalid arch name");
1569 }