lib/Support/Triple.cpp

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