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