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