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