llvm-native-core 0.1.4

//! LLVM Target Triple — parsing and representation of target triples
//! (e.g., "x86_64-unknown-linux-gnu").
//!
//! A target triple identifies the target architecture, vendor, operating
//! system, and environment. It drives code generation decisions.
//!
//! Format: `<arch><sub>-<vendor>-<os>-<environment>`
//!
//! Clean-room behavioral reconstruction from LLVM documentation.
//! No LLVM source code is consulted.

use std::fmt;

// ═══════════════════════════════════════════════════════════════════════════
// Architecture
// ═══════════════════════════════════════════════════════════════════════════

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum Arch {
    Unknown,
    X86,
    X86_64,
    ARM,
    AArch64,
    AArch64_32,
    ARMeb,
    AArch64_be,
    Thumb,
    Thumbeb,
    RISCV32,
    RISCV64,
    Mips,
    Mipsel,
    Mips64,
    Mips64el,
    PowerPC,
    PowerPC64,
    PowerPC64le,
    Sparc,
    Sparcv9,
    SystemZ,
    BPF,
    BPFEB,
    BPF64,
    Hexagon,
    AVR,
    MSP430,
    Lanai,
    WebAssembly32,
    WebAssembly64,
    AMDGPU,
    NVPTX,
    NVPTX64,
    ARC,
    CSKY,
    Xtensa,
    LoongArch64,
    VE,
    XCore,
}

impl Arch {
    /// Parse an architecture name from a string.
    pub fn parse(s: &str) -> Self {
        match s {
            "x86" | "i386" | "i486" | "i586" | "i686" => Arch::X86,
            "x86_64" | "amd64" => Arch::X86_64,
            "arm" | "armv7" | "armv7a" | "armv7r" | "armv7m" | "armv7k" => Arch::ARM,
            "armeb" | "armv7eb" => Arch::ARMeb,
            "aarch64" | "arm64" | "armv8" | "armv8a" => Arch::AArch64,
            "aarch64_32" | "arm64_32" => Arch::AArch64_32,
            "aarch64_be" => Arch::AArch64_be,
            "thumb" | "thumbv7" | "thumbv7a" | "thumbv7r" | "thumbv7m" => Arch::Thumb,
            "thumbeb" => Arch::Thumbeb,
            "riscv32" => Arch::RISCV32,
            "riscv64" => Arch::RISCV64,
            "mips" | "mips32" | "mips32r6" => Arch::Mips,
            "mipsel" | "mips32el" | "mips32r6el" => Arch::Mipsel,
            "mips64" | "mips64r6" => Arch::Mips64,
            "mips64el" | "mips64r6el" => Arch::Mips64el,
            "ppc" | "powerpc" => Arch::PowerPC,
            "ppc64" | "powerpc64" => Arch::PowerPC64,
            "ppc64le" | "powerpc64le" => Arch::PowerPC64le,
            "sparc" => Arch::Sparc,
            "sparcv9" | "sparc64" => Arch::Sparcv9,
            "s390x" | "systemz" => Arch::SystemZ,
            "bpf" | "bpfel" => Arch::BPF,
            "bpfeb" => Arch::BPFEB,
            "bpf64" => Arch::BPF64,
            "hexagon" => Arch::Hexagon,
            "avr" => Arch::AVR,
            "msp430" => Arch::MSP430,
            "lanai" => Arch::Lanai,
            "wasm32" => Arch::WebAssembly32,
            "wasm64" => Arch::WebAssembly64,
            "amdgcn" | "amdgpu" => Arch::AMDGPU,
            "nvptx" => Arch::NVPTX,
            "nvptx64" => Arch::NVPTX64,
            "arc" => Arch::ARC,
            "csky" => Arch::CSKY,
            "xtensa" => Arch::Xtensa,
            "loongarch64" => Arch::LoongArch64,
            "ve" => Arch::VE,
            "xcore" => Arch::XCore,
            _ => Arch::Unknown,
        }
    }

    /// Canonical architecture name.
    pub fn as_str(&self) -> &'static str {
        match self {
            Arch::Unknown => "unknown",
            Arch::X86 => "i386",
            Arch::X86_64 => "x86_64",
            Arch::ARM => "arm",
            Arch::AArch64 => "aarch64",
            Arch::AArch64_32 => "aarch64_32",
            Arch::ARMeb => "armeb",
            Arch::AArch64_be => "aarch64_be",
            Arch::Thumb => "thumb",
            Arch::Thumbeb => "thumbeb",
            Arch::RISCV32 => "riscv32",
            Arch::RISCV64 => "riscv64",
            Arch::Mips => "mips",
            Arch::Mipsel => "mipsel",
            Arch::Mips64 => "mips64",
            Arch::Mips64el => "mips64el",
            Arch::PowerPC => "powerpc",
            Arch::PowerPC64 => "powerpc64",
            Arch::PowerPC64le => "powerpc64le",
            Arch::Sparc => "sparc",
            Arch::Sparcv9 => "sparcv9",
            Arch::SystemZ => "s390x",
            Arch::BPF => "bpf",
            Arch::BPFEB => "bpfeb",
            Arch::BPF64 => "bpf64",
            Arch::Hexagon => "hexagon",
            Arch::AVR => "avr",
            Arch::MSP430 => "msp430",
            Arch::Lanai => "lanai",
            Arch::WebAssembly32 => "wasm32",
            Arch::WebAssembly64 => "wasm64",
            Arch::AMDGPU => "amdgcn",
            Arch::NVPTX => "nvptx",
            Arch::NVPTX64 => "nvptx64",
            Arch::ARC => "arc",
            Arch::CSKY => "csky",
            Arch::Xtensa => "xtensa",
            Arch::LoongArch64 => "loongarch64",
            Arch::VE => "ve",
            Arch::XCore => "xcore",
        }
    }

    /// Whether this is a 64-bit architecture.
    pub fn is_64bit(&self) -> bool {
        matches!(
            self,
            Arch::X86_64
                | Arch::AArch64
                | Arch::RISCV64
                | Arch::Mips64
                | Arch::Mips64el
                | Arch::PowerPC64
                | Arch::PowerPC64le
                | Arch::Sparcv9
                | Arch::SystemZ
                | Arch::BPF64
                | Arch::WebAssembly64
                | Arch::NVPTX64
                | Arch::LoongArch64
        )
    }

    /// Whether this is a little-endian architecture.
    pub fn is_little_endian(&self) -> bool {
        !matches!(
            self,
            Arch::ARMeb
                | Arch::AArch64_be
                | Arch::Thumbeb
                | Arch::Mips
                | Arch::Mips64
                | Arch::PowerPC
                | Arch::PowerPC64
                | Arch::Sparc
                | Arch::Sparcv9
                | Arch::BPFEB
        )
    }
}

// ═══════════════════════════════════════════════════════════════════════════
// Vendor
// ═══════════════════════════════════════════════════════════════════════════

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Vendor {
    Unknown,
    Apple,
    PC,
    SCEI,
    Freescale,
    IBM,
    Imagination,
    Mips,
    Nvidia,
    AMD,
}

impl Vendor {
    pub fn parse(s: &str) -> Self {
        match s {
            "apple" => Vendor::Apple,
            "pc" => Vendor::PC,
            "scei" | "sony" => Vendor::SCEI,
            "fsl" | "freescale" => Vendor::Freescale,
            "ibm" => Vendor::IBM,
            "img" | "imagination" => Vendor::Imagination,
            "mti" | "mips" => Vendor::Mips,
            "nvidia" => Vendor::Nvidia,
            "amd" => Vendor::AMD,
            _ => Vendor::Unknown,
        }
    }

    pub fn as_str(&self) -> &'static str {
        match self {
            Vendor::Unknown => "unknown",
            Vendor::Apple => "apple",
            Vendor::PC => "pc",
            Vendor::SCEI => "scei",
            Vendor::Freescale => "fsl",
            Vendor::IBM => "ibm",
            Vendor::Imagination => "img",
            Vendor::Mips => "mti",
            Vendor::Nvidia => "nvidia",
            Vendor::AMD => "amd",
        }
    }
}

// ═══════════════════════════════════════════════════════════════════════════
// Operating System
// ═══════════════════════════════════════════════════════════════════════════

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum OS {
    Unknown,
    Linux,
    Darwin,
    MacOSX,
    IOS,
    TvOS,
    WatchOS,
    FreeBSD,
    NetBSD,
    OpenBSD,
    DragonFly,
    Win32,
    Haiku,
    Minix,
    RTEMS,
    NaCl,
    CUDA,
    NVCL,
    AMDHSA,
    PS4,
    PS5,
    Emscripten,
    AIX,
    Fuchsia,
    ZOS,
    WASI,
    Ananas,
    CloudABI,
    Hurd,
}

impl OS {
    pub fn parse(s: &str) -> Self {
        match s {
            "linux" | "linux-gnu" | "linux-musl" | "linux-android" => OS::Linux,
            "darwin" => OS::Darwin,
            "macosx" | "macos" => OS::MacOSX,
            "ios" => OS::IOS,
            "tvos" => OS::TvOS,
            "watchos" => OS::WatchOS,
            "freebsd" => OS::FreeBSD,
            "netbsd" => OS::NetBSD,
            "openbsd" => OS::OpenBSD,
            "dragonfly" => OS::DragonFly,
            "windows" | "win32" | "mingw32" | "cygwin" => OS::Win32,
            "haiku" => OS::Haiku,
            "minix" => OS::Minix,
            "rtems" => OS::RTEMS,
            "nacl" => OS::NaCl,
            "cuda" => OS::CUDA,
            "nvcl" => OS::NVCL,
            "amdhsa" => OS::AMDHSA,
            "ps4" => OS::PS4,
            "ps5" => OS::PS5,
            "emscripten" => OS::Emscripten,
            "aix" => OS::AIX,
            "fuchsia" => OS::Fuchsia,
            "zos" => OS::ZOS,
            "wasi" => OS::WASI,
            "ananas" => OS::Ananas,
            "cloudabi" => OS::CloudABI,
            "hurd" => OS::Hurd,
            _ => OS::Unknown,
        }
    }

    pub fn as_str(&self) -> &'static str {
        match self {
            OS::Unknown => "unknown",
            OS::Linux => "linux",
            OS::Darwin => "darwin",
            OS::MacOSX => "macosx",
            OS::IOS => "ios",
            OS::TvOS => "tvos",
            OS::WatchOS => "watchos",
            OS::FreeBSD => "freebsd",
            OS::NetBSD => "netbsd",
            OS::OpenBSD => "openbsd",
            OS::DragonFly => "dragonfly",
            OS::Win32 => "windows",
            OS::Haiku => "haiku",
            OS::Minix => "minix",
            OS::RTEMS => "rtems",
            OS::NaCl => "nacl",
            OS::CUDA => "cuda",
            OS::NVCL => "nvcl",
            OS::AMDHSA => "amdhsa",
            OS::PS4 => "ps4",
            OS::PS5 => "ps5",
            OS::Emscripten => "emscripten",
            OS::AIX => "aix",
            OS::Fuchsia => "fuchsia",
            OS::ZOS => "zos",
            OS::WASI => "wasi",
            OS::Ananas => "ananas",
            OS::CloudABI => "cloudabi",
            OS::Hurd => "hurd",
        }
    }

    /// Whether this is a Unix-like OS.
    pub fn is_unix(&self) -> bool {
        matches!(
            self,
            OS::Linux
                | OS::Darwin
                | OS::MacOSX
                | OS::IOS
                | OS::TvOS
                | OS::WatchOS
                | OS::FreeBSD
                | OS::NetBSD
                | OS::OpenBSD
                | OS::DragonFly
                | OS::Haiku
                | OS::Minix
                | OS::AIX
                | OS::Fuchsia
                | OS::Hurd
                | OS::PS4
                | OS::PS5
        )
    }

    /// Whether this OS uses ELF binaries.
    pub fn is_elf(&self) -> bool {
        matches!(
            self,
            OS::Linux
                | OS::FreeBSD
                | OS::NetBSD
                | OS::OpenBSD
                | OS::DragonFly
                | OS::Haiku
                | OS::Minix
                | OS::RTEMS
                | OS::NaCl
                | OS::AMDHSA
                | OS::PS4
                | OS::PS5
                | OS::Fuchsia
                | OS::Ananas
                | OS::CloudABI
                | OS::Hurd
                | OS::AIX
        )
    }

    /// Whether this OS uses Mach-O binaries.
    pub fn is_macho(&self) -> bool {
        matches!(
            self,
            OS::Darwin | OS::MacOSX | OS::IOS | OS::TvOS | OS::WatchOS
        )
    }

    /// Whether this OS uses COFF/PE binaries.
    pub fn is_coff(&self) -> bool {
        *self == OS::Win32
    }
}

// ═══════════════════════════════════════════════════════════════════════════
// Environment
// ═══════════════════════════════════════════════════════════════════════════

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Environment {
    Unknown,
    GNU,
    GNUEABI,
    GNUEABIHF,
    GNUABI64,
    GNUX32,
    Android,
    Androideabi,
    MSVC,
    Itanium,
    Cygnus,
    CoreCLR,
    Simulator,
    MacABI,
    Musl,
}

impl Environment {
    pub fn parse(s: &str) -> Self {
        match s {
            "gnu" => Environment::GNU,
            "gnueabi" => Environment::GNUEABI,
            "gnueabihf" => Environment::GNUEABIHF,
            "gnuabi64" => Environment::GNUABI64,
            "gnux32" => Environment::GNUX32,
            "android" => Environment::Android,
            "androideabi" => Environment::Androideabi,
            "msvc" | "windows-msvc" => Environment::MSVC,
            "itanium" | "windows-itanium" => Environment::Itanium,
            "cygnus" | "windows-cygnus" => Environment::Cygnus,
            "coreclr" | "windows-coreclr" => Environment::CoreCLR,
            "simulator" => Environment::Simulator,
            "macabi" => Environment::MacABI,
            "musl" | "musleabi" | "musleabihf" => Environment::Musl,
            _ => Environment::Unknown,
        }
    }

    pub fn as_str(&self) -> &'static str {
        match self {
            Environment::Unknown => "unknown",
            Environment::GNU => "gnu",
            Environment::GNUEABI => "gnueabi",
            Environment::GNUEABIHF => "gnueabihf",
            Environment::GNUABI64 => "gnuabi64",
            Environment::GNUX32 => "gnux32",
            Environment::Android => "android",
            Environment::Androideabi => "androideabi",
            Environment::MSVC => "msvc",
            Environment::Itanium => "itanium",
            Environment::Cygnus => "cygnus",
            Environment::CoreCLR => "coreclr",
            Environment::Simulator => "simulator",
            Environment::MacABI => "macabi",
            Environment::Musl => "musl",
        }
    }
}

// ═══════════════════════════════════════════════════════════════════════════
// Target Triple
// ═══════════════════════════════════════════════════════════════════════════

/// A parsed target triple identifying the compilation target.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Triple {
    pub arch: Arch,
    pub vendor: Vendor,
    pub os: OS,
    pub environment: Environment,
    /// The original triple string.
    original: String,
}

impl Triple {
    /// Parse a target triple string (e.g., "x86_64-unknown-linux-gnu").
    pub fn parse(s: &str) -> Self {
        let parts: Vec<&str> = s.split('-').collect();
        let arch = parts
            .first()
            .map(|&p| Arch::parse(p))
            .unwrap_or(Arch::Unknown);
        let vendor = parts
            .get(1)
            .map(|&p| Vendor::parse(p))
            .unwrap_or(Vendor::Unknown);
        // The OS and environment may be combined (e.g., "linux-gnu")
        let os_str = parts.get(2).copied().unwrap_or("unknown");
        let env_str = parts.get(3).copied().unwrap_or("unknown");

        // Handle combined OS-environment like "linux-gnu"
        let (os, env) = if let Some(pos) = os_str.find('-') {
            let os_part = &os_str[..pos];
            let env_part = &os_str[pos + 1..];
            (OS::parse(os_part), Environment::parse(env_part))
        } else {
            (OS::parse(os_str), Environment::parse(env_str))
        };

        // If we didn't find environment from os_str, try env_str
        let env = if env_str == "unknown" || env != Environment::Unknown {
            env
        } else {
            Environment::parse(env_str)
        };

        Triple {
            arch,
            vendor,
            os,
            environment: env,
            original: s.to_string(),
        }
    }

    /// Create a Triple for x86_64-unknown-linux-gnu.
    pub fn x86_64_linux() -> Self {
        Self::parse("x86_64-unknown-linux-gnu")
    }

    /// Create a Triple for aarch64-unknown-linux-gnu.
    pub fn aarch64_linux() -> Self {
        Self::parse("aarch64-unknown-linux-gnu")
    }

    /// Get the canonical triple string.
    pub fn to_string(&self) -> String {
        format!(
            "{}-{}-{}-{}",
            self.arch.as_str(),
            self.vendor.as_str(),
            self.os.as_str(),
            self.environment.as_str()
        )
    }

    /// Get the original triple string.
    pub fn original(&self) -> &str {
        &self.original
    }

    /// Whether this is a 64-bit target.
    pub fn is_64bit(&self) -> bool {
        self.arch.is_64bit()
    }

    /// Whether this is a little-endian target.
    pub fn is_little_endian(&self) -> bool {
        self.arch.is_little_endian()
    }

    /// Whether this target uses ELF.
    pub fn is_elf(&self) -> bool {
        self.os.is_elf()
    }

    /// Whether this target uses Mach-O.
    pub fn is_macho(&self) -> bool {
        self.os.is_macho()
    }

    /// Whether this target uses COFF.
    pub fn is_coff(&self) -> bool {
        self.os.is_coff()
    }

    /// Whether this is a Linux target.
    pub fn is_linux(&self) -> bool {
        self.os == OS::Linux
    }

    /// Whether this is a macOS target.
    pub fn is_macos(&self) -> bool {
        self.os == OS::Darwin || self.os == OS::MacOSX
    }

    /// Whether this is a Windows target.
    pub fn is_windows(&self) -> bool {
        self.os == OS::Win32
    }
}

impl Default for Triple {
    fn default() -> Self {
        Self::x86_64_linux()
    }
}

impl fmt::Display for Triple {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.to_string())
    }
}

// ═══════════════════════════════════════════════════════════════════════════
// Additional Architecture Parsing — secondary arch table
// ═══════════════════════════════════════════════════════════════════════════

/// Parse additional architecture names not in the primary Arch enum.
/// Returns a canonical architecture string for triple normalization.
pub fn parse_arch_extended(s: &str) -> Option<&'static str> {
    Some(match s {
        "r600" => "r600",
        "amdgcn" | "amdgpu" => "amdgcn",
        "ve" => "ve",
        "csky" => "csky",
        "xtensa" => "xtensa",
        "loongarch32" => "loongarch32",
        "loongarch64" => "loongarch64",
        "sparcel" => "sparcel",
        "spir" => "spir",
        "spir64" => "spir64",
        "spirv32" => "spirv32",
        "spirv64" => "spirv64",
        "kalimba" => "kalimba",
        "shave" => "shave",
        "wasm32" => "wasm32",
        "wasm64" => "wasm64",
        "renderscript32" => "renderscript32",
        "renderscript64" => "renderscript64",
        "hsail" => "hsail",
        "hsail64" => "hsail64",
        "nvptx" => "nvptx",
        "nvptx64" => "nvptx64",
        "le32" => "le32",
        "le64" => "le64",
        "amdil" => "amdil",
        "amdil64" => "amdil64",
        "tce" => "tce",
        "tcele" => "tcele",
        "mosquito" => "mosquito",
        "epiphany" => "epiphany",
        "dxil" => "dxil",
        _ => return None,
    })
}

/// Resolve a triple's architecture to its canonical base architecture.
/// This handles aliases like amdgcn→AMDGPU, arm64→AArch64.
pub fn canonicalize_arch(arch_str: &str) -> Arch {
    match arch_str {
        "x86" | "i386" | "i486" | "i586" | "i686" | "i786" => Arch::X86,
        "x86_64" | "amd64" | "x86-64" | "em64t" | "intel64" => Arch::X86_64,
        "arm" | "armv4" | "armv4t" | "armv5" | "armv5e" | "armv5t" | "armv5te" | "armv5tej"
        | "armv6" | "armv6k" | "armv6kz" | "armv6m" | "armv6sm" | "armv6t2" | "armv7"
        | "armv7a" | "armv7em" | "armv7hl" | "armv7k" | "armv7l" | "armv7m" | "armv7r"
        | "armv7s" | "armv7ve" | "armv8" | "armv8a" | "armv8l" | "armv8m.base" | "armv8m.main"
        | "armv8r" => Arch::ARM,
        "armeb" | "armv4eb" | "armv4teb" | "armv5eb" | "armv5teb" | "armv5tejb" | "armv6eb"
        | "armv6keb" | "armv6kzeb" | "armv6meb" | "armv6smeb" | "armv6t2eb" | "armv7eb"
        | "armv7aeb" | "armv7emeb" | "armv7hleb" | "armv7keb" | "armv7leb" | "armv7meb"
        | "armv7reb" | "armv7seb" | "armv7veeb" | "armv8eb" | "armv8aeb" | "armv8leb"
        | "armv8m.baseeb" | "armv8m.maineb" | "armv8reb" => Arch::ARMeb,
        "aarch64" | "arm64" | "armv8a" | "armv8-a" | "armv8.1a" | "armv8.2a" | "armv8.3a"
        | "armv8.4a" | "armv8.5a" | "armv8.6a" | "armv8.7a" | "armv8.8a" | "armv8.9a"
        | "armv9a" | "armv9-a" | "armv9.1a" | "armv9.2a" | "armv9.3a" | "armv9.4a" => Arch::AArch64,
        "aarch64_32" | "arm64_32" => Arch::AArch64_32,
        "aarch64_be" | "arm64_be" => Arch::AArch64_be,
        "thumb" | "thumbv4" | "thumbv4t" | "thumbv5" | "thumbv5e" | "thumbv5t" | "thumbv6"
        | "thumbv6m" | "thumbv6sm" | "thumbv6t2" | "thumbv7" | "thumbv7a" | "thumbv7em"
        | "thumbv7hl" | "thumbv7k" | "thumbv7l" | "thumbv7m" | "thumbv7r" | "thumbv7s"
        | "thumbv7ve" | "thumbv8" | "thumbv8.base" | "thumbv8.main" | "thumbv8m.base"
        | "thumbv8m.main" => Arch::Thumb,
        "thumbeb" | "thumbv4eb" | "thumbv4teb" | "thumbv5eb" | "thumbv5teb" | "thumbv6eb"
        | "thumbv6meb" | "thumbv6smeb" | "thumbv6t2eb" | "thumbv7eb" | "thumbv7aeb"
        | "thumbv7emeb" | "thumbv7keb" | "thumbv7meb" | "thumbv7reb" => Arch::Thumbeb,
        "riscv32" | "riscv32imac" | "riscv32imafc" => Arch::RISCV32,
        "riscv64" | "riscv64imac" | "riscv64imafdc" => Arch::RISCV64,
        "mips" | "mips32" | "mips32r2" | "mips32r3" | "mips32r5" | "mips32r6" | "mips1"
        | "mips2" => Arch::Mips,
        "mipsel" | "mips32el" | "mips32r2el" | "mips32r3el" | "mips32r5el" | "mips32r6el" => {
            Arch::Mipsel
        }
        "mips64" | "mips64r2" | "mips64r3" | "mips64r5" | "mips64r6" | "mips3" | "mips4"
        | "mips5" => Arch::Mips64,
        "mips64el" | "mips64r2el" | "mips64r3el" | "mips64r5el" | "mips64r6el" => Arch::Mips64el,
        "ppc" | "powerpc" | "ppc32" => Arch::PowerPC,
        "ppc64" | "powerpc64" => Arch::PowerPC64,
        "ppc64le" | "powerpc64le" => Arch::PowerPC64le,
        "sparc" | "sparcv8" => Arch::Sparc,
        "sparcv9" | "sparc64" => Arch::Sparcv9,
        "s390x" | "systemz" | "s390" => Arch::SystemZ,
        "bpf" | "bpfel" | "bpf32" => Arch::BPF,
        "bpfeb" | "bpf32eb" => Arch::BPFEB,
        "bpf64" | "bpf64el" => Arch::BPF64,
        "hexagon" => Arch::Hexagon,
        "avr" | "atmelavr" => Arch::AVR,
        "msp430" => Arch::MSP430,
        "lanai" => Arch::Lanai,
        "wasm32" => Arch::WebAssembly32,
        "wasm64" => Arch::WebAssembly64,
        "amdgcn" | "amdgpu" => Arch::AMDGPU,
        "nvptx" => Arch::NVPTX,
        "nvptx64" => Arch::NVPTX64,
        "arc" => Arch::ARC,
        "csky" => Arch::CSKY,
        "xtensa" => Arch::Xtensa,
        "loongarch64" | "loongarch" => Arch::LoongArch64,
        "ve" => Arch::VE,
        _ => Arch::Unknown,
    }
}

// ═══════════════════════════════════════════════════════════════════════════
// Triple Normalization — canonicalize vendor/os/env to standard forms
// ═══════════════════════════════════════════════════════════════════════════

impl Triple {
    /// Normalize the triple to its canonical form.
    /// This resolves aliases and sets vendor to "unknown" when unknown.
    pub fn normalize(&self) -> Self {
        let arch = canonicalize_arch(self.arch.as_str());
        let vendor = self.normalize_vendor();
        let os = self.normalize_os();
        let env = self.normalize_environment();
        let normalized = format!(
            "{}-{}-{}-{}",
            arch.as_str(),
            vendor.as_str(),
            os.as_str(),
            env.as_str()
        );
        Triple {
            arch,
            vendor,
            os,
            environment: env,
            original: normalized,
        }
    }

    /// Normalize the vendor to a canonical form.
    fn normalize_vendor(&self) -> Vendor {
        match self.arch {
            Arch::X86_64 | Arch::X86 => match self.os {
                OS::Darwin | OS::MacOSX | OS::IOS | OS::TvOS | OS::WatchOS => Vendor::Apple,
                OS::Win32 => Vendor::PC,
                OS::PS4 | OS::PS5 => Vendor::SCEI,
                _ => Vendor::Unknown,
            },
            Arch::AArch64
            | Arch::AArch64_32
            | Arch::AArch64_be
            | Arch::ARM
            | Arch::ARMeb
            | Arch::Thumb
            | Arch::Thumbeb => match self.os {
                OS::Darwin | OS::MacOSX | OS::IOS | OS::TvOS | OS::WatchOS => Vendor::Apple,
                OS::Win32 => Vendor::Unknown,
                _ => Vendor::Unknown,
            },
            Arch::AMDGPU => Vendor::AMD,
            Arch::NVPTX | Arch::NVPTX64 => Vendor::Nvidia,
            _ => Vendor::Unknown,
        }
    }

    /// Normalize the OS to a canonical form.
    fn normalize_os(&self) -> OS {
        match self.os {
            OS::MacOSX | OS::IOS | OS::TvOS | OS::WatchOS => self.os,
            OS::Win32 => {
                if self.environment == Environment::MSVC
                    || self.environment == Environment::Itanium
                    || self.environment == Environment::Cygnus
                    || self.environment == Environment::CoreCLR
                {
                    OS::Win32
                } else {
                    OS::Win32
                }
            }
            other => other,
        }
    }

    /// Normalize the environment to a canonical form.
    fn normalize_environment(&self) -> Environment {
        match self.os {
            OS::Linux => match self.environment {
                Environment::Android | Environment::Androideabi => Environment::Android,
                Environment::GNUEABI | Environment::GNUEABIHF => self.environment,
                Environment::Unknown => Environment::GNU,
                other => other,
            },
            OS::Darwin | OS::MacOSX => Environment::Unknown,
            OS::IOS | OS::TvOS | OS::WatchOS => Environment::Unknown,
            OS::Win32 => match self.environment {
                Environment::Unknown => Environment::MSVC,
                other => other,
            },
            _ => self.environment,
        }
    }

    /// Return the canonical triple as a lowercase string.
    pub fn normalized_string(&self) -> String {
        let n = self.normalize();
        n.to_string()
    }
}

// ═══════════════════════════════════════════════════════════════════════════
// Arch Queries — isARM, isAArch64, isX86, etc.
// ═══════════════════════════════════════════════════════════════════════════

impl Triple {
    /// Whether this is an x86 (32-bit) target.
    pub fn is_x86(&self) -> bool {
        self.arch == Arch::X86
    }

    /// Whether this is an x86-64 target.
    pub fn is_x86_64(&self) -> bool {
        self.arch == Arch::X86_64
    }

    /// Whether this is an ARM (32-bit) target.
    pub fn is_arm(&self) -> bool {
        matches!(
            self.arch,
            Arch::ARM | Arch::ARMeb | Arch::Thumb | Arch::Thumbeb
        )
    }

    /// Whether this is an AArch64 target.
    pub fn is_aarch64(&self) -> bool {
        matches!(
            self.arch,
            Arch::AArch64 | Arch::AArch64_32 | Arch::AArch64_be
        )
    }

    /// Whether this is an X86-family target (x86 or x86-64).
    pub fn is_x86_family(&self) -> bool {
        matches!(self.arch, Arch::X86 | Arch::X86_64)
    }

    /// Whether this is a RISC-V target.
    pub fn is_riscv(&self) -> bool {
        matches!(self.arch, Arch::RISCV32 | Arch::RISCV64)
    }

    /// Whether this is a MIPS target.
    pub fn is_mips(&self) -> bool {
        matches!(
            self.arch,
            Arch::Mips | Arch::Mipsel | Arch::Mips64 | Arch::Mips64el
        )
    }

    /// Whether this is a PowerPC target.
    pub fn is_ppc(&self) -> bool {
        matches!(
            self.arch,
            Arch::PowerPC | Arch::PowerPC64 | Arch::PowerPC64le
        )
    }

    /// Whether this is a BPF target.
    pub fn is_bpf(&self) -> bool {
        matches!(self.arch, Arch::BPF | Arch::BPFEB | Arch::BPF64)
    }

    /// Whether this is a WebAssembly target.
    pub fn is_wasm(&self) -> bool {
        matches!(self.arch, Arch::WebAssembly32 | Arch::WebAssembly64)
    }

    /// Whether this is an NVPTX target.
    pub fn is_nvptx(&self) -> bool {
        matches!(self.arch, Arch::NVPTX | Arch::NVPTX64)
    }

    /// Whether this is an AMDGPU target.
    pub fn is_amdgpu(&self) -> bool {
        self.arch == Arch::AMDGPU
    }

    /// Whether this is a SystemZ target.
    pub fn is_systemz(&self) -> bool {
        self.arch == Arch::SystemZ
    }

    /// Whether this is a Sparc target.
    pub fn is_sparc(&self) -> bool {
        matches!(self.arch, Arch::Sparc | Arch::Sparcv9)
    }

    /// Whether this is a VE target.
    pub fn is_ve(&self) -> bool {
        self.arch == Arch::VE
    }

    /// Whether this is a Lanai target.
    pub fn is_lanai(&self) -> bool {
        self.arch == Arch::Lanai
    }

    /// Whether this is a Hexagon target.
    pub fn is_hexagon(&self) -> bool {
        self.arch == Arch::Hexagon
    }

    /// Whether this is an AVR target.
    pub fn is_avr(&self) -> bool {
        self.arch == Arch::AVR
    }

    /// Whether this is an MSP430 target.
    pub fn is_msp430(&self) -> bool {
        self.arch == Arch::MSP430
    }

    /// Whether this is an ARC target.
    pub fn is_arc(&self) -> bool {
        self.arch == Arch::ARC
    }

    /// Whether this is a CSKY target.
    pub fn is_csky(&self) -> bool {
        self.arch == Arch::CSKY
    }

    /// Whether this is an Xtensa target.
    pub fn is_xtensa(&self) -> bool {
        self.arch == Arch::Xtensa
    }

    /// Whether this is a LoongArch target.
    pub fn is_loongarch(&self) -> bool {
        self.arch == Arch::LoongArch64
    }

    /// Whether this is a logical SPIR target.
    pub fn is_spir(&self) -> bool {
        self.arch == Arch::Unknown && self.original.contains("spir")
    }

    /// Return the architecture family as a string.
    pub fn arch_family(&self) -> &'static str {
        match self.arch {
            Arch::X86 | Arch::X86_64 => "x86",
            Arch::ARM
            | Arch::ARMeb
            | Arch::Thumb
            | Arch::Thumbeb
            | Arch::AArch64
            | Arch::AArch64_32
            | Arch::AArch64_be => "arm",
            Arch::RISCV32 | Arch::RISCV64 => "riscv",
            Arch::Mips | Arch::Mipsel | Arch::Mips64 | Arch::Mips64el => "mips",
            Arch::PowerPC | Arch::PowerPC64 | Arch::PowerPC64le => "ppc",
            Arch::Sparc | Arch::Sparcv9 => "sparc",
            Arch::SystemZ => "s390x",
            Arch::BPF | Arch::BPFEB | Arch::BPF64 => "bpf",
            Arch::Hexagon => "hexagon",
            Arch::AVR => "avr",
            Arch::MSP430 => "msp430",
            Arch::Lanai => "lanai",
            Arch::WebAssembly32 | Arch::WebAssembly64 => "wasm",
            Arch::AMDGPU => "amdgpu",
            Arch::NVPTX | Arch::NVPTX64 => "nvptx",
            Arch::ARC => "arc",
            Arch::CSKY => "csky",
            Arch::Xtensa => "xtensa",
            Arch::LoongArch64 => "loongarch",
            Arch::VE => "ve",
            _ => "unknown",
        }
    }
}

// ═══════════════════════════════════════════════════════════════════════════
// OS Queries — isLinux, isDarwin, isMacOSX, isIOS, etc.
// ═══════════════════════════════════════════════════════════════════════════

impl Triple {
    /// Whether this is a Darwin (macOS family) target.
    pub fn is_darwin(&self) -> bool {
        self.os == OS::Darwin
    }

    /// Whether this is an iOS target.
    pub fn is_ios(&self) -> bool {
        self.os == OS::IOS
    }

    /// Whether this is a tvOS target.
    pub fn is_tvos(&self) -> bool {
        self.os == OS::TvOS
    }

    /// Whether this is a watchOS target.
    pub fn is_watchos(&self) -> bool {
        self.os == OS::WatchOS
    }

    /// Whether this is any Apple platform.
    pub fn is_apple(&self) -> bool {
        matches!(
            self.os,
            OS::Darwin | OS::MacOSX | OS::IOS | OS::TvOS | OS::WatchOS
        )
    }

    /// Whether this is a FreeBSD target.
    pub fn is_freebsd(&self) -> bool {
        self.os == OS::FreeBSD
    }

    /// Whether this is a NetBSD target.
    pub fn is_netbsd(&self) -> bool {
        self.os == OS::NetBSD
    }

    /// Whether this is an OpenBSD target.
    pub fn is_openbsd(&self) -> bool {
        self.os == OS::OpenBSD
    }

    /// Whether this is a DragonFly BSD target.
    pub fn is_dragonfly(&self) -> bool {
        self.os == OS::DragonFly
    }

    /// Whether this is a Solaris target (mapped through vendor or string).
    pub fn is_solaris(&self) -> bool {
        self.original.contains("solaris") || self.original.contains("sunos")
    }

    /// Whether this is an AIX target.
    pub fn is_aix(&self) -> bool {
        self.os == OS::AIX
    }

    /// Whether this is a Fuchsia target.
    pub fn is_fuchsia(&self) -> bool {
        self.os == OS::Fuchsia
    }

    /// Whether this is a Haiku target.
    pub fn is_haiku(&self) -> bool {
        self.os == OS::Haiku
    }

    /// Whether this is an RTEMS target.
    pub fn is_rtems(&self) -> bool {
        self.os == OS::RTEMS
    }

    /// Whether this is a NaCl target.
    pub fn is_nacl(&self) -> bool {
        self.os == OS::NaCl
    }

    /// Whether this is a CUDA target.
    pub fn is_cuda(&self) -> bool {
        self.os == OS::CUDA
    }

    /// Whether this is an AMD HSA target.
    pub fn is_amdhsa(&self) -> bool {
        self.os == OS::AMDHSA
    }

    /// Whether this is a PS4 target.
    pub fn is_ps4(&self) -> bool {
        self.os == OS::PS4
    }

    /// Whether this is a PS5 target.
    pub fn is_ps5(&self) -> bool {
        self.os == OS::PS5
    }

    /// Whether this is an Emscripten target.
    pub fn is_emscripten(&self) -> bool {
        self.os == OS::Emscripten
    }

    /// Whether this is a WASI target.
    pub fn is_wasi(&self) -> bool {
        self.os == OS::WASI
    }

    /// Whether this is a Hurd target.
    pub fn is_hurd(&self) -> bool {
        self.os == OS::Hurd
    }

    /// Whether this is an Ananas target.
    pub fn is_ananas(&self) -> bool {
        self.os == OS::Ananas
    }

    /// Whether this is a CloudABI target.
    pub fn is_cloudabi(&self) -> bool {
        self.os == OS::CloudABI
    }

    /// Whether this is a z/OS target.
    pub fn is_zos(&self) -> bool {
        self.os == OS::ZOS
    }

    /// Whether this is a Minix target.
    pub fn is_minix(&self) -> bool {
        self.os == OS::Minix
    }
}

// ═══════════════════════════════════════════════════════════════════════════
// Environment Queries — isAndroid, isMusl, isGNU, etc.
// ═══════════════════════════════════════════════════════════════════════════

impl Triple {
    /// Whether the target environment is Android.
    pub fn is_android(&self) -> bool {
        matches!(
            self.environment,
            Environment::Android | Environment::Androideabi
        )
    }

    /// Whether the target uses musl libc.
    pub fn is_musl(&self) -> bool {
        self.environment == Environment::Musl
    }

    /// Whether the target uses GNU environment.
    pub fn is_gnu(&self) -> bool {
        matches!(
            self.environment,
            Environment::GNU | Environment::GNUABI64 | Environment::GNUX32
        )
    }

    /// Whether the target uses GNU EABI.
    pub fn is_gnueabi(&self) -> bool {
        self.environment == Environment::GNUEABI
    }

    /// Whether the target uses GNU EABI with hard float.
    pub fn is_gnueabihf(&self) -> bool {
        self.environment == Environment::GNUEABIHF
    }

    /// Whether the target uses MSVC environment.
    pub fn is_msvc(&self) -> bool {
        self.environment == Environment::MSVC
    }

    /// Whether the target uses Itanium C++ ABI.
    pub fn is_itanium(&self) -> bool {
        self.environment == Environment::Itanium
    }

    /// Whether the target uses Cygnus environment.
    pub fn is_cygnus(&self) -> bool {
        self.environment == Environment::Cygnus
    }

    /// Whether the target uses CoreCLR environment.
    pub fn is_coreclr(&self) -> bool {
        self.environment == Environment::CoreCLR
    }

    /// Whether the target runs on a simulator.
    pub fn is_simulator(&self) -> bool {
        self.environment == Environment::Simulator
    }

    /// Whether the target uses Mac Catalyst ABI.
    pub fn is_macabi(&self) -> bool {
        self.environment == Environment::MacABI
    }

    /// Return the libc variant used by the target.
    pub fn libc_variant(&self) -> &'static str {
        match self.os {
            OS::Win32 => "msvcrt",
            _ => match self.environment {
                Environment::Musl => "musl",
                Environment::GNU
                | Environment::GNUEABI
                | Environment::GNUEABIHF
                | Environment::GNUABI64
                | Environment::GNUX32 => "glibc",
                Environment::Android | Environment::Androideabi => "bionic",
                Environment::MSVC
                | Environment::Itanium
                | Environment::Cygnus
                | Environment::CoreCLR => "msvcrt",
                _ => "unknown",
            },
        }
    }
}

// ═══════════════════════════════════════════════════════════════════════════
// Object Format from Triple — ELF, MachO, COFF, Wasm, XCOFF, GOFF, SPIRV
// ═══════════════════════════════════════════════════════════════════════════

/// The object file format determined by the triple.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ObjectFormat {
    ELF,
    MachO,
    COFF,
    Wasm,
    XCOFF,
    GOFF,
    SPIRV,
    Unknown,
}

impl ObjectFormat {
    pub fn as_str(&self) -> &'static str {
        match self {
            ObjectFormat::ELF => "elf",
            ObjectFormat::MachO => "macho",
            ObjectFormat::COFF => "coff",
            ObjectFormat::Wasm => "wasm",
            ObjectFormat::XCOFF => "xcoff",
            ObjectFormat::GOFF => "goff",
            ObjectFormat::SPIRV => "spirv",
            ObjectFormat::Unknown => "unknown",
        }
    }
}

impl Triple {
    /// Determine the object file format for this triple.
    pub fn get_object_format(&self) -> ObjectFormat {
        match self.arch {
            Arch::WebAssembly32 | Arch::WebAssembly64 => ObjectFormat::Wasm,
            _ => match self.os {
                OS::Darwin | OS::MacOSX | OS::IOS | OS::TvOS | OS::WatchOS => ObjectFormat::MachO,
                OS::Win32 => ObjectFormat::COFF,
                OS::AIX => ObjectFormat::XCOFF,
                OS::ZOS => ObjectFormat::GOFF,
                _ => {
                    if self.original.contains("spirv") {
                        ObjectFormat::SPIRV
                    } else if self.original.contains("wasm") {
                        ObjectFormat::Wasm
                    } else {
                        ObjectFormat::ELF
                    }
                }
            },
        }
    }

    /// Check if the triple's object format matches a given format.
    pub fn is_object_format(&self, fmt: ObjectFormat) -> bool {
        self.get_object_format() == fmt
    }
}

// ═══════════════════════════════════════════════════════════════════════════
// ARM-Specific — getARMCPUForArch, getARMFloatABI, isThumb
// ═══════════════════════════════════════════════════════════════════════════

impl Triple {
    /// Get the default ARM CPU for this triple's architecture.
    pub fn get_arm_cpu_for_arch(&self) -> &'static str {
        match self.arch {
            Arch::ARM | Arch::Thumb => "cortex-a8",
            Arch::AArch64 => "cortex-a53",
            Arch::AArch64_32 => "cortex-a53",
            _ => "generic",
        }
    }

    /// Determine the ARM float ABI for this triple.
    pub fn get_arm_float_abi(&self) -> &'static str {
        match self.environment {
            Environment::GNUEABIHF => "hard",
            Environment::GNUEABI => "softfp",
            Environment::Android | Environment::Androideabi => "softfp",
            Environment::Musl => "softfp",
            _ => {
                if self.arch == Arch::ARM || self.arch == Arch::Thumb {
                    "soft"
                } else {
                    "hard"
                }
            }
        }
    }

    /// Whether this triple targets ARM hard-float.
    pub fn is_arm_hf(&self) -> bool {
        self.get_arm_float_abi() == "hard"
    }

    /// Whether this is a Thumb-mode ARM target.
    pub fn is_thumb(&self) -> bool {
        matches!(self.arch, Arch::Thumb | Arch::Thumbeb)
    }

    /// Whether this triple is compatible with ARM code generation.
    pub fn is_arm_compatible(&self) -> bool {
        matches!(
            self.arch,
            Arch::ARM
                | Arch::ARMeb
                | Arch::AArch64
                | Arch::AArch64_32
                | Arch::AArch64_be
                | Arch::Thumb
                | Arch::Thumbeb
        )
    }

    /// Return the ARM architecture version.
    pub fn arm_arch_version(&self) -> u32 {
        match self.arch {
            Arch::ARM | Arch::ARMeb | Arch::Thumb | Arch::Thumbeb => 7,
            Arch::AArch64 | Arch::AArch64_32 | Arch::AArch64_be => 8,
            _ => 0,
        }
    }
}

// ═══════════════════════════════════════════════════════════════════════════
// Merging — merge two triples, isCompatibleWith
// ═══════════════════════════════════════════════════════════════════════════

impl Triple {
    /// Merge this triple with another, resolving conflicts.
    /// The `other` triple's fields take precedence when non-Unknown.
    pub fn merge(&self, other: &Triple) -> Triple {
        let arch = if other.arch != Arch::Unknown {
            other.arch
        } else {
            self.arch
        };
        let vendor = if other.vendor != Vendor::Unknown {
            other.vendor
        } else {
            self.vendor
        };
        let os = if other.os != OS::Unknown {
            other.os
        } else {
            self.os
        };
        let env = if other.environment != Environment::Unknown {
            other.environment
        } else {
            self.environment
        };
        let merged = format!(
            "{}-{}-{}-{}",
            arch.as_str(),
            vendor.as_str(),
            os.as_str(),
            env.as_str()
        );
        Triple {
            arch,
            vendor,
            os,
            environment: env,
            original: merged,
        }
    }

    /// Check if this triple is compatible with another for linking.
    /// Two triples are compatible if they share the same architecture,
    /// same OS family, and compatible environments.
    pub fn is_compatible_with(&self, other: &Triple) -> bool {
        if self.arch != other.arch && self.arch != Arch::Unknown && other.arch != Arch::Unknown {
            return false;
        }
        let self_os_family = self.os_family();
        let other_os_family = other.os_family();
        if self_os_family != other_os_family
            && self_os_family != "unknown"
            && other_os_family != "unknown"
        {
            return false;
        }
        if self.is_arm() && other.is_arm() {
            if self.is_arm_hf() != other.is_arm_hf() {
                return false;
            }
        }
        true
    }

    /// Get the OS family (for compatibility checking).
    fn os_family(&self) -> &'static str {
        match self.os {
            OS::Linux => "linux",
            OS::Darwin | OS::MacOSX | OS::IOS | OS::TvOS | OS::WatchOS => "darwin",
            OS::Win32 => "windows",
            OS::FreeBSD | OS::NetBSD | OS::OpenBSD | OS::DragonFly => "bsd",
            OS::Haiku => "haiku",
            OS::Fuchsia => "fuchsia",
            OS::AIX => "aix",
            OS::ZOS => "zos",
            OS::CUDA | OS::NVCL => "cuda",
            OS::AMDHSA => "amdhsa",
            OS::PS4 | OS::PS5 => "ps",
            _ => "unknown",
        }
    }

    /// Check if these two triples could be the same target in different
    /// representations (aliases, different vendors, etc.).
    pub fn is_equivalent(&self, other: &Triple) -> bool {
        let a = self.normalize();
        let b = other.normalize();
        a.arch == b.arch && a.os == b.os && a.environment == b.environment
    }
}

// ═══════════════════════════════════════════════════════════════════════════
// Predefined Triple Constructors
// ═══════════════════════════════════════════════════════════════════════════

impl Triple {
    /// x86_64-unknown-linux-gnu
    pub fn host() -> Self {
        #[cfg(target_arch = "x86_64")]
        #[cfg(target_os = "linux")]
        {
            return Self::parse("x86_64-unknown-linux-gnu");
        }
        #[cfg(target_arch = "aarch64")]
        #[cfg(target_os = "linux")]
        {
            return Self::parse("aarch64-unknown-linux-gnu");
        }
        #[cfg(target_arch = "x86_64")]
        #[cfg(target_os = "macos")]
        {
            return Self::parse("x86_64-apple-macosx");
        }
        #[cfg(target_arch = "aarch64")]
        #[cfg(target_os = "macos")]
        {
            return Self::parse("aarch64-apple-macosx");
        }
        #[cfg(target_arch = "x86_64")]
        #[cfg(target_os = "windows")]
        {
            return Self::parse("x86_64-pc-windows-msvc");
        }
        Self::x86_64_linux()
    }

    /// x86_64-apple-macosx
    pub fn x86_64_macos() -> Self {
        Self::parse("x86_64-apple-macosx")
    }
    /// x86_64-pc-windows-msvc
    pub fn x86_64_windows_msvc() -> Self {
        Self::parse("x86_64-pc-windows-msvc")
    }
    /// x86_64-pc-windows-gnu
    pub fn x86_64_windows_gnu() -> Self {
        Self::parse("x86_64-pc-windows-gnu")
    }
    /// aarch64-apple-ios
    pub fn aarch64_ios() -> Self {
        Self::parse("aarch64-apple-ios")
    }
    /// aarch64-apple-macosx
    pub fn aarch64_macos() -> Self {
        Self::parse("aarch64-apple-macosx")
    }
    /// armv7-unknown-linux-gnueabihf
    pub fn arm_linux_gnueabihf() -> Self {
        Self::parse("armv7-unknown-linux-gnueabihf")
    }
    /// riscv64-unknown-linux-gnu
    pub fn riscv64_linux() -> Self {
        Self::parse("riscv64-unknown-linux-gnu")
    }
    /// riscv32-unknown-linux-gnu
    pub fn riscv32_linux() -> Self {
        Self::parse("riscv32-unknown-linux-gnu")
    }
    /// wasm32-unknown-unknown
    pub fn wasm32() -> Self {
        Self::parse("wasm32-unknown-unknown")
    }
    /// wasm32-unknown-wasi
    pub fn wasm32_wasi() -> Self {
        Self::parse("wasm32-unknown-wasi")
    }
    /// wasm64-unknown-unknown
    pub fn wasm64() -> Self {
        Self::parse("wasm64-unknown-unknown")
    }
    /// powerpc64le-unknown-linux-gnu
    pub fn ppc64le_linux() -> Self {
        Self::parse("powerpc64le-unknown-linux-gnu")
    }
    /// s390x-unknown-linux-gnu
    pub fn systemz_linux() -> Self {
        Self::parse("s390x-unknown-linux-gnu")
    }
    /// mips64el-unknown-linux-gnuabi64
    pub fn mips64el_linux() -> Self {
        Self::parse("mips64el-unknown-linux-gnuabi64")
    }
    /// sparcv9-unknown-linux-gnu
    pub fn sparc_linux() -> Self {
        Self::parse("sparcv9-unknown-linux-gnu")
    }
    /// loongarch64-unknown-linux-gnu
    pub fn loongarch64_linux() -> Self {
        Self::parse("loongarch64-unknown-linux-gnu")
    }
    /// bpf-unknown-unknown
    pub fn bpf() -> Self {
        Self::parse("bpf-unknown-unknown")
    }
    /// amdgcn-amd-amdhsa
    pub fn amdgpu() -> Self {
        Self::parse("amdgcn-amd-amdhsa")
    }
    /// nvptx64-nvidia-cuda
    pub fn nvptx64() -> Self {
        Self::parse("nvptx64-nvidia-cuda")
    }
    /// i386-unknown-linux-gnu
    pub fn i386_linux() -> Self {
        Self::parse("i386-unknown-linux-gnu")
    }
    /// aarch64-unknown-linux-musl
    pub fn aarch64_linux_musl() -> Self {
        Self::parse("aarch64-unknown-linux-musl")
    }
    /// x86_64-unknown-linux-musl
    pub fn x86_64_linux_musl() -> Self {
        Self::parse("x86_64-unknown-linux-musl")
    }
    /// armv7-unknown-linux-musleabihf
    pub fn arm_linux_musleabihf() -> Self {
        Self::parse("armv7-unknown-linux-musleabihf")
    }
    /// aarch64-linux-android
    pub fn aarch64_android() -> Self {
        Self::parse("aarch64-linux-android")
    }
    /// armv7-linux-androideabi
    pub fn arm_android() -> Self {
        Self::parse("armv7-linux-androideabi")
    }
}

// ═══════════════════════════════════════════════════════════════════════════
// Additional Triple Format Detection & Platform Queries
// ═══════════════════════════════════════════════════════════════════════════

impl Triple {
    /// Whether this target uses position-independent code by default.
    pub fn is_pic_default(&self) -> bool {
        match self.os {
            OS::Darwin | OS::MacOSX | OS::IOS | OS::TvOS | OS::WatchOS => true,
            OS::Linux => matches!(
                self.arch,
                Arch::AArch64
                    | Arch::AArch64_32
                    | Arch::AArch64_be
                    | Arch::RISCV64
                    | Arch::PowerPC64le
            ),
            OS::Win32 => false,
            OS::Fuchsia => true,
            _ => false,
        }
    }

    /// Whether this target uses Integrated Assembler by default.
    pub fn default_use_integrated_as(&self) -> bool {
        match self.arch {
            Arch::XCore | Arch::MSP430 => false,
            _ => true,
        }
    }

    /// Whether LTO is supported.
    pub fn supports_lto(&self) -> bool {
        match self.os {
            OS::Win32 | OS::Linux | OS::Darwin | OS::MacOSX | OS::FreeBSD => true,
            _ => false,
        }
    }

    /// Get the default linker flavor.
    pub fn default_linker_flavor(&self) -> &'static str {
        match self.os {
            OS::Darwin | OS::MacOSX | OS::IOS | OS::TvOS | OS::WatchOS => "darwin",
            OS::Win32 => match self.environment {
                Environment::GNU | Environment::GNUEABI | Environment::GNUEABIHF => "gnu",
                _ => "msvc",
            },
            OS::WASI => "wasm",
            _ => "gnu",
        }
    }

    /// Check if the data layout is big-endian.
    pub fn is_big_endian(&self) -> bool {
        !self.arch.is_little_endian()
    }

    /// Get the architecture bit width.
    pub fn arch_width(&self) -> u32 {
        if self.arch.is_64bit() {
            64
        } else {
            32
        }
    }

    /// Whether this is a bare-metal target (no OS).
    pub fn is_bare_metal(&self) -> bool {
        self.os == OS::Unknown && self.environment != Environment::Unknown
    }

    /// Whether this is a freestanding target.
    pub fn is_freestanding(&self) -> bool {
        self.os == OS::Unknown || self.os == OS::WASI
    }

    /// Return the default relocation model for this target.
    pub fn default_reloc_model(&self) -> &'static str {
        if self.is_pic_default() {
            "pic"
        } else {
            "static"
        }
    }

    /// Return the default code model for this target.
    pub fn default_code_model(&self) -> &'static str {
        match self.arch {
            Arch::AArch64 | Arch::AArch64_be => "small",
            Arch::X86_64 => match self.os {
                OS::Win32 => "small",
                _ => "small",
            },
            Arch::SystemZ => "medium",
            Arch::PowerPC64 | Arch::PowerPC64le => "medium",
            _ => "small",
        }
    }

    /// Whether the target supports thread-local storage.
    pub fn supports_tls(&self) -> bool {
        match self.arch {
            Arch::X86
            | Arch::X86_64
            | Arch::ARM
            | Arch::ARMeb
            | Arch::AArch64
            | Arch::AArch64_be
            | Arch::PowerPC
            | Arch::PowerPC64
            | Arch::PowerPC64le
            | Arch::SystemZ
            | Arch::Mips
            | Arch::Mipsel
            | Arch::Mips64
            | Arch::Mips64el
            | Arch::RISCV64
            | Arch::Sparc
            | Arch::Sparcv9 => true,
            _ => false,
        }
    }

    /// Whether this target supports stack probing.
    pub fn supports_stack_probing(&self) -> bool {
        self.os == OS::Win32
    }

    /// Whether this target uses .init_array/.fini_array sections.
    pub fn uses_init_array(&self) -> bool {
        match self.os {
            OS::Linux
            | OS::FreeBSD
            | OS::NetBSD
            | OS::OpenBSD
            | OS::DragonFly
            | OS::Fuchsia
            | OS::Haiku
            | OS::Hurd => true,
            OS::Darwin | OS::MacOSX | OS::IOS | OS::TvOS | OS::WatchOS => true,
            _ => false,
        }
    }

    /// Return the maximum atomic width supported (in bits).
    pub fn max_atomic_width(&self) -> u32 {
        match self.arch {
            Arch::X86 | Arch::ARM | Arch::Thumb | Arch::Mips | Arch::Mipsel => 64,
            Arch::X86_64
            | Arch::AArch64
            | Arch::PowerPC64
            | Arch::PowerPC64le
            | Arch::SystemZ
            | Arch::Mips64
            | Arch::Mips64el
            | Arch::RISCV64
            | Arch::Sparcv9
            | Arch::LoongArch64 => 128,
            Arch::AVR | Arch::MSP430 => 0,
            _ => 64,
        }
    }

    /// Check if SEH (Structured Exception Handling) is available.
    pub fn supports_seh(&self) -> bool {
        self.os == OS::Win32 && self.arch == Arch::X86_64
    }

    /// Check if DWARF exception handling is available.
    pub fn supports_dwarf_eh(&self) -> bool {
        match self.arch {
            Arch::X86
            | Arch::X86_64
            | Arch::ARM
            | Arch::AArch64
            | Arch::Mips
            | Arch::Mipsel
            | Arch::Mips64
            | Arch::Mips64el
            | Arch::PowerPC
            | Arch::PowerPC64
            | Arch::PowerPC64le
            | Arch::Sparc
            | Arch::Sparcv9
            | Arch::SystemZ
            | Arch::RISCV32
            | Arch::RISCV64
            | Arch::LoongArch64 => true,
            _ => false,
        }
    }

    /// Whether the compiler-rt builtins should be used.
    pub fn use_compiler_rt(&self) -> bool {
        self.os != OS::Win32
    }

    /// Get the C++ name mangling scheme.
    pub fn name_mangling_scheme(&self) -> &'static str {
        match self.os {
            OS::Win32 => match self.environment {
                Environment::GNU | Environment::GNUEABI | Environment::GNUEABIHF => "itanium",
                _ => "msvc",
            },
            _ => "itanium",
        }
    }

    /// Whether this target has a red zone.
    pub fn has_red_zone(&self) -> bool {
        match self.arch {
            Arch::X86_64 => self.os != OS::Win32,
            Arch::AArch64 | Arch::PowerPC64 | Arch::PowerPC64le => true,
            _ => false,
        }
    }
}

// ═══════════════════════════════════════════════════════════════════════════
// Triple Format Variant Detection
// ═══════════════════════════════════════════════════════════════════════════

/// Known triple format variants.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum TripleFormat {
    /// Four-component: arch-vendor-os-env
    Full,
    /// Three-component: arch-vendor-os
    Triple,
    /// Two-component: arch-os
    Double,
    /// One-component: arch
    Single,
}

impl Triple {
    /// Detect the triple format from the original string.
    pub fn format(&self) -> TripleFormat {
        let count = self.original.split('-').count();
        match count {
            1 => TripleFormat::Single,
            2 => TripleFormat::Double,
            3 => TripleFormat::Triple,
            _ => TripleFormat::Full,
        }
    }

    /// Get a short architecture-OS string (arch-unknown-os).
    pub fn short_triple(&self) -> String {
        format!("{}-unknown-{}", self.arch.as_str(), self.os.as_str())
    }

    /// Get the platform name (OS without version).
    pub fn platform_name(&self) -> &'static str {
        match self.os {
            OS::Linux => "linux",
            OS::Darwin | OS::MacOSX => "macos",
            OS::IOS => "ios",
            OS::TvOS => "tvos",
            OS::WatchOS => "watchos",
            OS::FreeBSD => "freebsd",
            OS::NetBSD => "netbsd",
            OS::OpenBSD => "openbsd",
            OS::DragonFly => "dragonfly",
            OS::Win32 => "windows",
            OS::Haiku => "haiku",
            OS::Fuchsia => "fuchsia",
            OS::AIX => "aix",
            OS::ZOS => "zos",
            OS::WASI => "wasi",
            OS::Emscripten => "emscripten",
            OS::NaCl => "nacl",
            OS::CUDA => "cuda",
            OS::NVCL => "nvcl",
            OS::AMDHSA => "amdhsa",
            OS::PS4 => "ps4",
            OS::PS5 => "ps5",
            OS::Minix => "minix",
            OS::RTEMS => "rtems",
            OS::Ananas => "ananas",
            OS::CloudABI => "cloudabi",
            OS::Hurd => "hurd",
            _ => "unknown",
        }
    }

    /// Build a triple from architecture and OS with default vendor/env.
    pub fn from_arch_os(arch: Arch, os: OS) -> Self {
        let vendor = match arch {
            Arch::X86_64 | Arch::X86 => match os {
                OS::Darwin | OS::MacOSX | OS::IOS | OS::TvOS | OS::WatchOS => Vendor::Apple,
                OS::Win32 => Vendor::PC,
                OS::PS4 | OS::PS5 => Vendor::SCEI,
                _ => Vendor::Unknown,
            },
            Arch::AArch64
            | Arch::AArch64_32
            | Arch::AArch64_be
            | Arch::ARM
            | Arch::ARMeb
            | Arch::Thumb
            | Arch::Thumbeb => match os {
                OS::Darwin | OS::MacOSX | OS::IOS | OS::TvOS | OS::WatchOS => Vendor::Apple,
                _ => Vendor::Unknown,
            },
            Arch::AMDGPU => Vendor::AMD,
            Arch::NVPTX | Arch::NVPTX64 => Vendor::Nvidia,
            _ => Vendor::Unknown,
        };
        let env = match os {
            OS::Linux => match arch {
                Arch::ARM | Arch::ARMeb => Environment::GNUEABI,
                Arch::Thumb | Arch::Thumbeb => Environment::GNUEABIHF,
                Arch::AArch64 | Arch::AArch64_be => Environment::GNU,
                _ => Environment::GNU,
            },
            OS::Win32 => Environment::MSVC,
            _ => Environment::Unknown,
        };
        let triple_str = format!(
            "{}-{}-{}-{}",
            arch.as_str(),
            vendor.as_str(),
            os.as_str(),
            env.as_str()
        );
        Triple {
            arch,
            vendor,
            os,
            environment: env,
            original: triple_str,
        }
    }

    /// Return a GTriple-compatible string (arch-vendor-os-env).
    pub fn as_gtriple(&self) -> String {
        self.to_string()
    }
}

// ═══════════════════════════════════════════════════════════════════════════
// Tests
// ═══════════════════════════════════════════════════════════════════════════

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_parse_x86_64_linux() {
        let t = Triple::parse("x86_64-unknown-linux-gnu");
        assert_eq!(t.arch, Arch::X86_64);
        assert!(t.is_64bit());
        assert!(t.is_little_endian());
        assert!(t.is_elf());
        assert!(t.is_linux());
    }

    #[test]
    fn test_parse_aarch64() {
        let t = Triple::parse("aarch64-unknown-linux-gnu");
        assert_eq!(t.arch, Arch::AArch64);
        assert!(t.is_64bit());
        assert!(t.is_elf());
    }

    #[test]
    fn test_parse_arm_linux() {
        let t = Triple::parse("armv7-unknown-linux-gnueabihf");
        assert_eq!(t.arch, Arch::ARM);
        assert!(!t.is_64bit());
        assert_eq!(t.environment, Environment::GNUEABIHF);
    }

    #[test]
    fn test_parse_wasm() {
        let t = Triple::parse("wasm32-unknown-unknown");
        assert_eq!(t.arch, Arch::WebAssembly32);
        assert!(!t.is_64bit());
    }

    #[test]
    fn test_parse_macos() {
        let t = Triple::parse("x86_64-apple-macosx");
        assert_eq!(t.arch, Arch::X86_64);
        assert!(t.is_macho());
        assert!(t.is_macos());
    }

    #[test]
    fn test_parse_windows() {
        let t = Triple::parse("x86_64-pc-windows-msvc");
        assert_eq!(t.arch, Arch::X86_64);
        assert!(t.is_coff());
        assert!(t.is_windows());
    }

    #[test]
    fn test_default_is_x86_64_linux() {
        let t = Triple::default();
        assert!(t.is_linux());
        assert!(t.is_64bit());
    }

    #[test]
    fn test_to_string() {
        let t = Triple::parse("aarch64-apple-ios");
        let s = t.to_string();
        assert!(s.contains("aarch64"));
        assert!(s.contains("apple"));
        assert!(s.contains("ios"));
    }

    #[test]
    fn test_arch_is_64bit() {
        assert!(Arch::X86_64.is_64bit());
        assert!(Arch::AArch64.is_64bit());
        assert!(!Arch::X86.is_64bit());
        assert!(!Arch::ARM.is_64bit());
    }

    #[test]
    fn test_os_is_unix() {
        assert!(OS::Linux.is_unix());
        assert!(OS::Darwin.is_unix());
        assert!(!OS::Win32.is_unix());
    }
}