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