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   case WatchOS:
 962     // Ignore the version from the triple.  This is only handled because the
 963     // the clang driver combines OS X and IOS support into a common Darwin
 964     // toolchain that wants to know the iOS version number even when targeting
 965     // OS X.
 966     Major = 5;
 967     Minor = 0;
 968     Micro = 0;
 969     break;
 970   case IOS:
 971   case TvOS:
 972     getOSVersion(Major, Minor, Micro);
 973     // Default to 5.0 (or 7.0 for arm64).
 974     if (Major == 0)
 975       Major = (getArch() == aarch64) ? 7 : 5;
 976     break;
 977   }
 978 }
 979
 980 void Triple::setTriple(const Twine &Str) {
 981   *this = Triple(Str);
 982 }
 983
 984 void Triple::setArch(ArchType Kind) {
 985   setArchName(getArchTypeName(Kind));
 986 }
 987
 988 void Triple::setVendor(VendorType Kind) {
 989   setVendorName(getVendorTypeName(Kind));
 990 }
 991
 992 void Triple::setOS(OSType Kind) {
 993   setOSName(getOSTypeName(Kind));
 994 }
 995
 996 void Triple::setEnvironment(EnvironmentType Kind) {
 997   if (ObjectFormat == getDefaultFormat(*this))
 998     return setEnvironmentName(getEnvironmentTypeName(Kind));
 999
1000   setEnvironmentName((getEnvironmentTypeName(Kind) + Twine("-") +
1001                       getObjectFormatTypeName(ObjectFormat)).str());
1002 }
1003
1004 void Triple::setObjectFormat(ObjectFormatType Kind) {
1005   if (Environment == UnknownEnvironment)
1006     return setEnvironmentName(getObjectFormatTypeName(Kind));
1007
1008   setEnvironmentName((getEnvironmentTypeName(Environment) + Twine("-") +
1009                       getObjectFormatTypeName(Kind)).str());
1010 }
1011
1012 void Triple::setArchName(StringRef Str) {
1013   // Work around a miscompilation bug for Twines in gcc 4.0.3.
1014   SmallString<64> Triple;
1015   Triple += Str;
1016   Triple += "-";
1017   Triple += getVendorName();
1018   Triple += "-";
1019   Triple += getOSAndEnvironmentName();
1020   setTriple(Triple);
1021 }
1022
1023 void Triple::setVendorName(StringRef Str) {
1024   setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName());
1025 }
1026
1027 void Triple::setOSName(StringRef Str) {
1028   if (hasEnvironment())
1029     setTriple(getArchName() + "-" + getVendorName() + "-" + Str +
1030               "-" + getEnvironmentName());
1031   else
1032     setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
1033 }
1034
1035 void Triple::setEnvironmentName(StringRef Str) {
1036   setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() +
1037             "-" + Str);
1038 }
1039
1040 void Triple::setOSAndEnvironmentName(StringRef Str) {
1041   setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
1042 }
1043
1044 static unsigned getArchPointerBitWidth(llvm::Triple::ArchType Arch) {
1045   switch (Arch) {
1046   case llvm::Triple::UnknownArch:
1047     return 0;
1048
1049   case llvm::Triple::avr:
1050   case llvm::Triple::msp430:
1051     return 16;
1052
1053   case llvm::Triple::arm:
1054   case llvm::Triple::armeb:
1055   case llvm::Triple::hexagon:
1056   case llvm::Triple::le32:
1057   case llvm::Triple::mips:
1058   case llvm::Triple::mipsel:
1059   case llvm::Triple::nvptx:
1060   case llvm::Triple::ppc:
1061   case llvm::Triple::r600:
1062   case llvm::Triple::sparc:
1063   case llvm::Triple::sparcel:
1064   case llvm::Triple::tce:
1065   case llvm::Triple::thumb:
1066   case llvm::Triple::thumbeb:
1067   case llvm::Triple::x86:
1068   case llvm::Triple::xcore:
1069   case llvm::Triple::amdil:
1070   case llvm::Triple::hsail:
1071   case llvm::Triple::spir:
1072   case llvm::Triple::kalimba:
1073   case llvm::Triple::shave:
1074   case llvm::Triple::wasm32:
1075     return 32;
1076
1077   case llvm::Triple::aarch64:
1078   case llvm::Triple::aarch64_be:
1079   case llvm::Triple::amdgcn:
1080   case llvm::Triple::bpfel:
1081   case llvm::Triple::bpfeb:
1082   case llvm::Triple::le64:
1083   case llvm::Triple::mips64:
1084   case llvm::Triple::mips64el:
1085   case llvm::Triple::nvptx64:
1086   case llvm::Triple::ppc64:
1087   case llvm::Triple::ppc64le:
1088   case llvm::Triple::sparcv9:
1089   case llvm::Triple::systemz:
1090   case llvm::Triple::x86_64:
1091   case llvm::Triple::amdil64:
1092   case llvm::Triple::hsail64:
1093   case llvm::Triple::spir64:
1094   case llvm::Triple::wasm64:
1095     return 64;
1096   }
1097   llvm_unreachable("Invalid architecture value");
1098 }
1099
1100 bool Triple::isArch64Bit() const {
1101   return getArchPointerBitWidth(getArch()) == 64;
1102 }
1103
1104 bool Triple::isArch32Bit() const {
1105   return getArchPointerBitWidth(getArch()) == 32;
1106 }
1107
1108 bool Triple::isArch16Bit() const {
1109   return getArchPointerBitWidth(getArch()) == 16;
1110 }
1111
1112 Triple Triple::get32BitArchVariant() const {
1113   Triple T(*this);
1114   switch (getArch()) {
1115   case Triple::UnknownArch:
1116   case Triple::aarch64:
1117   case Triple::aarch64_be:
1118   case Triple::amdgcn:
1119   case Triple::avr:
1120   case Triple::bpfel:
1121   case Triple::bpfeb:
1122   case Triple::msp430:
1123   case Triple::systemz:
1124   case Triple::ppc64le:
1125     T.setArch(UnknownArch);
1126     break;
1127
1128   case Triple::amdil:
1129   case Triple::hsail:
1130   case Triple::spir:
1131   case Triple::arm:
1132   case Triple::armeb:
1133   case Triple::hexagon:
1134   case Triple::kalimba:
1135   case Triple::le32:
1136   case Triple::mips:
1137   case Triple::mipsel:
1138   case Triple::nvptx:
1139   case Triple::ppc:
1140   case Triple::r600:
1141   case Triple::sparc:
1142   case Triple::sparcel:
1143   case Triple::tce:
1144   case Triple::thumb:
1145   case Triple::thumbeb:
1146   case Triple::x86:
1147   case Triple::xcore:
1148   case Triple::shave:
1149   case Triple::wasm32:
1150     // Already 32-bit.
1151     break;
1152
1153   case Triple::le64:      T.setArch(Triple::le32);    break;
1154   case Triple::mips64:    T.setArch(Triple::mips);    break;
1155   case Triple::mips64el:  T.setArch(Triple::mipsel);  break;
1156   case Triple::nvptx64:   T.setArch(Triple::nvptx);   break;
1157   case Triple::ppc64:     T.setArch(Triple::ppc);     break;
1158   case Triple::sparcv9:   T.setArch(Triple::sparc);   break;
1159   case Triple::x86_64:    T.setArch(Triple::x86);     break;
1160   case Triple::amdil64:   T.setArch(Triple::amdil);   break;
1161   case Triple::hsail64:   T.setArch(Triple::hsail);   break;
1162   case Triple::spir64:    T.setArch(Triple::spir);    break;
1163   case Triple::wasm64:    T.setArch(Triple::wasm32);  break;
1164   }
1165   return T;
1166 }
1167
1168 Triple Triple::get64BitArchVariant() const {
1169   Triple T(*this);
1170   switch (getArch()) {
1171   case Triple::UnknownArch:
1172   case Triple::arm:
1173   case Triple::armeb:
1174   case Triple::avr:
1175   case Triple::hexagon:
1176   case Triple::kalimba:
1177   case Triple::msp430:
1178   case Triple::r600:
1179   case Triple::tce:
1180   case Triple::thumb:
1181   case Triple::thumbeb:
1182   case Triple::xcore:
1183   case Triple::sparcel:
1184   case Triple::shave:
1185     T.setArch(UnknownArch);
1186     break;
1187
1188   case Triple::aarch64:
1189   case Triple::aarch64_be:
1190   case Triple::bpfel:
1191   case Triple::bpfeb:
1192   case Triple::le64:
1193   case Triple::amdil64:
1194   case Triple::amdgcn:
1195   case Triple::hsail64:
1196   case Triple::spir64:
1197   case Triple::mips64:
1198   case Triple::mips64el:
1199   case Triple::nvptx64:
1200   case Triple::ppc64:
1201   case Triple::ppc64le:
1202   case Triple::sparcv9:
1203   case Triple::systemz:
1204   case Triple::x86_64:
1205   case Triple::wasm64:
1206     // Already 64-bit.
1207     break;
1208
1209   case Triple::le32:    T.setArch(Triple::le64);      break;
1210   case Triple::mips:    T.setArch(Triple::mips64);    break;
1211   case Triple::mipsel:  T.setArch(Triple::mips64el);  break;
1212   case Triple::nvptx:   T.setArch(Triple::nvptx64);   break;
1213   case Triple::ppc:     T.setArch(Triple::ppc64);     break;
1214   case Triple::sparc:   T.setArch(Triple::sparcv9);   break;
1215   case Triple::x86:     T.setArch(Triple::x86_64);    break;
1216   case Triple::amdil:   T.setArch(Triple::amdil64);   break;
1217   case Triple::hsail:   T.setArch(Triple::hsail64);   break;
1218   case Triple::spir:    T.setArch(Triple::spir64);    break;
1219   case Triple::wasm32:  T.setArch(Triple::wasm64);    break;
1220   }
1221   return T;
1222 }
1223
1224 Triple Triple::getBigEndianArchVariant() const {
1225   Triple T(*this);
1226   switch (getArch()) {
1227   case Triple::UnknownArch:
1228   case Triple::amdgcn:
1229   case Triple::amdil64:
1230   case Triple::amdil:
1231   case Triple::avr:
1232   case Triple::hexagon:
1233   case Triple::hsail64:
1234   case Triple::hsail:
1235   case Triple::kalimba:
1236   case Triple::le32:
1237   case Triple::le64:
1238   case Triple::msp430:
1239   case Triple::nvptx64:
1240   case Triple::nvptx:
1241   case Triple::r600:
1242   case Triple::shave:
1243   case Triple::spir64:
1244   case Triple::spir:
1245   case Triple::wasm32:
1246   case Triple::wasm64:
1247   case Triple::x86:
1248   case Triple::x86_64:
1249   case Triple::xcore:
1250
1251   // ARM is intentionally unsupported here, changing the architecture would
1252   // drop any arch suffixes.
1253   case Triple::arm:
1254   case Triple::thumb:
1255     T.setArch(UnknownArch);
1256     break;
1257
1258   case Triple::aarch64_be:
1259   case Triple::armeb:
1260   case Triple::bpfeb:
1261   case Triple::mips64:
1262   case Triple::mips:
1263   case Triple::ppc64:
1264   case Triple::ppc:
1265   case Triple::sparc:
1266   case Triple::sparcv9:
1267   case Triple::systemz:
1268   case Triple::tce:
1269   case Triple::thumbeb:
1270     // Already big endian.
1271     break;
1272
1273   case Triple::aarch64: T.setArch(Triple::aarch64_be); break;
1274   case Triple::bpfel:   T.setArch(Triple::bpfeb);      break;
1275   case Triple::mips64el:T.setArch(Triple::mips64);     break;
1276   case Triple::mipsel:  T.setArch(Triple::mips);       break;
1277   case Triple::ppc64le: T.setArch(Triple::ppc64);      break;
1278   case Triple::sparcel: T.setArch(Triple::sparc);      break;
1279   }
1280   return T;
1281 }
1282
1283 Triple Triple::getLittleEndianArchVariant() const {
1284   Triple T(*this);
1285   switch (getArch()) {
1286   case Triple::UnknownArch:
1287   case Triple::ppc:
1288   case Triple::sparcv9:
1289   case Triple::systemz:
1290   case Triple::tce:
1291
1292   // ARM is intentionally unsupported here, changing the architecture would
1293   // drop any arch suffixes.
1294   case Triple::armeb:
1295   case Triple::thumbeb:
1296     T.setArch(UnknownArch);
1297     break;
1298
1299   case Triple::aarch64:
1300   case Triple::amdgcn:
1301   case Triple::amdil64:
1302   case Triple::amdil:
1303   case Triple::arm:
1304   case Triple::avr:
1305   case Triple::bpfel:
1306   case Triple::hexagon:
1307   case Triple::hsail64:
1308   case Triple::hsail:
1309   case Triple::kalimba:
1310   case Triple::le32:
1311   case Triple::le64:
1312   case Triple::mips64el:
1313   case Triple::mipsel:
1314   case Triple::msp430:
1315   case Triple::nvptx64:
1316   case Triple::nvptx:
1317   case Triple::ppc64le:
1318   case Triple::r600:
1319   case Triple::shave:
1320   case Triple::sparcel:
1321   case Triple::spir64:
1322   case Triple::spir:
1323   case Triple::thumb:
1324   case Triple::wasm32:
1325   case Triple::wasm64:
1326   case Triple::x86:
1327   case Triple::x86_64:
1328   case Triple::xcore:
1329     // Already little endian.
1330     break;
1331
1332   case Triple::aarch64_be: T.setArch(Triple::aarch64);  break;
1333   case Triple::bpfeb:      T.setArch(Triple::bpfel);    break;
1334   case Triple::mips64:     T.setArch(Triple::mips64el); break;
1335   case Triple::mips:       T.setArch(Triple::mipsel);   break;
1336   case Triple::ppc64:      T.setArch(Triple::ppc64le);  break;
1337   case Triple::sparc:      T.setArch(Triple::sparcel);  break;
1338   }
1339   return T;
1340 }
1341
1342 StringRef Triple::getARMCPUForArch(StringRef MArch) const {
1343   if (MArch.empty())
1344     MArch = getArchName();
1345   MArch = ARM::getCanonicalArchName(MArch);
1346
1347   // Some defaults are forced.
1348   switch (getOS()) {
1349   case llvm::Triple::FreeBSD:
1350   case llvm::Triple::NetBSD:
1351     if (!MArch.empty() && MArch == "v6")
1352       return "arm1176jzf-s";
1353     break;
1354   case llvm::Triple::Win32:
1355     // FIXME: this is invalid for WindowsCE
1356     return "cortex-a9";
1357   default:
1358     break;
1359   }
1360
1361   if (MArch.empty())
1362     return StringRef();
1363
1364   StringRef CPU = ARM::getDefaultCPU(MArch);
1365   if (!CPU.empty())
1366     return CPU;
1367
1368   // If no specific architecture version is requested, return the minimum CPU
1369   // required by the OS and environment.
1370   switch (getOS()) {
1371   case llvm::Triple::NetBSD:
1372     switch (getEnvironment()) {
1373     case llvm::Triple::GNUEABIHF:
1374     case llvm::Triple::GNUEABI:
1375     case llvm::Triple::EABIHF:
1376     case llvm::Triple::EABI:
1377       return "arm926ej-s";
1378     default:
1379       return "strongarm";
1380     }
1381   case llvm::Triple::NaCl:
1382     return "cortex-a8";
1383   default:
1384     switch (getEnvironment()) {
1385     case llvm::Triple::EABIHF:
1386     case llvm::Triple::GNUEABIHF:
1387       return "arm1176jzf-s";
1388     default:
1389       return "arm7tdmi";
1390     }
1391   }
1392
1393   llvm_unreachable("invalid arch name");
1394 }