lib/Support/Triple.cpp

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