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