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