contrib/llvm/lib/Support/Triple.cpp

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