//===--- Triple.cpp - Target triple helper class --------------------------===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

#include "llvm/ADT/Triple.h"

#include "llvm/ADT/STLExtras.h"

#include "llvm/ADT/SmallString.h"

#include "llvm/ADT/StringExtras.h"

#include "llvm/ADT/StringSwitch.h"

#include "llvm/Support/ErrorHandling.h"

#include "llvm/Support/Host.h"

#include "llvm/Support/SwapByteOrder.h"

#include "llvm/Support/TargetParser.h"

#include <cassert>

#include <cstring>

using namespace llvm;

StringRef Triple::getArchTypeName(ArchType Kind) {

  switch (Kind) {

  case UnknownArch:    return "unknown";

  case aarch64:        return "aarch64";

  case aarch64_32:     return "aarch64_32";

  case aarch64_be:     return "aarch64_be";

  case amdgcn:         return "amdgcn";

  case amdil64:        return "amdil64";

  case amdil:          return "amdil";

  case arc:            return "arc";

  case arm:            return "arm";

  case armeb:          return "armeb";

  case avr:            return "avr";

  case bpfeb:          return "bpfeb";

  case bpfel:          return "bpfel";

  case hexagon:        return "hexagon";

  case hsail64:        return "hsail64";

  case hsail:          return "hsail";

  case kalimba:        return "kalimba";

  case lanai:          return "lanai";

  case le32:           return "le32";

  case le64:           return "le64";

  case mips64:         return "mips64";

  case mips64el:       return "mips64el";

  case mips:           return "mips";

  case mipsel:         return "mipsel";

  case msp430:         return "msp430";

  case nvptx64:        return "nvptx64";

  case nvptx:          return "nvptx";

  case ppc64:          return "powerpc64";

  case ppc64le:        return "powerpc64le";

  case ppc:            return "powerpc";

  case r600:           return "r600";

  case renderscript32: return "renderscript32";

  case renderscript64: return "renderscript64";

  case riscv32:        return "riscv32";

  case riscv64:        return "riscv64";

  case shave:          return "shave";

  case sparc:          return "sparc";

  case sparcel:        return "sparcel";

  case sparcv9:        return "sparcv9";

  case spir64:         return "spir64";

  case spir:           return "spir";

  case systemz:        return "s390x";

  case tce:            return "tce";

  case tcele:          return "tcele";

  case thumb:          return "thumb";

  case thumbeb:        return "thumbeb";

  case ve:             return "ve";

  case wasm32:         return "wasm32";

  case wasm64:         return "wasm64";

  case x86:            return "i386";

  case x86_64:         return "x86_64";

  case xcore:          return "xcore";

  }

  llvm_unreachable("Invalid ArchType!");

}

StringRef Triple::getArchTypePrefix(ArchType Kind) {

  switch (Kind) {

  default:

    return StringRef();

  case aarch64:

  case aarch64_be:

  case aarch64_32:  return "aarch64";

  case arc:         return "arc";

  case arm:

  case armeb:

  case thumb:

  case thumbeb:     return "arm";

  case avr:         return "avr";

  case ppc64:

  case ppc64le:

  case ppc:         return "ppc";

  case mips:

  case mipsel:

  case mips64:

  case mips64el:    return "mips";

  case hexagon:     return "hexagon";

  case amdgcn:      return "amdgcn";

  case r600:        return "r600";

  case bpfel:

  case bpfeb:       return "bpf";

  case sparcv9:

  case sparcel:

  case sparc:       return "sparc";

  case systemz:     return "s390";

  case x86:

  case x86_64:      return "x86";

  case xcore:       return "xcore";

  // NVPTX intrinsics are namespaced under nvvm.

  case nvptx:       return "nvvm";

  case nvptx64:     return "nvvm";

  case le32:        return "le32";

  case le64:        return "le64";

  case amdil:

  case amdil64:     return "amdil";

  case hsail:

  case hsail64:     return "hsail";

  case spir:

  case spir64:      return "spir";

  case kalimba:     return "kalimba";

  case lanai:       return "lanai";

  case shave:       return "shave";

  case wasm32:

  case wasm64:      return "wasm";

  case riscv32:

  case riscv64:     return "riscv";

  case ve:          return "ve";

  }

}

StringRef Triple::getVendorTypeName(VendorType Kind) {

  switch (Kind) {

  case UnknownVendor: return "unknown";

  case AMD: return "amd";

  case Apple: return "apple";

  case BGP: return "bgp";

  case BGQ: return "bgq";

  case CSR: return "csr";

  case Freescale: return "fsl";

  case IBM: return "ibm";

  case ImaginationTechnologies: return "img";

  case Mesa: return "mesa";

  case MipsTechnologies: return "mti";

  case Myriad: return "myriad";

  case NVIDIA: return "nvidia";

  case OpenEmbedded: return "oe";

  case PC: return "pc";

  case SCEI: return "scei";

  case SUSE: return "suse";

  }

  llvm_unreachable("Invalid VendorType!");

}

StringRef Triple::getOSTypeName(OSType Kind) {

  switch (Kind) {

  case UnknownOS: return "unknown";

  case AIX: return "aix";

  case AMDHSA: return "amdhsa";

  case AMDPAL: return "amdpal";

  case Ananas: return "ananas";

  case CNK: return "cnk";

  case CUDA: return "cuda";

  case CloudABI: return "cloudabi";

  case Contiki: return "contiki";

  case Darwin: return "darwin";

  case DragonFly: return "dragonfly";

  case ELFIAMCU: return "elfiamcu";

  case Emscripten: return "emscripten";

  case FreeBSD: return "freebsd";

  case Fuchsia: return "fuchsia";

  case Haiku: return "haiku";

  case HermitCore: return "hermit";

  case Hurd: return "hurd";

  case IOS: return "ios";

  case KFreeBSD: return "kfreebsd";

  case Linux: return "linux";

  case Lv2: return "lv2";

  case MacOSX: return "macosx";

  case Mesa3D: return "mesa3d";

  case Minix: return "minix";

  case NVCL: return "nvcl";

  case NaCl: return "nacl";

  case NetBSD: return "netbsd";

  case OpenBSD: return "openbsd";

  case PS4: return "ps4";

  case RTEMS: return "rtems";

  case Solaris: return "solaris";

  case TvOS: return "tvos";

  case WASI: return "wasi";

  case WatchOS: return "watchos";

  case Win32: return "windows";

  }

  llvm_unreachable("Invalid OSType");

}

StringRef Triple::getEnvironmentTypeName(EnvironmentType Kind) {

  switch (Kind) {

  case UnknownEnvironment: return "unknown";

  case Android: return "android";

  case CODE16: return "code16";

  case CoreCLR: return "coreclr";

  case Cygnus: return "cygnus";

  case EABI: return "eabi";

  case EABIHF: return "eabihf";

  case GNU: return "gnu";

  case GNUABI64: return "gnuabi64";

  case GNUABIN32: return "gnuabin32";

  case GNUEABI: return "gnueabi";

  case GNUEABIHF: return "gnueabihf";

  case GNUX32: return "gnux32";

  case Itanium: return "itanium";

  case MSVC: return "msvc";

  case MacABI: return "macabi";

  case Musl: return "musl";

  case MuslEABI: return "musleabi";

  case MuslEABIHF: return "musleabihf";

  case Simulator: return "simulator";

  }

  llvm_unreachable("Invalid EnvironmentType!");

}

static Triple::ArchType parseBPFArch(StringRef ArchName) {

  if (ArchName.equals("bpf")) {

    if (sys::IsLittleEndianHost)

      return Triple::bpfel;

    else

      return Triple::bpfeb;

  } else if (ArchName.equals("bpf_be") || ArchName.equals("bpfeb")) {

    return Triple::bpfeb;

  } else if (ArchName.equals("bpf_le") || ArchName.equals("bpfel")) {

    return Triple::bpfel;

  } else {

    return Triple::UnknownArch;

  }

}

Triple::ArchType Triple::getArchTypeForLLVMName(StringRef Name) {

  Triple::ArchType BPFArch(parseBPFArch(Name));

  return StringSwitch<Triple::ArchType>(Name)

    .Case("aarch64", aarch64)

    .Case("aarch64_be", aarch64_be)

    .Case("aarch64_32", aarch64_32)

    .Case("arc", arc)

    .Case("arm64", aarch64) // "arm64" is an alias for "aarch64"

    .Case("arm64_32", aarch64_32)

    .Case("arm", arm)

    .Case("armeb", armeb)

    .Case("avr", avr)

    .StartsWith("bpf", BPFArch)

    .Case("mips", mips)

    .Case("mipsel", mipsel)

    .Case("mips64", mips64)

    .Case("mips64el", mips64el)

    .Case("msp430", msp430)

    .Case("ppc64", ppc64)

    .Case("ppc32", ppc)

    .Case("ppc", ppc)

    .Case("ppc64le", ppc64le)

    .Case("r600", r600)

    .Case("amdgcn", amdgcn)

    .Case("riscv32", riscv32)

    .Case("riscv64", riscv64)

    .Case("hexagon", hexagon)

    .Case("sparc", sparc)

    .Case("sparcel", sparcel)

    .Case("sparcv9", sparcv9)

    .Case("systemz", systemz)

    .Case("tce", tce)

    .Case("tcele", tcele)

    .Case("thumb", thumb)

    .Case("thumbeb", thumbeb)

    .Case("x86", x86)

    .Case("x86-64", x86_64)

    .Case("xcore", xcore)

    .Case("nvptx", nvptx)

    .Case("nvptx64", nvptx64)

    .Case("le32", le32)

    .Case("le64", le64)

    .Case("amdil", amdil)

    .Case("amdil64", amdil64)

    .Case("hsail", hsail)

    .Case("hsail64", hsail64)

    .Case("spir", spir)

    .Case("spir64", spir64)

    .Case("kalimba", kalimba)

    .Case("lanai", lanai)

    .Case("shave", shave)

    .Case("wasm32", wasm32)

    .Case("wasm64", wasm64)

    .Case("renderscript32", renderscript32)

    .Case("renderscript64", renderscript64)

    .Case("ve", ve)

    .Default(UnknownArch);

}

static Triple::ArchType parseARMArch(StringRef ArchName) {

  ARM::ISAKind ISA = ARM::parseArchISA(ArchName);

  ARM::EndianKind ENDIAN = ARM::parseArchEndian(ArchName);

  Triple::ArchType arch = Triple::UnknownArch;

  switch (ENDIAN) {

  case ARM::EndianKind::LITTLE: {

    switch (ISA) {

    case ARM::ISAKind::ARM:

      arch = Triple::arm;

      break;

    case ARM::ISAKind::THUMB:

      arch = Triple::thumb;

      break;

    case ARM::ISAKind::AARCH64:

      arch = Triple::aarch64;

      break;

    case ARM::ISAKind::INVALID:

      break;

    }

    break;

  }

  case ARM::EndianKind::BIG: {

    switch (ISA) {

    case ARM::ISAKind::ARM:

      arch = Triple::armeb;

      break;

    case ARM::ISAKind::THUMB:

      arch = Triple::thumbeb;

      break;

    case ARM::ISAKind::AARCH64:

      arch = Triple::aarch64_be;

      break;

    case ARM::ISAKind::INVALID:

      break;

    }

    break;

  }

  case ARM::EndianKind::INVALID: {

    break;

  }

  }

  ArchName = ARM::getCanonicalArchName(ArchName);

  if (ArchName.empty())

    return Triple::UnknownArch;

  // Thumb only exists in v4+

  if (ISA == ARM::ISAKind::THUMB &&

      (ArchName.startswith("v2") || ArchName.startswith("v3")))

    return Triple::UnknownArch;

  // Thumb only for v6m

  ARM::ProfileKind Profile = ARM::parseArchProfile(ArchName);

  unsigned Version = ARM::parseArchVersion(ArchName);

  if (Profile == ARM::ProfileKind::M && Version == 6) {

    if (ENDIAN == ARM::EndianKind::BIG)

      return Triple::thumbeb;

    else

      return Triple::thumb;

  }

  return arch;

}

static Triple::ArchType parseArch(StringRef ArchName) {

  auto AT = StringSwitch<Triple::ArchType>(ArchName)

    .Cases("i386", "i486", "i586", "i686", Triple::x86)

    // FIXME: Do we need to support these?

    .Cases("i786", "i886", "i986", Triple::x86)

    .Cases("amd64", "x86_64", "x86_64h", Triple::x86_64)

    .Cases("powerpc", "powerpcspe", "ppc", "ppc32", Triple::ppc)

    .Cases("powerpc64", "ppu", "ppc64", Triple::ppc64)

    .Cases("powerpc64le", "ppc64le", Triple::ppc64le)

    .Case("xscale", Triple::arm)

    .Case("xscaleeb", Triple::armeb)

    .Case("aarch64", Triple::aarch64)

    .Case("aarch64_be", Triple::aarch64_be)

    .Case("aarch64_32", Triple::aarch64_32)

    .Case("arc", Triple::arc)

    .Case("arm64", Triple::aarch64)

    .Case("arm64_32", Triple::aarch64_32)

    .Case("arm", Triple::arm)

    .Case("armeb", Triple::armeb)

    .Case("thumb", Triple::thumb)

    .Case("thumbeb", Triple::thumbeb)

    .Case("avr", Triple::avr)

    .Case("msp430", Triple::msp430)

    .Cases("mips", "mipseb", "mipsallegrex", "mipsisa32r6",

           "mipsr6", Triple::mips)

    .Cases("mipsel", "mipsallegrexel", "mipsisa32r6el", "mipsr6el",

           Triple::mipsel)

    .Cases("mips64", "mips64eb", "mipsn32", "mipsisa64r6",

           "mips64r6", "mipsn32r6", Triple::mips64)

    .Cases("mips64el", "mipsn32el", "mipsisa64r6el", "mips64r6el",

           "mipsn32r6el", Triple::mips64el)

    .Case("r600", Triple::r600)

    .Case("amdgcn", Triple::amdgcn)

    .Case("riscv32", Triple::riscv32)

    .Case("riscv64", Triple::riscv64)

    .Case("hexagon", Triple::hexagon)

    .Cases("s390x", "systemz", Triple::systemz)

    .Case("sparc", Triple::sparc)

    .Case("sparcel", Triple::sparcel)

    .Cases("sparcv9", "sparc64", Triple::sparcv9)

    .Case("tce", Triple::tce)

    .Case("tcele", Triple::tcele)

    .Case("xcore", Triple::xcore)

    .Case("nvptx", Triple::nvptx)

    .Case("nvptx64", Triple::nvptx64)

    .Case("le32", Triple::le32)

    .Case("le64", Triple::le64)

    .Case("amdil", Triple::amdil)

    .Case("amdil64", Triple::amdil64)

    .Case("hsail", Triple::hsail)

    .Case("hsail64", Triple::hsail64)

    .Case("spir", Triple::spir)

    .Case("spir64", Triple::spir64)

    .StartsWith("kalimba", Triple::kalimba)

    .Case("lanai", Triple::lanai)

    .Case("renderscript32", Triple::renderscript32)

    .Case("renderscript64", Triple::renderscript64)

    .Case("shave", Triple::shave)

    .Case("ve", Triple::ve)

    .Case("wasm32", Triple::wasm32)

    .Case("wasm64", Triple::wasm64)

    .Default(Triple::UnknownArch);

  // Some architectures require special parsing logic just to compute the

  // ArchType result.

  if (AT == Triple::UnknownArch) {

    if (ArchName.startswith("arm") || ArchName.startswith("thumb") ||

        ArchName.startswith("aarch64"))

      return parseARMArch(ArchName);

    if (ArchName.startswith("bpf"))

      return parseBPFArch(ArchName);

  }

  return AT;

}

static Triple::VendorType parseVendor(StringRef VendorName) {

  return StringSwitch<Triple::VendorType>(VendorName)

    .Case("apple", Triple::Apple)

    .Case("pc", Triple::PC)

    .Case("scei", Triple::SCEI)

    .Case("bgp", Triple::BGP)

    .Case("bgq", Triple::BGQ)

    .Case("fsl", Triple::Freescale)

    .Case("ibm", Triple::IBM)

    .Case("img", Triple::ImaginationTechnologies)

    .Case("mti", Triple::MipsTechnologies)

    .Case("nvidia", Triple::NVIDIA)

    .Case("csr", Triple::CSR)

    .Case("myriad", Triple::Myriad)

    .Case("amd", Triple::AMD)

    .Case("mesa", Triple::Mesa)

    .Case("suse", Triple::SUSE)

    .Case("oe", Triple::OpenEmbedded)

    .Default(Triple::UnknownVendor);

}

static Triple::OSType parseOS(StringRef OSName) {

  return StringSwitch<Triple::OSType>(OSName)

    .StartsWith("ananas", Triple::Ananas)

    .StartsWith("cloudabi", Triple::CloudABI)

    .StartsWith("darwin", Triple::Darwin)

    .StartsWith("dragonfly", Triple::DragonFly)

    .StartsWith("freebsd", Triple::FreeBSD)

    .StartsWith("fuchsia", Triple::Fuchsia)

    .StartsWith("ios", Triple::IOS)

    .StartsWith("kfreebsd", Triple::KFreeBSD)

    .StartsWith("linux", Triple::Linux)

    .StartsWith("lv2", Triple::Lv2)

    .StartsWith("macos", Triple::MacOSX)

    .StartsWith("netbsd", Triple::NetBSD)

    .StartsWith("openbsd", Triple::OpenBSD)

    .StartsWith("solaris", Triple::Solaris)

    .StartsWith("win32", Triple::Win32)

    .StartsWith("windows", Triple::Win32)

    .StartsWith("haiku", Triple::Haiku)

    .StartsWith("minix", Triple::Minix)

    .StartsWith("rtems", Triple::RTEMS)

    .StartsWith("nacl", Triple::NaCl)

    .StartsWith("cnk", Triple::CNK)

    .StartsWith("aix", Triple::AIX)

    .StartsWith("cuda", Triple::CUDA)

    .StartsWith("nvcl", Triple::NVCL)

    .StartsWith("amdhsa", Triple::AMDHSA)

    .StartsWith("ps4", Triple::PS4)

    .StartsWith("elfiamcu", Triple::ELFIAMCU)

    .StartsWith("tvos", Triple::TvOS)

    .StartsWith("watchos", Triple::WatchOS)

    .StartsWith("mesa3d", Triple::Mesa3D)

    .StartsWith("contiki", Triple::Contiki)

    .StartsWith("amdpal", Triple::AMDPAL)

    .StartsWith("hermit", Triple::HermitCore)

    .StartsWith("hurd", Triple::Hurd)

    .StartsWith("wasi", Triple::WASI)

    .StartsWith("emscripten", Triple::Emscripten)

    .Default(Triple::UnknownOS);

}

static Triple::EnvironmentType parseEnvironment(StringRef EnvironmentName) {

  return StringSwitch<Triple::EnvironmentType>(EnvironmentName)

    .StartsWith("eabihf", Triple::EABIHF)

    .StartsWith("eabi", Triple::EABI)

    .StartsWith("gnuabin32", Triple::GNUABIN32)

    .StartsWith("gnuabi64", Triple::GNUABI64)

    .StartsWith("gnueabihf", Triple::GNUEABIHF)

    .StartsWith("gnueabi", Triple::GNUEABI)

    .StartsWith("gnux32", Triple::GNUX32)

    .StartsWith("code16", Triple::CODE16)

    .StartsWith("gnu", Triple::GNU)

    .StartsWith("android", Triple::Android)

    .StartsWith("musleabihf", Triple::MuslEABIHF)

    .StartsWith("musleabi", Triple::MuslEABI)

    .StartsWith("musl", Triple::Musl)

    .StartsWith("msvc", Triple::MSVC)

    .StartsWith("itanium", Triple::Itanium)

    .StartsWith("cygnus", Triple::Cygnus)

    .StartsWith("coreclr", Triple::CoreCLR)

    .StartsWith("simulator", Triple::Simulator)

    .StartsWith("macabi", Triple::MacABI)

    .Default(Triple::UnknownEnvironment);

}

static Triple::ObjectFormatType parseFormat(StringRef EnvironmentName) {

  return StringSwitch<Triple::ObjectFormatType>(EnvironmentName)

    // "xcoff" must come before "coff" because of the order-dependendent

    // pattern matching.

    .EndsWith("xcoff", Triple::XCOFF)

    .EndsWith("coff", Triple::COFF)

    .EndsWith("elf", Triple::ELF)

    .EndsWith("macho", Triple::MachO)

    .EndsWith("wasm", Triple::Wasm)

    .Default(Triple::UnknownObjectFormat);

}

static Triple::SubArchType parseSubArch(StringRef SubArchName) {

  if (SubArchName.startswith("mips") &&

      (SubArchName.endswith("r6el") || SubArchName.endswith("r6")))

    return Triple::MipsSubArch_r6;

  if (SubArchName == "powerpcspe")

    return Triple::PPCSubArch_spe;

  StringRef ARMSubArch = ARM::getCanonicalArchName(SubArchName);

  // For now, this is the small part. Early return.

  if (ARMSubArch.empty())

    return StringSwitch<Triple::SubArchType>(SubArchName)

      .EndsWith("kalimba3", Triple::KalimbaSubArch_v3)

      .EndsWith("kalimba4", Triple::KalimbaSubArch_v4)

      .EndsWith("kalimba5", Triple::KalimbaSubArch_v5)

      .Default(Triple::NoSubArch);

  // ARM sub arch.

  switch(ARM::parseArch(ARMSubArch)) {

  case ARM::ArchKind::ARMV4:

    return Triple::NoSubArch;

  case ARM::ArchKind::ARMV4T:

    return Triple::ARMSubArch_v4t;

  case ARM::ArchKind::ARMV5T:

    return Triple::ARMSubArch_v5;

  case ARM::ArchKind::ARMV5TE:

  case ARM::ArchKind::IWMMXT:

  case ARM::ArchKind::IWMMXT2:

  case ARM::ArchKind::XSCALE:

  case ARM::ArchKind::ARMV5TEJ:

    return Triple::ARMSubArch_v5te;

  case ARM::ArchKind::ARMV6:

    return Triple::ARMSubArch_v6;

  case ARM::ArchKind::ARMV6K:

  case ARM::ArchKind::ARMV6KZ:

    return Triple::ARMSubArch_v6k;

  case ARM::ArchKind::ARMV6T2:

    return Triple::ARMSubArch_v6t2;

  case ARM::ArchKind::ARMV6M:

    return Triple::ARMSubArch_v6m;

  case ARM::ArchKind::ARMV7A:

  case ARM::ArchKind::ARMV7R:

    return Triple::ARMSubArch_v7;

  case ARM::ArchKind::ARMV7VE:

    return Triple::ARMSubArch_v7ve;

  case ARM::ArchKind::ARMV7K:

    return Triple::ARMSubArch_v7k;

  case ARM::ArchKind::ARMV7M:

    return Triple::ARMSubArch_v7m;

  case ARM::ArchKind::ARMV7S:

    return Triple::ARMSubArch_v7s;

  case ARM::ArchKind::ARMV7EM:

    return Triple::ARMSubArch_v7em;

  case ARM::ArchKind::ARMV8A:

    return Triple::ARMSubArch_v8;

  case ARM::ArchKind::ARMV8_1A:

    return Triple::ARMSubArch_v8_1a;

  case ARM::ArchKind::ARMV8_2A:

    return Triple::ARMSubArch_v8_2a;

  case ARM::ArchKind::ARMV8_3A:

    return Triple::ARMSubArch_v8_3a;

  case ARM::ArchKind::ARMV8_4A:

    return Triple::ARMSubArch_v8_4a;

  case ARM::ArchKind::ARMV8_5A:

    return Triple::ARMSubArch_v8_5a;

  case ARM::ArchKind::ARMV8_6A:

    return Triple::ARMSubArch_v8_6a;

  case ARM::ArchKind::ARMV8R:

    return Triple::ARMSubArch_v8r;

  case ARM::ArchKind::ARMV8MBaseline:

    return Triple::ARMSubArch_v8m_baseline;

  case ARM::ArchKind::ARMV8MMainline:

    return Triple::ARMSubArch_v8m_mainline;

  case ARM::ArchKind::ARMV8_1MMainline:

    return Triple::ARMSubArch_v8_1m_mainline;

  default:

    return Triple::NoSubArch;

  }

}

static StringRef getObjectFormatTypeName(Triple::ObjectFormatType Kind) {

  switch (Kind) {

  case Triple::UnknownObjectFormat: return "";

  case Triple::COFF:  return "coff";

  case Triple::ELF:   return "elf";

  case Triple::MachO: return "macho";

  case Triple::Wasm:  return "wasm";

  case Triple::XCOFF: return "xcoff";

  }

  llvm_unreachable("unknown object format type");

}

static Triple::ObjectFormatType getDefaultFormat(const Triple &T) {

  switch (T.getArch()) {

  case Triple::UnknownArch:

  case Triple::aarch64:

  case Triple::aarch64_32:

  case Triple::arm:

  case Triple::thumb:

  case Triple::x86:

  case Triple::x86_64:

    if (T.isOSDarwin())

      return Triple::MachO;

    else if (T.isOSWindows())

      return Triple::COFF;

    return Triple::ELF;

  case Triple::aarch64_be:

  case Triple::amdgcn:

  case Triple::amdil64:

  case Triple::amdil:

  case Triple::arc:

  case Triple::armeb:

  case Triple::avr:

  case Triple::bpfeb:

  case Triple::bpfel:

  case Triple::hexagon:

  case Triple::hsail64:

  case Triple::hsail:

  case Triple::kalimba:

  case Triple::lanai:

  case Triple::le32:

  case Triple::le64:

  case Triple::mips64:

  case Triple::mips64el:

  case Triple::mips:

  case Triple::mipsel:

  case Triple::msp430:

  case Triple::nvptx64:

  case Triple::nvptx:

  case Triple::ppc64le:

  case Triple::r600:

  case Triple::renderscript32:

  case Triple::renderscript64:

  case Triple::riscv32:

  case Triple::riscv64:

  case Triple::shave:

  case Triple::sparc:

  case Triple::sparcel:

  case Triple::sparcv9:

  case Triple::spir64:

  case Triple::spir:

  case Triple::systemz:

  case Triple::tce:

  case Triple::tcele:

  case Triple::thumbeb:

  case Triple::ve:

  case Triple::xcore:

    return Triple::ELF;

  case Triple::ppc64:

  case Triple::ppc:

    if (T.isOSAIX())

      return Triple::XCOFF;

    return Triple::ELF;

  case Triple::wasm32:

  case Triple::wasm64:

    return Triple::Wasm;

  }

  llvm_unreachable("unknown architecture");

}

/// Construct a triple from the string representation provided.

///

/// This stores the string representation and parses the various pieces into

/// enum members.

Triple::Triple(const Twine &Str)

    : Data(Str.str()), Arch(UnknownArch), SubArch(NoSubArch),

      Vendor(UnknownVendor), OS(UnknownOS), Environment(UnknownEnvironment),

      ObjectFormat(UnknownObjectFormat) {

  // Do minimal parsing by hand here.

  SmallVector<StringRef, 4> Components;

  StringRef(Data).split(Components, '-', /*MaxSplit*/ 3);

  if (Components.size() > 0) {

    Arch = parseArch(Components[0]);

    SubArch = parseSubArch(Components[0]);

    if (Components.size() > 1) {

      Vendor = parseVendor(Components[1]);

      if (Components.size() > 2) {

        OS = parseOS(Components[2]);

        if (Components.size() > 3) {

          Environment = parseEnvironment(Components[3]);

          ObjectFormat = parseFormat(Components[3]);

        }

      }

    } else {

      Environment =

          StringSwitch<Triple::EnvironmentType>(Components[0])

              .StartsWith("mipsn32", Triple::GNUABIN32)

              .StartsWith("mips64", Triple::GNUABI64)

              .StartsWith("mipsisa64", Triple::GNUABI64)

              .StartsWith("mipsisa32", Triple::GNU)

              .Cases("mips", "mipsel", "mipsr6", "mipsr6el", Triple::GNU)

              .Default(UnknownEnvironment);

    }

  }

  if (ObjectFormat == UnknownObjectFormat)

    ObjectFormat = getDefaultFormat(*this);

}

/// Construct a triple from string representations of the architecture,

/// vendor, and OS.

///

/// This joins each argument into a canonical string representation and parses

/// them into enum members. It leaves the environment unknown and omits it from

/// the string representation.

Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr)

    : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr).str()),

      Arch(parseArch(ArchStr.str())),

      SubArch(parseSubArch(ArchStr.str())),

      Vendor(parseVendor(VendorStr.str())),

      OS(parseOS(OSStr.str())),

      Environment(), ObjectFormat(Triple::UnknownObjectFormat) {

  ObjectFormat = getDefaultFormat(*this);

}

/// Construct a triple from string representations of the architecture,

/// vendor, OS, and environment.

///

/// This joins each argument into a canonical string representation and parses

/// them into enum members.

Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr,

               const Twine &EnvironmentStr)

    : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr + Twine('-') +

            EnvironmentStr).str()),

      Arch(parseArch(ArchStr.str())),

      SubArch(parseSubArch(ArchStr.str())),

      Vendor(parseVendor(VendorStr.str())),

      OS(parseOS(OSStr.str())),

      Environment(parseEnvironment(EnvironmentStr.str())),

      ObjectFormat(parseFormat(EnvironmentStr.str())) {

  if (ObjectFormat == Triple::UnknownObjectFormat)

    ObjectFormat = getDefaultFormat(*this);

}

std::string Triple::normalize(StringRef Str) {

  bool IsMinGW32 = false;

  bool IsCygwin = false;

  // Parse into components.

  SmallVector<StringRef, 4> Components;

  Str.split(Components, '-');

  // If the first component corresponds to a known architecture, preferentially

  // use it for the architecture.  If the second component corresponds to a

  // known vendor, preferentially use it for the vendor, etc.  This avoids silly

  // component movement when a component parses as (eg) both a valid arch and a

  // valid os.

  ArchType Arch = UnknownArch;

  if (Components.size() > 0)

    Arch = parseArch(Components[0]);

  VendorType Vendor = UnknownVendor;

  if (Components.size() > 1)

    Vendor = parseVendor(Components[1]);

  OSType OS = UnknownOS;

  if (Components.size() > 2) {

    OS = parseOS(Components[2]);

    IsCygwin = Components[2].startswith("cygwin");

    IsMinGW32 = Components[2].startswith("mingw");

  }

  EnvironmentType Environment = UnknownEnvironment;

  if (Components.size() > 3)

    Environment = parseEnvironment(Components[3]);

  ObjectFormatType ObjectFormat = UnknownObjectFormat;

  if (Components.size() > 4)

    ObjectFormat = parseFormat(Components[4]);

  // Note which components are already in their final position.  These will not

  // be moved.

  bool Found[4];

  Found[0] = Arch != UnknownArch;

  Found[1] = Vendor != UnknownVendor;

  Found[2] = OS != UnknownOS;

  Found[3] = Environment != UnknownEnvironment;

  // If they are not there already, permute the components into their canonical

  // positions by seeing if they parse as a valid architecture, and if so moving

  // the component to the architecture position etc.

  for (unsigned Pos = 0; Pos != array_lengthof(Found); ++Pos) {

    if (Found[Pos])

      continue; // Already in the canonical position.

    for (unsigned Idx = 0; Idx != Components.size(); ++Idx) {

      // Do not reparse any components that already matched.

      if (Idx < array_lengthof(Found) && Found[Idx])

        continue;

      // Does this component parse as valid for the target position?

      bool Valid = false;

      StringRef Comp = Components[Idx];

      switch (Pos) {

      default: llvm_unreachable("unexpected component type!");

      case 0:

        Arch = parseArch(Comp);

        Valid = Arch != UnknownArch;

        break;

      case 1:

        Vendor = parseVendor(Comp);

        Valid = Vendor != UnknownVendor;

        break;

      case 2:

        OS = parseOS(Comp);

        IsCygwin = Comp.startswith("cygwin");

        IsMinGW32 = Comp.startswith("mingw");

        Valid = OS != UnknownOS || IsCygwin || IsMinGW32;

        break;

      case 3:

        Environment = parseEnvironment(Comp);

        Valid = Environment != UnknownEnvironment;

        if (!Valid) {

          ObjectFormat = parseFormat(Comp);

          Valid = ObjectFormat != UnknownObjectFormat;

        }

        break;

      }

      if (!Valid)

        continue; // Nope, try the next component.

      // Move the component to the target position, pushing any non-fixed

      // components that are in the way to the right.  This tends to give

      // good results in the common cases of a forgotten vendor component

      // or a wrongly positioned environment.

      if (Pos < Idx) {

        // Insert left, pushing the existing components to the right.  For

        // example, a-b-i386 -> i386-a-b when moving i386 to the front.

        StringRef CurrentComponent(""); // The empty component.

        // Replace the component we are moving with an empty component.

        std::swap(CurrentComponent, Components[Idx]);

        // Insert the component being moved at Pos, displacing any existing

        // components to the right.

        for (unsigned i = Pos; !CurrentComponent.empty(); ++i) {

          // Skip over any fixed components.

          while (i < array_lengthof(Found) && Found[i])

            ++i;