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