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::xcore:
 653     return Triple::ELF;
 654
 655   case Triple::wasm32:
 656   case Triple::wasm64:
 657     return Triple::Wasm;
 658
 659   case Triple::ppc:
 660   case Triple::ppc64:
 661     if (T.isOSDarwin())
 662       return Triple::MachO;
 663     return Triple::ELF;
 664   }
 665   llvm_unreachable("unknown architecture");
 666 }
 667
 668 /// \brief Construct a triple from the string representation provided.
 669 ///
 670 /// This stores the string representation and parses the various pieces into
 671 /// enum members.
 672 Triple::Triple(const Twine &Str)
 673     : Data(Str.str()), Arch(UnknownArch), SubArch(NoSubArch),
 674       Vendor(UnknownVendor), OS(UnknownOS), Environment(UnknownEnvironment),
 675       ObjectFormat(UnknownObjectFormat) {
 676   // Do minimal parsing by hand here.
 677   SmallVector<StringRef, 4> Components;
 678   StringRef(Data).split(Components, '-', /*MaxSplit*/ 3);
 679   if (Components.size() > 0) {
 680     Arch = parseArch(Components[0]);
 681     SubArch = parseSubArch(Components[0]);
 682     if (Components.size() > 1) {
 683       Vendor = parseVendor(Components[1]);
 684       if (Components.size() > 2) {
 685         OS = parseOS(Components[2]);
 686         if (Components.size() > 3) {
 687           Environment = parseEnvironment(Components[3]);
 688           ObjectFormat = parseFormat(Components[3]);
 689         }
 690       }
 691     }
 692   }
 693   if (ObjectFormat == UnknownObjectFormat)
 694     ObjectFormat = getDefaultFormat(*this);
 695 }
 696
 697 /// \brief Construct a triple from string representations of the architecture,
 698 /// vendor, and OS.
 699 ///
 700 /// This joins each argument into a canonical string representation and parses
 701 /// them into enum members. It leaves the environment unknown and omits it from
 702 /// the string representation.
 703 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr)
 704     : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr).str()),
 705       Arch(parseArch(ArchStr.str())),
 706       SubArch(parseSubArch(ArchStr.str())),
 707       Vendor(parseVendor(VendorStr.str())),
 708       OS(parseOS(OSStr.str())),
 709       Environment(), ObjectFormat(Triple::UnknownObjectFormat) {
 710   ObjectFormat = getDefaultFormat(*this);
 711 }
 712
 713 /// \brief Construct a triple from string representations of the architecture,
 714 /// vendor, OS, and environment.
 715 ///
 716 /// This joins each argument into a canonical string representation and parses
 717 /// them into enum members.
 718 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr,
 719                const Twine &EnvironmentStr)
 720     : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr + Twine('-') +
 721             EnvironmentStr).str()),
 722       Arch(parseArch(ArchStr.str())),
 723       SubArch(parseSubArch(ArchStr.str())),
 724       Vendor(parseVendor(VendorStr.str())),
 725       OS(parseOS(OSStr.str())),
 726       Environment(parseEnvironment(EnvironmentStr.str())),
 727       ObjectFormat(parseFormat(EnvironmentStr.str())) {
 728   if (ObjectFormat == Triple::UnknownObjectFormat)
 729     ObjectFormat = getDefaultFormat(*this);
 730 }
 731
 732 std::string Triple::normalize(StringRef Str) {
 733   bool IsMinGW32 = false;
 734   bool IsCygwin = false;
 735
 736   // Parse into components.
 737   SmallVector<StringRef, 4> Components;
 738   Str.split(Components, '-');
 739
 740   // If the first component corresponds to a known architecture, preferentially
 741   // use it for the architecture.  If the second component corresponds to a
 742   // known vendor, preferentially use it for the vendor, etc.  This avoids silly
 743   // component movement when a component parses as (eg) both a valid arch and a
 744   // valid os.
 745   ArchType Arch = UnknownArch;
 746   if (Components.size() > 0)
 747     Arch = parseArch(Components[0]);
 748   VendorType Vendor = UnknownVendor;
 749   if (Components.size() > 1)
 750     Vendor = parseVendor(Components[1]);
 751   OSType OS = UnknownOS;
 752   if (Components.size() > 2) {
 753     OS = parseOS(Components[2]);
 754     IsCygwin = Components[2].startswith("cygwin");
 755     IsMinGW32 = Components[2].startswith("mingw");
 756   }
 757   EnvironmentType Environment = UnknownEnvironment;
 758   if (Components.size() > 3)
 759     Environment = parseEnvironment(Components[3]);
 760   ObjectFormatType ObjectFormat = UnknownObjectFormat;
 761   if (Components.size() > 4)
 762     ObjectFormat = parseFormat(Components[4]);
 763
 764   // Note which components are already in their final position.  These will not
 765   // be moved.
 766   bool Found[4];
 767   Found[0] = Arch != UnknownArch;
 768   Found[1] = Vendor != UnknownVendor;
 769   Found[2] = OS != UnknownOS;
 770   Found[3] = Environment != UnknownEnvironment;
 771
 772   // If they are not there already, permute the components into their canonical
 773   // positions by seeing if they parse as a valid architecture, and if so moving
 774   // the component to the architecture position etc.
 775   for (unsigned Pos = 0; Pos != array_lengthof(Found); ++Pos) {
 776     if (Found[Pos])
 777       continue; // Already in the canonical position.
 778
 779     for (unsigned Idx = 0; Idx != Components.size(); ++Idx) {
 780       // Do not reparse any components that already matched.
 781       if (Idx < array_lengthof(Found) && Found[Idx])
 782         continue;
 783
 784       // Does this component parse as valid for the target position?
 785       bool Valid = false;
 786       StringRef Comp = Components[Idx];
 787       switch (Pos) {
 788       default: llvm_unreachable("unexpected component type!");
 789       case 0:
 790         Arch = parseArch(Comp);
 791         Valid = Arch != UnknownArch;
 792         break;
 793       case 1:
 794         Vendor = parseVendor(Comp);
 795         Valid = Vendor != UnknownVendor;
 796         break;
 797       case 2:
 798         OS = parseOS(Comp);
 799         IsCygwin = Comp.startswith("cygwin");
 800         IsMinGW32 = Comp.startswith("mingw");
 801         Valid = OS != UnknownOS || IsCygwin || IsMinGW32;
 802         break;
 803       case 3:
 804         Environment = parseEnvironment(Comp);
 805         Valid = Environment != UnknownEnvironment;
 806         if (!Valid) {
 807           ObjectFormat = parseFormat(Comp);
 808           Valid = ObjectFormat != UnknownObjectFormat;
 809         }
 810         break;
 811       }
 812       if (!Valid)
 813         continue; // Nope, try the next component.
 814
 815       // Move the component to the target position, pushing any non-fixed
 816       // components that are in the way to the right.  This tends to give
 817       // good results in the common cases of a forgotten vendor component
 818       // or a wrongly positioned environment.
 819       if (Pos < Idx) {
 820         // Insert left, pushing the existing components to the right.  For
 821         // example, a-b-i386 -> i386-a-b when moving i386 to the front.
 822         StringRef CurrentComponent(""); // The empty component.
 823         // Replace the component we are moving with an empty component.
 824         std::swap(CurrentComponent, Components[Idx]);
 825         // Insert the component being moved at Pos, displacing any existing
 826         // components to the right.
 827         for (unsigned i = Pos; !CurrentComponent.empty(); ++i) {
 828           // Skip over any fixed components.
 829           while (i < array_lengthof(Found) && Found[i])
 830             ++i;
 831           // Place the component at the new position, getting the component
 832           // that was at this position - it will be moved right.
 833           std::swap(CurrentComponent, Components[i]);
 834         }
 835       } else if (Pos > Idx) {
 836         // Push right by inserting empty components until the component at Idx
 837         // reaches the target position Pos.  For example, pc-a -> -pc-a when
 838         // moving pc to the second position.
 839         do {
 840           // Insert one empty component at Idx.
 841           StringRef CurrentComponent(""); // The empty component.
 842           for (unsigned i = Idx; i < Components.size();) {
 843             // Place the component at the new position, getting the component
 844             // that was at this position - it will be moved right.
 845             std::swap(CurrentComponent, Components[i]);
 846             // If it was placed on top of an empty component then we are done.
 847             if (CurrentComponent.empty())
 848               break;
 849             // Advance to the next component, skipping any fixed components.
 850             while (++i < array_lengthof(Found) && Found[i])
 851               ;
 852           }
 853           // The last component was pushed off the end - append it.
 854           if (!CurrentComponent.empty())
 855             Components.push_back(CurrentComponent);
 856
 857           // Advance Idx to the component's new position.
 858           while (++Idx < array_lengthof(Found) && Found[Idx])
 859             ;
 860         } while (Idx < Pos); // Add more until the final position is reached.
 861       }
 862       assert(Pos < Components.size() && Components[Pos] == Comp &&
 863              "Component moved wrong!");
 864       Found[Pos] = true;
 865       break;
 866     }
 867   }
 868
 869   // Special case logic goes here.  At this point Arch, Vendor and OS have the
 870   // correct values for the computed components.
 871   std::string NormalizedEnvironment;
 872   if (Environment == Triple::Android && Components[3].startswith("androideabi")) {
 873     StringRef AndroidVersion = Components[3].drop_front(strlen("androideabi"));
 874     if (AndroidVersion.empty()) {
 875       Components[3] = "android";
 876     } else {
 877       NormalizedEnvironment = Twine("android", AndroidVersion).str();
 878       Components[3] = NormalizedEnvironment;
 879     }
 880   }
 881
 882   if (OS == Triple::Win32) {
 883     Components.resize(4);
 884     Components[2] = "windows";
 885     if (Environment == UnknownEnvironment) {
 886       if (ObjectFormat == UnknownObjectFormat || ObjectFormat == Triple::COFF)
 887         Components[3] = "msvc";
 888       else
 889         Components[3] = getObjectFormatTypeName(ObjectFormat);
 890     }
 891   } else if (IsMinGW32) {
 892     Components.resize(4);
 893     Components[2] = "windows";
 894     Components[3] = "gnu";
 895   } else if (IsCygwin) {
 896     Components.resize(4);
 897     Components[2] = "windows";
 898     Components[3] = "cygnus";
 899   }
 900   if (IsMinGW32 || IsCygwin ||
 901       (OS == Triple::Win32 && Environment != UnknownEnvironment)) {
 902     if (ObjectFormat != UnknownObjectFormat && ObjectFormat != Triple::COFF) {
 903       Components.resize(5);
 904       Components[4] = getObjectFormatTypeName(ObjectFormat);
 905     }
 906   }
 907
 908   // Stick the corrected components back together to form the normalized string.
 909   std::string Normalized;
 910   for (unsigned i = 0, e = Components.size(); i != e; ++i) {
 911     if (i) Normalized += '-';
 912     Normalized += Components[i];
 913   }
 914   return Normalized;
 915 }
 916
 917 StringRef Triple::getArchName() const {
 918   return StringRef(Data).split('-').first;           // Isolate first component
 919 }
 920
 921 StringRef Triple::getVendorName() const {
 922   StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
 923   return Tmp.split('-').first;                       // Isolate second component
 924 }
 925
 926 StringRef Triple::getOSName() const {
 927   StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
 928   Tmp = Tmp.split('-').second;                       // Strip second component
 929   return Tmp.split('-').first;                       // Isolate third component
 930 }
 931
 932 StringRef Triple::getEnvironmentName() const {
 933   StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
 934   Tmp = Tmp.split('-').second;                       // Strip second component
 935   return Tmp.split('-').second;                      // Strip third component
 936 }
 937
 938 StringRef Triple::getOSAndEnvironmentName() const {
 939   StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
 940   return Tmp.split('-').second;                      // Strip second component
 941 }
 942
 943 static unsigned EatNumber(StringRef &Str) {
 944   assert(!Str.empty() && Str[0] >= '0' && Str[0] <= '9' && "Not a number");
 945   unsigned Result = 0;
 946
 947   do {
 948     // Consume the leading digit.
 949     Result = Result*10 + (Str[0] - '0');
 950
 951     // Eat the digit.
 952     Str = Str.substr(1);
 953   } while (!Str.empty() && Str[0] >= '0' && Str[0] <= '9');
 954
 955   return Result;
 956 }
 957
 958 static void parseVersionFromName(StringRef Name, unsigned &Major,
 959                                  unsigned &Minor, unsigned &Micro) {
 960   // Any unset version defaults to 0.
 961   Major = Minor = Micro = 0;
 962
 963   // Parse up to three components.
 964   unsigned *Components[3] = {&Major, &Minor, &Micro};
 965   for (unsigned i = 0; i != 3; ++i) {
 966     if (Name.empty() || Name[0] < '0' || Name[0] > '9')
 967       break;
 968
 969     // Consume the leading number.
 970     *Components[i] = EatNumber(Name);
 971
 972     // Consume the separator, if present.
 973     if (Name.startswith("."))
 974       Name = Name.substr(1);
 975   }
 976 }
 977
 978 void Triple::getEnvironmentVersion(unsigned &Major, unsigned &Minor,
 979                                    unsigned &Micro) const {
 980   StringRef EnvironmentName = getEnvironmentName();
 981   StringRef EnvironmentTypeName = getEnvironmentTypeName(getEnvironment());
 982   if (EnvironmentName.startswith(EnvironmentTypeName))
 983     EnvironmentName = EnvironmentName.substr(EnvironmentTypeName.size());
 984
 985   parseVersionFromName(EnvironmentName, Major, Minor, Micro);
 986 }
 987
 988 void Triple::getOSVersion(unsigned &Major, unsigned &Minor,
 989                           unsigned &Micro) const {
 990   StringRef OSName = getOSName();
 991   // Assume that the OS portion of the triple starts with the canonical name.
 992   StringRef OSTypeName = getOSTypeName(getOS());
 993   if (OSName.startswith(OSTypeName))
 994     OSName = OSName.substr(OSTypeName.size());
 995   else if (getOS() == MacOSX)
 996     OSName.consume_front("macos");
 997
 998   parseVersionFromName(OSName, Major, Minor, Micro);
 999 }
1000
1001 bool Triple::getMacOSXVersion(unsigned &Major, unsigned &Minor,
1002                               unsigned &Micro) const {
1003   getOSVersion(Major, Minor, Micro);
1004
1005   switch (getOS()) {
1006   default: llvm_unreachable("unexpected OS for Darwin triple");
1007   case Darwin:
1008     // Default to darwin8, i.e., MacOSX 10.4.
1009     if (Major == 0)
1010       Major = 8;
1011     // Darwin version numbers are skewed from OS X versions.
1012     if (Major < 4)
1013       return false;
1014     Micro = 0;
1015     Minor = Major - 4;
1016     Major = 10;
1017     break;
1018   case MacOSX:
1019     // Default to 10.4.
1020     if (Major == 0) {
1021       Major = 10;
1022       Minor = 4;
1023     }
1024     if (Major != 10)
1025       return false;
1026     break;
1027   case IOS:
1028   case TvOS:
1029   case WatchOS:
1030     // Ignore the version from the triple.  This is only handled because the
1031     // the clang driver combines OS X and IOS support into a common Darwin
1032     // toolchain that wants to know the OS X version number even when targeting
1033     // IOS.
1034     Major = 10;
1035     Minor = 4;
1036     Micro = 0;
1037     break;
1038   }
1039   return true;
1040 }
1041
1042 void Triple::getiOSVersion(unsigned &Major, unsigned &Minor,
1043                            unsigned &Micro) const {
1044   switch (getOS()) {
1045   default: llvm_unreachable("unexpected OS for Darwin triple");
1046   case Darwin:
1047   case MacOSX:
1048     // Ignore the version from the triple.  This is only handled because the
1049     // the clang driver combines OS X and IOS support into a common Darwin
1050     // toolchain that wants to know the iOS version number even when targeting
1051     // OS X.
1052     Major = 5;
1053     Minor = 0;
1054     Micro = 0;
1055     break;
1056   case IOS:
1057   case TvOS:
1058     getOSVersion(Major, Minor, Micro);
1059     // Default to 5.0 (or 7.0 for arm64).
1060     if (Major == 0)
1061       Major = (getArch() == aarch64) ? 7 : 5;
1062     break;
1063   case WatchOS:
1064     llvm_unreachable("conflicting triple info");
1065   }
1066 }
1067
1068 void Triple::getWatchOSVersion(unsigned &Major, unsigned &Minor,
1069                                unsigned &Micro) const {
1070   switch (getOS()) {
1071   default: llvm_unreachable("unexpected OS for Darwin triple");
1072   case Darwin:
1073   case MacOSX:
1074     // Ignore the version from the triple.  This is only handled because the
1075     // the clang driver combines OS X and IOS support into a common Darwin
1076     // toolchain that wants to know the iOS version number even when targeting
1077     // OS X.
1078     Major = 2;
1079     Minor = 0;
1080     Micro = 0;
1081     break;
1082   case WatchOS:
1083     getOSVersion(Major, Minor, Micro);
1084     if (Major == 0)
1085       Major = 2;
1086     break;
1087   case IOS:
1088     llvm_unreachable("conflicting triple info");
1089   }
1090 }
1091
1092 void Triple::setTriple(const Twine &Str) {
1093   *this = Triple(Str);
1094 }
1095
1096 void Triple::setArch(ArchType Kind) {
1097   setArchName(getArchTypeName(Kind));
1098 }
1099
1100 void Triple::setVendor(VendorType Kind) {
1101   setVendorName(getVendorTypeName(Kind));
1102 }
1103
1104 void Triple::setOS(OSType Kind) {
1105   setOSName(getOSTypeName(Kind));
1106 }
1107
1108 void Triple::setEnvironment(EnvironmentType Kind) {
1109   if (ObjectFormat == getDefaultFormat(*this))
1110     return setEnvironmentName(getEnvironmentTypeName(Kind));
1111
1112   setEnvironmentName((getEnvironmentTypeName(Kind) + Twine("-") +
1113                       getObjectFormatTypeName(ObjectFormat)).str());
1114 }
1115
1116 void Triple::setObjectFormat(ObjectFormatType Kind) {
1117   if (Environment == UnknownEnvironment)
1118     return setEnvironmentName(getObjectFormatTypeName(Kind));
1119
1120   setEnvironmentName((getEnvironmentTypeName(Environment) + Twine("-") +
1121                       getObjectFormatTypeName(Kind)).str());
1122 }
1123
1124 void Triple::setArchName(StringRef Str) {
1125   // Work around a miscompilation bug for Twines in gcc 4.0.3.
1126   SmallString<64> Triple;
1127   Triple += Str;
1128   Triple += "-";
1129   Triple += getVendorName();
1130   Triple += "-";
1131   Triple += getOSAndEnvironmentName();
1132   setTriple(Triple);
1133 }
1134
1135 void Triple::setVendorName(StringRef Str) {
1136   setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName());
1137 }
1138
1139 void Triple::setOSName(StringRef Str) {
1140   if (hasEnvironment())
1141     setTriple(getArchName() + "-" + getVendorName() + "-" + Str +
1142               "-" + getEnvironmentName());
1143   else
1144     setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
1145 }
1146
1147 void Triple::setEnvironmentName(StringRef Str) {
1148   setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() +
1149             "-" + Str);
1150 }
1151
1152 void Triple::setOSAndEnvironmentName(StringRef Str) {
1153   setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
1154 }
1155
1156 static unsigned getArchPointerBitWidth(llvm::Triple::ArchType Arch) {
1157   switch (Arch) {
1158   case llvm::Triple::UnknownArch:
1159     return 0;
1160
1161   case llvm::Triple::avr:
1162   case llvm::Triple::msp430:
1163     return 16;
1164
1165   case llvm::Triple::arm:
1166   case llvm::Triple::armeb:
1167   case llvm::Triple::hexagon:
1168   case llvm::Triple::le32:
1169   case llvm::Triple::mips:
1170   case llvm::Triple::mipsel:
1171   case llvm::Triple::nios2:
1172   case llvm::Triple::nvptx:
1173   case llvm::Triple::ppc:
1174   case llvm::Triple::r600:
1175   case llvm::Triple::riscv32:
1176   case llvm::Triple::sparc:
1177   case llvm::Triple::sparcel:
1178   case llvm::Triple::tce:
1179   case llvm::Triple::tcele:
1180   case llvm::Triple::thumb:
1181   case llvm::Triple::thumbeb:
1182   case llvm::Triple::x86:
1183   case llvm::Triple::xcore:
1184   case llvm::Triple::amdil:
1185   case llvm::Triple::hsail:
1186   case llvm::Triple::spir:
1187   case llvm::Triple::kalimba:
1188   case llvm::Triple::lanai:
1189   case llvm::Triple::shave:
1190   case llvm::Triple::wasm32:
1191   case llvm::Triple::renderscript32:
1192     return 32;
1193
1194   case llvm::Triple::aarch64:
1195   case llvm::Triple::aarch64_be:
1196   case llvm::Triple::amdgcn:
1197   case llvm::Triple::bpfel:
1198   case llvm::Triple::bpfeb:
1199   case llvm::Triple::le64:
1200   case llvm::Triple::mips64:
1201   case llvm::Triple::mips64el:
1202   case llvm::Triple::nvptx64:
1203   case llvm::Triple::ppc64:
1204   case llvm::Triple::ppc64le:
1205   case llvm::Triple::riscv64:
1206   case llvm::Triple::sparcv9:
1207   case llvm::Triple::systemz:
1208   case llvm::Triple::x86_64:
1209   case llvm::Triple::amdil64:
1210   case llvm::Triple::hsail64:
1211   case llvm::Triple::spir64:
1212   case llvm::Triple::wasm64:
1213   case llvm::Triple::renderscript64:
1214     return 64;
1215   }
1216   llvm_unreachable("Invalid architecture value");
1217 }
1218
1219 bool Triple::isArch64Bit() const {
1220   return getArchPointerBitWidth(getArch()) == 64;
1221 }
1222
1223 bool Triple::isArch32Bit() const {
1224   return getArchPointerBitWidth(getArch()) == 32;
1225 }
1226
1227 bool Triple::isArch16Bit() const {
1228   return getArchPointerBitWidth(getArch()) == 16;
1229 }
1230
1231 Triple Triple::get32BitArchVariant() const {
1232   Triple T(*this);
1233   switch (getArch()) {
1234   case Triple::UnknownArch:
1235   case Triple::amdgcn:
1236   case Triple::avr:
1237   case Triple::bpfel:
1238   case Triple::bpfeb:
1239   case Triple::msp430:
1240   case Triple::systemz:
1241   case Triple::ppc64le:
1242     T.setArch(UnknownArch);
1243     break;
1244
1245   case Triple::amdil:
1246   case Triple::hsail:
1247   case Triple::spir:
1248   case Triple::arm:
1249   case Triple::armeb:
1250   case Triple::hexagon:
1251   case Triple::kalimba:
1252   case Triple::le32:
1253   case Triple::mips:
1254   case Triple::mipsel:
1255   case Triple::nios2:
1256   case Triple::nvptx:
1257   case Triple::ppc:
1258   case Triple::r600:
1259   case Triple::riscv32:
1260   case Triple::sparc:
1261   case Triple::sparcel:
1262   case Triple::tce:
1263   case Triple::tcele:
1264   case Triple::thumb:
1265   case Triple::thumbeb:
1266   case Triple::x86:
1267   case Triple::xcore:
1268   case Triple::lanai:
1269   case Triple::shave:
1270   case Triple::wasm32:
1271   case Triple::renderscript32:
1272     // Already 32-bit.
1273     break;
1274
1275   case Triple::aarch64:        T.setArch(Triple::arm);     break;
1276   case Triple::aarch64_be:     T.setArch(Triple::armeb);   break;
1277   case Triple::le64:           T.setArch(Triple::le32);    break;
1278   case Triple::mips64:         T.setArch(Triple::mips);    break;
1279   case Triple::mips64el:       T.setArch(Triple::mipsel);  break;
1280   case Triple::nvptx64:        T.setArch(Triple::nvptx);   break;
1281   case Triple::ppc64:          T.setArch(Triple::ppc);     break;
1282   case Triple::sparcv9:        T.setArch(Triple::sparc);   break;
1283   case Triple::riscv64:        T.setArch(Triple::riscv32); break;
1284   case Triple::x86_64:         T.setArch(Triple::x86);     break;
1285   case Triple::amdil64:        T.setArch(Triple::amdil);   break;
1286   case Triple::hsail64:        T.setArch(Triple::hsail);   break;
1287   case Triple::spir64:         T.setArch(Triple::spir);    break;
1288   case Triple::wasm64:         T.setArch(Triple::wasm32);  break;
1289   case Triple::renderscript64: T.setArch(Triple::renderscript32); break;
1290   }
1291   return T;
1292 }
1293
1294 Triple Triple::get64BitArchVariant() const {
1295   Triple T(*this);
1296   switch (getArch()) {
1297   case Triple::UnknownArch:
1298   case Triple::avr:
1299   case Triple::hexagon:
1300   case Triple::kalimba:
1301   case Triple::lanai:
1302   case Triple::msp430:
1303   case Triple::nios2:
1304   case Triple::r600:
1305   case Triple::tce:
1306   case Triple::tcele:
1307   case Triple::xcore:
1308   case Triple::sparcel:
1309   case Triple::shave:
1310     T.setArch(UnknownArch);
1311     break;
1312
1313   case Triple::aarch64:
1314   case Triple::aarch64_be:
1315   case Triple::bpfel:
1316   case Triple::bpfeb:
1317   case Triple::le64:
1318   case Triple::amdil64:
1319   case Triple::amdgcn:
1320   case Triple::hsail64:
1321   case Triple::spir64:
1322   case Triple::mips64:
1323   case Triple::mips64el:
1324   case Triple::nvptx64:
1325   case Triple::ppc64:
1326   case Triple::ppc64le:
1327   case Triple::riscv64:
1328   case Triple::sparcv9:
1329   case Triple::systemz:
1330   case Triple::x86_64:
1331   case Triple::wasm64:
1332   case Triple::renderscript64:
1333     // Already 64-bit.
1334     break;
1335
1336   case Triple::arm:             T.setArch(Triple::aarch64);    break;
1337   case Triple::armeb:           T.setArch(Triple::aarch64_be); break;
1338   case Triple::le32:            T.setArch(Triple::le64);       break;
1339   case Triple::mips:            T.setArch(Triple::mips64);     break;
1340   case Triple::mipsel:          T.setArch(Triple::mips64el);   break;
1341   case Triple::nvptx:           T.setArch(Triple::nvptx64);    break;
1342   case Triple::ppc:             T.setArch(Triple::ppc64);      break;
1343   case Triple::sparc:           T.setArch(Triple::sparcv9);    break;
1344   case Triple::riscv32:         T.setArch(Triple::riscv64);    break;
1345   case Triple::x86:             T.setArch(Triple::x86_64);     break;
1346   case Triple::amdil:           T.setArch(Triple::amdil64);    break;
1347   case Triple::hsail:           T.setArch(Triple::hsail64);    break;
1348   case Triple::spir:            T.setArch(Triple::spir64);     break;
1349   case Triple::thumb:           T.setArch(Triple::aarch64);    break;
1350   case Triple::thumbeb:         T.setArch(Triple::aarch64_be); break;
1351   case Triple::wasm32:          T.setArch(Triple::wasm64);     break;
1352   case Triple::renderscript32:  T.setArch(Triple::renderscript64);     break;
1353   }
1354   return T;
1355 }
1356
1357 Triple Triple::getBigEndianArchVariant() const {
1358   Triple T(*this);
1359   // Already big endian.
1360   if (!isLittleEndian())
1361     return T;
1362   switch (getArch()) {
1363   case Triple::UnknownArch:
1364   case Triple::amdgcn:
1365   case Triple::amdil64:
1366   case Triple::amdil:
1367   case Triple::avr:
1368   case Triple::hexagon:
1369   case Triple::hsail64:
1370   case Triple::hsail:
1371   case Triple::kalimba:
1372   case Triple::le32:
1373   case Triple::le64:
1374   case Triple::msp430:
1375   case Triple::nios2:
1376   case Triple::nvptx64:
1377   case Triple::nvptx:
1378   case Triple::r600:
1379   case Triple::riscv32:
1380   case Triple::riscv64:
1381   case Triple::shave:
1382   case Triple::spir64:
1383   case Triple::spir:
1384   case Triple::wasm32:
1385   case Triple::wasm64:
1386   case Triple::x86:
1387   case Triple::x86_64:
1388   case Triple::xcore:
1389   case Triple::renderscript32:
1390   case Triple::renderscript64:
1391
1392   // ARM is intentionally unsupported here, changing the architecture would
1393   // drop any arch suffixes.
1394   case Triple::arm:
1395   case Triple::thumb:
1396     T.setArch(UnknownArch);
1397     break;
1398
1399   case Triple::tcele:   T.setArch(Triple::tce);        break;
1400   case Triple::aarch64: T.setArch(Triple::aarch64_be); break;
1401   case Triple::bpfel:   T.setArch(Triple::bpfeb);      break;
1402   case Triple::mips64el:T.setArch(Triple::mips64);     break;
1403   case Triple::mipsel:  T.setArch(Triple::mips);       break;
1404   case Triple::ppc64le: T.setArch(Triple::ppc64);      break;
1405   case Triple::sparcel: T.setArch(Triple::sparc);      break;
1406   default:
1407     llvm_unreachable("getBigEndianArchVariant: unknown triple.");
1408   }
1409   return T;
1410 }
1411
1412 Triple Triple::getLittleEndianArchVariant() const {
1413   Triple T(*this);
1414   if (isLittleEndian())
1415     return T;
1416
1417   switch (getArch()) {
1418   case Triple::UnknownArch:
1419   case Triple::lanai:
1420   case Triple::ppc:
1421   case Triple::sparcv9:
1422   case Triple::systemz:
1423
1424   // ARM is intentionally unsupported here, changing the architecture would
1425   // drop any arch suffixes.
1426   case Triple::armeb:
1427   case Triple::thumbeb:
1428     T.setArch(UnknownArch);
1429     break;
1430
1431   case Triple::tce:        T.setArch(Triple::tcele);    break;
1432   case Triple::aarch64_be: T.setArch(Triple::aarch64);  break;
1433   case Triple::bpfeb:      T.setArch(Triple::bpfel);    break;
1434   case Triple::mips64:     T.setArch(Triple::mips64el); break;
1435   case Triple::mips:       T.setArch(Triple::mipsel);   break;
1436   case Triple::ppc64:      T.setArch(Triple::ppc64le);  break;
1437   case Triple::sparc:      T.setArch(Triple::sparcel);  break;
1438   default:
1439     llvm_unreachable("getLittleEndianArchVariant: unknown triple.");
1440   }
1441   return T;
1442 }
1443
1444 bool Triple::isLittleEndian() const {
1445   switch (getArch()) {
1446   case Triple::aarch64:
1447   case Triple::amdgcn:
1448   case Triple::amdil64:
1449   case Triple::amdil:
1450   case Triple::arm:
1451   case Triple::avr:
1452   case Triple::bpfel:
1453   case Triple::hexagon:
1454   case Triple::hsail64:
1455   case Triple::hsail:
1456   case Triple::kalimba:
1457   case Triple::le32:
1458   case Triple::le64:
1459   case Triple::mips64el:
1460   case Triple::mipsel:
1461   case Triple::msp430:
1462   case Triple::nios2:
1463   case Triple::nvptx64:
1464   case Triple::nvptx:
1465   case Triple::ppc64le:
1466   case Triple::r600:
1467   case Triple::riscv32:
1468   case Triple::riscv64:
1469   case Triple::shave:
1470   case Triple::sparcel:
1471   case Triple::spir64:
1472   case Triple::spir:
1473   case Triple::thumb:
1474   case Triple::wasm32:
1475   case Triple::wasm64:
1476   case Triple::x86:
1477   case Triple::x86_64:
1478   case Triple::xcore:
1479   case Triple::tcele:
1480   case Triple::renderscript32:
1481   case Triple::renderscript64:
1482     return true;
1483   default:
1484     return false;
1485   }
1486 }
1487
1488 bool Triple::isCompatibleWith(const Triple &Other) const {
1489   // If vendor is apple, ignore the version number.
1490   if (getVendor() == Triple::Apple)
1491     return getArch() == Other.getArch() && getSubArch() == Other.getSubArch() &&
1492            getVendor() == Other.getVendor() && getOS() == Other.getOS();
1493
1494   return *this == Other;
1495 }
1496
1497 std::string Triple::merge(const Triple &Other) const {
1498   // If vendor is apple, pick the triple with the larger version number.
1499   if (getVendor() == Triple::Apple)
1500     if (Other.isOSVersionLT(*this))
1501       return str();
1502
1503   return Other.str();
1504 }
1505
1506 StringRef Triple::getARMCPUForArch(StringRef MArch) const {
1507   if (MArch.empty())
1508     MArch = getArchName();
1509   MArch = ARM::getCanonicalArchName(MArch);
1510
1511   // Some defaults are forced.
1512   switch (getOS()) {
1513   case llvm::Triple::FreeBSD:
1514   case llvm::Triple::NetBSD:
1515     if (!MArch.empty() && MArch == "v6")
1516       return "arm1176jzf-s";
1517     break;
1518   case llvm::Triple::Win32:
1519     // FIXME: this is invalid for WindowsCE
1520     return "cortex-a9";
1521   case llvm::Triple::MacOSX:
1522   case llvm::Triple::IOS:
1523   case llvm::Triple::WatchOS:
1524   case llvm::Triple::TvOS:
1525     if (MArch == "v7k")
1526       return "cortex-a7";
1527     break;
1528   default:
1529     break;
1530   }
1531
1532   if (MArch.empty())
1533     return StringRef();
1534
1535   StringRef CPU = ARM::getDefaultCPU(MArch);
1536   if (!CPU.empty())
1537     return CPU;
1538
1539   // If no specific architecture version is requested, return the minimum CPU
1540   // required by the OS and environment.
1541   switch (getOS()) {
1542   case llvm::Triple::NetBSD:
1543     switch (getEnvironment()) {
1544     case llvm::Triple::GNUEABIHF:
1545     case llvm::Triple::GNUEABI:
1546     case llvm::Triple::EABIHF:
1547     case llvm::Triple::EABI:
1548       return "arm926ej-s";
1549     default:
1550       return "strongarm";
1551     }
1552   case llvm::Triple::NaCl:
1553   case llvm::Triple::OpenBSD:
1554     return "cortex-a8";
1555   default:
1556     switch (getEnvironment()) {
1557     case llvm::Triple::EABIHF:
1558     case llvm::Triple::GNUEABIHF:
1559     case llvm::Triple::MuslEABIHF:
1560       return "arm1176jzf-s";
1561     default:
1562       return "arm7tdmi";
1563     }
1564   }
1565
1566   llvm_unreachable("invalid arch name");
1567 }