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()), Arch(UnknownArch), SubArch(NoSubArch),
 576       Vendor(UnknownVendor), OS(UnknownOS), Environment(UnknownEnvironment),
 577       ObjectFormat(UnknownObjectFormat) {
 578   // Do minimal parsing by hand here.
 579   SmallVector<StringRef, 4> Components;
 580   StringRef(Data).split(Components, '-', /*MaxSplit*/ 3);
 581   if (Components.size() > 0) {
 582     Arch = parseArch(Components[0]);
 583     SubArch = parseSubArch(Components[0]);
 584     if (Components.size() > 1) {
 585       Vendor = parseVendor(Components[1]);
 586       if (Components.size() > 2) {
 587         OS = parseOS(Components[2]);
 588         if (Components.size() > 3) {
 589           Environment = parseEnvironment(Components[3]);
 590           ObjectFormat = parseFormat(Components[3]);
 591         }
 592       }
 593     }
 594   }
 595   if (ObjectFormat == UnknownObjectFormat)
 596     ObjectFormat = getDefaultFormat(*this);
 597 }
 598
 599 /// \brief Construct a triple from string representations of the architecture,
 600 /// vendor, and OS.
 601 ///
 602 /// This joins each argument into a canonical string representation and parses
 603 /// them into enum members. It leaves the environment unknown and omits it from
 604 /// the string representation.
 605 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr)
 606     : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr).str()),
 607       Arch(parseArch(ArchStr.str())),
 608       SubArch(parseSubArch(ArchStr.str())),
 609       Vendor(parseVendor(VendorStr.str())),
 610       OS(parseOS(OSStr.str())),
 611       Environment(), ObjectFormat(Triple::UnknownObjectFormat) {
 612   ObjectFormat = getDefaultFormat(*this);
 613 }
 614
 615 /// \brief Construct a triple from string representations of the architecture,
 616 /// vendor, OS, and environment.
 617 ///
 618 /// This joins each argument into a canonical string representation and parses
 619 /// them into enum members.
 620 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr,
 621                const Twine &EnvironmentStr)
 622     : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr + Twine('-') +
 623             EnvironmentStr).str()),
 624       Arch(parseArch(ArchStr.str())),
 625       SubArch(parseSubArch(ArchStr.str())),
 626       Vendor(parseVendor(VendorStr.str())),
 627       OS(parseOS(OSStr.str())),
 628       Environment(parseEnvironment(EnvironmentStr.str())),
 629       ObjectFormat(parseFormat(EnvironmentStr.str())) {
 630   if (ObjectFormat == Triple::UnknownObjectFormat)
 631     ObjectFormat = getDefaultFormat(*this);
 632 }
 633
 634 std::string Triple::normalize(StringRef Str) {
 635   bool IsMinGW32 = false;
 636   bool IsCygwin = false;
 637
 638   // Parse into components.
 639   SmallVector<StringRef, 4> Components;
 640   Str.split(Components, '-');
 641
 642   // If the first component corresponds to a known architecture, preferentially
 643   // use it for the architecture.  If the second component corresponds to a
 644   // known vendor, preferentially use it for the vendor, etc.  This avoids silly
 645   // component movement when a component parses as (eg) both a valid arch and a
 646   // valid os.
 647   ArchType Arch = UnknownArch;
 648   if (Components.size() > 0)
 649     Arch = parseArch(Components[0]);
 650   VendorType Vendor = UnknownVendor;
 651   if (Components.size() > 1)
 652     Vendor = parseVendor(Components[1]);
 653   OSType OS = UnknownOS;
 654   if (Components.size() > 2) {
 655     OS = parseOS(Components[2]);
 656     IsCygwin = Components[2].startswith("cygwin");
 657     IsMinGW32 = Components[2].startswith("mingw");
 658   }
 659   EnvironmentType Environment = UnknownEnvironment;
 660   if (Components.size() > 3)
 661     Environment = parseEnvironment(Components[3]);
 662   ObjectFormatType ObjectFormat = UnknownObjectFormat;
 663   if (Components.size() > 4)
 664     ObjectFormat = parseFormat(Components[4]);
 665
 666   // Note which components are already in their final position.  These will not
 667   // be moved.
 668   bool Found[4];
 669   Found[0] = Arch != UnknownArch;
 670   Found[1] = Vendor != UnknownVendor;
 671   Found[2] = OS != UnknownOS;
 672   Found[3] = Environment != UnknownEnvironment;
 673
 674   // If they are not there already, permute the components into their canonical
 675   // positions by seeing if they parse as a valid architecture, and if so moving
 676   // the component to the architecture position etc.
 677   for (unsigned Pos = 0; Pos != array_lengthof(Found); ++Pos) {
 678     if (Found[Pos])
 679       continue; // Already in the canonical position.
 680
 681     for (unsigned Idx = 0; Idx != Components.size(); ++Idx) {
 682       // Do not reparse any components that already matched.
 683       if (Idx < array_lengthof(Found) && Found[Idx])
 684         continue;
 685
 686       // Does this component parse as valid for the target position?
 687       bool Valid = false;
 688       StringRef Comp = Components[Idx];
 689       switch (Pos) {
 690       default: llvm_unreachable("unexpected component type!");
 691       case 0:
 692         Arch = parseArch(Comp);
 693         Valid = Arch != UnknownArch;
 694         break;
 695       case 1:
 696         Vendor = parseVendor(Comp);
 697         Valid = Vendor != UnknownVendor;
 698         break;
 699       case 2:
 700         OS = parseOS(Comp);
 701         IsCygwin = Comp.startswith("cygwin");
 702         IsMinGW32 = Comp.startswith("mingw");
 703         Valid = OS != UnknownOS || IsCygwin || IsMinGW32;
 704         break;
 705       case 3:
 706         Environment = parseEnvironment(Comp);
 707         Valid = Environment != UnknownEnvironment;
 708         if (!Valid) {
 709           ObjectFormat = parseFormat(Comp);
 710           Valid = ObjectFormat != UnknownObjectFormat;
 711         }
 712         break;
 713       }
 714       if (!Valid)
 715         continue; // Nope, try the next component.
 716
 717       // Move the component to the target position, pushing any non-fixed
 718       // components that are in the way to the right.  This tends to give
 719       // good results in the common cases of a forgotten vendor component
 720       // or a wrongly positioned environment.
 721       if (Pos < Idx) {
 722         // Insert left, pushing the existing components to the right.  For
 723         // example, a-b-i386 -> i386-a-b when moving i386 to the front.
 724         StringRef CurrentComponent(""); // The empty component.
 725         // Replace the component we are moving with an empty component.
 726         std::swap(CurrentComponent, Components[Idx]);
 727         // Insert the component being moved at Pos, displacing any existing
 728         // components to the right.
 729         for (unsigned i = Pos; !CurrentComponent.empty(); ++i) {
 730           // Skip over any fixed components.
 731           while (i < array_lengthof(Found) && Found[i])
 732             ++i;
 733           // Place the component at the new position, getting the component
 734           // that was at this position - it will be moved right.
 735           std::swap(CurrentComponent, Components[i]);
 736         }
 737       } else if (Pos > Idx) {
 738         // Push right by inserting empty components until the component at Idx
 739         // reaches the target position Pos.  For example, pc-a -> -pc-a when
 740         // moving pc to the second position.
 741         do {
 742           // Insert one empty component at Idx.
 743           StringRef CurrentComponent(""); // The empty component.
 744           for (unsigned i = Idx; i < Components.size();) {
 745             // Place the component at the new position, getting the component
 746             // that was at this position - it will be moved right.
 747             std::swap(CurrentComponent, Components[i]);
 748             // If it was placed on top of an empty component then we are done.
 749             if (CurrentComponent.empty())
 750               break;
 751             // Advance to the next component, skipping any fixed components.
 752             while (++i < array_lengthof(Found) && Found[i])
 753               ;
 754           }
 755           // The last component was pushed off the end - append it.
 756           if (!CurrentComponent.empty())
 757             Components.push_back(CurrentComponent);
 758
 759           // Advance Idx to the component's new position.
 760           while (++Idx < array_lengthof(Found) && Found[Idx])
 761             ;
 762         } while (Idx < Pos); // Add more until the final position is reached.
 763       }
 764       assert(Pos < Components.size() && Components[Pos] == Comp &&
 765              "Component moved wrong!");
 766       Found[Pos] = true;
 767       break;
 768     }
 769   }
 770
 771   // Special case logic goes here.  At this point Arch, Vendor and OS have the
 772   // correct values for the computed components.
 773   std::string NormalizedEnvironment;
 774   if (Environment == Triple::Android && Components[3].startswith("androideabi")) {
 775     StringRef AndroidVersion = Components[3].drop_front(strlen("androideabi"));
 776     if (AndroidVersion.empty()) {
 777       Components[3] = "android";
 778     } else {
 779       NormalizedEnvironment = Twine("android", AndroidVersion).str();
 780       Components[3] = NormalizedEnvironment;
 781     }
 782   }
 783
 784   if (OS == Triple::Win32) {
 785     Components.resize(4);
 786     Components[2] = "windows";
 787     if (Environment == UnknownEnvironment) {
 788       if (ObjectFormat == UnknownObjectFormat || ObjectFormat == Triple::COFF)
 789         Components[3] = "msvc";
 790       else
 791         Components[3] = getObjectFormatTypeName(ObjectFormat);
 792     }
 793   } else if (IsMinGW32) {
 794     Components.resize(4);
 795     Components[2] = "windows";
 796     Components[3] = "gnu";
 797   } else if (IsCygwin) {
 798     Components.resize(4);
 799     Components[2] = "windows";
 800     Components[3] = "cygnus";
 801   }
 802   if (IsMinGW32 || IsCygwin ||
 803       (OS == Triple::Win32 && Environment != UnknownEnvironment)) {
 804     if (ObjectFormat != UnknownObjectFormat && ObjectFormat != Triple::COFF) {
 805       Components.resize(5);
 806       Components[4] = getObjectFormatTypeName(ObjectFormat);
 807     }
 808   }
 809
 810   // Stick the corrected components back together to form the normalized string.
 811   std::string Normalized;
 812   for (unsigned i = 0, e = Components.size(); i != e; ++i) {
 813     if (i) Normalized += '-';
 814     Normalized += Components[i];
 815   }
 816   return Normalized;
 817 }
 818
 819 StringRef Triple::getArchName() const {
 820   return StringRef(Data).split('-').first;           // Isolate first component
 821 }
 822
 823 StringRef Triple::getVendorName() const {
 824   StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
 825   return Tmp.split('-').first;                       // Isolate second component
 826 }
 827
 828 StringRef Triple::getOSName() const {
 829   StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
 830   Tmp = Tmp.split('-').second;                       // Strip second component
 831   return Tmp.split('-').first;                       // Isolate third component
 832 }
 833
 834 StringRef Triple::getEnvironmentName() const {
 835   StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
 836   Tmp = Tmp.split('-').second;                       // Strip second component
 837   return Tmp.split('-').second;                      // Strip third component
 838 }
 839
 840 StringRef Triple::getOSAndEnvironmentName() const {
 841   StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
 842   return Tmp.split('-').second;                      // Strip second component
 843 }
 844
 845 static unsigned EatNumber(StringRef &Str) {
 846   assert(!Str.empty() && Str[0] >= '0' && Str[0] <= '9' && "Not a number");
 847   unsigned Result = 0;
 848
 849   do {
 850     // Consume the leading digit.
 851     Result = Result*10 + (Str[0] - '0');
 852
 853     // Eat the digit.
 854     Str = Str.substr(1);
 855   } while (!Str.empty() && Str[0] >= '0' && Str[0] <= '9');
 856
 857   return Result;
 858 }
 859
 860 static void parseVersionFromName(StringRef Name, unsigned &Major,
 861                                  unsigned &Minor, unsigned &Micro) {
 862   // Any unset version defaults to 0.
 863   Major = Minor = Micro = 0;
 864
 865   // Parse up to three components.
 866   unsigned *Components[3] = {&Major, &Minor, &Micro};
 867   for (unsigned i = 0; i != 3; ++i) {
 868     if (Name.empty() || Name[0] < '0' || Name[0] > '9')
 869       break;
 870
 871     // Consume the leading number.
 872     *Components[i] = EatNumber(Name);
 873
 874     // Consume the separator, if present.
 875     if (Name.startswith("."))
 876       Name = Name.substr(1);
 877   }
 878 }
 879
 880 void Triple::getEnvironmentVersion(unsigned &Major, unsigned &Minor,
 881                                    unsigned &Micro) const {
 882   StringRef EnvironmentName = getEnvironmentName();
 883   StringRef EnvironmentTypeName = getEnvironmentTypeName(getEnvironment());
 884   if (EnvironmentName.startswith(EnvironmentTypeName))
 885     EnvironmentName = EnvironmentName.substr(EnvironmentTypeName.size());
 886
 887   parseVersionFromName(EnvironmentName, Major, Minor, Micro);
 888 }
 889
 890 void Triple::getOSVersion(unsigned &Major, unsigned &Minor,
 891                           unsigned &Micro) const {
 892   StringRef OSName = getOSName();
 893   // Assume that the OS portion of the triple starts with the canonical name.
 894   StringRef OSTypeName = getOSTypeName(getOS());
 895   if (OSName.startswith(OSTypeName))
 896     OSName = OSName.substr(OSTypeName.size());
 897
 898   parseVersionFromName(OSName, Major, Minor, Micro);
 899 }
 900
 901 bool Triple::getMacOSXVersion(unsigned &Major, unsigned &Minor,
 902                               unsigned &Micro) const {
 903   getOSVersion(Major, Minor, Micro);
 904
 905   switch (getOS()) {
 906   default: llvm_unreachable("unexpected OS for Darwin triple");
 907   case Darwin:
 908     // Default to darwin8, i.e., MacOSX 10.4.
 909     if (Major == 0)
 910       Major = 8;
 911     // Darwin version numbers are skewed from OS X versions.
 912     if (Major < 4)
 913       return false;
 914     Micro = 0;
 915     Minor = Major - 4;
 916     Major = 10;
 917     break;
 918   case MacOSX:
 919     // Default to 10.4.
 920     if (Major == 0) {
 921       Major = 10;
 922       Minor = 4;
 923     }
 924     if (Major != 10)
 925       return false;
 926     break;
 927   case IOS:
 928     // Ignore the version from the triple.  This is only handled because the
 929     // the clang driver combines OS X and IOS support into a common Darwin
 930     // toolchain that wants to know the OS X version number even when targeting
 931     // IOS.
 932     Major = 10;
 933     Minor = 4;
 934     Micro = 0;
 935     break;
 936   }
 937   return true;
 938 }
 939
 940 void Triple::getiOSVersion(unsigned &Major, unsigned &Minor,
 941                            unsigned &Micro) const {
 942   switch (getOS()) {
 943   default: llvm_unreachable("unexpected OS for Darwin triple");
 944   case Darwin:
 945   case MacOSX:
 946     // Ignore the version from the triple.  This is only handled because the
 947     // the clang driver combines OS X and IOS support into a common Darwin
 948     // toolchain that wants to know the iOS version number even when targeting
 949     // OS X.
 950     Major = 5;
 951     Minor = 0;
 952     Micro = 0;
 953     break;
 954   case IOS:
 955     getOSVersion(Major, Minor, Micro);
 956     // Default to 5.0 (or 7.0 for arm64).
 957     if (Major == 0)
 958       Major = (getArch() == aarch64) ? 7 : 5;
 959     break;
 960   }
 961 }
 962
 963 void Triple::setTriple(const Twine &Str) {
 964   *this = Triple(Str);
 965 }
 966
 967 void Triple::setArch(ArchType Kind) {
 968   setArchName(getArchTypeName(Kind));
 969 }
 970
 971 void Triple::setVendor(VendorType Kind) {
 972   setVendorName(getVendorTypeName(Kind));
 973 }
 974
 975 void Triple::setOS(OSType Kind) {
 976   setOSName(getOSTypeName(Kind));
 977 }
 978
 979 void Triple::setEnvironment(EnvironmentType Kind) {
 980   if (ObjectFormat == getDefaultFormat(*this))
 981     return setEnvironmentName(getEnvironmentTypeName(Kind));
 982
 983   setEnvironmentName((getEnvironmentTypeName(Kind) + Twine("-") +
 984                       getObjectFormatTypeName(ObjectFormat)).str());
 985 }
 986
 987 void Triple::setObjectFormat(ObjectFormatType Kind) {
 988   if (Environment == UnknownEnvironment)
 989     return setEnvironmentName(getObjectFormatTypeName(Kind));
 990
 991   setEnvironmentName((getEnvironmentTypeName(Environment) + Twine("-") +
 992                       getObjectFormatTypeName(Kind)).str());
 993 }
 994
 995 void Triple::setArchName(StringRef Str) {
 996   // Work around a miscompilation bug for Twines in gcc 4.0.3.
 997   SmallString<64> Triple;
 998   Triple += Str;
 999   Triple += "-";
1000   Triple += getVendorName();
1001   Triple += "-";
1002   Triple += getOSAndEnvironmentName();
1003   setTriple(Triple);
1004 }
1005
1006 void Triple::setVendorName(StringRef Str) {
1007   setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName());
1008 }
1009
1010 void Triple::setOSName(StringRef Str) {
1011   if (hasEnvironment())
1012     setTriple(getArchName() + "-" + getVendorName() + "-" + Str +
1013               "-" + getEnvironmentName());
1014   else
1015     setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
1016 }
1017
1018 void Triple::setEnvironmentName(StringRef Str) {
1019   setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() +
1020             "-" + Str);
1021 }
1022
1023 void Triple::setOSAndEnvironmentName(StringRef Str) {
1024   setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
1025 }
1026
1027 static unsigned getArchPointerBitWidth(llvm::Triple::ArchType Arch) {
1028   switch (Arch) {
1029   case llvm::Triple::UnknownArch:
1030     return 0;
1031
1032   case llvm::Triple::msp430:
1033     return 16;
1034
1035   case llvm::Triple::arm:
1036   case llvm::Triple::armeb:
1037   case llvm::Triple::hexagon:
1038   case llvm::Triple::le32:
1039   case llvm::Triple::mips:
1040   case llvm::Triple::mipsel:
1041   case llvm::Triple::nvptx:
1042   case llvm::Triple::ppc:
1043   case llvm::Triple::r600:
1044   case llvm::Triple::sparc:
1045   case llvm::Triple::sparcel:
1046   case llvm::Triple::tce:
1047   case llvm::Triple::thumb:
1048   case llvm::Triple::thumbeb:
1049   case llvm::Triple::x86:
1050   case llvm::Triple::xcore:
1051   case llvm::Triple::amdil:
1052   case llvm::Triple::hsail:
1053   case llvm::Triple::spir:
1054   case llvm::Triple::kalimba:
1055   case llvm::Triple::shave:
1056   case llvm::Triple::wasm32:
1057     return 32;
1058
1059   case llvm::Triple::aarch64:
1060   case llvm::Triple::aarch64_be:
1061   case llvm::Triple::amdgcn:
1062   case llvm::Triple::bpfel:
1063   case llvm::Triple::bpfeb:
1064   case llvm::Triple::le64:
1065   case llvm::Triple::mips64:
1066   case llvm::Triple::mips64el:
1067   case llvm::Triple::nvptx64:
1068   case llvm::Triple::ppc64:
1069   case llvm::Triple::ppc64le:
1070   case llvm::Triple::sparcv9:
1071   case llvm::Triple::systemz:
1072   case llvm::Triple::x86_64:
1073   case llvm::Triple::amdil64:
1074   case llvm::Triple::hsail64:
1075   case llvm::Triple::spir64:
1076   case llvm::Triple::wasm64:
1077     return 64;
1078   }
1079   llvm_unreachable("Invalid architecture value");
1080 }
1081
1082 bool Triple::isArch64Bit() const {
1083   return getArchPointerBitWidth(getArch()) == 64;
1084 }
1085
1086 bool Triple::isArch32Bit() const {
1087   return getArchPointerBitWidth(getArch()) == 32;
1088 }
1089
1090 bool Triple::isArch16Bit() const {
1091   return getArchPointerBitWidth(getArch()) == 16;
1092 }
1093
1094 Triple Triple::get32BitArchVariant() const {
1095   Triple T(*this);
1096   switch (getArch()) {
1097   case Triple::UnknownArch:
1098   case Triple::aarch64:
1099   case Triple::aarch64_be:
1100   case Triple::amdgcn:
1101   case Triple::bpfel:
1102   case Triple::bpfeb:
1103   case Triple::msp430:
1104   case Triple::systemz:
1105   case Triple::ppc64le:
1106     T.setArch(UnknownArch);
1107     break;
1108
1109   case Triple::amdil:
1110   case Triple::hsail:
1111   case Triple::spir:
1112   case Triple::arm:
1113   case Triple::armeb:
1114   case Triple::hexagon:
1115   case Triple::kalimba:
1116   case Triple::le32:
1117   case Triple::mips:
1118   case Triple::mipsel:
1119   case Triple::nvptx:
1120   case Triple::ppc:
1121   case Triple::r600:
1122   case Triple::sparc:
1123   case Triple::sparcel:
1124   case Triple::tce:
1125   case Triple::thumb:
1126   case Triple::thumbeb:
1127   case Triple::x86:
1128   case Triple::xcore:
1129   case Triple::shave:
1130   case Triple::wasm32:
1131     // Already 32-bit.
1132     break;
1133
1134   case Triple::le64:      T.setArch(Triple::le32);    break;
1135   case Triple::mips64:    T.setArch(Triple::mips);    break;
1136   case Triple::mips64el:  T.setArch(Triple::mipsel);  break;
1137   case Triple::nvptx64:   T.setArch(Triple::nvptx);   break;
1138   case Triple::ppc64:     T.setArch(Triple::ppc);     break;
1139   case Triple::sparcv9:   T.setArch(Triple::sparc);   break;
1140   case Triple::x86_64:    T.setArch(Triple::x86);     break;
1141   case Triple::amdil64:   T.setArch(Triple::amdil);   break;
1142   case Triple::hsail64:   T.setArch(Triple::hsail);   break;
1143   case Triple::spir64:    T.setArch(Triple::spir);    break;
1144   case Triple::wasm64:    T.setArch(Triple::wasm32);  break;
1145   }
1146   return T;
1147 }
1148
1149 Triple Triple::get64BitArchVariant() const {
1150   Triple T(*this);
1151   switch (getArch()) {
1152   case Triple::UnknownArch:
1153   case Triple::arm:
1154   case Triple::armeb:
1155   case Triple::hexagon:
1156   case Triple::kalimba:
1157   case Triple::msp430:
1158   case Triple::r600:
1159   case Triple::tce:
1160   case Triple::thumb:
1161   case Triple::thumbeb:
1162   case Triple::xcore:
1163   case Triple::sparcel:
1164   case Triple::shave:
1165     T.setArch(UnknownArch);
1166     break;
1167
1168   case Triple::aarch64:
1169   case Triple::aarch64_be:
1170   case Triple::bpfel:
1171   case Triple::bpfeb:
1172   case Triple::le64:
1173   case Triple::amdil64:
1174   case Triple::amdgcn:
1175   case Triple::hsail64:
1176   case Triple::spir64:
1177   case Triple::mips64:
1178   case Triple::mips64el:
1179   case Triple::nvptx64:
1180   case Triple::ppc64:
1181   case Triple::ppc64le:
1182   case Triple::sparcv9:
1183   case Triple::systemz:
1184   case Triple::x86_64:
1185   case Triple::wasm64:
1186     // Already 64-bit.
1187     break;
1188
1189   case Triple::le32:    T.setArch(Triple::le64);      break;
1190   case Triple::mips:    T.setArch(Triple::mips64);    break;
1191   case Triple::mipsel:  T.setArch(Triple::mips64el);  break;
1192   case Triple::nvptx:   T.setArch(Triple::nvptx64);   break;
1193   case Triple::ppc:     T.setArch(Triple::ppc64);     break;
1194   case Triple::sparc:   T.setArch(Triple::sparcv9);   break;
1195   case Triple::x86:     T.setArch(Triple::x86_64);    break;
1196   case Triple::amdil:   T.setArch(Triple::amdil64);   break;
1197   case Triple::hsail:   T.setArch(Triple::hsail64);   break;
1198   case Triple::spir:    T.setArch(Triple::spir64);    break;
1199   case Triple::wasm32:  T.setArch(Triple::wasm64);    break;
1200   }
1201   return T;
1202 }
1203
1204 Triple Triple::getBigEndianArchVariant() const {
1205   Triple T(*this);
1206   switch (getArch()) {
1207   case Triple::UnknownArch:
1208   case Triple::amdgcn:
1209   case Triple::amdil64:
1210   case Triple::amdil:
1211   case Triple::hexagon:
1212   case Triple::hsail64:
1213   case Triple::hsail:
1214   case Triple::kalimba:
1215   case Triple::le32:
1216   case Triple::le64:
1217   case Triple::msp430:
1218   case Triple::nvptx64:
1219   case Triple::nvptx:
1220   case Triple::r600:
1221   case Triple::shave:
1222   case Triple::spir64:
1223   case Triple::spir:
1224   case Triple::wasm32:
1225   case Triple::wasm64:
1226   case Triple::x86:
1227   case Triple::x86_64:
1228   case Triple::xcore:
1229
1230   // ARM is intentionally unsupported here, changing the architecture would
1231   // drop any arch suffixes.
1232   case Triple::arm:
1233   case Triple::thumb:
1234     T.setArch(UnknownArch);
1235     break;
1236
1237   case Triple::aarch64_be:
1238   case Triple::armeb:
1239   case Triple::bpfeb:
1240   case Triple::mips64:
1241   case Triple::mips:
1242   case Triple::ppc64:
1243   case Triple::ppc:
1244   case Triple::sparc:
1245   case Triple::sparcv9:
1246   case Triple::systemz:
1247   case Triple::tce:
1248   case Triple::thumbeb:
1249     // Already big endian.
1250     break;
1251
1252   case Triple::aarch64: T.setArch(Triple::aarch64_be); break;
1253   case Triple::bpfel:   T.setArch(Triple::bpfeb);      break;
1254   case Triple::mips64el:T.setArch(Triple::mips64);     break;
1255   case Triple::mipsel:  T.setArch(Triple::mips);       break;
1256   case Triple::ppc64le: T.setArch(Triple::ppc64);      break;
1257   case Triple::sparcel: T.setArch(Triple::sparc);      break;
1258   }
1259   return T;
1260 }
1261
1262 Triple Triple::getLittleEndianArchVariant() const {
1263   Triple T(*this);
1264   switch (getArch()) {
1265   case Triple::UnknownArch:
1266   case Triple::ppc:
1267   case Triple::sparcv9:
1268   case Triple::systemz:
1269   case Triple::tce:
1270
1271   // ARM is intentionally unsupported here, changing the architecture would
1272   // drop any arch suffixes.
1273   case Triple::armeb:
1274   case Triple::thumbeb:
1275     T.setArch(UnknownArch);
1276     break;
1277
1278   case Triple::aarch64:
1279   case Triple::amdgcn:
1280   case Triple::amdil64:
1281   case Triple::amdil:
1282   case Triple::arm:
1283   case Triple::bpfel:
1284   case Triple::hexagon:
1285   case Triple::hsail64:
1286   case Triple::hsail:
1287   case Triple::kalimba:
1288   case Triple::le32:
1289   case Triple::le64:
1290   case Triple::mips64el:
1291   case Triple::mipsel:
1292   case Triple::msp430:
1293   case Triple::nvptx64:
1294   case Triple::nvptx:
1295   case Triple::ppc64le:
1296   case Triple::r600:
1297   case Triple::shave:
1298   case Triple::sparcel:
1299   case Triple::spir64:
1300   case Triple::spir:
1301   case Triple::thumb:
1302   case Triple::wasm32:
1303   case Triple::wasm64:
1304   case Triple::x86:
1305   case Triple::x86_64:
1306   case Triple::xcore:
1307     // Already little endian.
1308     break;
1309
1310   case Triple::aarch64_be: T.setArch(Triple::aarch64);  break;
1311   case Triple::bpfeb:      T.setArch(Triple::bpfel);    break;
1312   case Triple::mips64:     T.setArch(Triple::mips64el); break;
1313   case Triple::mips:       T.setArch(Triple::mipsel);   break;
1314   case Triple::ppc64:      T.setArch(Triple::ppc64le);  break;
1315   case Triple::sparc:      T.setArch(Triple::sparcel);  break;
1316   }
1317   return T;
1318 }
1319
1320 StringRef Triple::getARMCPUForArch(StringRef MArch) const {
1321   if (MArch.empty())
1322     MArch = getArchName();
1323   MArch = ARM::getCanonicalArchName(MArch);
1324
1325   // Some defaults are forced.
1326   switch (getOS()) {
1327   case llvm::Triple::FreeBSD:
1328   case llvm::Triple::NetBSD:
1329     if (!MArch.empty() && MArch == "v6")
1330       return "arm1176jzf-s";
1331     break;
1332   case llvm::Triple::Win32:
1333     // FIXME: this is invalid for WindowsCE
1334     return "cortex-a9";
1335   default:
1336     break;
1337   }
1338
1339   if (MArch.empty())
1340     return StringRef();
1341
1342   StringRef CPU = ARM::getDefaultCPU(MArch);
1343   if (!CPU.empty())
1344     return CPU;
1345
1346   // If no specific architecture version is requested, return the minimum CPU
1347   // required by the OS and environment.
1348   switch (getOS()) {
1349   case llvm::Triple::NetBSD:
1350     switch (getEnvironment()) {
1351     case llvm::Triple::GNUEABIHF:
1352     case llvm::Triple::GNUEABI:
1353     case llvm::Triple::EABIHF:
1354     case llvm::Triple::EABI:
1355       return "arm926ej-s";
1356     default:
1357       return "strongarm";
1358     }
1359   case llvm::Triple::NaCl:
1360     return "cortex-a8";
1361   default:
1362     switch (getEnvironment()) {
1363     case llvm::Triple::EABIHF:
1364     case llvm::Triple::GNUEABIHF:
1365       return "arm1176jzf-s";
1366     default:
1367       return "arm7tdmi";
1368     }
1369   }
1370
1371   llvm_unreachable("invalid arch name");
1372 }