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