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