lib/Support/Triple.cpp

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