lib/Support/Triple.cpp

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