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