llvm-native-core 0.1.16

//! Clang X86 Driver Full Integration — master driver module that coordinates
//! the complete driver-level pipeline between the Clang C/C++ frontend and the
//! LLVM X86 backend.
//!
//! This module provides the full driver infrastructure needed to compile, link,
//! and produce final binaries for x86/x86_64 targets using the Clang/LLVM Native
//! toolchain. It includes:
//!
//! 1.  **X86HostInfo** — auto-detects host CPU features, cache sizes, vector
//!     capabilities, and microarchitectural characteristics.
//! 2.  **X86TargetTriple** — full x86 target triple parsing, normalization, and
//!     resolution for all common x86 triples.
//! 3.  **X86ClangDriver** — master driver that coordinates frontend compilation,
//!     backend codegen, and tool orchestration for X86 targets.
//! 4.  **X86ToolchainPath** — header and library search path resolution for
//!     Linux (glibc/musl), Windows (MSVC/MinGW), Darwin, and Android toolchains.
//! 5.  **X86LinkerInvocation** — full linker command construction supporting
//!     GNU ld, gold, lld, and MSVC link.exe.
//! 6.  **X86AssemblerInvocation** — assembler command construction for GNU as
//!     and LLVM-MC integrated assembler.
//! 7.  **X86SanitizerSetup** — sanitizer runtime integration for Address,
//!     Memory, Thread, Undefined Behavior, Leak, DataFlow, and HWAddress
//!     sanitizers on x86 targets.
//! 8.  **X86CoverageSetup** — coverage and profiling runtime setup for
//!     `-fprofile-instr-generate`, `-fcoverage-mapping`, and PGO.
//! 9.  **X86HeaderSearch** — system header detection and search paths for C
//!     and C++ standard headers across all x86 target platforms.
//! 10. **X86StdLibSetup** — standard library detection for glibc, musl, msvcrt,
//!     bionic (Android), and macOS libSystem.
//! 11. **X86Multilib** — multilib support for `-m32`, `-m64`, and `-mx32`
//!     with automatic library path switching.
//! 12. **X86DriverArgs** — full argument parsing for x86-specific compiler
//!     flags (`-march`, `-mcpu`, `-mtune`, `-mfpmath`, `-mregparm`, etc.).
//! 13. **X86LTOConfig** — LTO and ThinLTO configuration for x86 targets
//!     including linker plugin setup and caching.
//! 14. **X86BitcodeReproducer** — reproducer generation for debugging
//!     compilation failures, capturing full driver state.
//!
//! Clean-room behavioral reconstruction from:
//! - Clang Driver Design documentation (published)
//! - GCC/Clang command-line interface specifications
//! - System V ABI: AMD64 Architecture Processor Supplement
//! - Microsoft x64 Software Conventions
//! - Intel® 64 and IA-32 Architectures Software Developer's Manual
//! - AMD64 Architecture Programmer's Manual
//! - ELF, PE/COFF, and Mach-O specifications
//!
//! Zero Clang/LLVM C++ source code consultation.

use std::collections::{BTreeMap, HashMap, HashSet};
use std::fmt;
use std::fs;
use std::path::{Path, PathBuf};
use std::process::Command as ProcessCommand;
use std::time::{Duration, SystemTime};

use crate::clang::*;
use crate::triple::{Arch, Environment, Triple, Vendor, OS};
use crate::x86::*;

// ═══════════════════════════════════════════════════════════════════════════════
// 1. X86HostInfo — Host CPU Auto-Detection
// ═══════════════════════════════════════════════════════════════════════════════

/// Auto-detected host CPU information including model, features, cache sizes,
/// and vector capabilities. Used to select `-march=native` and tune for the
/// current machine.
#[derive(Debug, Clone)]
pub struct X86HostInfo {
    /// CPU vendor string (e.g., "GenuineIntel", "AuthenticAMD").
    pub vendor: String,
    /// CPU brand string (e.g., "Intel(R) Core(TM) i7-10700K CPU @ 3.80GHz").
    pub brand: String,
    /// CPU family/model/stepping.
    pub family: u32,
    pub model: u32,
    pub stepping: u32,
    /// Detected feature flags.
    pub features: HashSet<String>,
    /// CPU feature levels: `x86-64`, `x86-64-v2`, `x86-64-v3`, `x86-64-v4`.
    pub architecture_level: X86ArchitectureLevel,
    /// Cache information.
    pub cache_l1_data_kb: u32,
    pub cache_l1_inst_kb: u32,
    pub cache_l2_kb: u32,
    pub cache_l3_kb: u32,
    /// Cache line size in bytes.
    pub cache_line_size: u32,
    /// Number of physical cores.
    pub physical_cores: u32,
    /// Number of logical processors (including HT).
    pub logical_processors: u32,
    /// Base and max frequency in MHz.
    pub base_frequency_mhz: u32,
    pub max_frequency_mhz: u32,
    /// Vector register widths supported (in bits).
    pub vector_widths: Vec<u32>,
    /// Preferred scheduling model name.
    pub sched_model: String,
    /// Whether this is a big.LITTLE hybrid architecture.
    pub is_hybrid: bool,
    /// Efficiency core model (if hybrid).
    pub e_core_model: Option<String>,
    /// Microarchitecture codename.
    pub uarch_codename: String,
    /// Whether AVX-512 is present.
    pub has_avx512: bool,
    /// Whether AMX (Advanced Matrix Extensions) is present.
    pub has_amx: bool,
}

/// x86-64 architecture feature levels as defined by the x86-64 psABI.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub enum X86ArchitectureLevel {
    /// Baseline x86-64 (SSE2, FXSR).
    V1,
    /// x86-64-v2: SSE4.2, SSSE3, POPCNT, CMPXCHG16B.
    V2,
    /// x86-64-v3: AVX2, BMI1/2, FMA, LZCNT, MOVBE.
    V3,
    /// x86-64-v4: AVX512F/BW/CD/DQ/VL.
    V4,
}

impl X86ArchitectureLevel {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::V1 => "x86-64",
            Self::V2 => "x86-64-v2",
            Self::V3 => "x86-64-v3",
            Self::V4 => "x86-64-v4",
        }
    }

    pub fn required_features(&self) -> &'static [&'static str] {
        match self {
            Self::V1 => &[
                "cmov", "cx8", "fpu", "fxsr", "mmx", "syscall", "sse", "sse2",
            ],
            Self::V2 => &["cx16", "lahf_lm", "popcnt", "sse4_1", "sse4_2", "ssse3"],
            Self::V3 => &[
                "avx", "avx2", "bmi1", "bmi2", "f16c", "fma", "abm", "movbe", "xsave",
            ],
            Self::V4 => &["avx512f", "avx512bw", "avx512cd", "avx512dq", "avx512vl"],
        }
    }

    pub fn from_features(features: &HashSet<String>) -> Self {
        let has = |f: &str| features.contains(f);

        if Self::V4.required_features().iter().all(|f| has(f)) {
            Self::V4
        } else if Self::V3.required_features().iter().all(|f| has(f)) {
            Self::V3
        } else if Self::V2.required_features().iter().all(|f| has(f)) {
            Self::V2
        } else {
            Self::V1
        }
    }
}

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

impl X86HostInfo {
    /// Create a new `X86HostInfo` by probing the host system.
    pub fn detect() -> Self {
        let mut info = Self::default_host();
        info.probe_cpuid();
        info.probe_cache();
        info.probe_topology();
        info.determine_arch_level();
        info.determine_sched_model();
        info
    }

    fn default_host() -> Self {
        Self {
            vendor: String::new(),
            brand: String::new(),
            family: 0,
            model: 0,
            stepping: 0,
            features: HashSet::new(),
            architecture_level: X86ArchitectureLevel::V1,
            cache_l1_data_kb: 32,
            cache_l1_inst_kb: 32,
            cache_l2_kb: 256,
            cache_l3_kb: 0,
            cache_line_size: 64,
            physical_cores: 1,
            logical_processors: 1,
            base_frequency_mhz: 0,
            max_frequency_mhz: 0,
            vector_widths: Vec::new(),
            sched_model: "generic".to_string(),
            is_hybrid: false,
            e_core_model: None,
            uarch_codename: "generic".to_string(),
            has_avx512: false,
            has_amx: false,
        }
    }

    /// Probe CPUID for feature flags, vendor, brand, and family/model/stepping.
    fn probe_cpuid(&mut self) {
        // In a real implementation, this would execute CPUID instructions.
        // Here we populate with common defaults for modern x86_64 processors.

        // Leaf 0: Vendor ID
        self.vendor = detect_vendor_string();

        // Leaf 1: Family/Model/Stepping + Feature flags
        self.family = 6;
        self.model = detect_cpu_model(&self.vendor);
        self.stepping = 1;

        // Feature flags from CPUID leaf 1 ECX/EDX, leaf 7 EBX/ECX/EDX
        self.features = detect_host_features(&self.vendor, self.model, self.family);

        // Leaf 0x80000002-0x80000004: Brand string
        self.brand = detect_brand_string(&self.vendor, self.model);

        // Detect vector widths
        if self.features.contains("avx512f") {
            self.vector_widths = vec![64, 128, 256, 512];
        } else if self.features.contains("avx") || self.features.contains("avx2") {
            self.vector_widths = vec![64, 128, 256];
        } else {
            self.vector_widths = vec![64, 128];
        }

        self.has_avx512 = self.features.contains("avx512f");
        self.has_amx = self.features.contains("amx-tile");
    }

    /// Probe cache topology via CPUID leaf 2/4 or sysfs on Linux.
    fn probe_cache(&mut self) {
        #[cfg(target_os = "linux")]
        {
            self.cache_l1_data_kb = read_sysfs_cache("L1-DATA").unwrap_or(32);
            self.cache_l1_inst_kb = read_sysfs_cache("L1-INST").unwrap_or(32);
            self.cache_l2_kb = read_sysfs_cache("L2").unwrap_or(256);
            self.cache_l3_kb = read_sysfs_cache("L3").unwrap_or(0);
            self.cache_line_size = read_sysfs_cache_line().unwrap_or(64);
        }
    }

    /// Probe CPU topology (cores, threads) via CPUID leaf B or sysfs.
    fn probe_topology(&mut self) {
        #[cfg(target_os = "linux")]
        {
            if let Ok(cpuinfo) = fs::read_to_string("/proc/cpuinfo") {
                let mut phys_ids = HashSet::new();
                let mut core_ids = HashSet::new();
                for line in cpuinfo.lines() {
                    if line.starts_with("physical id") {
                        if let Some(v) = line.split(':').nth(1) {
                            phys_ids.insert(v.trim().to_string());
                        }
                    }
                    if line.starts_with("core id") {
                        if let Some(v) = line.split(':').nth(1) {
                            core_ids.insert(v.trim().to_string());
                        }
                    }
                }
                self.physical_cores = phys_ids.len().max(1) as u32;
                self.logical_processors = core_ids.len().max(1) as u32;
            }
        }
        if self.logical_processors == 0 {
            self.logical_processors = num_cpus::get() as u32;
            self.physical_cores = (self.logical_processors / 2).max(1);
        }
    }

    fn determine_arch_level(&mut self) {
        self.architecture_level = X86ArchitectureLevel::from_features(&self.features);
    }

    fn determine_sched_model(&mut self) {
        self.sched_model = match (self.vendor.as_str(), self.model) {
            ("GenuineIntel", 0x8e..=0x9e) | ("GenuineIntel", 0xa5..=0xaf) => {
                self.uarch_codename = "skylake".to_string();
                "skylake".to_string()
            }
            ("GenuineIntel", 0x55..=0x57) | ("GenuineIntel", 0x6a..=0x6c) => {
                self.uarch_codename = "icelake".to_string();
                "icelake".to_string()
            }
            ("GenuineIntel", 0x97..=0x9f) | ("GenuineIntel", 0xb7..=0xbf) => {
                self.uarch_codename = "alderlake".to_string();
                self.is_hybrid = true;
                self.e_core_model = Some("gracemont".to_string());
                "alderlake".to_string()
            }
            ("AuthenticAMD", 0x00..=0x2f) => {
                self.uarch_codename = "zen2".to_string();
                "znver2".to_string()
            }
            ("AuthenticAMD", 0x30..=0x4f) => {
                self.uarch_codename = "zen3".to_string();
                "znver3".to_string()
            }
            ("AuthenticAMD", 0x60..=0x7f) => {
                self.uarch_codename = "zen4".to_string();
                "znver4".to_string()
            }
            _ => {
                self.uarch_codename = "generic".to_string();
                "generic".to_string()
            }
        };
    }

    /// Get the target CPU string for `-march=native`.
    pub fn target_cpu(&self) -> &str {
        &self.uarch_codename
    }

    /// Get enabled feature flags as a feature string for LLVM.
    pub fn target_features_string(&self) -> String {
        let mut feats: Vec<&str> = self.features.iter().map(|s| s.as_str()).collect();
        feats.sort();
        feats.join(",")
    }

    /// Check if a specific feature is supported.
    pub fn has_feature(&self, feature: &str) -> bool {
        self.features.contains(feature)
    }

    /// Get the maximum supported vector register width in bits.
    pub fn max_vector_width_bits(&self) -> u32 {
        self.vector_widths.last().copied().unwrap_or(128)
    }

    /// Check if the host supports the given architecture level.
    pub fn supports_arch_level(&self, level: X86ArchitectureLevel) -> bool {
        self.architecture_level >= level
    }
}

// ── Host detection helpers ───────────────────────────────────────────────────

fn detect_vendor_string() -> String {
    // In a real implementation, use CPUID leaf 0.
    // For now, probe common paths.
    #[cfg(target_os = "linux")]
    {
        if let Ok(cpuinfo) = fs::read_to_string("/proc/cpuinfo") {
            for line in cpuinfo.lines() {
                if line.starts_with("vendor_id") {
                    if let Some(v) = line.split(':').nth(1) {
                        return v.trim().to_string();
                    }
                }
            }
        }
    }
    // Default fallback for the test environment
    "GenuineIntel".to_string()
}

fn detect_cpu_model(vendor: &str) -> u32 {
    #[cfg(target_os = "linux")]
    {
        if let Ok(cpuinfo) = fs::read_to_string("/proc/cpuinfo") {
            for line in cpuinfo.lines() {
                if line.starts_with("model") && !line.starts_with("model name") {
                    if let Some(v) = line.split(':').nth(1) {
                        if let Ok(m) = v.trim().parse::<u32>() {
                            return m;
                        }
                    }
                }
            }
        }
    }
    match vendor {
        "AuthenticAMD" => 0x30, // Zen family default
        _ => 0x8e,              // Skylake-ish Intel default
    }
}

fn detect_host_features(vendor: &str, _model: u32, _family: u32) -> HashSet<String> {
    let mut feats = HashSet::new();

    // Base x86-64 features (always present on any x86_64 capable CPU)
    let base = [
        "cmov", "cx8", "fpu", "fxsr", "mmx", "syscall", "sse", "sse2", "sse3", "ssse3", "sse4.1",
        "sse4.2", "popcnt", "lahf_lm", "cx16", "movbe", "aes", "pclmul", "rdrnd", "xsave",
        "xsaveopt", "fsgsbase", "prfchw", "clflush", "f16c",
    ];
    for f in &base {
        feats.insert(f.to_string());
    }

    // Extended features based on vendor
    match vendor {
        "GenuineIntel" => {
            let intel_feats = [
                "avx",
                "avx2",
                "bmi",
                "bmi2",
                "fma",
                "lzcnt",
                "adx",
                "rdseed",
                "clflushopt",
                "clwb",
                "pku",
                "sgx",
                "rtm",
                "hle",
                "mpx",
                "xsaves",
            ];
            for f in &intel_feats {
                feats.insert(f.to_string());
            }
        }
        "AuthenticAMD" => {
            let amd_feats = [
                "avx",
                "avx2",
                "bmi",
                "bmi2",
                "fma",
                "lzcnt",
                "adx",
                "rdseed",
                "clflushopt",
                "clwb",
                "mwaitx",
                "clzero",
                "wbnoinvd",
                "xsaves",
            ];
            for f in &amd_feats {
                feats.insert(f.to_string());
            }
        }
        _ => {
            // Generic features
            for f in &["avx", "avx2", "bmi", "bmi2", "fma", "lzcnt"] {
                feats.insert(f.to_string());
            }
        }
    }

    feats
}

fn detect_brand_string(vendor: &str, model: u32) -> String {
    #[cfg(target_os = "linux")]
    {
        if let Ok(cpuinfo) = fs::read_to_string("/proc/cpuinfo") {
            for line in cpuinfo.lines() {
                if line.starts_with("model name") {
                    if let Some(v) = line.split(':').nth(1) {
                        return v.trim().to_string();
                    }
                }
            }
        }
    }
    match (vendor, model) {
        ("GenuineIntel", 0x8e) => "Intel(R) Core(TM) i7-8700K CPU @ 3.70GHz".to_string(),
        ("AuthenticAMD", 0x30) => "AMD Ryzen 9 5950X 16-Core Processor".to_string(),
        _ => "Unknown x86_64 CPU".to_string(),
    }
}

#[cfg(target_os = "linux")]
fn read_sysfs_cache(cache_type: &str) -> Option<u32> {
    let paths = [
        format!("/sys/devices/system/cpu/cpu0/cache/index0/size"),
        format!("/sys/devices/system/cpu/cpu0/cache/index1/size"),
        format!("/sys/devices/system/cpu/cpu0/cache/index2/size"),
        format!("/sys/devices/system/cpu/cpu0/cache/index3/size"),
    ];
    for (i, path) in paths.iter().enumerate() {
        if let Ok(type_path) = fs::read_to_string(format!(
            "/sys/devices/system/cpu/cpu0/cache/index{}/type",
            i
        )) {
            if type_path.trim() == cache_type {
                if let Ok(size_str) = fs::read_to_string(path) {
                    let s = size_str.trim();
                    if s.ends_with('K') {
                        return s[..s.len() - 1].parse::<u32>().ok();
                    }
                    if s.ends_with('M') {
                        return s[..s.len() - 1].parse::<u32>().ok().map(|v| v * 1024);
                    }
                }
            }
        }
    }
    None
}

#[cfg(target_os = "linux")]
fn read_sysfs_cache_line() -> Option<u32> {
    fs::read_to_string("/sys/devices/system/cpu/cpu0/cache/index0/coherency_line_size")
        .ok()
        .and_then(|s| s.trim().parse::<u32>().ok())
}

impl Default for X86HostInfo {
    fn default() -> Self {
        Self::detect()
    }
}

impl fmt::Display for X86HostInfo {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(
            f,
            "{} ({} cores, {} threads, {:?}, L1={}K L2={}K L3={}K)",
            self.brand,
            self.physical_cores,
            self.logical_processors,
            self.architecture_level,
            self.cache_l1_data_kb,
            self.cache_l2_kb,
            self.cache_l3_kb,
        )
    }
}

// ═══════════════════════════════════════════════════════════════════════════════
// 2. X86TargetTriple — Full x86 Target Triple Parsing
// ═══════════════════════════════════════════════════════════════════════════════

/// Represents a fully resolved x86 target triple with all sub-arch and
/// environment information.
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct X86TargetTriple {
    /// The original triple string.
    pub original: String,
    /// The canonical architecture.
    pub arch: X86TripleArch,
    /// The vendor component.
    pub vendor: X86TripleVendor,
    /// The OS component.
    pub os: X86TripleOS,
    /// The environment/ABI component.
    pub environment: X86TripleEnvironment,
    /// The normalized triple string (canonical form).
    pub normalized: String,
    /// Whether it's a 64-bit target.
    pub is_64bit: bool,
    /// Whether it's the x32 ABI (ILP32 on x86_64).
    pub is_x32: bool,
    /// The default data layout string for this triple.
    pub data_layout: String,
    /// The default object format.
    pub object_format: X86ObjectFormat,
    /// Default code model.
    pub default_code_model: X86CodeModel,
    /// Whether PIC is the default.
    pub default_pic: bool,
}

/// X86-specific architecture variants.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum X86TripleArch {
    /// i386 / i486 / i586 / i686 (32-bit)
    I386,
    /// x86_64 / amd64 (64-bit)
    X86_64,
    /// x32 ABI (ILP32 on x86_64 kernel)
    X32,
    /// i386 with specific ISA level.
    I486,
    I586,
    I686,
    /// Pentium variants.
    Pentium,
    PentiumMMX,
    PentiumPro,
    Pentium2,
    Pentium3,
    Pentium4,
    /// AMD specific.
    K6,
    K6_2,
    K6_3,
    Athlon,
    AthlonXP,
    Athlon64,
    /// Intel Core variants.
    Core2,
    Nehalem,
    SandyBridge,
    IvyBridge,
    Haswell,
    Broadwell,
    Skylake,
    Icelake,
    AlderLake,
}

impl X86TripleArch {
    pub fn from_str(s: &str) -> Self {
        match s {
            "i386" | "i486" | "i586" | "i686" | "x86" => Self::I386,
            "i486" => Self::I486,
            "i586" => Self::I586,
            "i686" => Self::I686,
            "x86_64" | "amd64" | "x86-64" | "x64" => Self::X86_64,
            "x32" => Self::X32,
            _ if s.starts_with("x86_64") => Self::X86_64,
            _ if s.starts_with("i386")
                || s.starts_with("i486")
                || s.starts_with("i586")
                || s.starts_with("i686") =>
            {
                Self::I386
            }
            _ => Self::X86_64, // Default to x86_64
        }
    }

    pub fn as_str(&self) -> &'static str {
        match self {
            Self::I386
            | Self::I486
            | Self::I586
            | Self::I686
            | Self::Pentium
            | Self::PentiumMMX
            | Self::PentiumPro
            | Self::Pentium2
            | Self::Pentium3
            | Self::Pentium4
            | Self::K6
            | Self::K6_2
            | Self::K6_3
            | Self::Athlon
            | Self::AthlonXP => "i386",
            Self::Athlon64
            | Self::Core2
            | Self::Nehalem
            | Self::SandyBridge
            | Self::IvyBridge
            | Self::Haswell
            | Self::Broadwell
            | Self::Skylake
            | Self::Icelake
            | Self::AlderLake
            | Self::X86_64 => "x86_64",
            Self::X32 => "x86_64", // x32 has x86_64 architecture
        }
    }

    pub fn is_64bit(&self) -> bool {
        matches!(
            self,
            Self::X86_64
                | Self::X32
                | Self::Athlon64
                | Self::Core2
                | Self::Nehalem
                | Self::SandyBridge
                | Self::IvyBridge
                | Self::Haswell
                | Self::Broadwell
                | Self::Skylake
                | Self::Icelake
                | Self::AlderLake
        )
    }

    pub fn pointer_width_bits(&self) -> u32 {
        if matches!(self, Self::X32) {
            32
        } else if self.is_64bit() {
            64
        } else {
            32
        }
    }
}

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

/// Vendor component of an x86 triple.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum X86TripleVendor {
    Unknown,
    PC,
    Apple,
    AMD,
    Intel,
}

impl X86TripleVendor {
    pub fn from_str(s: &str) -> Self {
        match s {
            "pc" => Self::PC,
            "apple" => Self::Apple,
            "amd" => Self::AMD,
            "intel" => Self::Intel,
            _ => Self::Unknown,
        }
    }

    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Unknown => "unknown",
            Self::PC => "pc",
            Self::Apple => "apple",
            Self::AMD => "amd",
            Self::Intel => "intel",
        }
    }
}

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

/// OS component of an x86 triple.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum X86TripleOS {
    Unknown,
    Linux,
    Darwin,
    MacOSX,
    Win32,
    FreeBSD,
    NetBSD,
    OpenBSD,
    DragonFly,
    Solaris,
    Haiku,
    Android,
    Emscripten,
    Fuchsia,
    WASI,
    Hurd,
}

impl X86TripleOS {
    pub fn from_str(s: &str) -> Self {
        match s {
            "linux" => Self::Linux,
            "darwin" | "macos" | "macosx" | "ios" => Self::Darwin,
            "macosx" => Self::MacOSX,
            "win32" | "windows" | "mingw32" | "cygwin" => Self::Win32,
            "freebsd" => Self::FreeBSD,
            "netbsd" => Self::NetBSD,
            "openbsd" => Self::OpenBSD,
            "dragonfly" => Self::DragonFly,
            "solaris" | "sunos" => Self::Solaris,
            "haiku" => Self::Haiku,
            "android" => Self::Android,
            "emscripten" => Self::Emscripten,
            "fuchsia" => Self::Fuchsia,
            "wasi" => Self::WASI,
            "hurd" => Self::Hurd,
            _ => Self::Unknown,
        }
    }

    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Unknown => "unknown",
            Self::Linux => "linux",
            Self::Darwin | Self::MacOSX => "darwin",
            Self::Win32 => "win32",
            Self::FreeBSD => "freebsd",
            Self::NetBSD => "netbsd",
            Self::OpenBSD => "openbsd",
            Self::DragonFly => "dragonfly",
            Self::Solaris => "solaris",
            Self::Haiku => "haiku",
            Self::Android => "android",
            Self::Emscripten => "emscripten",
            Self::Fuchsia => "fuchsia",
            Self::WASI => "wasi",
            Self::Hurd => "hurd",
        }
    }

    pub fn is_unix(&self) -> bool {
        matches!(
            self,
            Self::Linux
                | Self::Darwin
                | Self::MacOSX
                | Self::FreeBSD
                | Self::NetBSD
                | Self::OpenBSD
                | Self::DragonFly
                | Self::Solaris
                | Self::Haiku
                | Self::Android
                | Self::Hurd
        )
    }

    pub fn is_elf(&self) -> bool {
        matches!(
            self,
            Self::Linux
                | Self::FreeBSD
                | Self::NetBSD
                | Self::OpenBSD
                | Self::DragonFly
                | Self::Solaris
                | Self::Haiku
                | Self::Android
                | Self::Hurd
                | Self::Fuchsia
        )
    }

    pub fn is_macho(&self) -> bool {
        matches!(self, Self::Darwin | Self::MacOSX)
    }

    pub fn is_coff(&self) -> bool {
        matches!(self, Self::Win32)
    }
}

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

/// Environment/ABI component of an x86 triple.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum X86TripleEnvironment {
    Unknown,
    GNU,
    GNUEABI,
    GNUEABIHF,
    GNUX32,
    Android,
    Androideabi,
    MSVC,
    Itanium,
    Cygnus,
    Musl,
    Musleabi,
    Musleabihf,
    CoreCLR,
}

impl X86TripleEnvironment {
    pub fn from_str(s: &str) -> Self {
        match s {
            "gnu" => Self::GNU,
            "gnueabi" => Self::GNUEABI,
            "gnueabihf" => Self::GNUEABIHF,
            "gnux32" => Self::GNUX32,
            "android" => Self::Android,
            "androideabi" => Self::Androideabi,
            "msvc" => Self::MSVC,
            "itanium" => Self::Itanium,
            "cygnus" => Self::Cygnus,
            "musl" => Self::Musl,
            "musleabi" => Self::Musleabi,
            "musleabihf" => Self::Musleabihf,
            "coreclr" => Self::CoreCLR,
            _ => Self::Unknown,
        }
    }

    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Unknown => "",
            Self::GNU => "gnu",
            Self::GNUEABI => "gnueabi",
            Self::GNUEABIHF => "gnueabihf",
            Self::GNUX32 => "gnux32",
            Self::Android => "android",
            Self::Androideabi => "androideabi",
            Self::MSVC => "msvc",
            Self::Itanium => "itanium",
            Self::Cygnus => "cygnus",
            Self::Musl => "musl",
            Self::Musleabi => "musleabi",
            Self::Musleabihf => "musleabihf",
            Self::CoreCLR => "coreclr",
        }
    }

    pub fn is_msvc(&self) -> bool {
        matches!(self, Self::MSVC)
    }

    pub fn is_gnu(&self) -> bool {
        matches!(
            self,
            Self::GNU | Self::GNUEABI | Self::GNUEABIHF | Self::GNUX32
        )
    }

    pub fn is_musl(&self) -> bool {
        matches!(self, Self::Musl | Self::Musleabi | Self::Musleabihf)
    }

    pub fn is_android(&self) -> bool {
        matches!(self, Self::Android | Self::Androideabi)
    }
}

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

/// Object file format for x86 targets.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum X86ObjectFormat {
    ELF,
    MachO,
    COFF,
    Wasm,
}

impl X86ObjectFormat {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::ELF => "elf",
            Self::MachO => "macho",
            Self::COFF => "coff",
            Self::Wasm => "wasm",
        }
    }
}

/// Code model for x86 code generation.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum X86CodeModel {
    Tiny,
    Small,
    Kernel,
    Medium,
    Large,
}

impl X86CodeModel {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Tiny => "tiny",
            Self::Small => "small",
            Self::Kernel => "kernel",
            Self::Medium => "medium",
            Self::Large => "large",
        }
    }
}

impl Default for X86CodeModel {
    fn default() -> Self {
        Self::Small
    }
}

impl X86TargetTriple {
    /// Parse and fully resolve an x86 target triple string.
    pub fn parse(triple_str: &str) -> Self {
        let original = triple_str.to_string();
        let parts: Vec<&str> = triple_str.split('-').collect();

        let arch = if !parts.is_empty() {
            X86TripleArch::from_str(parts[0])
        } else {
            X86TripleArch::X86_64
        };

        let vendor = if parts.len() > 1 {
            X86TripleVendor::from_str(parts[1])
        } else {
            X86TripleVendor::Unknown
        };

        let os = if parts.len() > 2 {
            X86TripleOS::from_str(parts[2])
        } else {
            X86TripleOS::Unknown
        };

        let environment = if parts.len() > 3 {
            X86TripleEnvironment::from_str(parts[3])
        } else {
            X86TripleEnvironment::Unknown
        };

        let is_x32 = arch == X86TripleArch::X32 || environment == X86TripleEnvironment::GNUX32;
        let is_64bit = arch.is_64bit() && !is_x32;

        let object_format = if os.is_macho() {
            X86ObjectFormat::MachO
        } else if os.is_coff() {
            X86ObjectFormat::COFF
        } else {
            X86ObjectFormat::ELF
        };

        let default_pic = matches!(
            os,
            X86TripleOS::Darwin | X86TripleOS::MacOSX | X86TripleOS::Android
        );

        let default_code_model = if is_64bit {
            X86CodeModel::Small
        } else {
            X86CodeModel::Small
        };

        let data_layout = if is_64bit {
            "e-m:e-p:64:64-i64:64-i128:128-n32:64-S128".to_string()
        } else if is_x32 {
            "e-m:e-p:32:32-i64:64-i128:128-n32:64-S128".to_string()
        } else {
            "e-m:e-p:32:32-f64:32:64-f80:32-n8:16:32-S128".to_string()
        };

        // Build normalized triple
        let normalized = Self::build_normalized(arch, vendor, os, environment);

        Self {
            original,
            arch,
            vendor,
            os,
            environment,
            normalized,
            is_64bit,
            is_x32,
            data_layout,
            object_format,
            default_code_model,
            default_pic,
        }
    }

    fn build_normalized(
        arch: X86TripleArch,
        vendor: X86TripleVendor,
        os: X86TripleOS,
        env: X86TripleEnvironment,
    ) -> String {
        let env_str = env.as_str();
        if env_str.is_empty() {
            format!("{}-{}-{}", arch.as_str(), vendor.as_str(), os.as_str())
        } else {
            format!(
                "{}-{}-{}-{}",
                arch.as_str(),
                vendor.as_str(),
                os.as_str(),
                env_str
            )
        }
    }

    /// Create an x86_64-unknown-linux-gnu triple.
    pub fn x86_64_linux_gnu() -> Self {
        Self::parse("x86_64-unknown-linux-gnu")
    }

    /// Create an i386-unknown-linux-gnu triple.
    pub fn i386_linux_gnu() -> Self {
        Self::parse("i386-unknown-linux-gnu")
    }

    /// Create an x86_64-pc-windows-msvc triple.
    pub fn x86_64_windows_msvc() -> Self {
        Self::parse("x86_64-pc-windows-msvc")
    }

    /// Create an x86_64-apple-darwin triple.
    pub fn x86_64_apple_darwin() -> Self {
        Self::parse("x86_64-apple-darwin")
    }

    /// Create an x86_64-unknown-linux-musl triple.
    pub fn x86_64_linux_musl() -> Self {
        Self::parse("x86_64-unknown-linux-musl")
    }

    /// Create an i686-linux-android triple.
    pub fn i686_linux_android() -> Self {
        Self::parse("i686-linux-android")
    }

    /// Create an x86_64-linux-android triple.
    pub fn x86_64_linux_android() -> Self {
        Self::parse("x86_64-linux-android")
    }

    /// Create an x86_64-unknown-linux-gnux32 triple.
    pub fn x86_64_linux_gnux32() -> Self {
        Self::parse("x86_64-unknown-linux-gnux32")
    }

    /// Get the default linker flavor for this triple.
    pub fn default_linker(&self) -> X86LinkerFlavor {
        if self.os.is_coff() {
            if self.environment.is_msvc() {
                X86LinkerFlavor::MSVCLink
            } else {
                X86LinkerFlavor::GnuLd
            }
        } else if self.os.is_macho() {
            X86LinkerFlavor::DarwinLd
        } else {
            X86LinkerFlavor::GnuLd
        }
    }

    /// Get default C runtime object name.
    pub fn default_crt_object(&self) -> Option<&'static str> {
        match (self.os, self.environment) {
            (X86TripleOS::Win32, X86TripleEnvironment::MSVC) if self.is_64bit => Some("msvcrt"),
            (X86TripleOS::Win32, X86TripleEnvironment::MSVC) => Some("msvcrt"),
            (X86TripleOS::Win32, X86TripleEnvironment::GNU) => Some("msvcrt"),
            _ => None,
        }
    }

    /// Get the default C++ runtime library.
    pub fn default_cxx_lib(&self) -> &'static str {
        match (self.os, self.environment) {
            (X86TripleOS::Win32, X86TripleEnvironment::MSVC) => "msvcprt",
            (X86TripleOS::Android, _) => "c++_shared",
            _ => "stdc++",
        }
    }

    /// Check if this triple supports TLS.
    pub fn supports_tls(&self) -> bool {
        !self.os.is_coff() || matches!(self.environment, X86TripleEnvironment::GNU)
    }

    /// Check if SEH (Structured Exception Handling) is the default.
    pub fn default_seh(&self) -> bool {
        self.os.is_coff() && matches!(self.environment, X86TripleEnvironment::MSVC) && self.is_64bit
    }

    /// Check if DWARF EH is the default.
    pub fn default_dwarf_eh(&self) -> bool {
        !self.os.is_coff() || matches!(self.environment, X86TripleEnvironment::GNU)
    }
}

impl Default for X86TargetTriple {
    fn default() -> Self {
        Self::x86_64_linux_gnu()
    }
}

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

// ═══════════════════════════════════════════════════════════════════════════════
// 3. X86ClangDriver — Master Driver
// ═══════════════════════════════════════════════════════════════════════════════

/// Linker flavor for x86 targets.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum X86LinkerFlavor {
    /// GNU ld (bfd or gold).
    GnuLd,
    /// lld (LLVM's linker).
    Lld,
    /// Darwin ld64 / ld_prime.
    DarwinLd,
    /// MSVC link.exe.
    MSVCLink,
    /// lld-link (Windows).
    LldLink,
}

impl X86LinkerFlavor {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::GnuLd => "gnu-ld",
            Self::Lld => "lld",
            Self::DarwinLd => "darwin-ld",
            Self::MSVCLink => "msvc-link",
            Self::LldLink => "lld-link",
        }
    }

    pub fn default_executable(&self) -> &'static str {
        match self {
            Self::GnuLd => "ld",
            Self::Lld => "ld.lld",
            Self::DarwinLd => "ld",
            Self::MSVCLink => "link.exe",
            Self::LldLink => "lld-link",
        }
    }

    pub fn supports_lto(&self) -> bool {
        matches!(
            self,
            Self::GnuLd | Self::Lld | Self::DarwinLd | Self::LldLink
        )
    }

    pub fn supports_thin_lto(&self) -> bool {
        matches!(self, Self::Lld | Self::LldLink)
    }
}

/// The master Clang X86 driver. Coordinates compilation from source to binary.
#[derive(Debug, Clone)]
pub struct X86ClangDriver {
    /// Target triple information.
    pub triple: X86TargetTriple,
    /// Host CPU information.
    pub host_info: X86HostInfo,
    /// Toolchain paths.
    pub toolchain: X86ToolchainPath,
    /// Parsed x86-specific arguments.
    pub x86_args: X86DriverArgs,
    /// Linker configuration.
    pub linker_flavor: X86LinkerFlavor,
    /// Sanitizer setup.
    pub sanitizers: X86SanitizerSetup,
    /// Coverage/profiling setup.
    pub coverage: X86CoverageSetup,
    /// Header search configuration.
    pub header_search: X86HeaderSearch,
    /// Standard library setup.
    pub stdlib: X86StdLibSetup,
    /// Multilib configuration.
    pub multilib: X86Multilib,
    /// LTO configuration.
    pub lto_config: X86LTOConfig,
    /// Bitcode reproducer.
    pub reproducer: Option<X86BitcodeReproducer>,
    /// Clang options (language standard, etc.).
    pub clang_options: ClangOptions,
    /// Input files to compile.
    pub input_files: Vec<PathBuf>,
    /// Output file path.
    pub output_file: Option<PathBuf>,
    /// Include paths (-I).
    pub include_paths: Vec<PathBuf>,
    /// System include paths.
    pub system_include_paths: Vec<PathBuf>,
    /// Library paths (-L).
    pub library_paths: Vec<PathBuf>,
    /// Libraries to link (-l).
    pub libraries: Vec<String>,
    /// Defines (-D NAME=VALUE).
    pub defines: Vec<(String, Option<String>)>,
    /// Undefines (-U).
    pub undefines: Vec<String>,
    /// Optimization level.
    pub opt_level: X86DriverOptLevel,
    /// Debug info kind.
    pub debug_info: X86DriverDebugInfo,
    /// PIC/PIE level.
    pub pic_level: X86DriverPicLevel,
    /// Verbose output.
    pub verbose: bool,
    /// Dry run (print commands, don't execute).
    pub dry_run: bool,
    /// Extra linker flags.
    pub linker_flags: Vec<String>,
    /// Extra assembler flags.
    pub assembler_flags: Vec<String>,
    /// Preprocessor defines from flags.
    pub preprocessor_defines: Vec<String>,
    /// Output type.
    pub output_type: X86DriverOutputType,
    /// Compilation phases to execute.
    pub phases: Vec<X86CompilationPhase>,
}

/// Optimization level for the driver.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum X86DriverOptLevel {
    O0,
    O1,
    O2,
    O3,
    Os,
    Oz,
}

impl X86DriverOptLevel {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::O0 => "-O0",
            Self::O1 => "-O1",
            Self::O2 => "-O2",
            Self::O3 => "-O3",
            Self::Os => "-Os",
            Self::Oz => "-Oz",
        }
    }

    pub fn is_optimizing(&self) -> bool {
        !matches!(self, Self::O0)
    }

    pub fn lto_enabled_by_default(&self) -> bool {
        false
    }
}

impl Default for X86DriverOptLevel {
    fn default() -> Self {
        Self::O0
    }
}

/// Debug info configuration.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum X86DriverDebugInfo {
    None,
    LineTablesOnly,
    Limited,
    Full,
    FullWithMacros,
}

impl X86DriverDebugInfo {
    pub fn has_debug(&self) -> bool {
        !matches!(self, Self::None)
    }
}

impl Default for X86DriverDebugInfo {
    fn default() -> Self {
        Self::None
    }
}

/// PIC/PIE level.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum X86DriverPicLevel {
    Default,
    PIC,
    PIE,
    NoPIC,
}

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

/// Output type for the compilation.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum X86DriverOutputType {
    PreprocessedSource,
    LLVMIR,
    LLVMBitcode,
    Assembly,
    Object,
    SharedLibrary,
    Executable,
}

impl X86DriverOutputType {
    pub fn extension(&self) -> &'static str {
        match self {
            Self::PreprocessedSource => ".i",
            Self::LLVMIR => ".ll",
            Self::LLVMBitcode => ".bc",
            Self::Assembly => ".s",
            Self::Object => ".o",
            Self::SharedLibrary => ".so",
            Self::Executable => "",
        }
    }

    pub fn requires_linking(&self) -> bool {
        matches!(self, Self::SharedLibrary | Self::Executable)
    }
}

impl Default for X86DriverOutputType {
    fn default() -> Self {
        Self::Executable
    }
}

/// Compilation phases the driver can execute.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub enum X86CompilationPhase {
    Preprocess,
    Compile,
    Backend,
    Assemble,
    Link,
}

impl X86CompilationPhase {
    pub fn name(&self) -> &'static str {
        match self {
            Self::Preprocess => "preprocess",
            Self::Compile => "compile",
            Self::Backend => "backend",
            Self::Assemble => "assemble",
            Self::Link => "link",
        }
    }

    pub fn all() -> &'static [Self] {
        &[
            Self::Preprocess,
            Self::Compile,
            Self::Backend,
            Self::Assemble,
            Self::Link,
        ]
    }
}

impl X86ClangDriver {
    /// Create a new X86ClangDriver with default settings.
    pub fn new() -> Self {
        let host_info = X86HostInfo::detect();
        let triple = X86TargetTriple::x86_64_linux_gnu();
        let toolchain = X86ToolchainPath::detect(&triple);
        let x86_args = X86DriverArgs::default();

        Self {
            linker_flavor: triple.default_linker(),
            sanitizers: X86SanitizerSetup::new(),
            coverage: X86CoverageSetup::new(),
            header_search: X86HeaderSearch::new(&triple, &toolchain),
            stdlib: X86StdLibSetup::new(&triple, &toolchain),
            multilib: X86Multilib::new(&triple),
            lto_config: X86LTOConfig::default(),
            reproducer: None,
            clang_options: ClangOptions::default(),
            triple,
            host_info,
            toolchain,
            x86_args,
            input_files: Vec::new(),
            output_file: None,
            include_paths: Vec::new(),
            system_include_paths: Vec::new(),
            library_paths: Vec::new(),
            libraries: Vec::new(),
            defines: Vec::new(),
            undefines: Vec::new(),
            opt_level: X86DriverOptLevel::default(),
            debug_info: X86DriverDebugInfo::default(),
            pic_level: X86DriverPicLevel::default(),
            verbose: false,
            dry_run: false,
            linker_flags: Vec::new(),
            assembler_flags: Vec::new(),
            preprocessor_defines: Vec::new(),
            output_type: X86DriverOutputType::default(),
            phases: X86CompilationPhase::all().to_vec(),
        }
    }

    /// Build a driver with Linux x86_64 defaults.
    pub fn x86_64_linux() -> Self {
        let mut driver = Self::new();
        driver.triple = X86TargetTriple::x86_64_linux_gnu();
        driver.toolchain = X86ToolchainPath::detect(&driver.triple);
        driver.linker_flavor = driver.triple.default_linker();
        driver.header_search = X86HeaderSearch::new(&driver.triple, &driver.toolchain);
        driver.stdlib = X86StdLibSetup::new(&driver.triple, &driver.toolchain);
        driver
    }

    /// Build a driver with i386 Linux defaults.
    pub fn i386_linux() -> Self {
        let mut driver = Self::new();
        driver.triple = X86TargetTriple::i386_linux_gnu();
        driver.toolchain = X86ToolchainPath::detect(&driver.triple);
        driver.linker_flavor = driver.triple.default_linker();
        driver.multilib = X86Multilib::new(&driver.triple);
        driver.header_search = X86HeaderSearch::new(&driver.triple, &driver.toolchain);
        driver.stdlib = X86StdLibSetup::new(&driver.triple, &driver.toolchain);
        driver
    }

    /// Build a driver with Windows x86_64 MSVC defaults.
    pub fn x86_64_windows() -> Self {
        let mut driver = Self::new();
        driver.triple = X86TargetTriple::x86_64_windows_msvc();
        driver.toolchain = X86ToolchainPath::detect(&driver.triple);
        driver.linker_flavor = driver.triple.default_linker();
        driver.header_search = X86HeaderSearch::new(&driver.triple, &driver.toolchain);
        driver.stdlib = X86StdLibSetup::new(&driver.triple, &driver.toolchain);
        driver
    }

    /// Parse command-line arguments into the driver.
    pub fn parse_args(&mut self, args: &[String]) {
        self.x86_args = X86DriverArgs::parse(args);

        // Apply x86_args to driver state
        if let Some(ref arch) = self.x86_args.march {
            self.x86_args.target_cpu = Some(arch.clone());
        }
        if let Some(ref cpu) = self.x86_args.mcpu {
            self.x86_args.target_cpu = Some(cpu.clone());
        }

        if let Some(ref triple) = self.x86_args.target {
            self.triple = X86TargetTriple::parse(triple);
            self.toolchain = X86ToolchainPath::detect(&self.triple);
            self.linker_flavor = self.triple.default_linker();
            self.header_search = X86HeaderSearch::new(&self.triple, &self.toolchain);
            self.stdlib = X86StdLibSetup::new(&self.triple, &self.toolchain);
        }

        if self.x86_args.m32 {
            self.triple = X86TargetTriple::i386_linux_gnu();
            self.multilib.select_32bit();
            self.toolchain = X86ToolchainPath::detect(&self.triple);
            self.header_search = X86HeaderSearch::new(&self.triple, &self.toolchain);
            self.stdlib = X86StdLibSetup::new(&self.triple, &self.toolchain);
        } else if self.x86_args.mx32 {
            self.triple = X86TargetTriple::x86_64_linux_gnux32();
            self.multilib.select_x32();
            self.toolchain = X86ToolchainPath::detect(&self.triple);
        }

        // Apply optimization level
        if let Some(opt) = &self.x86_args.opt_level {
            self.opt_level = *opt;
        }

        // Apply PIC/PIE
        if self.x86_args.fpic || self.x86_args.fPIC {
            self.pic_level = X86DriverPicLevel::PIC;
        } else if self.x86_args.fpie || self.x86_args.fPIE {
            self.pic_level = X86DriverPicLevel::PIE;
        } else if self.x86_args.fno_pic {
            self.pic_level = X86DriverPicLevel::NoPIC;
        }

        // Apply sanitizers
        self.sanitizers = X86SanitizerSetup::from_args(&self.x86_args);
        self.coverage = X86CoverageSetup::from_args(&self.x86_args);

        // Apply LTO
        if self.x86_args.flto.is_some() || self.x86_args.flto_thin {
            self.lto_config = X86LTOConfig::from_args(&self.x86_args);
        }

        // Verbose / dry-run
        self.verbose = self.x86_args.v;
        self.dry_run = self.x86_args.dry_run;

        // Collect include paths, library paths, etc.
        self.include_paths
            .extend(self.x86_args.include_paths.iter().map(PathBuf::from));
        self.system_include_paths
            .extend(self.x86_args.system_include_paths.iter().map(PathBuf::from));
        self.library_paths
            .extend(self.x86_args.library_paths.iter().map(PathBuf::from));
        self.libraries.extend(self.x86_args.libraries.clone());
        self.defines.extend(self.x86_args.defines.clone());
        self.undefines.extend(self.x86_args.undefines.clone());

        // Input files
        self.input_files = self
            .x86_args
            .input_files
            .iter()
            .map(PathBuf::from)
            .collect();

        // Output file
        self.output_file = self.x86_args.output_file.as_ref().map(PathBuf::from);
    }

    /// Get the full list of include paths (user + system + toolchain).
    pub fn all_include_paths(&self) -> Vec<PathBuf> {
        let mut paths = Vec::new();
        paths.extend(self.include_paths.clone());
        paths.extend(self.system_include_paths.clone());
        paths.extend(self.header_search.system_include_paths());
        paths.extend(self.header_search.cxx_include_paths());
        paths.extend(self.header_search.builtin_include_paths());
        paths
    }

    /// Get the full list of library search paths.
    pub fn all_library_paths(&self) -> Vec<PathBuf> {
        let mut paths = Vec::new();
        paths.extend(self.library_paths.clone());
        paths.extend(self.stdlib.library_paths());
        paths.extend(self.multilib.library_paths());
        paths
    }

    /// Get the list of default libraries to link.
    pub fn default_libraries(&self) -> Vec<String> {
        let mut libs = Vec::new();
        libs.extend(self.libraries.clone());
        libs.extend(self.stdlib.default_link_libraries());
        libs.extend(self.sanitizers.linker_libraries());
        libs.extend(self.coverage.linker_libraries());
        libs
    }

    /// Build the compiler invocation for the frontend.
    pub fn build_compiler_command(&self, input: &Path, output: &Path) -> Vec<String> {
        let mut cmd = vec!["clang".to_string()];

        // Target
        cmd.push(format!("-target={}", self.triple.normalized));

        // CPU
        if let Some(ref cpu) = self.x86_args.target_cpu {
            cmd.push(format!("-mcpu={}", cpu));
        }

        // Features
        if !self.x86_args.target_features.is_empty() {
            cmd.push(format!(
                "-mattr={}",
                self.x86_args.target_features.join(",")
            ));
        }

        // Optimization
        cmd.push(self.opt_level.as_str().to_string());

        // Debug info
        match self.debug_info {
            X86DriverDebugInfo::None => {}
            X86DriverDebugInfo::LineTablesOnly => cmd.push("-gline-tables-only".to_string()),
            X86DriverDebugInfo::Limited => cmd.push("-g1".to_string()),
            X86DriverDebugInfo::Full => cmd.push("-g".to_string()),
            X86DriverDebugInfo::FullWithMacros => cmd.push("-g3".to_string()),
        }

        // PIC/PIE
        match self.pic_level {
            X86DriverPicLevel::PIC => cmd.push("-fPIC".to_string()),
            X86DriverPicLevel::PIE => cmd.push("-fPIE".to_string()),
            X86DriverPicLevel::NoPIC => cmd.push("-fno-PIC".to_string()),
            X86DriverPicLevel::Default => {}
        }

        // Language standard
        cmd.push(format!("-std={}", self.clang_options.standard.as_str()));

        // x86-specific flags
        cmd.extend(self.x86_args.to_clang_flags());

        // Includes
        for inc in &self.include_paths {
            cmd.push(format!("-I{}", inc.display()));
        }
        for inc in &self.system_include_paths {
            cmd.push(format!("-isystem{}", inc.display()));
        }
        for inc in self.header_search.system_include_paths() {
            cmd.push(format!("-isystem{}", inc.display()));
        }

        // Defines
        for (name, val) in &self.defines {
            if let Some(v) = val {
                cmd.push(format!("-D{}={}", name, v));
            } else {
                cmd.push(format!("-D{}", name));
            }
        }

        // Undefines
        for u in &self.undefines {
            cmd.push(format!("-U{}", u));
        }

        // Sanitizers
        cmd.extend(self.sanitizers.compiler_flags());

        // Coverage
        cmd.extend(self.coverage.compiler_flags());

        // LTO
        if self.lto_config.is_enabled() {
            cmd.push("-flto".to_string());
            if let Some(ref jobs) = self.lto_config.thin_lto_jobs {
                cmd.push(format!("-flto-jobs={}", jobs));
            }
        }

        // Input/output
        cmd.push(input.to_string_lossy().to_string());
        cmd.push("-o".to_string());
        cmd.push(output.to_string_lossy().to_string());

        cmd
    }

    /// Build the linker invocation.
    pub fn build_linker_invocation(&self) -> X86LinkerInvocation {
        let mut inv = X86LinkerInvocation::new(self.linker_flavor, &self.triple);

        for input in &self.input_files {
            inv.add_input(input);
        }
        if let Some(ref out) = self.output_file {
            inv.set_output(out);
        }

        for lib in &self.library_paths {
            inv.add_library_path(lib);
        }
        for lib in &self.libraries {
            inv.add_library(lib);
        }
        for lib in self.stdlib.default_link_libraries() {
            inv.add_library(&lib);
        }
        for lib in self.sanitizers.linker_libraries() {
            inv.add_library(&lib);
        }
        for lib in self.coverage.linker_libraries() {
            inv.add_library(&lib);
        }

        // Multilib paths
        for p in self.multilib.library_paths() {
            inv.add_library_path(&p);
        }

        for flag in &self.linker_flags {
            inv.add_flag(flag);
        }

        // LTO plugin
        if self.lto_config.is_enabled() {
            if let Some(ref plugin) = self.lto_config.linker_plugin {
                inv.set_lto_plugin(plugin);
            }
        }

        inv
    }

    /// Build the assembler invocation.
    pub fn build_assembler_invocation(
        &self,
        input: &Path,
        output: &Path,
    ) -> X86AssemblerInvocation {
        let mut inv = X86AssemblerInvocation::new(&self.triple);
        inv.set_input(input);
        inv.set_output(output);
        for flag in &self.assembler_flags {
            inv.add_flag(flag);
        }
        inv
    }

    /// Execute a full compilation pipeline.
    pub fn compile(&self) -> Result<Vec<PathBuf>, String> {
        if self.input_files.is_empty() {
            return Err("No input files specified".to_string());
        }

        let mut intermediate_files = Vec::new();
        let mut current_inputs: Vec<PathBuf> = self.input_files.clone();

        for phase in &self.phases {
            match phase {
                X86CompilationPhase::Preprocess => {
                    let mut outputs = Vec::new();
                    for input in &current_inputs {
                        let output = input.with_extension("i");
                        let cmd = self.build_preprocess_command(input, &output);
                        if self.verbose || self.dry_run {
                            eprintln!("[preprocess] {}", cmd.join(" "));
                        }
                        if !self.dry_run {
                            Self::run_command(&cmd)?;
                        }
                        outputs.push(output);
                    }
                    intermediate_files.extend(outputs.clone());
                    current_inputs = outputs;
                }
                X86CompilationPhase::Compile => {
                    let mut outputs = Vec::new();
                    for input in &current_inputs {
                        let output = input.with_extension("bc");
                        let cmd = self.build_compiler_command(input, &output);
                        if self.verbose || self.dry_run {
                            eprintln!("[compile] {}", cmd.join(" "));
                        }
                        if !self.dry_run {
                            Self::run_command(&cmd)?;
                        }
                        outputs.push(output);
                    }
                    intermediate_files.extend(outputs.clone());
                    current_inputs = outputs;
                }
                X86CompilationPhase::Backend => {
                    let mut outputs = Vec::new();
                    for input in &current_inputs {
                        let output = input.with_extension("o");
                        // Backend: LLVM IR → object code
                        let cmd = self.build_backend_command(input, &output);
                        if self.verbose || self.dry_run {
                            eprintln!("[backend] {}", cmd.join(" "));
                        }
                        if !self.dry_run {
                            Self::run_command(&cmd)?;
                        }
                        outputs.push(output);
                    }
                    intermediate_files.extend(outputs.clone());
                    current_inputs = outputs;
                }
                X86CompilationPhase::Assemble => {
                    let mut outputs = Vec::new();
                    for input in &current_inputs {
                        let output = input.with_extension("o");
                        let inv = self.build_assembler_invocation(input, &output);
                        let cmd = inv.to_command();
                        if self.verbose || self.dry_run {
                            eprintln!("[assemble] {}", cmd.join(" "));
                        }
                        if !self.dry_run {
                            Self::run_command(&cmd)?;
                        }
                        if !intermediate_files.contains(&output) {
                            outputs.push(output);
                        }
                    }
                    current_inputs = outputs;
                }
                X86CompilationPhase::Link => {
                    let inv = self.build_linker_invocation();
                    let cmd = inv.to_command();
                    if self.verbose || self.dry_run {
                        eprintln!("[link] {}", cmd.join(" "));
                    }
                    if !self.dry_run {
                        Self::run_command(&cmd)?;
                    }
                }
            }
        }

        Ok(intermediate_files)
    }

    fn build_preprocess_command(&self, input: &Path, output: &Path) -> Vec<String> {
        let mut cmd = vec!["clang".to_string(), "-E".to_string()];
        cmd.push(format!("-target={}", self.triple.normalized));
        cmd.push(format!("-std={}", self.clang_options.standard.as_str()));
        for inc in &self.include_paths {
            cmd.push(format!("-I{}", inc.display()));
        }
        for (name, val) in &self.defines {
            if let Some(v) = val {
                cmd.push(format!("-D{}={}", name, v));
            } else {
                cmd.push(format!("-D{}", name));
            }
        }
        cmd.push(input.to_string_lossy().to_string());
        cmd.push("-o".to_string());
        cmd.push(output.to_string_lossy().to_string());
        cmd
    }

    fn build_backend_command(&self, input: &Path, output: &Path) -> Vec<String> {
        let mut cmd = vec!["llc".to_string()];
        cmd.push(format!("-mtriple={}", self.triple.normalized));
        if let Some(ref cpu) = self.x86_args.target_cpu {
            cmd.push(format!("-mcpu={}", cpu));
        }
        cmd.push(self.opt_level.as_str().to_string());
        cmd.push("-filetype=obj".to_string());
        cmd.push(input.to_string_lossy().to_string());
        cmd.push("-o".to_string());
        cmd.push(output.to_string_lossy().to_string());
        cmd
    }

    fn run_command(cmd: &[String]) -> Result<(), String> {
        if cmd.is_empty() {
            return Err("Empty command".to_string());
        }
        let status = ProcessCommand::new(&cmd[0])
            .args(&cmd[1..])
            .status()
            .map_err(|e| format!("Failed to execute {}: {}", cmd[0], e))?;
        if !status.success() {
            return Err(format!(
                "Command failed with exit code: {:?}",
                status.code()
            ));
        }
        Ok(())
    }

    /// Set the output type.
    pub fn set_output_type(&mut self, ty: X86DriverOutputType) {
        self.output_type = ty;
        // Adjust phases based on output type
        self.phases = match ty {
            X86DriverOutputType::PreprocessedSource => {
                vec![X86CompilationPhase::Preprocess]
            }
            X86DriverOutputType::LLVMIR | X86DriverOutputType::LLVMBitcode => {
                vec![
                    X86CompilationPhase::Preprocess,
                    X86CompilationPhase::Compile,
                ]
            }
            X86DriverOutputType::Assembly => {
                vec![
                    X86CompilationPhase::Preprocess,
                    X86CompilationPhase::Compile,
                    X86CompilationPhase::Backend,
                ]
            }
            X86DriverOutputType::Object => {
                vec![
                    X86CompilationPhase::Preprocess,
                    X86CompilationPhase::Compile,
                    X86CompilationPhase::Backend,
                    X86CompilationPhase::Assemble,
                ]
            }
            X86DriverOutputType::SharedLibrary | X86DriverOutputType::Executable => {
                X86CompilationPhase::all().to_vec()
            }
        };
    }

    /// Enable the bitcode reproducer.
    pub fn enable_reproducer(&mut self, output_dir: &Path) {
        self.reproducer = Some(X86BitcodeReproducer::new(output_dir));
    }

    /// Capture current driver state for the reproducer.
    pub fn capture_for_reproducer(&self) {
        if let Some(ref reproducer) = self.reproducer {
            let _ = reproducer.capture_state(self);
        }
    }

    /// Get a description of the current configuration.
    pub fn describe(&self) -> String {
        let mut desc = String::new();
        desc.push_str(&format!("Target: {}\n", self.triple.normalized));
        desc.push_str(&format!("Host: {}\n", self.host_info));
        desc.push_str(&format!("Toolchain: {}\n", self.toolchain));
        desc.push_str(&format!("Linker: {:?}\n", self.linker_flavor));
        desc.push_str(&format!("Optimization: {:?}\n", self.opt_level));
        desc.push_str(&format!("Output: {:?}\n", self.output_type));
        desc.push_str(&format!("Multilib: {:?}\n", self.multilib.active_variant));
        if !self.include_paths.is_empty() {
            desc.push_str(&format!("Include paths: {:?}\n", self.include_paths));
        }
        if !self.library_paths.is_empty() {
            desc.push_str(&format!("Library paths: {:?}\n", self.library_paths));
        }
        desc
    }
}

impl Default for X86ClangDriver {
    fn default() -> Self {
        Self::new()
    }
}

// ═══════════════════════════════════════════════════════════════════════════════
// 4. X86ToolchainPath — Header/Library Search Path Resolution
// ═══════════════════════════════════════════════════════════════════════════════

/// Resolved toolchain paths for x86 targets. Detects headers, libraries,
/// crt objects, and tool binaries.
#[derive(Debug, Clone)]
pub struct X86ToolchainPath {
    /// The triple this toolchain is for.
    pub triple: X86TargetTriple,
    /// Installation directory (e.g., /usr/lib/gcc/x86_64-linux-gnu/12/).
    pub install_dir: Option<PathBuf>,
    /// Sysroot directory.
    pub sysroot: Option<PathBuf>,
    /// Resource directory for Clang builtins.
    pub resource_dir: Option<PathBuf>,
    /// C include directories.
    pub c_include_dirs: Vec<PathBuf>,
    /// C++ include directories.
    pub cxx_include_dirs: Vec<PathBuf>,
    /// Library directories.
    pub lib_dirs: Vec<PathBuf>,
    /// 32-bit library directories (for multilib).
    pub lib32_dirs: Vec<PathBuf>,
    /// x32 library directories (for multilib).
    pub libx32_dirs: Vec<PathBuf>,
    /// CRT object files (crt1.o, crti.o, crtn.o, etc.).
    pub crt_objects: HashMap<String, PathBuf>,
    /// Compiler binary path.
    pub compiler_path: Option<PathBuf>,
    /// Assembler binary path.
    pub assembler_path: Option<PathBuf>,
    /// Linker binary path.
    pub linker_path: Option<PathBuf>,
    /// Whether the toolchain was auto-detected.
    pub auto_detected: bool,
}

impl X86ToolchainPath {
    /// Auto-detect the toolchain for the given triple.
    pub fn detect(triple: &X86TargetTriple) -> Self {
        let mut tc = Self {
            triple: triple.clone(),
            install_dir: None,
            sysroot: None,
            resource_dir: None,
            c_include_dirs: Vec::new(),
            cxx_include_dirs: Vec::new(),
            lib_dirs: Vec::new(),
            lib32_dirs: Vec::new(),
            libx32_dirs: Vec::new(),
            crt_objects: HashMap::new(),
            compiler_path: None,
            assembler_path: None,
            linker_path: None,
            auto_detected: true,
        };

        tc.detect_sysroot();
        tc.detect_gcc_install();
        tc.detect_resource_dir();
        tc.detect_include_paths();
        tc.detect_library_paths();
        tc.detect_crt_objects();
        tc.detect_tool_paths();
        tc
    }

    fn detect_sysroot(&mut self) {
        let candidates = ["/", "/usr", "/usr/local", "/opt/llvm"];

        for candidate in &candidates {
            let path = Path::new(candidate);
            if path.exists() {
                self.sysroot = Some(path.to_path_buf());
                break;
            }
        }
    }

    fn detect_gcc_install(&mut self) {
        // Try to find GCC installation for headers
        let candidates = ["/usr/lib/gcc", "/usr/lib/gcc-cross", "/usr/local/lib/gcc"];

        for base in &candidates {
            let base_path = Path::new(base);
            if let Ok(entries) = fs::read_dir(base_path) {
                for entry in entries.flatten() {
                    let target_dir = entry.path();
                    if let Ok(versions) = fs::read_dir(&target_dir) {
                        for ver in versions.flatten() {
                            let install = ver.path();
                            if install.join("include").exists() {
                                self.install_dir = Some(install);
                                return;
                            }
                        }
                    }
                }
            }
        }
    }

    fn detect_resource_dir(&mut self) {
        // Clang resource directory contains builtin headers and runtime libraries.
        let candidates = [
            "/usr/lib/clang",
            "/usr/local/lib/clang",
            "/opt/llvm/lib/clang",
        ];

        for base in &candidates {
            let base_path = Path::new(base);
            if let Ok(entries) = fs::read_dir(base_path) {
                for entry in entries.flatten() {
                    let ver_path = entry.path();
                    if ver_path.join("include").exists() {
                        self.resource_dir = Some(ver_path);
                        return;
                    }
                }
            }
        }

        // Default fallback
        if self.resource_dir.is_none() {
            self.resource_dir = Some(PathBuf::from("/usr/lib/clang/16/include"));
        }
    }

    fn detect_include_paths(&mut self) {
        let triple_str = self.triple.normalized.clone();

        // C include directories
        let c_candidates = vec![
            PathBuf::from("/usr/include"),
            PathBuf::from("/usr/local/include"),
            format!("/usr/{}/include", triple_str).into(),
        ];

        for path in c_candidates {
            if path.exists() {
                self.c_include_dirs.push(path);
            }
        }

        // C++ include directories
        let cxx_candidates = vec![
            PathBuf::from("/usr/include/c++/v1"),
            format!("/usr/include/c++/12").into(),
            format!("/usr/include/c++/12/{}/", triple_str).into(),
            PathBuf::from("/usr/local/include/c++/v1"),
        ];

        for path in cxx_candidates {
            if path.exists() {
                self.cxx_include_dirs.push(path);
            }
        }

        // GCC-installed headers
        if let Some(ref install_dir) = self.install_dir {
            let gcc_include = install_dir.join("include");
            if gcc_include.exists() {
                self.c_include_dirs.push(gcc_include);
            }
            let gcc_include_fixed = install_dir.join("include-fixed");
            if gcc_include_fixed.exists() {
                self.c_include_dirs.push(gcc_include_fixed);
            }
        }

        // Resource dir builtins
        if let Some(ref resource_dir) = self.resource_dir {
            let builtin_include = resource_dir.join("include");
            if builtin_include.exists() {
                self.c_include_dirs.push(builtin_include);
            }
        }
    }

    fn detect_library_paths(&mut self) {
        let triple_str = self.triple.normalized.clone();
        let is_64bit = self.triple.is_64bit;
        let is_x32 = self.triple.is_x32;

        // Library directories
        let lib_candidates = if is_64bit {
            vec![
                PathBuf::from("/usr/lib64"),
                PathBuf::from("/usr/lib"),
                PathBuf::from("/usr/lib/x86_64-linux-gnu"),
                format!("/usr/{}/lib64", triple_str).into(),
                format!("/usr/{}/lib", triple_str).into(),
            ]
        } else if is_x32 {
            vec![
                PathBuf::from("/usr/libx32"),
                PathBuf::from("/usr/lib/x86_64-linux-gnux32"),
            ]
        } else {
            vec![
                PathBuf::from("/usr/lib32"),
                PathBuf::from("/usr/lib"),
                PathBuf::from("/usr/lib/i386-linux-gnu"),
                format!("/usr/{}/lib32", triple_str).into(),
                format!("/usr/{}/lib", triple_str).into(),
            ]
        };

        for path in lib_candidates {
            if path.exists() {
                self.lib_dirs.push(path);
            }
        }

        // 32-bit multilib directories
        let lib32_candidates = [
            PathBuf::from("/usr/lib32"),
            PathBuf::from("/usr/lib/i386-linux-gnu"),
        ];
        for path in &lib32_candidates {
            if path.exists() {
                self.lib32_dirs.push(path.clone());
            }
        }

        // x32 multilib directories
        let libx32_candidates = [
            PathBuf::from("/usr/libx32"),
            PathBuf::from("/usr/lib/x86_64-linux-gnux32"),
        ];
        for path in &libx32_candidates {
            if path.exists() {
                self.libx32_dirs.push(path.clone());
            }
        }

        // GCC install library path
        if let Some(ref install_dir) = self.install_dir {
            let gcc_lib = install_dir.clone();
            if gcc_lib.exists() {
                self.lib_dirs.push(gcc_lib);
            }
        }
    }

    fn detect_crt_objects(&mut self) {
        let crt_names = [
            "crt1.o",
            "crti.o",
            "crtbegin.o",
            "crtend.o",
            "crtn.o",
            "Scrt1.o",
            "gcrt1.o",
            "rcrt1.o",
        ];

        for name in &crt_names {
            for lib_dir in &self.lib_dirs {
                let candidate = lib_dir.join(name);
                if candidate.exists() {
                    self.crt_objects.insert(name.to_string(), candidate);
                    break;
                }
            }
        }
    }

    fn detect_tool_paths(&mut self) {
        // Detect compiler
        self.compiler_path = find_executable("clang")
            .or_else(|| find_executable("clang-16"))
            .or_else(|| find_executable("clang-15"));

        // Detect assembler
        self.assembler_path = find_executable("as").or_else(|| find_executable("llvm-mc"));

        // Detect linker
        self.linker_path = find_executable("ld")
            .or_else(|| find_executable("ld.lld"))
            .or_else(|| find_executable("ld.gold"));
    }

    /// Get the C include directories.
    pub fn c_include_dirs(&self) -> &[PathBuf] {
        &self.c_include_dirs
    }

    /// Get the C++ include directories.
    pub fn cxx_include_dirs(&self) -> &[PathBuf] {
        &self.cxx_include_dirs
    }

    /// Get both C and C++ include directories.
    pub fn all_include_dirs(&self) -> Vec<PathBuf> {
        let mut dirs = self.c_include_dirs.clone();
        dirs.extend(self.cxx_include_dirs.clone());
        dirs
    }

    /// Get library directories for the current multilib variant.
    pub fn active_lib_dirs(&self, variant: X86MultilibVariant) -> &[PathBuf] {
        match variant {
            X86MultilibVariant::Default64 => &self.lib_dirs,
            X86MultilibVariant::M32 => &self.lib32_dirs,
            X86MultilibVariant::MX32 => &self.libx32_dirs,
        }
    }

    /// Get the CRT object path.
    pub fn crt_object(&self, name: &str) -> Option<&PathBuf> {
        self.crt_objects.get(name)
    }

    /// Get the resource directory.
    pub fn resource_dir(&self) -> Option<&PathBuf> {
        self.resource_dir.as_ref()
    }
}

impl Default for X86ToolchainPath {
    fn default() -> Self {
        Self::detect(&X86TargetTriple::default())
    }
}

impl fmt::Display for X86ToolchainPath {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(
            f,
            "Toolchain[triple={}, compiler={:?}, linker={:?}]",
            self.triple.normalized, self.compiler_path, self.linker_path,
        )
    }
}

/// Find an executable in PATH.
fn find_executable(name: &str) -> Option<PathBuf> {
    if let Ok(paths) = std::env::var("PATH") {
        for dir in paths.split(':') {
            let candidate = Path::new(dir).join(name);
            if candidate.exists() && candidate.is_file() {
                return Some(candidate);
            }
        }
    }
    None
}

// ═══════════════════════════════════════════════════════════════════════════════
// 5. X86LinkerInvocation — Full Linker Command Construction
// ═══════════════════════════════════════════════════════════════════════════════

/// Full linker invocation for x86 targets, supporting GNU ld, gold, lld,
/// and MSVC link.exe.
#[derive(Debug, Clone)]
pub struct X86LinkerInvocation {
    /// Linker flavor.
    pub flavor: X86LinkerFlavor,
    /// Target triple.
    pub triple: X86TargetTriple,
    /// Input object files.
    pub inputs: Vec<PathBuf>,
    /// Output file.
    pub output: Option<PathBuf>,
    /// Library search paths (-L).
    pub library_paths: Vec<PathBuf>,
    /// Libraries to link (-l).
    pub libraries: Vec<String>,
    /// Extra linker flags.
    pub flags: Vec<String>,
    /// Entry point symbol.
    pub entry: Option<String>,
    /// Dynamic linker/interpreter path.
    pub dynamic_linker: Option<String>,
    /// Script/response file.
    pub script: Option<PathBuf>,
    /// LTO plugin path.
    pub lto_plugin: Option<PathBuf>,
    /// Whether to produce a shared library.
    pub shared: bool,
    /// Whether to strip symbols.
    pub strip: bool,
    /// Whether to allow unresolved symbols during linking.
    pub allow_unresolved: bool,
    /// Whether to export all symbols (for shared libs).
    pub export_all: bool,
    /// Export dynamic symbol list.
    pub export_dynamic: bool,
    /// Whether this is a PIE executable.
    pub pie: bool,
    /// SONAME for shared libraries.
    pub soname: Option<String>,
    /// GCC installation for runtime paths.
    pub gcc_install: Option<PathBuf>,
    /// Emulation mode (e.g., elf_x86_64, elf_i386).
    pub emulation: Option<String>,
    /// Subsystem for Windows targets.
    pub subsystem: Option<String>,
    /// Entry point for Windows.
    pub win_entry: Option<String>,
}

impl X86LinkerInvocation {
    pub fn new(flavor: X86LinkerFlavor, triple: &X86TargetTriple) -> Self {
        let emulation = match flavor {
            X86LinkerFlavor::GnuLd | X86LinkerFlavor::Lld => {
                if triple.is_64bit {
                    Some("elf_x86_64".to_string())
                } else if triple.is_x32 {
                    Some("elf32_x86_64".to_string())
                } else {
                    Some("elf_i386".to_string())
                }
            }
            _ => None,
        };

        Self {
            flavor,
            triple: triple.clone(),
            inputs: Vec::new(),
            output: None,
            library_paths: Vec::new(),
            libraries: Vec::new(),
            flags: Vec::new(),
            entry: None,
            dynamic_linker: None,
            script: None,
            lto_plugin: None,
            shared: false,
            strip: false,
            allow_unresolved: false,
            export_all: false,
            export_dynamic: false,
            pie: false,
            soname: None,
            gcc_install: None,
            emulation,
            subsystem: None,
            win_entry: None,
        }
    }

    pub fn add_input(&mut self, input: &Path) {
        self.inputs.push(input.to_path_buf());
    }

    pub fn add_library_path(&mut self, path: &Path) {
        self.library_paths.push(path.to_path_buf());
    }

    pub fn add_library(&mut self, lib: &str) {
        self.libraries.push(lib.to_string());
    }

    pub fn add_flag(&mut self, flag: &str) {
        self.flags.push(flag.to_string());
    }

    pub fn set_output(&mut self, output: &Path) {
        self.output = Some(output.to_path_buf());
    }

    pub fn set_entry(&mut self, entry: &str) {
        self.entry = Some(entry.to_string());
    }

    pub fn set_lto_plugin(&mut self, plugin: &Path) {
        self.lto_plugin = Some(plugin.to_path_buf());
    }

    pub fn set_dynamic_linker(&mut self, linker: &str) {
        self.dynamic_linker = Some(linker.to_string());
    }

    /// Convert to a command-line argument list.
    pub fn to_command(&self) -> Vec<String> {
        match self.flavor {
            X86LinkerFlavor::GnuLd => self.build_gnu_ld_command(),
            X86LinkerFlavor::Lld => self.build_lld_command(),
            X86LinkerFlavor::DarwinLd => self.build_darwin_ld_command(),
            X86LinkerFlavor::MSVCLink => self.build_msvc_link_command(),
            X86LinkerFlavor::LldLink => self.build_lld_link_command(),
        }
    }

    fn build_gnu_ld_command(&self) -> Vec<String> {
        let mut cmd = vec!["ld".to_string()];

        // Emulation
        if let Some(ref emulation) = self.emulation {
            cmd.push("-m".to_string());
            cmd.push(emulation.clone());
        }

        // LTO plugin
        if let Some(ref plugin) = self.lto_plugin {
            cmd.push(format!("-plugin={}", plugin.display()));
            cmd.push("-plugin-opt=mcpu=x86-64".to_string());
        }

        // Dynamic linker
        if let Some(ref linker) = self.dynamic_linker {
            cmd.push(format!("-dynamic-linker={}", linker));
        } else if !self.shared {
            // Default dynamic linker for Linux
            let default_ld = if self.triple.is_64bit {
                "/lib64/ld-linux-x86-64.so.2"
            } else if self.triple.is_x32 {
                "/libx32/ld-linux-x32.so.2"
            } else {
                "/lib/ld-linux.so.2"
            };
            cmd.push(format!("-dynamic-linker={}", default_ld));
        }

        // Entry point
        if let Some(ref entry) = self.entry {
            cmd.push("-e".to_string());
            cmd.push(entry.clone());
        } else if !self.shared {
            cmd.push("-e".to_string());
            cmd.push("_start".to_string());
        }

        // Output
        if let Some(ref output) = self.output {
            cmd.push("-o".to_string());
            cmd.push(output.to_string_lossy().to_string());
        }

        // Shared library
        if self.shared {
            cmd.push("-shared".to_string());
            if let Some(ref soname) = self.soname {
                cmd.push(format!("-soname={}", soname));
            }
        }

        // PIE
        if self.pie {
            cmd.push("-pie".to_string());
        }

        // Library paths
        for lp in &self.library_paths {
            cmd.push(format!("-L{}", lp.display()));
        }

        // Libraries
        for lib in &self.libraries {
            cmd.push(format!("-l{}", lib));
        }

        // Strip
        if self.strip {
            cmd.push("-s".to_string());
        }

        // Allow unresolved
        if self.allow_unresolved {
            cmd.push("--allow-shlib-undefined".to_string());
        }

        // Export dynamic
        if self.export_dynamic {
            cmd.push("--export-dynamic".to_string());
        }

        // Build ID
        cmd.push("--build-id".to_string());

        // EH frame
        cmd.push("--eh-frame-hdr".to_string());

        // Hash style
        cmd.push("--hash-style=gnu".to_string());

        // GC sections
        cmd.push("--gc-sections".to_string());

        // Extra flags
        cmd.extend(self.flags.clone());

        // Input files
        for input in &self.inputs {
            cmd.push(input.to_string_lossy().to_string());
        }

        cmd
    }

    fn build_lld_command(&self) -> Vec<String> {
        let mut cmd = vec!["ld.lld".to_string()];

        // Emulation
        if let Some(ref emulation) = self.emulation {
            cmd.push("-m".to_string());
            cmd.push(emulation.clone());
        }

        // LTO
        if self.lto_plugin.is_some() {
            cmd.push("--lto=thin".to_string());
        }

        if let Some(ref entry) = self.entry {
            cmd.push("--entry".to_string());
            cmd.push(entry.clone());
        } else if !self.shared {
            cmd.push("--entry=_start".to_string());
        }

        if let Some(ref output) = self.output {
            cmd.push("-o".to_string());
            cmd.push(output.to_string_lossy().to_string());
        }

        if self.shared {
            cmd.push("-shared".to_string());
        }

        for lp in &self.library_paths {
            cmd.push(format!("-L{}", lp.display()));
        }

        for lib in &self.libraries {
            cmd.push(format!("-l{}", lib));
        }

        if self.strip {
            cmd.push("--strip-all".to_string());
        }

        if self.export_dynamic {
            cmd.push("--export-dynamic".to_string());
        }

        cmd.push("--build-id".to_string());
        cmd.push("--eh-frame-hdr".to_string());
        cmd.push("--hash-style=gnu".to_string());
        cmd.push("--gc-sections".to_string());

        cmd.extend(self.flags.clone());

        for input in &self.inputs {
            cmd.push(input.to_string_lossy().to_string());
        }

        cmd
    }

    fn build_darwin_ld_command(&self) -> Vec<String> {
        let mut cmd = vec!["ld".to_string()];

        if let Some(ref entry) = self.entry {
            cmd.push("-e".to_string());
            cmd.push(entry.clone());
        }

        if let Some(ref output) = self.output {
            cmd.push("-o".to_string());
            cmd.push(output.to_string_lossy().to_string());
        }

        if self.shared {
            cmd.push("-dylib".to_string());
            if let Some(ref soname) = self.soname {
                cmd.push(format!("-install_name={}", soname));
            }
        }

        for lp in &self.library_paths {
            cmd.push(format!("-L{}", lp.display()));
        }

        for lib in &self.libraries {
            cmd.push(format!("-l{}", lib));
        }

        cmd.extend(self.flags.clone());

        cmd.push("-macosx_version_min".to_string());
        cmd.push("10.15".to_string());
        cmd.push("-platform_version".to_string());
        cmd.push("macos".to_string());
        cmd.push("10.15".to_string());
        cmd.push("10.15".to_string());

        for input in &self.inputs {
            cmd.push(input.to_string_lossy().to_string());
        }

        cmd
    }

    fn build_msvc_link_command(&self) -> Vec<String> {
        let mut cmd = vec!["link.exe".to_string()];

        if let Some(ref output) = self.output {
            cmd.push(format!("/OUT:{}", output.display()));
        }

        if self.shared {
            cmd.push("/DLL".to_string());
        }

        if let Some(ref entry) = self.win_entry {
            cmd.push(format!("/ENTRY:{}", entry));
        }

        if let Some(ref subsystem) = self.subsystem {
            cmd.push(format!("/SUBSYSTEM:{}", subsystem));
        } else {
            cmd.push("/SUBSYSTEM:CONSOLE".to_string());
        }

        for lp in &self.library_paths {
            cmd.push(format!("/LIBPATH:{}", lp.display()));
        }

        for lib in &self.libraries {
            cmd.push(format!("{}.lib", lib));
        }

        if self.strip {
            cmd.push("/DEBUG:NONE".to_string());
        }

        cmd.extend(self.flags.clone());

        for input in &self.inputs {
            cmd.push(input.to_string_lossy().to_string());
        }

        cmd
    }

    fn build_lld_link_command(&self) -> Vec<String> {
        let mut cmd = vec!["lld-link".to_string()];

        if let Some(ref output) = self.output {
            cmd.push(format!("/out:{}", output.display()));
        }

        if self.shared {
            cmd.push("/dll".to_string());
        }

        if let Some(ref entry) = self.win_entry {
            cmd.push(format!("/entry:{}", entry));
        }

        for lp in &self.library_paths {
            cmd.push(format!("/libpath:{}", lp.display()));
        }

        for lib in &self.libraries {
            cmd.push(format!("{}.lib", lib));
        }

        cmd.extend(self.flags.clone());

        for input in &self.inputs {
            cmd.push(input.to_string_lossy().to_string());
        }

        cmd
    }

    /// Write a response file for Windows linkers (to avoid command-line length limits).
    pub fn to_response_file(&self) -> String {
        let mut resp = String::new();
        for input in &self.inputs {
            resp.push_str(&format!("{}\n", input.display()));
        }
        for lp in &self.library_paths {
            resp.push_str(&format!("/LIBPATH:{}\n", lp.display()));
        }
        for lib in &self.libraries {
            resp.push_str(&format!("{}.lib\n", lib));
        }
        if let Some(ref output) = self.output {
            resp.push_str(&format!("/OUT:{}\n", output.display()));
        }
        resp
    }
}

// ═══════════════════════════════════════════════════════════════════════════════
// 6. X86AssemblerInvocation — Assembler Command Construction
// ═══════════════════════════════════════════════════════════════════════════════

/// Assembler invocation for x86 targets. Supports GNU as (gas) and the LLVM-MC
/// integrated assembler.
#[derive(Debug, Clone)]
pub struct X86AssemblerInvocation {
    /// Target triple.
    pub triple: X86TargetTriple,
    /// Input assembly file.
    pub input: Option<PathBuf>,
    /// Output object file.
    pub output: Option<PathBuf>,
    /// Use integrated assembler (LLVM-MC) instead of GNU as.
    pub integrated_as: bool,
    /// Extra assembler flags.
    pub flags: Vec<String>,
    /// Generate debug info in the object.
    pub gen_debug: bool,
    /// Architecture flag (-march for gas).
    pub arch_flag: Option<String>,
    /// Use AVX encoding.
    pub use_avx: bool,
    /// Position-independent code.
    pub pic: bool,
}

impl X86AssemblerInvocation {
    pub fn new(triple: &X86TargetTriple) -> Self {
        Self {
            triple: triple.clone(),
            input: None,
            output: None,
            integrated_as: true,
            flags: Vec::new(),
            gen_debug: false,
            arch_flag: None,
            use_avx: false,
            pic: false,
        }
    }

    pub fn set_input(&mut self, input: &Path) {
        self.input = Some(input.to_path_buf());
    }

    pub fn set_output(&mut self, output: &Path) {
        self.output = Some(output.to_path_buf());
    }

    pub fn add_flag(&mut self, flag: &str) {
        self.flags.push(flag.to_string());
    }

    /// Convert to a command-line argument list.
    pub fn to_command(&self) -> Vec<String> {
        if self.integrated_as {
            self.build_llvm_mc_command()
        } else {
            self.build_gnu_as_command()
        }
    }

    fn build_llvm_mc_command(&self) -> Vec<String> {
        let mut cmd = vec!["llvm-mc".to_string()];

        // Target triple
        cmd.push(format!("-triple={}", self.triple.normalized));

        // Architecture
        if self.triple.is_64bit {
            cmd.push("-arch=x86-64".to_string());
        } else {
            cmd.push("-arch=x86".to_string());
        }

        // Output format
        cmd.push("-filetype=obj".to_string());

        // Position-independent
        if self.pic {
            cmd.push("-position-independent".to_string());
        }

        // Debug info
        if self.gen_debug {
            cmd.push("-g".to_string());
        }

        // AVX
        if self.use_avx {
            cmd.push("-mattr=+avx".to_string());
        }

        cmd.extend(self.flags.clone());

        // Input/Output
        if let Some(ref input) = self.input {
            cmd.push(input.to_string_lossy().to_string());
        }
        if let Some(ref output) = self.output {
            cmd.push("-o".to_string());
            cmd.push(output.to_string_lossy().to_string());
        }

        cmd
    }

    fn build_gnu_as_command(&self) -> Vec<String> {
        let mut cmd = vec!["as".to_string()];

        // Architecture
        if self.triple.is_64bit {
            cmd.push("--64".to_string());
        } else if self.triple.is_x32 {
            cmd.push("--x32".to_string());
        } else {
            cmd.push("--32".to_string());
        }

        // Debug info
        if self.gen_debug {
            cmd.push("--gdwarf-5".to_string());
        }

        // AVX
        if self.use_avx {
            cmd.push("-mavx=1".to_string());
        }

        cmd.extend(self.flags.clone());

        // Output
        if let Some(ref output) = self.output {
            cmd.push("-o".to_string());
            cmd.push(output.to_string_lossy().to_string());
        }

        // Input
        if let Some(ref input) = self.input {
            cmd.push(input.to_string_lossy().to_string());
        }

        cmd
    }
}

// ═══════════════════════════════════════════════════════════════════════════════
// 7. X86SanitizerSetup — Sanitizer Runtime Integration
// ═══════════════════════════════════════════════════════════════════════════════

/// Sanitizer configuration for x86 targets.
#[derive(Debug, Clone)]
pub struct X86SanitizerSetup {
    /// Enable AddressSanitizer.
    pub address: bool,
    /// Enable MemorySanitizer.
    pub memory: bool,
    /// Enable ThreadSanitizer.
    pub thread: bool,
    /// Enable UndefinedBehaviorSanitizer.
    pub undefined: bool,
    /// Enable LeakSanitizer.
    pub leak: bool,
    /// Enable DataFlowSanitizer.
    pub data_flow: bool,
    /// Enable SafeStack.
    pub safe_stack: bool,
    /// Enable ShadowCallStack.
    pub shadow_call_stack: bool,
    /// Enable HWAddressSanitizer.
    pub hwaddress: bool,
    /// Recovery mode for UBSan.
    pub ubsan_recover: bool,
    /// Trap on UBSan violations.
    pub ubsan_trap: bool,
    /// Minimal runtime (ASan).
    pub minimal_runtime: bool,
    /// Blacklist file.
    pub blacklist_file: Option<PathBuf>,
    /// Extra sanitizer flags.
    pub extra_flags: Vec<String>,
}

impl X86SanitizerSetup {
    pub fn new() -> Self {
        Self {
            address: false,
            memory: false,
            thread: false,
            undefined: false,
            leak: false,
            data_flow: false,
            safe_stack: false,
            shadow_call_stack: false,
            hwaddress: false,
            ubsan_recover: false,
            ubsan_trap: false,
            minimal_runtime: false,
            blacklist_file: None,
            extra_flags: Vec::new(),
        }
    }

    /// Create from parsed driver arguments.
    pub fn from_args(args: &X86DriverArgs) -> Self {
        let mut setup = Self::new();

        if let Some(ref sanitizers) = args.fsanitize {
            for san in sanitizers.split(',') {
                match san.trim() {
                    "address" => setup.address = true,
                    "memory" => setup.memory = true,
                    "thread" => setup.thread = true,
                    "undefined" | "undefined-behavior" => setup.undefined = true,
                    "leak" => setup.leak = true,
                    "dataflow" => setup.data_flow = true,
                    "safe-stack" => setup.safe_stack = true,
                    "shadow-call-stack" => setup.shadow_call_stack = true,
                    "hwaddress" => setup.hwaddress = true,
                    _ => {}
                }
            }
        }

        if let Some(ref recover) = args.fsanitize_recover {
            if recover == "all" || recover.contains("undefined") {
                setup.ubsan_recover = true;
            }
        }

        if args.fsanitize_trap.is_some() {
            setup.ubsan_trap = true;
        }

        if args.fsanitize_minimal_runtime {
            setup.minimal_runtime = true;
        }

        setup
    }

    /// Whether any sanitizer is enabled.
    pub fn has_any(&self) -> bool {
        self.address
            || self.memory
            || self.thread
            || self.undefined
            || self.leak
            || self.data_flow
            || self.safe_stack
            || self.shadow_call_stack
            || self.hwaddress
    }

    /// Get compiler flags for enabled sanitizers.
    pub fn compiler_flags(&self) -> Vec<String> {
        let mut flags = Vec::new();

        if !self.has_any() {
            return flags;
        }

        let mut san_list = Vec::new();
        if self.address {
            san_list.push("address");
        }
        if self.memory {
            san_list.push("memory");
        }
        if self.thread {
            san_list.push("thread");
        }
        if self.undefined {
            san_list.push("undefined");
        }
        if self.leak {
            san_list.push("leak");
        }
        if self.data_flow {
            san_list.push("dataflow");
        }
        if self.safe_stack {
            san_list.push("safe-stack");
        }
        if self.shadow_call_stack {
            san_list.push("shadow-call-stack");
        }
        if self.hwaddress {
            san_list.push("hwaddress");
        }

        if !san_list.is_empty() {
            flags.push(format!("-fsanitize={}", san_list.join(",")));
        }

        if self.ubsan_recover {
            flags.push("-fsanitize-recover=undefined".to_string());
        }
        if self.ubsan_trap {
            flags.push("-fsanitize-trap=undefined".to_string());
        }
        if self.minimal_runtime {
            flags.push("-fsanitize-minimal-runtime".to_string());
        }
        if let Some(ref bl) = self.blacklist_file {
            flags.push(format!("-fsanitize-blacklist={}", bl.display()));
        }

        flags
    }

    /// Get linker libraries needed by enabled sanitizers.
    pub fn linker_libraries(&self) -> Vec<String> {
        let mut libs = Vec::new();
        if self.address {
            libs.push("asan".to_string());
            libs.push("asan-preinit".to_string());
        }
        if self.memory {
            libs.push("msan".to_string());
        }
        if self.thread {
            libs.push("tsan".to_string());
        }
        if self.undefined {
            libs.push("ubsan_standalone".to_string());
        }
        if self.leak {
            libs.push("lsan".to_string());
        }
        if self.data_flow {
            libs.push("dfsan".to_string());
        }
        if self.hwaddress {
            libs.push("hwasan".to_string());
        }
        libs
    }

    /// Get runtime flags for ASan (via ASAN_OPTIONS environment variable).
    pub fn asan_options(&self) -> Vec<String> {
        let mut opts = Vec::new();
        if self.address {
            opts.push("detect_leaks=1".to_string());
            opts.push("check_initialization_order=true".to_string());
            opts.push("detect_stack_use_after_return=true".to_string());
            opts.push("strict_string_checks=true".to_string());
        }
        opts
    }

    /// Get runtime flags for UBSan.
    pub fn ubsan_options(&self) -> Vec<String> {
        let mut opts = Vec::new();
        if self.undefined {
            opts.push("print_stacktrace=1".to_string());
            if self.ubsan_recover {
                opts.push("halt_on_error=0".to_string());
            }
        }
        opts
    }

    /// Check compatibility — some sanitizer combinations are mutually exclusive.
    pub fn check_compatibility(&self) -> Result<(), String> {
        if self.address && self.memory {
            return Err("AddressSanitizer and MemorySanitizer are mutually exclusive".to_string());
        }
        if self.address && self.thread {
            return Err("AddressSanitizer and ThreadSanitizer are mutually exclusive".to_string());
        }
        if self.memory && self.thread {
            return Err("MemorySanitizer and ThreadSanitizer are mutually exclusive".to_string());
        }
        Ok(())
    }
}

impl Default for X86SanitizerSetup {
    fn default() -> Self {
        Self::new()
    }
}

// ═══════════════════════════════════════════════════════════════════════════════
// 8. X86CoverageSetup — Coverage/Profiling Runtime Setup
// ═══════════════════════════════════════════════════════════════════════════════

/// Coverage and profiling configuration for x86 targets.
#[derive(Debug, Clone)]
pub struct X86CoverageSetup {
    /// Enable coverage mapping (-fcoverage-mapping).
    pub coverage_mapping: bool,
    /// Enable profile instrumentation (-fprofile-instr-generate).
    pub profile_instr_generate: bool,
    /// Use profile for PGO (-fprofile-instr-use).
    pub profile_instr_use: Option<PathBuf>,
    /// Sample-based profile (-fprofile-sample-use).
    pub profile_sample_use: Option<PathBuf>,
    /// Context-sensitive PGO (-fcs-profile-generate).
    pub cs_profile_generate: Option<PathBuf>,
    /// Context-sensitive PGO use.
    pub cs_profile_use: Option<PathBuf>,
    /// Coverage directory.
    pub coverage_dir: Option<PathBuf>,
    /// Coverage notes file.
    pub coverage_notes_file: Option<PathBuf>,
    /// Coverage data file.
    pub coverage_data_file: Option<PathBuf>,
    /// Function-sections for profile generation.
    pub function_sections: bool,
    /// Debug info needed for coverage.
    pub debug_info_for_profiling: bool,
}

impl X86CoverageSetup {
    pub fn new() -> Self {
        Self {
            coverage_mapping: false,
            profile_instr_generate: false,
            profile_instr_use: None,
            profile_sample_use: None,
            cs_profile_generate: None,
            cs_profile_use: None,
            coverage_dir: None,
            coverage_notes_file: None,
            coverage_data_file: None,
            function_sections: false,
            debug_info_for_profiling: false,
        }
    }

    /// Create from parsed driver arguments.
    pub fn from_args(args: &X86DriverArgs) -> Self {
        let mut setup = Self::new();

        if args.fprofile_instr_generate.is_some() {
            setup.profile_instr_generate = true;
            if let Some(ref dir) = args.fprofile_instr_generate {
                if !dir.is_empty() {
                    setup.coverage_dir = Some(PathBuf::from(dir));
                }
            }
        }

        if let Some(ref profile) = args.fprofile_instr_use {
            if !profile.is_empty() {
                setup.profile_instr_use = Some(PathBuf::from(profile));
            }
        }

        if args.fcoverage_mapping {
            setup.coverage_mapping = true;
            setup.debug_info_for_profiling = true;
        }

        if let Some(ref cs_profile) = args.fcs_profile_generate {
            setup.cs_profile_generate = Some(PathBuf::from(cs_profile));
        }

        if args.ffunction_sections {
            setup.function_sections = true;
        }

        setup
    }

    /// Whether any profiling is enabled.
    pub fn has_any(&self) -> bool {
        self.coverage_mapping
            || self.profile_instr_generate
            || self.profile_instr_use.is_some()
            || self.profile_sample_use.is_some()
    }

    /// Get compiler flags for coverage/profiling.
    pub fn compiler_flags(&self) -> Vec<String> {
        let mut flags = Vec::new();

        if self.coverage_mapping {
            flags.push("-fcoverage-mapping".to_string());
        }

        if self.profile_instr_generate {
            if let Some(ref dir) = self.coverage_dir {
                flags.push(format!("-fprofile-instr-generate={}", dir.display()));
            } else {
                flags.push("-fprofile-instr-generate".to_string());
            }
        }

        if let Some(ref profile) = self.profile_instr_use {
            flags.push(format!("-fprofile-instr-use={}", profile.display()));
        }

        if let Some(ref sample) = self.profile_sample_use {
            flags.push(format!("-fprofile-sample-use={}", sample.display()));
        }

        if let Some(ref cs) = self.cs_profile_generate {
            flags.push(format!("-fcs-profile-generate={}", cs.display()));
        }

        if let Some(ref cs) = self.cs_profile_use {
            flags.push(format!("-fcs-profile-use={}", cs.display()));
        }

        if self.function_sections {
            flags.push("-ffunction-sections".to_string());
            flags.push("-fdata-sections".to_string());
        }

        if self.debug_info_for_profiling {
            flags.push("-fdebug-info-for-profiling".to_string());
        }

        flags
    }

    /// Get linker libraries for coverage/profiling.
    pub fn linker_libraries(&self) -> Vec<String> {
        let mut libs = Vec::new();
        if self.profile_instr_generate || self.profile_instr_use.is_some() {
            libs.push("clang_rt.profile-x86_64".to_string());
        }
        if self.coverage_mapping {
            libs.push("clang_rt.profile-x86_64".to_string());
        }
        libs
    }

    /// Set default coverage output paths.
    pub fn set_default_paths(&mut self) {
        if self.coverage_dir.is_none() {
            self.coverage_dir = Some(PathBuf::from("."));
        }
        if self.profile_instr_generate && self.coverage_data_file.is_none() {
            self.coverage_data_file = Some(PathBuf::from("default.profraw"));
        }
    }
}

impl Default for X86CoverageSetup {
    fn default() -> Self {
        Self::new()
    }
}

// ═══════════════════════════════════════════════════════════════════════════════
// 9. X86HeaderSearch — System Header Detection for X86
// ═══════════════════════════════════════════════════════════════════════════════

/// System header search configuration for x86 targets. Handles detection of
/// system C and C++ headers, builtin headers, and target-specific headers.
#[derive(Debug, Clone)]
pub struct X86HeaderSearch {
    /// Target triple.
    pub triple: X86TargetTriple,
    /// System C include paths.
    pub c_system_includes: Vec<PathBuf>,
    /// System C++ include paths.
    pub cxx_system_includes: Vec<PathBuf>,
    /// Builtin include paths (from resource directory).
    pub builtin_includes: Vec<PathBuf>,
    /// Framework include paths (macOS).
    pub framework_includes: Vec<PathBuf>,
    /// Include paths added via -idirafter.
    pub idirafter_paths: Vec<PathBuf>,
    /// Whether to include system headers.
    pub nostdinc: bool,
    /// Whether to include C++ system headers.
    pub nostdincxx: bool,
    /// Standard include directories (e.g., /usr/include/c++/v1).
    pub standard_includes: Vec<PathBuf>,
}

impl X86HeaderSearch {
    pub fn new(triple: &X86TargetTriple, toolchain: &X86ToolchainPath) -> Self {
        let mut hs = Self {
            triple: triple.clone(),
            c_system_includes: Vec::new(),
            cxx_system_includes: Vec::new(),
            builtin_includes: Vec::new(),
            framework_includes: Vec::new(),
            idirafter_paths: Vec::new(),
            nostdinc: false,
            nostdincxx: false,
            standard_includes: Vec::new(),
        };
        hs.populate_from_toolchain(toolchain);
        hs
    }

    fn populate_from_toolchain(&mut self, toolchain: &X86ToolchainPath) {
        // System C includes
        self.c_system_includes = toolchain.c_include_dirs.clone();

        // C++ includes
        self.cxx_system_includes = toolchain.cxx_include_dirs.clone();

        // Builtin includes
        if let Some(ref resource_dir) = toolchain.resource_dir {
            let builtin_include = resource_dir.join("include");
            if builtin_include.exists() {
                self.builtin_includes.push(builtin_include);
            }
            let share_include = resource_dir.join("share");
            if share_include.exists() {
                self.builtin_includes.push(share_include);
            }
        }

        // Standard C++ includes
        let std_includes = [
            "/usr/include/c++/v1",
            "/usr/include/c++/12",
            "/usr/local/include/c++/v1",
        ];
        for path in &std_includes {
            let p = PathBuf::from(path);
            if p.exists() && !self.cxx_system_includes.contains(&p) {
                self.standard_includes.push(p);
            }
        }
    }

    /// Get system C include paths.
    pub fn system_include_paths(&self) -> Vec<PathBuf> {
        if self.nostdinc {
            return Vec::new();
        }
        let mut paths = Vec::new();
        paths.extend(self.builtin_includes.clone());
        paths.extend(self.c_system_includes.clone());
        paths.extend(self.idirafter_paths.clone());
        paths
    }

    /// Get C++ include paths.
    pub fn cxx_include_paths(&self) -> Vec<PathBuf> {
        if self.nostdinc || self.nostdincxx {
            return Vec::new();
        }
        let mut paths = Vec::new();
        paths.extend(self.standard_includes.clone());
        paths.extend(self.cxx_system_includes.clone());
        paths
    }

    /// Get builtin include paths (intrinsics, stddef, etc.).
    pub fn builtin_include_paths(&self) -> Vec<PathBuf> {
        self.builtin_includes.clone()
    }

    /// Add a framework search path (macOS).
    pub fn add_framework_path(&mut self, path: &Path) {
        self.framework_includes.push(path.to_path_buf());
    }

    /// Get all include paths in search order.
    pub fn all_include_paths(&self) -> Vec<PathBuf> {
        let mut paths = Vec::new();
        paths.extend(self.builtin_include_paths());
        paths.extend(self.standard_includes.clone());
        paths.extend(self.c_system_includes.clone());
        paths.extend(self.cxx_system_includes.clone());
        paths.extend(self.framework_includes.clone());
        paths.extend(self.idirafter_paths.clone());
        paths
    }
}

// ═══════════════════════════════════════════════════════════════════════════════
// 10. X86StdLibSetup — Standard Library Detection
// ═══════════════════════════════════════════════════════════════════════════════

/// Standard library detection and configuration for x86 targets.
/// Supports glibc, musl, msvcrt, bionic (Android), and macOS libSystem.
#[derive(Debug, Clone)]
pub struct X86StdLibSetup {
    /// Target triple.
    pub triple: X86TargetTriple,
    /// Detected C library.
    pub c_lib: X86CLibKind,
    /// Detected C++ library.
    pub cxx_lib: X86CXXLibKind,
    /// Library paths for the standard library.
    pub std_lib_paths: Vec<PathBuf>,
    /// CRT startup files.
    pub crt_files: Vec<PathBuf>,
    /// Default libraries to link.
    pub link_libraries: Vec<String>,
    /// Whether to use compiler-rt instead of libgcc.
    pub use_compiler_rt: bool,
    /// Whether to use libunwind instead of libgcc_s.
    pub use_libunwind: bool,
    /// Whether -nodefaultlibs was specified.
    pub nodefaultlibs: bool,
    /// Whether -nostdlib was specified.
    pub nostdlib: bool,
    /// Whether -nostartfiles was specified.
    pub nostartfiles: bool,
}

/// Kind of C standard library.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum X86CLibKind {
    /// GNU C Library (glibc).
    Glibc,
    /// musl libc.
    Musl,
    /// Microsoft Visual C Runtime.
    Msvcrt,
    /// Android Bionic.
    Bionic,
    /// macOS/iOS libSystem.
    LibSystem,
    /// Newlib (bare metal / embedded).
    Newlib,
    /// diet libc.
    DietLibc,
    /// uClibc / uClibc-ng.
    UClibc,
    /// Unknown / other.
    Unknown,
}

impl X86CLibKind {
    pub fn default_crt_object(&self) -> &'static str {
        match self {
            Self::Glibc | Self::Musl | Self::Newlib | Self::DietLibc | Self::UClibc => "crt1.o",
            Self::Msvcrt => "crt0.obj",
            Self::Bionic => "crtbegin_dynamic.o",
            Self::LibSystem => "crt1.o",
            Self::Unknown => "crt1.o",
        }
    }

    pub fn default_c_lib(&self) -> &'static str {
        match self {
            Self::Glibc | Self::Musl | Self::Newlib | Self::DietLibc | Self::UClibc => "c",
            Self::Msvcrt => "msvcrt",
            Self::Bionic => "c",
            Self::LibSystem => "System",
            Self::Unknown => "c",
        }
    }
}

/// Kind of C++ standard library.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum X86CXXLibKind {
    /// GNU libstdc++.
    LibStdCXX,
    /// LLVM libc++.
    LibCXX,
    /// Microsoft STL (msvcprt).
    Msvcprt,
    /// Android libc++_shared.
    AndroidCXX,
    /// None (no C++ stdlib).
    None,
}

impl X86CXXLibKind {
    pub fn default_cxx_lib(&self) -> Option<&'static str> {
        match self {
            Self::LibStdCXX => Some("stdc++"),
            Self::LibCXX => Some("c++"),
            Self::Msvcprt => Some("msvcprt"),
            Self::AndroidCXX => Some("c++_shared"),
            Self::None => None,
        }
    }
}

impl X86StdLibSetup {
    pub fn new(triple: &X86TargetTriple, toolchain: &X86ToolchainPath) -> Self {
        let c_lib = Self::detect_c_lib(triple);
        let cxx_lib = Self::detect_cxx_lib(triple);

        let mut setup = Self {
            triple: triple.clone(),
            c_lib,
            cxx_lib,
            std_lib_paths: Vec::new(),
            crt_files: Vec::new(),
            link_libraries: Vec::new(),
            use_compiler_rt: false,
            use_libunwind: false,
            nodefaultlibs: false,
            nostdlib: false,
            nostartfiles: false,
        };

        setup.detect_lib_paths(toolchain);
        setup.detect_crt_files(toolchain);
        setup.setup_default_libraries();
        setup
    }

    fn detect_c_lib(triple: &X86TargetTriple) -> X86CLibKind {
        match (triple.os, triple.environment) {
            (X86TripleOS::Win32, X86TripleEnvironment::MSVC) => X86CLibKind::Msvcrt,
            (X86TripleOS::Android, _) => X86CLibKind::Bionic,
            (X86TripleOS::Darwin, _) | (X86TripleOS::MacOSX, _) => X86CLibKind::LibSystem,
            (_, X86TripleEnvironment::Musl)
            | (_, X86TripleEnvironment::Musleabi)
            | (_, X86TripleEnvironment::Musleabihf) => X86CLibKind::Musl,
            _ => X86CLibKind::Glibc,
        }
    }

    fn detect_cxx_lib(triple: &X86TargetTriple) -> X86CXXLibKind {
        match (triple.os, triple.environment) {
            (X86TripleOS::Win32, X86TripleEnvironment::MSVC) => X86CXXLibKind::Msvcprt,
            (X86TripleOS::Android, _) => X86CXXLibKind::AndroidCXX,
            _ => X86CXXLibKind::LibStdCXX,
        }
    }

    fn detect_lib_paths(&mut self, toolchain: &X86ToolchainPath) {
        self.std_lib_paths = toolchain.lib_dirs.clone();

        // Add common system library paths
        let extra_paths = ["/usr/lib", "/usr/lib64", "/usr/local/lib", "/lib", "/lib64"];

        for path in &extra_paths {
            let p = PathBuf::from(path);
            if p.exists() && !self.std_lib_paths.contains(&p) {
                self.std_lib_paths.push(p);
            }
        }
    }

    fn detect_crt_files(&mut self, toolchain: &X86ToolchainPath) {
        let crt_names = ["crt1.o", "crti.o", "crtbegin.o", "crtend.o", "crtn.o"];

        for name in &crt_names {
            if let Some(path) = toolchain.crt_object(name).cloned() {
                self.crt_files.push(path);
            } else {
                // Try to find in lib directories
                for lib_dir in &self.std_lib_paths {
                    let candidate = lib_dir.join(name);
                    if candidate.exists() {
                        self.crt_files.push(candidate);
                        break;
                    }
                }
            }
        }
    }

    fn setup_default_libraries(&mut self) {
        if self.nostdlib || self.nodefaultlibs {
            return;
        }

        match self.c_lib {
            X86CLibKind::Glibc => {
                self.link_libraries.extend([
                    "c".to_string(),
                    "m".to_string(),
                    "resolv".to_string(),
                    "pthread".to_string(),
                    "dl".to_string(),
                    "rt".to_string(),
                ]);
            }
            X86CLibKind::Musl => {
                self.link_libraries.extend([
                    "c".to_string(),
                    "m".to_string(),
                    "pthread".to_string(),
                    "dl".to_string(),
                ]);
            }
            X86CLibKind::Msvcrt => {
                self.link_libraries.extend([
                    "msvcrt".to_string(),
                    "kernel32".to_string(),
                    "user32".to_string(),
                    "advapi32".to_string(),
                    "shell32".to_string(),
                    "ole32".to_string(),
                ]);
            }
            X86CLibKind::Bionic => {
                self.link_libraries
                    .extend(["c".to_string(), "m".to_string(), "dl".to_string()]);
            }
            X86CLibKind::LibSystem => {
                self.link_libraries.extend([
                    "System".to_string(),
                    "c".to_string(),
                    "m".to_string(),
                ]);
            }
            _ => {
                self.link_libraries
                    .extend(["c".to_string(), "m".to_string()]);
            }
        }

        // C++ library
        if let Some(cxx_lib) = self.cxx_lib.default_cxx_lib() {
            self.link_libraries.push(cxx_lib.to_string());
        }

        // Compiler runtime
        if self.use_compiler_rt {
            self.link_libraries
                .push("clang_rt.builtins-x86_64".to_string());
        } else {
            self.link_libraries.push("gcc".to_string());
            self.link_libraries.push("gcc_s".to_string());
        }

        // libunwind
        if self.use_libunwind {
            self.link_libraries.push("unwind".to_string());
        }
    }

    /// Get library search paths.
    pub fn library_paths(&self) -> Vec<PathBuf> {
        self.std_lib_paths.clone()
    }

    /// Get default libraries to link.
    pub fn default_link_libraries(&self) -> Vec<String> {
        self.link_libraries.clone()
    }

    /// Get CRT startup files in link order.
    pub fn crt_startup_files(&self) -> &[PathBuf] {
        &self.crt_files
    }
}

// ═══════════════════════════════════════════════════════════════════════════════
// 11. X86Multilib — Multilib Support for -m32/-m64/-mx32
// ═══════════════════════════════════════════════════════════════════════════════

/// Multilib configuration for x86 targets. Handles automatic library path
/// switching between 32-bit, 64-bit, and x32 ABIs.
#[derive(Debug, Clone)]
pub struct X86Multilib {
    /// The target triple.
    pub triple: X86TargetTriple,
    /// The currently active multilib variant.
    pub active_variant: X86MultilibVariant,
    /// Whether multilib is supported.
    pub multilib_enabled: bool,
    /// Include paths for 32-bit libraries.
    pub include_paths_32: Vec<PathBuf>,
    /// Include paths for 64-bit libraries.
    pub include_paths_64: Vec<PathBuf>,
    /// Include paths for x32 libraries.
    pub include_paths_x32: Vec<PathBuf>,
    /// Library paths for 32-bit.
    pub lib_paths_32: Vec<PathBuf>,
    /// Library paths for 64-bit.
    pub lib_paths_64: Vec<PathBuf>,
    /// Library paths for x32.
    pub lib_paths_x32: Vec<PathBuf>,
    /// GCC multilib OS directory.
    pub gcc_multilib_dir: Option<PathBuf>,
    /// GCC multilib 32-bit directory.
    pub gcc_multilib_32_dir: Option<PathBuf>,
}

/// The active multilib variant.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum X86MultilibVariant {
    /// Default 64-bit.
    Default64,
    /// 32-bit (-m32).
    M32,
    /// x32 ABI (-mx32).
    MX32,
}

impl X86MultilibVariant {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Default64 => "64",
            Self::M32 => "32",
            Self::MX32 => "x32",
        }
    }

    pub fn is_64bit(&self) -> bool {
        matches!(self, Self::Default64)
    }

    pub fn is_32bit(&self) -> bool {
        matches!(self, Self::M32)
    }

    pub fn pointer_width_bits(&self) -> u32 {
        match self {
            Self::Default64 => 64,
            Self::M32 => 32,
            Self::MX32 => 32,
        }
    }

    pub fn gcc_multilib_suffix(&self) -> &'static str {
        match self {
            Self::Default64 => "64",
            Self::M32 => "32",
            Self::MX32 => "x32",
        }
    }
}

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

impl X86Multilib {
    pub fn new(triple: &X86TargetTriple) -> Self {
        let active = if triple.is_x32 {
            X86MultilibVariant::MX32
        } else if triple.is_64bit {
            X86MultilibVariant::Default64
        } else {
            X86MultilibVariant::M32
        };

        let mut m = Self {
            triple: triple.clone(),
            active_variant: active,
            multilib_enabled: true,
            include_paths_32: Vec::new(),
            include_paths_64: Vec::new(),
            include_paths_x32: Vec::new(),
            lib_paths_32: Vec::new(),
            lib_paths_64: Vec::new(),
            lib_paths_x32: Vec::new(),
            gcc_multilib_dir: None,
            gcc_multilib_32_dir: None,
        };

        m.detect_multilib_paths();
        m
    }

    fn detect_multilib_paths(&mut self) {
        // 32-bit paths
        self.lib_paths_32 = vec![
            PathBuf::from("/usr/lib32"),
            PathBuf::from("/usr/lib/i386-linux-gnu"),
            PathBuf::from("/lib32"),
        ];

        self.include_paths_32 = vec![
            PathBuf::from("/usr/include/i386-linux-gnu"),
            PathBuf::from("/usr/include32"),
        ];

        // 64-bit paths
        self.lib_paths_64 = vec![
            PathBuf::from("/usr/lib64"),
            PathBuf::from("/usr/lib/x86_64-linux-gnu"),
            PathBuf::from("/lib64"),
        ];

        self.include_paths_64 = vec![
            PathBuf::from("/usr/include/x86_64-linux-gnu"),
            PathBuf::from("/usr/include64"),
        ];

        // x32 paths
        self.lib_paths_x32 = vec![
            PathBuf::from("/usr/libx32"),
            PathBuf::from("/usr/lib/x86_64-linux-gnux32"),
            PathBuf::from("/libx32"),
        ];

        self.include_paths_x32 = vec![PathBuf::from("/usr/include/x86_64-linux-gnux32")];

        // Detect GCC multilib directories
        let gcc_base = PathBuf::from("/usr/lib/gcc/x86_64-linux-gnu");
        if gcc_base.exists() {
            if let Ok(entries) = fs::read_dir(&gcc_base) {
                for entry in entries.flatten() {
                    let path = entry.path();
                    if path.is_dir() {
                        let dir32 = path.join("32");
                        if dir32.exists() {
                            self.gcc_multilib_32_dir = Some(dir32);
                        }
                        self.gcc_multilib_dir = Some(path);
                        break;
                    }
                }
            }
        }
    }

    /// Select the 32-bit multilib variant.
    pub fn select_32bit(&mut self) {
        self.active_variant = X86MultilibVariant::M32;
    }

    /// Select the x32 multilib variant.
    pub fn select_x32(&mut self) {
        self.active_variant = X86MultilibVariant::MX32;
    }

    /// Select the 64-bit multilib variant.
    pub fn select_64bit(&mut self) {
        self.active_variant = X86MultilibVariant::Default64;
    }

    /// Get active library paths for the current variant.
    pub fn library_paths(&self) -> Vec<PathBuf> {
        match self.active_variant {
            X86MultilibVariant::Default64 => self.lib_paths_64.clone(),
            X86MultilibVariant::M32 => self.lib_paths_32.clone(),
            X86MultilibVariant::MX32 => self.lib_paths_x32.clone(),
        }
    }

    /// Get active include paths for the current variant.
    pub fn include_paths(&self) -> Vec<PathBuf> {
        match self.active_variant {
            X86MultilibVariant::Default64 => self.include_paths_64.clone(),
            X86MultilibVariant::M32 => self.include_paths_32.clone(),
            X86MultilibVariant::MX32 => self.include_paths_x32.clone(),
        }
    }

    /// Get the GCC multilib directory for the current variant.
    pub fn gcc_lib_dir(&self) -> Option<PathBuf> {
        match self.active_variant {
            X86MultilibVariant::Default64 => self.gcc_multilib_dir.clone(),
            X86MultilibVariant::M32 => self.gcc_multilib_32_dir.clone(),
            X86MultilibVariant::MX32 => self.gcc_multilib_dir.clone(),
        }
    }
}

// ═══════════════════════════════════════════════════════════════════════════════
// 12. X86DriverArgs — X86-Specific Argument Parsing
// ═══════════════════════════════════════════════════════════════════════════════

/// Parsed x86-specific driver arguments.
#[derive(Debug, Clone, Default)]
pub struct X86DriverArgs {
    /// Target triple (-target).
    pub target: Option<String>,
    /// Target CPU (-march, -mcpu).
    pub target_cpu: Option<String>,
    /// Target ABI (-mabi).
    pub target_abi: Option<String>,
    /// Target features (-mattr, -mno-*).
    pub target_features: Vec<String>,
    /// Optimization level.
    pub opt_level: Option<X86DriverOptLevel>,
    /// -m32 flag.
    pub m32: bool,
    /// -m64 flag.
    pub m64: bool,
    /// -mx32 flag.
    pub mx32: bool,
    /// -march=native or specific.
    pub march: Option<String>,
    /// -mcpu flag.
    pub mcpu: Option<String>,
    /// -mtune flag.
    pub mtune: Option<String>,
    /// -mfpmath (387, sse, sse+387).
    pub mfpmath: Option<String>,
    /// -mregparm=N.
    pub mregparm: Option<u32>,
    /// -mstackrealign.
    pub mstackrealign: bool,
    /// -mstack-alignment=N.
    pub mstack_alignment: Option<u32>,
    /// -mred-zone / -mno-red-zone.
    pub mred_zone: Option<bool>,
    /// -mcmodel (small, kernel, medium, large).
    pub mcmodel: Option<String>,
    /// -fPIC / -fpic.
    pub fPIC: bool,
    pub fpic: bool,
    /// -fPIE / -fpie.
    pub fPIE: bool,
    pub fpie: bool,
    /// -fno-pic.
    pub fno_pic: bool,
    /// -fsanitize=LIST.
    pub fsanitize: Option<String>,
    /// -fsanitize-recover=LIST.
    pub fsanitize_recover: Option<String>,
    /// -fsanitize-trap=LIST.
    pub fsanitize_trap: Option<String>,
    /// -fsanitize-minimal-runtime.
    pub fsanitize_minimal_runtime: bool,
    /// -fprofile-instr-generate[=DIR].
    pub fprofile_instr_generate: Option<String>,
    /// -fprofile-instr-use=FILE.
    pub fprofile_instr_use: Option<String>,
    /// -fcoverage-mapping.
    pub fcoverage_mapping: bool,
    /// -fcs-profile-generate=DIR.
    pub fcs_profile_generate: Option<String>,
    /// -ffunction-sections.
    pub ffunction_sections: bool,
    /// -flto / -flto=thin / -flto=full.
    pub flto: Option<String>,
    /// -flto-thin (alias).
    pub flto_thin: bool,
    /// -flto-jobs=N.
    pub flto_jobs: Option<u32>,
    /// -fuse-ld=NAME.
    pub fuse_ld: Option<String>,
    /// -mno-sse, -mno-avx, etc.
    pub mno_features: Vec<String>,
    /// -mavx, -msse2, etc.
    pub m_features: Vec<String>,
    /// -include.
    pub include_prefixes: Vec<String>,
    /// -I paths.
    pub include_paths: Vec<String>,
    /// -isystem paths.
    pub system_include_paths: Vec<String>,
    /// -L paths.
    pub library_paths: Vec<String>,
    /// -l libraries.
    pub libraries: Vec<String>,
    /// -D defines.
    pub defines: Vec<(String, Option<String>)>,
    /// -U undefines.
    pub undefines: Vec<String>,
    /// -o output file.
    pub output_file: Option<String>,
    /// Input files.
    pub input_files: Vec<String>,
    /// -v (verbose).
    pub v: bool,
    /// --verbose.
    pub verbose: bool,
    /// -### (dry run).
    pub dry_run: bool,
    /// -Wl, flags.
    pub wl_flags: Vec<String>,
    /// -Wa, flags.
    pub wa_flags: Vec<String>,
    /// -Wp, flags.
    pub wp_flags: Vec<String>,
    /// -Xlinker flags.
    pub xlinker_flags: Vec<String>,
    /// -Xassembler flags.
    pub xassembler_flags: Vec<String>,
    /// -E (preprocess only).
    pub preprocess_only: bool,
    /// -S (compile to assembly).
    pub assembly_only: bool,
    /// -c (compile to object only).
    pub compile_only: bool,
    /// -shared.
    pub shared: bool,
    /// -static.
    pub static_linking: bool,
    /// -rdynamic.
    pub rdynamic: bool,
    /// -nodefaultlibs.
    pub nodefaultlibs: bool,
    /// -nostdlib.
    pub nostdlib: bool,
    /// -nostartfiles.
    pub nostartfiles: bool,
    /// -nostdinc.
    pub nostdinc: bool,
    /// -nostdinc++.
    pub nostdincxx: bool,
    /// -stdlib=NAME.
    pub stdlib: Option<String>,
}

impl X86DriverArgs {
    /// Parse x86-specific driver arguments from a list of strings.
    pub fn parse(args: &[String]) -> Self {
        let mut parsed = Self::default();
        let mut i = 0;

        while i < args.len() {
            let arg = &args[i];

            match arg.as_str() {
                "-target" => {
                    if i + 1 < args.len() {
                        i += 1;
                        parsed.target = Some(args[i].clone());
                    }
                }
                "-m32" => parsed.m32 = true,
                "-m64" => parsed.m64 = true,
                "-mx32" => parsed.mx32 = true,
                "-march" | "--march" => {
                    if i + 1 < args.len() {
                        i += 1;
                        parsed.march = Some(args[i].clone());
                    }
                }
                "-mcpu" | "--mcpu" => {
                    if i + 1 < args.len() {
                        i += 1;
                        parsed.mcpu = Some(args[i].clone());
                    }
                }
                "-mtune" | "--mtune" => {
                    if i + 1 < args.len() {
                        i += 1;
                        parsed.mtune = Some(args[i].clone());
                    }
                }
                "-mfpmath" => {
                    if i + 1 < args.len() {
                        i += 1;
                        parsed.mfpmath = Some(args[i].clone());
                    }
                }
                "-mregparm" => {
                    if i + 1 < args.len() {
                        i += 1;
                        parsed.mregparm = args[i].parse::<u32>().ok();
                    }
                }
                "-mstackrealign" => parsed.mstackrealign = true,
                "-mstack-alignment" => {
                    if i + 1 < args.len() {
                        i += 1;
                        parsed.mstack_alignment = args[i].parse::<u32>().ok();
                    }
                }
                "-mred-zone" => parsed.mred_zone = Some(true),
                "-mno-red-zone" => parsed.mred_zone = Some(false),
                "-mcmodel" => {
                    if i + 1 < args.len() {
                        i += 1;
                        parsed.mcmodel = Some(args[i].clone());
                    }
                }
                "-fPIC" => parsed.fPIC = true,
                "-fpic" => parsed.fpic = true,
                "-fPIE" => parsed.fPIE = true,
                "-fpie" => parsed.fpie = true,
                "-fno-pic" | "-fno-PIC" | "-fno-pie" | "-fno-PIE" => {
                    parsed.fno_pic = true;
                }
                "-fsanitize" => {
                    if i + 1 < args.len() {
                        i += 1;
                        parsed.fsanitize = Some(args[i].clone());
                    }
                }
                a if a.starts_with("-fsanitize=") => {
                    parsed.fsanitize = Some(a[11..].to_string());
                }
                "-fsanitize-recover" => {
                    if i + 1 < args.len() {
                        i += 1;
                        parsed.fsanitize_recover = Some(args[i].clone());
                    }
                }
                a if a.starts_with("-fsanitize-recover=") => {
                    parsed.fsanitize_recover = Some(a[19..].to_string());
                }
                "-fsanitize-trap" => {
                    if i + 1 < args.len() {
                        i += 1;
                        parsed.fsanitize_trap = Some(args[i].clone());
                    }
                }
                a if a.starts_with("-fsanitize-trap=") => {
                    parsed.fsanitize_trap = Some(a[16..].to_string());
                }
                "-fsanitize-minimal-runtime" => parsed.fsanitize_minimal_runtime = true,
                "-fprofile-instr-generate" => {
                    if i + 1 < args.len() && !args[i + 1].starts_with('-') {
                        i += 1;
                        parsed.fprofile_instr_generate = Some(args[i].clone());
                    } else {
                        parsed.fprofile_instr_generate = Some(String::new());
                    }
                }
                a if a.starts_with("-fprofile-instr-generate=") => {
                    parsed.fprofile_instr_generate = Some(a[25..].to_string());
                }
                "-fprofile-instr-use" => {
                    if i + 1 < args.len() {
                        i += 1;
                        parsed.fprofile_instr_use = Some(args[i].clone());
                    }
                }
                a if a.starts_with("-fprofile-instr-use=") => {
                    parsed.fprofile_instr_use = Some(a[21..].to_string());
                }
                "-fcoverage-mapping" => parsed.fcoverage_mapping = true,
                "-fcs-profile-generate" => {
                    if i + 1 < args.len() {
                        i += 1;
                        parsed.fcs_profile_generate = Some(args[i].clone());
                    }
                }
                a if a.starts_with("-fcs-profile-generate=") => {
                    parsed.fcs_profile_generate = Some(a[22..].to_string());
                }
                "-ffunction-sections" => parsed.ffunction_sections = true,
                "-flto" => {
                    if i + 1 < args.len() && !args[i + 1].starts_with('-') {
                        i += 1;
                        parsed.flto = Some(args[i].clone());
                    } else {
                        parsed.flto = Some("full".to_string());
                    }
                }
                a if a.starts_with("-flto=") => {
                    parsed.flto = Some(a[6..].to_string());
                }
                "-flto-thin" => {
                    parsed.flto_thin = true;
                    parsed.flto = Some("thin".to_string());
                }
                "-flto-jobs" => {
                    if i + 1 < args.len() {
                        i += 1;
                        parsed.flto_jobs = args[i].parse::<u32>().ok();
                    }
                }
                a if a.starts_with("-flto-jobs=") => {
                    parsed.flto_jobs = a[11..].parse::<u32>().ok();
                }
                "-fuse-ld" => {
                    if i + 1 < args.len() {
                        i += 1;
                        parsed.fuse_ld = Some(args[i].clone());
                    }
                }
                a if a.starts_with("-fuse-ld=") => {
                    parsed.fuse_ld = Some(a[9..].to_string());
                }
                "-I" => {
                    if i + 1 < args.len() {
                        i += 1;
                        parsed.include_paths.push(args[i].clone());
                    }
                }
                a if a.starts_with("-I") && a.len() > 2 => {
                    parsed.include_paths.push(a[2..].to_string());
                }
                "-isystem" => {
                    if i + 1 < args.len() {
                        i += 1;
                        parsed.system_include_paths.push(args[i].clone());
                    }
                }
                a if a.starts_with("-isystem") && a.len() > 8 => {
                    parsed.system_include_paths.push(a[8..].to_string());
                }
                "-L" => {
                    if i + 1 < args.len() {
                        i += 1;
                        parsed.library_paths.push(args[i].clone());
                    }
                }
                a if a.starts_with("-L") && a.len() > 2 => {
                    parsed.library_paths.push(a[2..].to_string());
                }
                "-l" => {
                    if i + 1 < args.len() {
                        i += 1;
                        parsed.libraries.push(args[i].clone());
                    }
                }
                a if a.starts_with("-l") && a.len() > 2 => {
                    parsed.libraries.push(a[2..].to_string());
                }
                "-D" => {
                    if i + 1 < args.len() {
                        i += 1;
                        let def = &args[i];
                        if let Some(eq) = def.find('=') {
                            let name = def[..eq].to_string();
                            let val = def[eq + 1..].to_string();
                            parsed.defines.push((name, Some(val)));
                        } else {
                            parsed.defines.push((def.clone(), Some("1".to_string())));
                        }
                    }
                }
                a if a.starts_with("-D") && a.len() > 2 => {
                    let def = &a[2..];
                    if let Some(eq) = def.find('=') {
                        let name = def[..eq].to_string();
                        let val = def[eq + 1..].to_string();
                        parsed.defines.push((name, Some(val)));
                    } else {
                        parsed
                            .defines
                            .push((def.to_string(), Some("1".to_string())));
                    }
                }
                "-U" => {
                    if i + 1 < args.len() {
                        i += 1;
                        parsed.undefines.push(args[i].clone());
                    }
                }
                a if a.starts_with("-U") && a.len() > 2 => {
                    parsed.undefines.push(a[2..].to_string());
                }
                "-o" => {
                    if i + 1 < args.len() {
                        i += 1;
                        parsed.output_file = Some(args[i].clone());
                    }
                }
                "-include" => {
                    if i + 1 < args.len() {
                        i += 1;
                        parsed.include_prefixes.push(args[i].clone());
                    }
                }
                a if a.starts_with("-include") && a.len() > 8 => {
                    parsed.include_prefixes.push(a[8..].to_string());
                }
                "-v" => parsed.v = true,
                "--verbose" => parsed.verbose = true,
                "-###" => parsed.dry_run = true,
                "-E" => parsed.preprocess_only = true,
                "-S" => parsed.assembly_only = true,
                "-c" => parsed.compile_only = true,
                "-shared" => parsed.shared = true,
                "-static" => parsed.static_linking = true,
                "-rdynamic" => parsed.rdynamic = true,
                "-nodefaultlibs" => parsed.nodefaultlibs = true,
                "-nostdlib" => parsed.nostdlib = true,
                "-nostartfiles" => parsed.nostartfiles = true,
                "-nostdinc" => parsed.nostdinc = true,
                "-nostdinc++" | "-nostdincxx" => parsed.nostdincxx = true,
                "-stdlib" => {
                    if i + 1 < args.len() {
                        i += 1;
                        parsed.stdlib = Some(args[i].clone());
                    }
                }
                a if a.starts_with("-stdlib=") => {
                    parsed.stdlib = Some(a[9..].to_string());
                }
                "-Wl," => {
                    // -Wl,flag is followed by more content
                }
                a if a.starts_with("-Wl,") => {
                    for flag in a[4..].split(',') {
                        if !flag.is_empty() {
                            parsed.wl_flags.push(flag.to_string());
                        }
                    }
                }
                a if a.starts_with("-Wa,") => {
                    for flag in a[4..].split(',') {
                        if !flag.is_empty() {
                            parsed.wa_flags.push(flag.to_string());
                        }
                    }
                }
                a if a.starts_with("-Wp,") => {
                    for flag in a[4..].split(',') {
                        if !flag.is_empty() {
                            parsed.wp_flags.push(flag.to_string());
                        }
                    }
                }
                "-Xlinker" => {
                    if i + 1 < args.len() {
                        i += 1;
                        parsed.xlinker_flags.push(args[i].clone());
                    }
                }
                "-Xassembler" => {
                    if i + 1 < args.len() {
                        i += 1;
                        parsed.xassembler_flags.push(args[i].clone());
                    }
                }
                a if a.starts_with("-O") => {
                    let level = &a[2..];
                    parsed.opt_level = match level {
                        "0" => Some(X86DriverOptLevel::O0),
                        "1" => Some(X86DriverOptLevel::O1),
                        "2" => Some(X86DriverOptLevel::O2),
                        "3" => Some(X86DriverOptLevel::O3),
                        "s" => Some(X86DriverOptLevel::Os),
                        "z" => Some(X86DriverOptLevel::Oz),
                        "" => Some(X86DriverOptLevel::O1),
                        _ => None,
                    };
                }
                a if a.starts_with("-mno-") => {
                    parsed.mno_features.push(a[5..].to_string());
                }
                a if a.starts_with("-m")
                    && !a.starts_with("-m32")
                    && !a.starts_with("-m64")
                    && !a.starts_with("-mx32")
                    && !a.starts_with("-march")
                    && !a.starts_with("-mcpu")
                    && !a.starts_with("-mtune")
                    && !a.starts_with("-mfpmath")
                    && !a.starts_with("-mregparm")
                    && !a.starts_with("-mstack")
                    && !a.starts_with("-mred-zone")
                    && !a.starts_with("-mcmodel") =>
                {
                    parsed.m_features.push(a[2..].to_string());
                }
                a if !a.starts_with('-') => {
                    parsed.input_files.push(a.to_string());
                }
                _ => {}
            }

            i += 1;
        }

        // If -m32 and not explicitly given a target triple, set it
        if parsed.m32 && parsed.target.is_none() {
            parsed.target = Some("i386-unknown-linux-gnu".to_string());
        }
        if parsed.mx32 && parsed.target.is_none() {
            parsed.target = Some("x86_64-unknown-linux-gnux32".to_string());
        }

        parsed
    }

    /// Convert x86-specific arguments back to clang flags.
    pub fn to_clang_flags(&self) -> Vec<String> {
        let mut flags = Vec::new();

        if self.m32 {
            flags.push("-m32".to_string());
        }
        if self.m64 {
            flags.push("-m64".to_string());
        }
        if self.mx32 {
            flags.push("-mx32".to_string());
        }
        if let Some(ref march) = self.march {
            flags.push(format!("-march={}", march));
        }
        if let Some(ref mcpu) = self.mcpu {
            flags.push(format!("-mcpu={}", mcpu));
        }
        if let Some(ref mtune) = self.mtune {
            flags.push(format!("-mtune={}", mtune));
        }
        if let Some(ref fpmath) = self.mfpmath {
            flags.push(format!("-mfpmath={}", fpmath));
        }
        if let Some(regparm) = self.mregparm {
            flags.push(format!("-mregparm={}", regparm));
        }
        if self.mstackrealign {
            flags.push("-mstackrealign".to_string());
        }
        if let Some(align) = self.mstack_alignment {
            flags.push(format!("-mstack-alignment={}", align));
        }
        if let Some(red_zone) = self.mred_zone {
            if red_zone {
                flags.push("-mred-zone".to_string());
            } else {
                flags.push("-mno-red-zone".to_string());
            }
        }
        if let Some(ref cmodel) = self.mcmodel {
            flags.push(format!("-mcmodel={}", cmodel));
        }

        // Features
        for feat in &self.m_features {
            flags.push(format!("-m{}", feat));
        }
        for feat in &self.mno_features {
            flags.push(format!("-mno-{}", feat));
        }

        // PIC / PIE
        if self.fPIC {
            flags.push("-fPIC".to_string());
        }
        if self.fpic {
            flags.push("-fpic".to_string());
        }
        if self.fPIE {
            flags.push("-fPIE".to_string());
        }
        if self.fpie {
            flags.push("-fpie".to_string());
        }
        if self.fno_pic {
            flags.push("-fno-pic".to_string());
        }

        // Sanitizers
        if let Some(ref san) = self.fsanitize {
            flags.push(format!("-fsanitize={}", san));
        }
        if self.fsanitize_minimal_runtime {
            flags.push("-fsanitize-minimal-runtime".to_string());
        }

        // Profiling
        if let Some(ref r#gen) = self.fprofile_instr_generate {
            if r#gen.is_empty() {
                flags.push("-fprofile-instr-generate".to_string());
            } else {
                flags.push(format!("-fprofile-instr-generate={}", r#gen));
            }
        }
        if let Some(ref profile_path) = self.fprofile_instr_use {
            flags.push(format!("-fprofile-instr-use={}", profile_path));
        }
        if self.fcoverage_mapping {
            flags.push("-fcoverage-mapping".to_string());
        }
        if self.ffunction_sections {
            flags.push("-ffunction-sections".to_string());
        }

        // LTO
        if let Some(ref lto) = self.flto {
            flags.push(format!("-flto={}", lto));
        }

        if let Some(ref ld) = self.fuse_ld {
            flags.push(format!("-fuse-ld={}", ld));
        }

        // Other
        if let Some(ref abi) = self.target_abi {
            flags.push(format!("-mabi={}", abi));
        }

        flags
    }
}

// ═══════════════════════════════════════════════════════════════════════════════
// 13. X86LTOConfig — LTO / ThinLTO Configuration for X86
// ═══════════════════════════════════════════════════════════════════════════════

/// Link-Time Optimization configuration for x86 targets.
#[derive(Debug, Clone)]
pub struct X86LTOConfig {
    /// Whether LTO is enabled.
    pub enabled: bool,
    /// Whether to use ThinLTO instead of full LTO.
    pub thin: bool,
    /// Number of parallel ThinLTO backend jobs.
    pub thin_lto_jobs: Option<String>,
    /// Cache directory for ThinLTO.
    pub cache_dir: Option<PathBuf>,
    /// Cache pruning interval (seconds).
    pub cache_pruning_interval: u64,
    /// Maximum cache size (bytes).
    pub cache_max_size_bytes: Option<u64>,
    /// Maximum cache size (percentage of available space).
    pub cache_max_size_percent: Option<u32>,
    /// Path to the linker plugin (LLVMgold.so or similar).
    pub linker_plugin: Option<PathBuf>,
    /// LTO optimization level.
    pub lto_opt_level: Option<u32>,
    /// Enable debug info with LTO.
    pub lto_debug_info: bool,
    /// Enable new pass manager for LTO.
    pub new_pass_manager: bool,
    /// Visibility of LTO-generated symbols.
    pub lto_visibility: X86LTOVisibility,
    /// Whether to generate a resolution file.
    pub generate_resolution: bool,
    /// Resolution file path.
    pub resolution_file: Option<PathBuf>,
    /// Sample PGO profile for LTO.
    pub sample_profile: Option<PathBuf>,
    /// Whether to enable CSIRPGO.
    pub csirpgo: bool,
}

/// LTO symbol visibility mode.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum X86LTOVisibility {
    Default,
    Hidden,
    Protected,
}

impl X86LTOConfig {
    /// Create default LTO config (disabled).
    pub fn new() -> Self {
        Self {
            enabled: false,
            thin: false,
            thin_lto_jobs: None,
            cache_dir: None,
            cache_pruning_interval: 3600,
            cache_max_size_bytes: None,
            cache_max_size_percent: Some(75),
            linker_plugin: None,
            lto_opt_level: None,
            lto_debug_info: false,
            new_pass_manager: true,
            lto_visibility: X86LTOVisibility::Default,
            generate_resolution: false,
            resolution_file: None,
            sample_profile: None,
            csirpgo: false,
        }
    }

    /// Create from parsed driver arguments.
    pub fn from_args(args: &X86DriverArgs) -> Self {
        let mut config = Self::new();

        if let Some(ref lto) = args.flto {
            config.enabled = true;
            config.thin = lto == "thin";
            if args.flto_thin {
                config.thin = true;
            }
        }

        if let Some(ref ld) = args.fuse_ld {
            if ld == "lld" || ld == "gold" {
                // These linkers support LTO plugins
                config.detect_plugin();
            }
        }

        if let Some(jobs) = args.flto_jobs {
            config.thin_lto_jobs = Some(jobs.to_string());
        }

        config
    }

    pub fn is_enabled(&self) -> bool {
        self.enabled
    }

    pub fn is_thin(&self) -> bool {
        self.thin
    }

    /// Detect the linker plugin path.
    pub fn detect_plugin(&mut self) {
        let candidates = [
            "/usr/lib/LLVMgold.so",
            "/usr/lib64/LLVMgold.so",
            "/usr/local/lib/LLVMgold.so",
            "/opt/llvm/lib/LLVMgold.so",
            "/usr/lib/bfd-plugins/LLVMgold.so",
        ];

        for candidate in &candidates {
            let path = Path::new(candidate);
            if path.exists() {
                self.linker_plugin = Some(path.to_path_buf());
                return;
            }
        }
    }

    /// Generate linker flags for LTO.
    pub fn linker_flags(&self) -> Vec<String> {
        let mut flags = Vec::new();

        if !self.enabled {
            return flags;
        }

        if self.thin {
            flags.push("-flto=thin".to_string());
            if let Some(ref jobs) = self.thin_lto_jobs {
                flags.push(format!("-plugin-opt=jobs={}", jobs));
            }
        } else {
            flags.push("-flto".to_string());
        }

        if let Some(ref plugin) = self.linker_plugin {
            flags.push(format!("-plugin={}", plugin.display()));
        }

        if let Some(ref cache) = self.cache_dir {
            flags.push(format!("-plugin-opt=cache-dir={}", cache.display()));
            flags.push(format!(
                "-plugin-opt=cache-pruning-interval={}",
                self.cache_pruning_interval
            ));
        }

        if self.new_pass_manager {
            flags.push("-plugin-opt=new-pass-manager".to_string());
        }

        if self.lto_debug_info {
            flags.push("-plugin-opt=debug-info".to_string());
        }

        flags
    }

    /// Get compiler flags for LTO.
    pub fn compiler_flags(&self) -> Vec<String> {
        let mut flags = Vec::new();

        if !self.enabled {
            return flags;
        }

        if self.thin {
            flags.push("-flto=thin".to_string());
        } else {
            flags.push("-flto".to_string());
        }

        if let Some(opt) = self.lto_opt_level {
            flags.push(format!("-flto-O{}", opt));
        }

        flags
    }
}

impl Default for X86LTOConfig {
    fn default() -> Self {
        Self::new()
    }
}

// ═══════════════════════════════════════════════════════════════════════════════
// 14. X86BitcodeReproducer — Reproducer Generation for Debugging
// ═══════════════════════════════════════════════════════════════════════════════

/// Bitcode reproducer for debugging compilation failures. Captures the full
/// driver state, input files, and intermediate outputs for offline reproduction.
#[derive(Debug, Clone)]
pub struct X86BitcodeReproducer {
    /// Output directory for the reproducer.
    pub output_dir: PathBuf,
    /// Whether to capture preprocessed source.
    pub capture_preprocessed: bool,
    /// Whether to capture bitcode.
    pub capture_bitcode: bool,
    /// Whether to capture assembly.
    pub capture_assembly: bool,
    /// Whether to generate a shell script to replay.
    pub generate_replay_script: bool,
    /// Captured state.
    pub captured_state: Option<X86ReproducerState>,
    /// Timestamp of capture.
    pub capture_time: Option<SystemTime>,
}

/// Captured driver state for reproduction.
#[derive(Debug, Clone)]
pub struct X86ReproducerState {
    /// Target triple.
    pub triple: String,
    /// Compiler invocation command.
    pub compiler_command: Vec<String>,
    /// Linker invocation command.
    pub linker_command: Vec<String>,
    /// Include paths.
    pub include_paths: Vec<PathBuf>,
    /// Input files (copied into reproducer directory).
    pub input_files: Vec<PathBuf>,
    /// Preprocessed source (if captured).
    pub preprocessed_file: Option<PathBuf>,
    /// Bitcode file (if captured).
    pub bitcode_file: Option<PathBuf>,
    /// Assembly file (if captured).
    pub assembly_file: Option<PathBuf>,
    /// Environment variables.
    pub environment: HashMap<String, String>,
    /// Working directory.
    pub working_dir: PathBuf,
    /// Full argument list.
    pub arguments: Vec<String>,
}

impl X86BitcodeReproducer {
    pub fn new(output_dir: &Path) -> Self {
        Self {
            output_dir: output_dir.to_path_buf(),
            capture_preprocessed: true,
            capture_bitcode: true,
            capture_assembly: false,
            generate_replay_script: true,
            captured_state: None,
            capture_time: None,
        }
    }

    /// Capture the current driver state.
    pub fn capture_state(&self, driver: &X86ClangDriver) -> Result<(), String> {
        // Ensure output directory exists
        fs::create_dir_all(&self.output_dir)
            .map_err(|e| format!("Failed to create output dir: {}", e))?;

        let mut state = X86ReproducerState {
            triple: driver.triple.normalized.clone(),
            compiler_command: Vec::new(),
            linker_command: Vec::new(),
            include_paths: driver.all_include_paths(),
            input_files: driver.input_files.clone(),
            preprocessed_file: None,
            bitcode_file: None,
            assembly_file: None,
            environment: HashMap::new(),
            working_dir: std::env::current_dir().unwrap_or_else(|_| PathBuf::from(".")),
            arguments: Vec::new(),
        };

        // Capture environment
        for (key, value) in std::env::vars() {
            state.environment.insert(key, value);
        }

        // Generate replay script if requested
        if self.generate_replay_script {
            let script_path = self.output_dir.join("replay.sh");
            let script = self.generate_replay_script(&state);
            fs::write(&script_path, script)
                .map_err(|e| format!("Failed to write replay script: {}", e))?;

            // Make it executable on Unix
            #[cfg(unix)]
            {
                use std::os::unix::fs::PermissionsExt;
                let mut perms = fs::metadata(&script_path)
                    .map_err(|e| format!("Failed to get metadata: {}", e))?
                    .permissions();
                perms.set_mode(0o755);
                fs::set_permissions(&script_path, perms)
                    .map_err(|e| format!("Failed to make script executable: {}", e))?;
            }
        }

        // Copy input files
        for input in &state.input_files {
            if input.exists() {
                let dest = self
                    .output_dir
                    .join(input.file_name().unwrap_or_else(|| input.as_os_str()));
                fs::copy(input, &dest).map_err(|e| format!("Failed to copy input file: {}", e))?;
            }
        }

        Ok(())
    }

    fn generate_replay_script(&self, state: &X86ReproducerState) -> String {
        let mut script = String::new();
        script.push_str("#!/bin/sh\n");
        script.push_str("# Clang X86 Bitcode Reproducer — Replay Script\n");
        script.push_str("# Generated automatically for debugging\n\n");

        script.push_str("set -e\n\n");

        // Restore environment
        script.push_str("# Environment\n");
        for (key, value) in &state.environment {
            if key != "PATH" && key != "HOME" && key != "USER" {
                script.push_str(&format!("export {}='{}'\n", key, value));
            }
        }
        script.push('\n');

        // Change to working directory
        script.push_str(&format!("cd '{}'\n\n", state.working_dir.display()));

        // Replay compiler command
        script.push_str("# Replay compilation\n");
        script.push_str(&state.compiler_command.join(" "));
        script.push('\n');

        script
    }

    /// Set the captured state (used after compilation to store results).
    pub fn set_state(&mut self, state: X86ReproducerState) {
        self.capture_time = Some(SystemTime::now());
        self.captured_state = Some(state);
    }

    /// Get the replay script path.
    pub fn replay_script_path(&self) -> PathBuf {
        self.output_dir.join("replay.sh")
    }

    /// Check if a reproducer was captured.
    pub fn has_capture(&self) -> bool {
        self.captured_state.is_some()
    }
}

// ═══════════════════════════════════════════════════════════════════════════════
// Convenience Functions
// ═══════════════════════════════════════════════════════════════════════════════

/// Create a full x86_64 Linux driver with common defaults.
pub fn create_x86_64_linux_driver() -> X86ClangDriver {
    X86ClangDriver::x86_64_linux()
}

/// Create a full i386 Linux driver with common defaults.
pub fn create_i386_linux_driver() -> X86ClangDriver {
    X86ClangDriver::i386_linux()
}

/// Create a full x86_64 Windows driver with MSVC defaults.
pub fn create_x86_64_windows_driver() -> X86ClangDriver {
    X86ClangDriver::x86_64_windows()
}

/// Parse a full command-line string and return driver arguments.
pub fn parse_x86_driver_args(args: &[String]) -> X86DriverArgs {
    X86DriverArgs::parse(args)
}

/// Detect the host x86 CPU info.
pub fn detect_host_x86() -> X86HostInfo {
    X86HostInfo::detect()
}

/// Parse an x86 target triple string.
pub fn parse_x86_target_triple(s: &str) -> X86TargetTriple {
    X86TargetTriple::parse(s)
}

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

// ==============================================================================
// Additional Driver Utilities
// ==============================================================================

/// A driver job representing a single compilation action.
#[derive(Debug, Clone)]
pub struct X86DriverJob {
    pub phase: X86CompilationPhase,
    pub input: PathBuf,
    pub output: PathBuf,
    pub arguments: Vec<String>,
    pub use_response_file: bool,
    pub working_dir: Option<PathBuf>,
    pub env_vars: HashMap<String, String>,
    pub estimated_memory_mb: u64,
    pub timeout_secs: u64,
}

impl X86DriverJob {
    pub fn new(phase: X86CompilationPhase, input: &Path, output: &Path) -> Self {
        Self {
            phase,
            input: input.to_path_buf(),
            output: output.to_path_buf(),
            arguments: Vec::new(),
            use_response_file: false,
            working_dir: None,
            env_vars: HashMap::new(),
            estimated_memory_mb: 0,
            timeout_secs: 0,
        }
    }

    pub fn add_arg(&mut self, arg: &str) {
        self.arguments.push(arg.to_string());
    }

    pub fn add_args(&mut self, args: &[String]) {
        self.arguments.extend(args.iter().cloned());
    }

    pub fn to_shell_command(&self) -> String {
        let mut cmd = String::new();
        for (key, value) in &self.env_vars {
            cmd.push_str(&format!("{}='{}' ", key, value));
        }
        if let Some(ref dir) = self.working_dir {
            cmd.push_str(&format!("cd '{}' && ", dir.display()));
        }
        cmd.push_str(&self.arguments.join(" "));
        cmd
    }
}

/// A collection of driver jobs.
#[derive(Debug, Clone)]
pub struct X86DriverJobList {
    pub jobs: Vec<X86DriverJob>,
    pub parallel: bool,
    pub max_parallel_jobs: usize,
}

impl X86DriverJobList {
    pub fn new() -> Self {
        Self {
            jobs: Vec::new(),
            parallel: true,
            max_parallel_jobs: num_cpus::get(),
        }
    }

    pub fn add_job(&mut self, job: X86DriverJob) {
        self.jobs.push(job);
    }

    pub fn is_empty(&self) -> bool {
        self.jobs.is_empty()
    }

    pub fn len(&self) -> usize {
        self.jobs.len()
    }

    pub fn to_shell_script(&self) -> String {
        let mut script = String::from("#!/bin/sh\nset -e\n\n");
        for (i, job) in self.jobs.iter().enumerate() {
            script.push_str(&format!("# Job {}: {:?}\n", i + 1, job.phase));
            script.push_str(&job.to_shell_command());
            script.push_str("\n\n");
        }
        script
    }
}

impl Default for X86DriverJobList {
    fn default() -> Self {
        Self::new()
    }
}

/// x86-specific predefined macros.
#[derive(Debug, Clone)]
pub struct X86PredefinedMacros {
    pub macros: Vec<(String, String)>,
}

impl X86PredefinedMacros {
    pub fn for_triple(triple: &X86TargetTriple) -> Self {
        let mut macros = Vec::new();
        if triple.is_64bit {
            macros.push(("__x86_64__".to_string(), "1".to_string()));
            macros.push(("__amd64__".to_string(), "1".to_string()));
        } else {
            macros.push(("__i386__".to_string(), "1".to_string()));
        }
        match triple.os {
            X86TripleOS::Linux => {
                macros.push(("__linux__".to_string(), "1".to_string()));
                macros.push(("__gnu_linux__".to_string(), "1".to_string()));
            }
            X86TripleOS::Darwin | X86TripleOS::MacOSX => {
                macros.push(("__APPLE__".to_string(), "1".to_string()));
                macros.push(("__MACH__".to_string(), "1".to_string()));
            }
            X86TripleOS::Win32 => {
                macros.push(("_WIN32".to_string(), "1".to_string()));
                if triple.is_64bit {
                    macros.push(("_WIN64".to_string(), "1".to_string()));
                }
            }
            _ => {}
        }
        macros.push((
            "__SIZEOF_POINTER__".to_string(),
            triple.arch.pointer_width_bits().to_string(),
        ));
        macros.push((
            "__BYTE_ORDER__".to_string(),
            "__ORDER_LITTLE_ENDIAN__".to_string(),
        ));
        macros.push(("__ORDER_LITTLE_ENDIAN__".to_string(), "1234".to_string()));
        Self { macros }
    }

    pub fn to_clang_flags(&self) -> Vec<String> {
        self.macros
            .iter()
            .map(|(name, value)| format!("-D{}={}", name, value))
            .collect()
    }
}

/// Trait for types that can emit a diagnostic report.
pub trait X86DiagnosticReport {
    fn report(&self) -> String;
    fn report_short(&self) -> String;
}

impl X86DiagnosticReport for X86ClangDriver {
    fn report(&self) -> String {
        self.describe()
    }
    fn report_short(&self) -> String {
        format!(
            "Driver[triple={}, opt={:?}]",
            self.triple.normalized, self.opt_level
        )
    }
}

impl X86DiagnosticReport for X86TargetTriple {
    fn report(&self) -> String {
        format!(
            "Triple[norm={}, 64bit={}, x32={}]",
            self.normalized, self.is_64bit, self.is_x32
        )
    }
    fn report_short(&self) -> String {
        self.normalized.clone()
    }
}

impl X86DiagnosticReport for X86SanitizerSetup {
    fn report(&self) -> String {
        let mut parts = Vec::new();
        if self.address {
            parts.push("addr");
        }
        if self.memory {
            parts.push("mem");
        }
        if self.thread {
            parts.push("thread");
        }
        if self.undefined {
            parts.push("undef");
        }
        if parts.is_empty() {
            "Sanitizers[none]".to_string()
        } else {
            format!("Sanitizers[{}]", parts.join(","))
        }
    }
    fn report_short(&self) -> String {
        if self.has_any() {
            "San[on]".to_string()
        } else {
            "San[off]".to_string()
        }
    }
}

impl X86DiagnosticReport for X86LTOConfig {
    fn report(&self) -> String {
        if !self.enabled {
            "LTO[off]".to_string()
        } else if self.thin {
            "LTO[thin]".to_string()
        } else {
            "LTO[full]".to_string()
        }
    }
    fn report_short(&self) -> String {
        if self.enabled {
            "LTO[on]".to_string()
        } else {
            "LTO[off]".to_string()
        }
    }
}

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

    // ── X86HostInfo tests ────────────────────────────────────────────────────

    #[test]
    fn test_host_info_detect() {
        let info = X86HostInfo::detect();
        assert!(!info.vendor.is_empty());
        assert!(!info.brand.is_empty());
        assert!(
            !info.features.is_empty(),
            "Should have at least base features"
        );
        assert!(info.logical_processors > 0);
        assert!(info.physical_cores > 0);
        assert!(!info.vector_widths.is_empty());
    }

    #[test]
    fn test_host_info_has_sse2() {
        let info = X86HostInfo::detect();
        assert!(
            info.has_feature("sse2"),
            "All x86_64 CPUs must support SSE2"
        );
    }

    #[test]
    fn test_host_info_architecture_level() {
        let info = X86HostInfo::detect();
        // All x86_64 CPUs are at least V1
        assert!(info.supports_arch_level(X86ArchitectureLevel::V1));
    }

    #[test]
    fn test_arch_level_ordering() {
        assert!(X86ArchitectureLevel::V4 > X86ArchitectureLevel::V3);
        assert!(X86ArchitectureLevel::V3 > X86ArchitectureLevel::V2);
        assert!(X86ArchitectureLevel::V2 > X86ArchitectureLevel::V1);
    }

    #[test]
    fn test_arch_level_required_features_v1() {
        let feats = X86ArchitectureLevel::V1.required_features();
        assert!(feats.contains(&"sse"));
        assert!(feats.contains(&"sse2"));
    }

    #[test]
    fn test_arch_level_required_features_v2() {
        let feats = X86ArchitectureLevel::V2.required_features();
        assert!(feats.contains(&"popcnt"));
        assert!(feats.contains(&"sse4_2"));
    }

    #[test]
    fn test_arch_level_required_features_v3() {
        let feats = X86ArchitectureLevel::V3.required_features();
        assert!(feats.contains(&"avx2"));
        assert!(feats.contains(&"bmi2"));
    }

    #[test]
    fn test_arch_level_required_features_v4() {
        let feats = X86ArchitectureLevel::V4.required_features();
        assert!(feats.contains(&"avx512f"));
        assert!(feats.contains(&"avx512bw"));
    }

    #[test]
    fn test_host_info_target_cpu() {
        let info = X86HostInfo::detect();
        let cpu = info.target_cpu();
        assert!(!cpu.is_empty());
    }

    #[test]
    fn test_host_info_target_features_string() {
        let info = X86HostInfo::detect();
        let feats = info.target_features_string();
        assert!(feats.contains("sse"));
        assert!(feats.contains("sse2"));
    }

    #[test]
    fn test_host_info_display() {
        let info = X86HostInfo::detect();
        let display = format!("{}", info);
        assert!(display.contains("cores"));
        assert!(display.contains("threads"));
    }

    #[test]
    fn test_host_info_max_vector_width() {
        let info = X86HostInfo::detect();
        assert!(info.max_vector_width_bits() >= 128);
    }

    #[test]
    fn test_arch_level_as_str() {
        assert_eq!(X86ArchitectureLevel::V1.as_str(), "x86-64");
        assert_eq!(X86ArchitectureLevel::V2.as_str(), "x86-64-v2");
        assert_eq!(X86ArchitectureLevel::V3.as_str(), "x86-64-v3");
        assert_eq!(X86ArchitectureLevel::V4.as_str(), "x86-64-v4");
    }

    // ── X86TargetTriple tests ────────────────────────────────────────────────

    #[test]
    fn test_triple_parse_x86_64_linux_gnu() {
        let t = X86TargetTriple::parse("x86_64-unknown-linux-gnu");
        assert_eq!(t.arch, X86TripleArch::X86_64);
        assert_eq!(t.os, X86TripleOS::Linux);
        assert_eq!(t.environment, X86TripleEnvironment::GNU);
        assert!(t.is_64bit);
        assert!(!t.is_x32);
    }

    #[test]
    fn test_triple_parse_i386_linux_gnu() {
        let t = X86TargetTriple::parse("i386-unknown-linux-gnu");
        assert_eq!(t.arch, X86TripleArch::I386);
        assert!(!t.is_64bit);
    }

    #[test]
    fn test_triple_parse_x86_64_windows_msvc() {
        let t = X86TargetTriple::parse("x86_64-pc-windows-msvc");
        assert_eq!(t.arch, X86TripleArch::X86_64);
        assert_eq!(t.os, X86TripleOS::Win32);
        assert_eq!(t.environment, X86TripleEnvironment::MSVC);
        assert_eq!(t.object_format, X86ObjectFormat::COFF);
    }

    #[test]
    fn test_triple_parse_x86_64_linux_gnux32() {
        let t = X86TargetTriple::parse("x86_64-unknown-linux-gnux32");
        assert!(t.is_x32);
        assert!(!t.is_64bit);
    }

    #[test]
    fn test_triple_normalized() {
        let t = X86TargetTriple::parse("x86_64-unknown-linux-gnu");
        assert_eq!(t.normalized, "x86_64-unknown-linux-gnu");
    }

    #[test]
    fn test_triple_data_layout_64() {
        let t = X86TargetTriple::x86_64_linux_gnu();
        assert!(t.data_layout.contains("p:64:64"));
    }

    #[test]
    fn test_triple_data_layout_32() {
        let t = X86TargetTriple::i386_linux_gnu();
        assert!(t.data_layout.contains("p:32:32"));
    }

    #[test]
    fn test_triple_default_linker_gnu() {
        let t = X86TargetTriple::x86_64_linux_gnu();
        assert_eq!(t.default_linker(), X86LinkerFlavor::GnuLd);
    }

    #[test]
    fn test_triple_default_linker_msvc() {
        let t = X86TargetTriple::x86_64_windows_msvc();
        assert_eq!(t.default_linker(), X86LinkerFlavor::MSVCLink);
    }

    #[test]
    fn test_triple_default_linker_darwin() {
        let t = X86TargetTriple::x86_64_apple_darwin();
        assert_eq!(t.default_linker(), X86LinkerFlavor::DarwinLd);
    }

    #[test]
    fn test_triple_default_cxx_lib_linux() {
        let t = X86TargetTriple::x86_64_linux_gnu();
        assert_eq!(t.default_cxx_lib(), "stdc++");
    }

    #[test]
    fn test_triple_default_cxx_lib_windows() {
        let t = X86TargetTriple::x86_64_windows_msvc();
        assert_eq!(t.default_cxx_lib(), "msvcprt");
    }

    #[test]
    fn test_triple_supports_tls_linux() {
        let t = X86TargetTriple::x86_64_linux_gnu();
        assert!(t.supports_tls());
    }

    #[test]
    fn test_triple_default_pic_linux() {
        let t = X86TargetTriple::x86_64_linux_gnu();
        assert!(!t.default_pic);
    }

    #[test]
    fn test_triple_default_pic_darwin() {
        let t = X86TargetTriple::x86_64_apple_darwin();
        assert!(t.default_pic);
    }

    #[test]
    fn test_triple_object_format() {
        assert_eq!(
            X86TargetTriple::x86_64_linux_gnu().object_format,
            X86ObjectFormat::ELF
        );
        assert_eq!(
            X86TargetTriple::x86_64_windows_msvc().object_format,
            X86ObjectFormat::COFF
        );
        assert_eq!(
            X86TargetTriple::x86_64_apple_darwin().object_format,
            X86ObjectFormat::MachO
        );
    }

    #[test]
    fn test_triple_display() {
        let t = X86TargetTriple::x86_64_linux_gnu();
        assert_eq!(format!("{}", t), "x86_64-unknown-linux-gnu");
    }

    // ── X86ClangDriver tests ─────────────────────────────────────────────────

    #[test]
    fn test_driver_new() {
        let driver = X86ClangDriver::new();
        assert_eq!(driver.triple.normalized, "x86_64-unknown-linux-gnu");
    }

    #[test]
    fn test_driver_x86_64_linux() {
        let driver = X86ClangDriver::x86_64_linux();
        assert!(driver.triple.is_64bit);
    }

    #[test]
    fn test_driver_i386_linux() {
        let driver = X86ClangDriver::i386_linux();
        assert!(!driver.triple.is_64bit);
    }

    #[test]
    fn test_driver_x86_64_windows() {
        let driver = X86ClangDriver::x86_64_windows();
        assert_eq!(driver.triple.os, X86TripleOS::Win32);
        assert_eq!(driver.linker_flavor, X86LinkerFlavor::MSVCLink);
    }

    #[test]
    fn test_driver_parse_args_basic() {
        let mut driver = X86ClangDriver::new();
        let args = vec![
            "-c".to_string(),
            "-O2".to_string(),
            "-o".to_string(),
            "output.o".to_string(),
            "input.c".to_string(),
        ];
        driver.parse_args(&args);
        assert_eq!(driver.opt_level, X86DriverOptLevel::O2);
        assert_eq!(driver.output_file, Some(PathBuf::from("output.o")));
        assert_eq!(driver.input_files, vec![PathBuf::from("input.c")]);
    }

    #[test]
    fn test_driver_parse_args_m32() {
        let mut driver = X86ClangDriver::new();
        let args = vec!["-m32".to_string(), "input.c".to_string()];
        driver.parse_args(&args);
        assert!(!driver.triple.is_64bit);
    }

    #[test]
    fn test_driver_parse_args_sanitizer() {
        let mut driver = X86ClangDriver::new();
        let args = vec![
            "-fsanitize=address,undefined".to_string(),
            "input.c".to_string(),
        ];
        driver.parse_args(&args);
        assert!(driver.sanitizers.address);
        assert!(driver.sanitizers.undefined);
    }

    #[test]
    fn test_driver_all_include_paths() {
        let driver = X86ClangDriver::new();
        let paths = driver.all_include_paths();
        assert!(!paths.is_empty(), "Should have default include paths");
    }

    #[test]
    fn test_driver_all_library_paths() {
        let driver = X86ClangDriver::new();
        let paths = driver.all_library_paths();
        // Library paths may or may not be available in test environment
    }

    #[test]
    fn test_driver_default_libraries() {
        let driver = X86ClangDriver::x86_64_linux();
        let libs = driver.default_libraries();
        assert!(libs.contains(&"c".to_string()));
    }

    #[test]
    fn test_driver_build_compiler_command() {
        let driver = X86ClangDriver::x86_64_linux();
        let cmd = driver.build_compiler_command(Path::new("test.c"), Path::new("test.o"));
        assert!(cmd.contains(&"-target=x86_64-unknown-linux-gnu".to_string()));
        assert!(cmd.contains(&"-O0".to_string()));
    }

    #[test]
    fn test_driver_set_output_type() {
        let mut driver = X86ClangDriver::new();
        driver.set_output_type(X86DriverOutputType::Assembly);
        assert_eq!(driver.phases.len(), 3);
    }

    #[test]
    fn test_driver_set_output_type_executable() {
        let mut driver = X86ClangDriver::new();
        driver.set_output_type(X86DriverOutputType::Executable);
        assert_eq!(driver.phases.len(), 5);
    }

    #[test]
    fn test_driver_describe() {
        let driver = X86ClangDriver::new();
        let desc = driver.describe();
        assert!(desc.contains("Target:"));
        assert!(desc.contains("Host:"));
    }

    // ── X86ToolchainPath tests ───────────────────────────────────────────────

    #[test]
    fn test_toolchain_detect() {
        let triple = X86TargetTriple::x86_64_linux_gnu();
        let tc = X86ToolchainPath::detect(&triple);
        assert!(tc.auto_detected);
    }

    #[test]
    fn test_toolchain_default() {
        let tc = X86ToolchainPath::default();
        assert_eq!(tc.triple.normalized, "x86_64-unknown-linux-gnu");
    }

    #[test]
    fn test_toolchain_display() {
        let tc = X86ToolchainPath::default();
        let display = format!("{}", tc);
        assert!(display.contains("Toolchain"));
    }

    // ── X86LinkerInvocation tests ────────────────────────────────────────────

    #[test]
    fn test_linker_invocation_gnu_ld() {
        let triple = X86TargetTriple::x86_64_linux_gnu();
        let inv = X86LinkerInvocation::new(X86LinkerFlavor::GnuLd, &triple);
        let cmd = inv.to_command();
        assert!(!cmd.is_empty());
        assert_eq!(cmd[0], "ld");
    }

    #[test]
    fn test_linker_invocation_lld() {
        let triple = X86TargetTriple::x86_64_linux_gnu();
        let inv = X86LinkerInvocation::new(X86LinkerFlavor::Lld, &triple);
        let cmd = inv.to_command();
        assert_eq!(cmd[0], "ld.lld");
    }

    #[test]
    fn test_linker_invocation_msvc() {
        let triple = X86TargetTriple::x86_64_windows_msvc();
        let inv = X86LinkerInvocation::new(X86LinkerFlavor::MSVCLink, &triple);
        let cmd = inv.to_command();
        assert_eq!(cmd[0], "link.exe");
    }

    #[test]
    fn test_linker_invocation_darwin() {
        let triple = X86TargetTriple::x86_64_apple_darwin();
        let inv = X86LinkerInvocation::new(X86LinkerFlavor::DarwinLd, &triple);
        let cmd = inv.to_command();
        assert_eq!(cmd[0], "ld");
    }

    #[test]
    fn test_linker_invocation_lld_link() {
        let triple = X86TargetTriple::x86_64_windows_msvc();
        let inv = X86LinkerInvocation::new(X86LinkerFlavor::LldLink, &triple);
        let cmd = inv.to_command();
        assert_eq!(cmd[0], "lld-link");
    }

    #[test]
    fn test_linker_invocation_shared() {
        let triple = X86TargetTriple::x86_64_linux_gnu();
        let mut inv = X86LinkerInvocation::new(X86LinkerFlavor::GnuLd, &triple);
        inv.shared = true;
        let cmd = inv.to_command();
        assert!(cmd.contains(&"-shared".to_string()));
    }

    #[test]
    fn test_linker_invocation_output() {
        let triple = X86TargetTriple::x86_64_linux_gnu();
        let mut inv = X86LinkerInvocation::new(X86LinkerFlavor::GnuLd, &triple);
        inv.set_output(Path::new("a.out"));
        let cmd = inv.to_command();
        assert!(cmd.contains(&"a.out".to_string()));
    }

    #[test]
    fn test_linker_invocation_library_paths() {
        let triple = X86TargetTriple::x86_64_linux_gnu();
        let mut inv = X86LinkerInvocation::new(X86LinkerFlavor::GnuLd, &triple);
        inv.add_library_path(Path::new("/custom/lib"));
        let cmd = inv.to_command();
        assert!(cmd.iter().any(|a| a.contains("/custom/lib")));
    }

    #[test]
    fn test_linker_invocation_libraries() {
        let triple = X86TargetTriple::x86_64_linux_gnu();
        let mut inv = X86LinkerInvocation::new(X86LinkerFlavor::GnuLd, &triple);
        inv.add_library("pthread");
        let cmd = inv.to_command();
        assert!(cmd.contains(&"-lpthread".to_string()));
    }

    #[test]
    fn test_linker_invocation_pie() {
        let triple = X86TargetTriple::x86_64_linux_gnu();
        let mut inv = X86LinkerInvocation::new(X86LinkerFlavor::GnuLd, &triple);
        inv.pie = true;
        let cmd = inv.to_command();
        assert!(cmd.contains(&"-pie".to_string()));
    }

    #[test]
    fn test_linker_flavor_str() {
        assert_eq!(X86LinkerFlavor::GnuLd.as_str(), "gnu-ld");
        assert_eq!(X86LinkerFlavor::Lld.as_str(), "lld");
        assert_eq!(X86LinkerFlavor::MSVCLink.as_str(), "msvc-link");
        assert_eq!(X86LinkerFlavor::LldLink.as_str(), "lld-link");
    }

    #[test]
    fn test_linker_flavor_supports_lto() {
        assert!(X86LinkerFlavor::GnuLd.supports_lto());
        assert!(X86LinkerFlavor::Lld.supports_lto());
        assert!(X86LinkerFlavor::LldLink.supports_lto());
    }

    #[test]
    fn test_linker_flavor_supports_thin_lto() {
        assert!(X86LinkerFlavor::Lld.supports_thin_lto());
        assert!(X86LinkerFlavor::LldLink.supports_thin_lto());
        assert!(!X86LinkerFlavor::GnuLd.supports_thin_lto());
    }

    // ── X86AssemblerInvocation tests ─────────────────────────────────────────

    #[test]
    fn test_assembler_invocation_llvm_mc() {
        let triple = X86TargetTriple::x86_64_linux_gnu();
        let inv = X86AssemblerInvocation::new(&triple);
        let cmd = inv.to_command();
        assert_eq!(cmd[0], "llvm-mc");
    }

    #[test]
    fn test_assembler_invocation_gnu_as() {
        let triple = X86TargetTriple::x86_64_linux_gnu();
        let mut inv = X86AssemblerInvocation::new(&triple);
        inv.integrated_as = false;
        let cmd = inv.to_command();
        assert_eq!(cmd[0], "as");
    }

    #[test]
    fn test_assembler_invocation_input_output() {
        let triple = X86TargetTriple::x86_64_linux_gnu();
        let mut inv = X86AssemblerInvocation::new(&triple);
        inv.set_input(Path::new("test.s"));
        inv.set_output(Path::new("test.o"));
        let cmd = inv.to_command();
        assert!(cmd.contains(&"test.s".to_string()));
        assert!(cmd.contains(&"test.o".to_string()));
    }

    // ── X86SanitizerSetup tests ──────────────────────────────────────────────

    #[test]
    fn test_sanitizer_setup_empty() {
        let setup = X86SanitizerSetup::new();
        assert!(!setup.has_any());
        assert!(setup.compiler_flags().is_empty());
        assert!(setup.linker_libraries().is_empty());
    }

    #[test]
    fn test_sanitizer_setup_address() {
        let mut setup = X86SanitizerSetup::new();
        setup.address = true;
        assert!(setup.has_any());
        let flags = setup.compiler_flags();
        assert!(flags.iter().any(|f| f.contains("address")));
    }

    #[test]
    fn test_sanitizer_setup_address_and_undefined() {
        let mut setup = X86SanitizerSetup::new();
        setup.address = true;
        setup.undefined = true;
        assert!(setup.has_any());
        let flags = setup.compiler_flags();
        let joined = flags.join(" ");
        assert!(joined.contains("address"));
        assert!(joined.contains("undefined"));
    }

    #[test]
    fn test_sanitizer_setup_compatibility_address_memory() {
        let mut setup = X86SanitizerSetup::new();
        setup.address = true;
        setup.memory = true;
        assert!(setup.check_compatibility().is_err());
    }

    #[test]
    fn test_sanitizer_setup_compatibility_address_thread() {
        let mut setup = X86SanitizerSetup::new();
        setup.address = true;
        setup.thread = true;
        assert!(setup.check_compatibility().is_err());
    }

    #[test]
    fn test_sanitizer_setup_compatibility_ok() {
        let mut setup = X86SanitizerSetup::new();
        setup.address = true;
        setup.undefined = true;
        assert!(setup.check_compatibility().is_ok());
    }

    #[test]
    fn test_sanitizer_setup_linker_libraries() {
        let mut setup = X86SanitizerSetup::new();
        setup.address = true;
        let libs = setup.linker_libraries();
        assert!(libs.contains(&"asan".to_string()));
    }

    #[test]
    fn test_sanitizer_setup_ubsan_linker_libraries() {
        let mut setup = X86SanitizerSetup::new();
        setup.undefined = true;
        let libs = setup.linker_libraries();
        assert!(libs.contains(&"ubsan_standalone".to_string()));
    }

    #[test]
    fn test_sanitizer_setup_asan_options() {
        let mut setup = X86SanitizerSetup::new();
        setup.address = true;
        let opts = setup.asan_options();
        assert!(!opts.is_empty());
    }

    #[test]
    fn test_sanitizer_setup_ubsan_options() {
        let mut setup = X86SanitizerSetup::new();
        setup.undefined = true;
        let opts = setup.ubsan_options();
        assert!(opts.iter().any(|o| o.contains("print_stacktrace")));
    }

    #[test]
    fn test_sanitizer_setup_from_args() {
        let mut args = X86DriverArgs::default();
        args.fsanitize = Some("address,undefined".to_string());
        let setup = X86SanitizerSetup::from_args(&args);
        assert!(setup.address);
        assert!(setup.undefined);
    }

    #[test]
    fn test_sanitizer_setup_ubsan_recover() {
        let mut args = X86DriverArgs::default();
        args.fsanitize = Some("undefined".to_string());
        args.fsanitize_recover = Some("undefined".to_string());
        let setup = X86SanitizerSetup::from_args(&args);
        assert!(setup.ubsan_recover);
    }

    #[test]
    fn test_sanitizer_setup_ubsan_trap() {
        let mut args = X86DriverArgs::default();
        args.fsanitize_trap = Some("undefined".to_string());
        let setup = X86SanitizerSetup::from_args(&args);
        assert!(setup.ubsan_trap);
    }

    // ── X86CoverageSetup tests ───────────────────────────────────────────────

    #[test]
    fn test_coverage_setup_empty() {
        let setup = X86CoverageSetup::new();
        assert!(!setup.has_any());
        assert!(setup.compiler_flags().is_empty());
    }

    #[test]
    fn test_coverage_setup_profile_generate() {
        let mut args = X86DriverArgs::default();
        args.fprofile_instr_generate = Some(String::new());
        let setup = X86CoverageSetup::from_args(&args);
        assert!(setup.profile_instr_generate);
        assert!(setup.has_any());
    }

    #[test]
    fn test_coverage_setup_profile_use() {
        let mut args = X86DriverArgs::default();
        args.fprofile_instr_use = Some("profile.profdata".to_string());
        let setup = X86CoverageSetup::from_args(&args);
        assert!(setup.profile_instr_use.is_some());
    }

    #[test]
    fn test_coverage_setup_coverage_mapping() {
        let mut args = X86DriverArgs::default();
        args.fcoverage_mapping = true;
        let setup = X86CoverageSetup::from_args(&args);
        assert!(setup.coverage_mapping);
        assert!(setup.debug_info_for_profiling);
    }

    #[test]
    fn test_coverage_setup_compiler_flags() {
        let mut setup = X86CoverageSetup::new();
        setup.profile_instr_generate = true;
        let flags = setup.compiler_flags();
        assert!(flags.iter().any(|f| f.contains("fprofile-instr-generate")));
    }

    #[test]
    fn test_coverage_setup_linker_libraries() {
        let mut setup = X86CoverageSetup::new();
        setup.profile_instr_generate = true;
        let libs = setup.linker_libraries();
        assert!(!libs.is_empty());
    }

    // ── X86HeaderSearch tests ────────────────────────────────────────────────

    #[test]
    fn test_header_search_new() {
        let triple = X86TargetTriple::x86_64_linux_gnu();
        let tc = X86ToolchainPath::detect(&triple);
        let hs = X86HeaderSearch::new(&triple, &tc);
        assert!(!hs.builtin_includes.is_empty() || hs.c_system_includes.is_empty());
    }

    #[test]
    fn test_header_search_nostdinc() {
        let triple = X86TargetTriple::x86_64_linux_gnu();
        let tc = X86ToolchainPath::detect(&triple);
        let mut hs = X86HeaderSearch::new(&triple, &tc);
        hs.nostdinc = true;
        assert!(hs.system_include_paths().is_empty());
    }

    #[test]
    fn test_header_search_nostdincxx() {
        let triple = X86TargetTriple::x86_64_linux_gnu();
        let tc = X86ToolchainPath::detect(&triple);
        let mut hs = X86HeaderSearch::new(&triple, &tc);
        hs.nostdincxx = true;
        assert!(hs.cxx_include_paths().is_empty());
    }

    // ── X86StdLibSetup tests ─────────────────────────────────────────────────

    #[test]
    fn test_stdlib_setup_new_linux() {
        let triple = X86TargetTriple::x86_64_linux_gnu();
        let tc = X86ToolchainPath::detect(&triple);
        let setup = X86StdLibSetup::new(&triple, &tc);
        assert_eq!(setup.c_lib, X86CLibKind::Glibc);
    }

    #[test]
    fn test_stdlib_setup_new_windows() {
        let triple = X86TargetTriple::x86_64_windows_msvc();
        let tc = X86ToolchainPath::detect(&triple);
        let setup = X86StdLibSetup::new(&triple, &tc);
        assert_eq!(setup.c_lib, X86CLibKind::Msvcrt);
    }

    #[test]
    fn test_stdlib_setup_new_musl() {
        let triple = X86TargetTriple::x86_64_linux_musl();
        let tc = X86ToolchainPath::detect(&triple);
        let setup = X86StdLibSetup::new(&triple, &tc);
        assert_eq!(setup.c_lib, X86CLibKind::Musl);
    }

    #[test]
    fn test_stdlib_setup_library_paths() {
        let triple = X86TargetTriple::x86_64_linux_gnu();
        let tc = X86ToolchainPath::detect(&triple);
        let setup = X86StdLibSetup::new(&triple, &tc);
        assert!(!setup.library_paths().is_empty());
    }

    #[test]
    fn test_stdlib_setup_default_libraries_glibc() {
        let triple = X86TargetTriple::x86_64_linux_gnu();
        let tc = X86ToolchainPath::detect(&triple);
        let setup = X86StdLibSetup::new(&triple, &tc);
        let libs = setup.default_link_libraries();
        assert!(libs.contains(&"c".to_string()));
    }

    #[test]
    fn test_stdlib_setup_default_libraries_msvcrt() {
        let triple = X86TargetTriple::x86_64_windows_msvc();
        let tc = X86ToolchainPath::detect(&triple);
        let setup = X86StdLibSetup::new(&triple, &tc);
        let libs = setup.default_link_libraries();
        assert!(libs
            .iter()
            .any(|l| l.contains("msvcrt") || l.contains("kernel32")));
    }

    #[test]
    fn test_clib_kind_default_crt() {
        assert_eq!(X86CLibKind::Glibc.default_crt_object(), "crt1.o");
        assert_eq!(X86CLibKind::Msvcrt.default_crt_object(), "crt0.obj");
    }

    #[test]
    fn test_clib_kind_default_c_lib() {
        assert_eq!(X86CLibKind::Glibc.default_c_lib(), "c");
        assert_eq!(X86CLibKind::Msvcrt.default_c_lib(), "msvcrt");
    }

    #[test]
    fn test_cxx_lib_kind_default_cxx_lib() {
        assert_eq!(X86CXXLibKind::LibStdCXX.default_cxx_lib(), Some("stdc++"));
        assert_eq!(X86CXXLibKind::LibCXX.default_cxx_lib(), Some("c++"));
        assert_eq!(X86CXXLibKind::Msvcprt.default_cxx_lib(), Some("msvcprt"));
        assert_eq!(X86CXXLibKind::None.default_cxx_lib(), None);
    }

    // ── X86Multilib tests ────────────────────────────────────────────────────

    #[test]
    fn test_multilib_new_64() {
        let triple = X86TargetTriple::x86_64_linux_gnu();
        let m = X86Multilib::new(&triple);
        assert_eq!(m.active_variant, X86MultilibVariant::Default64);
    }

    #[test]
    fn test_multilib_new_32() {
        let triple = X86TargetTriple::i386_linux_gnu();
        let m = X86Multilib::new(&triple);
        assert_eq!(m.active_variant, X86MultilibVariant::M32);
    }

    #[test]
    fn test_multilib_new_x32() {
        let triple = X86TargetTriple::x86_64_linux_gnux32();
        let m = X86Multilib::new(&triple);
        assert_eq!(m.active_variant, X86MultilibVariant::MX32);
    }

    #[test]
    fn test_multilib_select_32bit() {
        let triple = X86TargetTriple::x86_64_linux_gnu();
        let mut m = X86Multilib::new(&triple);
        m.select_32bit();
        assert_eq!(m.active_variant, X86MultilibVariant::M32);
    }

    #[test]
    fn test_multilib_select_x32() {
        let triple = X86TargetTriple::x86_64_linux_gnu();
        let mut m = X86Multilib::new(&triple);
        m.select_x32();
        assert_eq!(m.active_variant, X86MultilibVariant::MX32);
    }

    #[test]
    fn test_multilib_library_paths() {
        let triple = X86TargetTriple::x86_64_linux_gnu();
        let m = X86Multilib::new(&triple);
        let paths = m.library_paths();
        // Should have at least some 64-bit paths
        assert!(!paths.is_empty());
    }

    #[test]
    fn test_multilib_variant_display() {
        assert_eq!(format!("{}", X86MultilibVariant::Default64), "64");
        assert_eq!(format!("{}", X86MultilibVariant::M32), "32");
        assert_eq!(format!("{}", X86MultilibVariant::MX32), "x32");
    }

    #[test]
    fn test_multilib_variant_pointer_width() {
        assert_eq!(X86MultilibVariant::Default64.pointer_width_bits(), 64);
        assert_eq!(X86MultilibVariant::M32.pointer_width_bits(), 32);
        assert_eq!(X86MultilibVariant::MX32.pointer_width_bits(), 32);
    }

    // ── X86DriverArgs tests ──────────────────────────────────────────────────

    #[test]
    fn test_driver_args_default() {
        let args = X86DriverArgs::default();
        assert!(!args.m32);
        assert!(!args.m64);
        assert!(args.opt_level.is_none());
        assert!(args.input_files.is_empty());
    }

    #[test]
    fn test_driver_args_parse_simple() {
        let args =
            X86DriverArgs::parse(&["-c".to_string(), "-O2".to_string(), "test.c".to_string()]);
        assert_eq!(args.opt_level, Some(X86DriverOptLevel::O2));
        assert!(args.compile_only);
        assert_eq!(args.input_files, vec!["test.c"]);
    }

    #[test]
    fn test_driver_args_parse_target() {
        let args = X86DriverArgs::parse(&[
            "-target".to_string(),
            "i386-unknown-linux-gnu".to_string(),
            "test.c".to_string(),
        ]);
        assert_eq!(args.target, Some("i386-unknown-linux-gnu".to_string()));
    }

    #[test]
    fn test_driver_args_parse_m32() {
        let args = X86DriverArgs::parse(&["-m32".to_string(), "test.c".to_string()]);
        assert!(args.m32);
        assert_eq!(args.target, Some("i386-unknown-linux-gnu".to_string()));
    }

    #[test]
    fn test_driver_args_parse_march() {
        let args = X86DriverArgs::parse(&[
            "-march".to_string(),
            "skylake".to_string(),
            "test.c".to_string(),
        ]);
        assert_eq!(args.march, Some("skylake".to_string()));
    }

    #[test]
    fn test_driver_args_parse_sanitize() {
        let args = X86DriverArgs::parse(&[
            "-fsanitize=address,undefined".to_string(),
            "test.c".to_string(),
        ]);
        assert_eq!(args.fsanitize, Some("address,undefined".to_string()));
    }

    #[test]
    fn test_driver_args_parse_flto() {
        let args = X86DriverArgs::parse(&["-flto=thin".to_string(), "test.c".to_string()]);
        assert_eq!(args.flto, Some("thin".to_string()));
    }

    #[test]
    fn test_driver_args_parse_flto_thin_alias() {
        let args = X86DriverArgs::parse(&["-flto-thin".to_string(), "test.c".to_string()]);
        assert!(args.flto_thin);
        assert_eq!(args.flto, Some("thin".to_string()));
    }

    #[test]
    fn test_driver_args_parse_include_paths() {
        let args = X86DriverArgs::parse(&[
            "-I/usr/local/include".to_string(),
            "-I".to_string(),
            "/custom/include".to_string(),
            "test.c".to_string(),
        ]);
        assert!(args
            .include_paths
            .contains(&"/usr/local/include".to_string()));
        assert!(args.include_paths.contains(&"/custom/include".to_string()));
    }

    #[test]
    fn test_driver_args_parse_library_paths() {
        let args = X86DriverArgs::parse(&[
            "-L/usr/local/lib".to_string(),
            "-L".to_string(),
            "/custom/lib".to_string(),
            "test.c".to_string(),
        ]);
        assert!(args.library_paths.contains(&"/usr/local/lib".to_string()));
        assert!(args.library_paths.contains(&"/custom/lib".to_string()));
    }

    #[test]
    fn test_driver_args_parse_defines() {
        let args = X86DriverArgs::parse(&[
            "-DFOO=bar".to_string(),
            "-D".to_string(),
            "BAZ=qux".to_string(),
            "-DNODEF".to_string(),
            "test.c".to_string(),
        ]);
        assert!(args
            .defines
            .contains(&("FOO".to_string(), Some("bar".to_string()))));
        assert!(args
            .defines
            .contains(&("NODEF".to_string(), Some("1".to_string()))));
    }

    #[test]
    fn test_driver_args_parse_opt_levels() {
        for level in &["-O0", "-O1", "-O2", "-O3", "-Os", "-Oz"] {
            let args = X86DriverArgs::parse(&[level.to_string(), "test.c".to_string()]);
            assert!(args.opt_level.is_some(), "Failed for {}", level);
        }
    }

    #[test]
    fn test_driver_args_parse_pic_flags() {
        let args = X86DriverArgs::parse(&["-fPIC".to_string(), "test.c".to_string()]);
        assert!(args.fPIC);
    }

    #[test]
    fn test_driver_args_parse_fuse_ld() {
        let args = X86DriverArgs::parse(&["-fuse-ld=lld".to_string(), "test.c".to_string()]);
        assert_eq!(args.fuse_ld, Some("lld".to_string()));
    }

    #[test]
    fn test_driver_args_to_clang_flags() {
        let mut args = X86DriverArgs::default();
        args.m32 = true;
        args.march = Some("skylake".to_string());
        let flags = args.to_clang_flags();
        assert!(flags.contains(&"-m32".to_string()));
        assert!(flags.contains(&"-march=skylake".to_string()));
    }

    // ── X86LTOConfig tests ───────────────────────────────────────────────────

    #[test]
    fn test_lto_config_default_disabled() {
        let config = X86LTOConfig::default();
        assert!(!config.is_enabled());
        assert!(!config.is_thin());
    }

    #[test]
    fn test_lto_config_from_args_full() {
        let mut args = X86DriverArgs::default();
        args.flto = Some("full".to_string());
        let config = X86LTOConfig::from_args(&args);
        assert!(config.is_enabled());
        assert!(!config.is_thin());
    }

    #[test]
    fn test_lto_config_from_args_thin() {
        let mut args = X86DriverArgs::default();
        args.flto = Some("thin".to_string());
        let config = X86LTOConfig::from_args(&args);
        assert!(config.is_enabled());
        assert!(config.is_thin());
    }

    #[test]
    fn test_lto_config_linker_flags_disabled() {
        let config = X86LTOConfig::default();
        assert!(config.linker_flags().is_empty());
    }

    #[test]
    fn test_lto_config_linker_flags_enabled() {
        let mut config = X86LTOConfig::new();
        config.enabled = true;
        config.thin = true;
        let flags = config.linker_flags();
        assert!(!flags.is_empty());
    }

    #[test]
    fn test_lto_config_compiler_flags() {
        let mut config = X86LTOConfig::new();
        config.enabled = true;
        config.thin = true;
        let flags = config.compiler_flags();
        assert!(flags.iter().any(|f| f.contains("flto")));
    }

    // ── X86BitcodeReproducer tests ───────────────────────────────────────────

    #[test]
    fn test_reproducer_new() {
        let reproducer = X86BitcodeReproducer::new(Path::new("/tmp/test_repro"));
        assert_eq!(reproducer.output_dir, PathBuf::from("/tmp/test_repro"));
        assert!(!reproducer.has_capture());
    }

    #[test]
    fn test_reproducer_replay_script_path() {
        let reproducer = X86BitcodeReproducer::new(Path::new("/tmp/test_repro"));
        assert_eq!(
            reproducer.replay_script_path(),
            PathBuf::from("/tmp/test_repro/replay.sh")
        );
    }

    #[test]
    fn test_reproducer_set_state() {
        let mut reproducer = X86BitcodeReproducer::new(Path::new("/tmp/test_repro"));
        let state = X86ReproducerState {
            triple: "x86_64-unknown-linux-gnu".to_string(),
            compiler_command: vec!["clang".to_string()],
            linker_command: vec!["ld".to_string()],
            include_paths: vec![],
            input_files: vec![],
            preprocessed_file: None,
            bitcode_file: None,
            assembly_file: None,
            environment: HashMap::new(),
            working_dir: PathBuf::from("."),
            arguments: vec![],
        };
        reproducer.set_state(state);
        assert!(reproducer.has_capture());
        assert!(reproducer.capture_time.is_some());
    }

    // ── Convenience function tests ───────────────────────────────────────────

    #[test]
    fn test_create_x86_64_linux_driver() {
        let driver = create_x86_64_linux_driver();
        assert!(driver.triple.is_64bit);
    }

    #[test]
    fn test_create_i386_linux_driver() {
        let driver = create_i386_linux_driver();
        assert!(!driver.triple.is_64bit);
    }

    #[test]
    fn test_create_x86_64_windows_driver() {
        let driver = create_x86_64_windows_driver();
        assert_eq!(driver.triple.os, X86TripleOS::Win32);
    }

    #[test]
    fn test_parse_x86_driver_args_fn() {
        let args = vec!["-c".to_string(), "test.c".to_string()];
        let parsed = parse_x86_driver_args(&args);
        assert!(parsed.compile_only);
    }

    #[test]
    fn test_detect_host_x86_fn() {
        let info = detect_host_x86();
        assert!(!info.vendor.is_empty());
    }

    #[test]
    fn test_parse_x86_target_triple_fn() {
        let t = parse_x86_target_triple("x86_64-unknown-linux-gnu");
        assert!(t.is_64bit);
    }

    // ── Integration tests ────────────────────────────────────────────────────

    #[test]
    fn test_driver_full_pipeline_x86_64_linux() {
        let driver = X86ClangDriver::x86_64_linux();
        assert_eq!(driver.triple.arch, X86TripleArch::X86_64);
        assert_eq!(driver.triple.os, X86TripleOS::Linux);
        assert_eq!(driver.linker_flavor, X86LinkerFlavor::GnuLd);
        assert_eq!(driver.stdlib.c_lib, X86CLibKind::Glibc);
    }

    #[test]
    fn test_driver_full_pipeline_i386_linux() {
        let driver = X86ClangDriver::i386_linux();
        assert_eq!(driver.triple.arch, X86TripleArch::I386);
        assert_eq!(driver.multilib.active_variant, X86MultilibVariant::M32);
    }

    #[test]
    fn test_driver_parse_and_build_linker() {
        let mut driver = X86ClangDriver::x86_64_linux();
        let args = vec![
            "-O2".to_string(),
            "test.c".to_string(),
            "-o".to_string(),
            "a.out".to_string(),
        ];
        driver.parse_args(&args);

        let inv = driver.build_linker_invocation();
        let cmd = inv.to_command();
        assert!(!cmd.is_empty());
    }

    #[test]
    fn test_driver_with_sanitizer_and_lto() {
        let mut driver = X86ClangDriver::x86_64_linux();
        let args = vec![
            "-fsanitize=address".to_string(),
            "-flto=thin".to_string(),
            "test.c".to_string(),
        ];
        driver.parse_args(&args);
        assert!(driver.sanitizers.address);
        assert!(driver.lto_config.is_enabled());
    }

    #[test]
    fn test_driver_parse_full_command() {
        let args = vec![
            "-target".to_string(),
            "x86_64-unknown-linux-gnu".to_string(),
            "-march=skylake".to_string(),
            "-O2".to_string(),
            "-g".to_string(),
            "-fPIC".to_string(),
            "-I/usr/include".to_string(),
            "-L/usr/lib64".to_string(),
            "-lpthread".to_string(),
            "-DDEBUG=1".to_string(),
            "-o".to_string(),
            "output".to_string(),
            "input.c".to_string(),
        ];

        let mut driver = X86ClangDriver::new();
        driver.parse_args(&args);

        assert_eq!(driver.opt_level, X86DriverOptLevel::O2);
        assert_eq!(driver.x86_args.march, Some("skylake".to_string()));
        assert_eq!(driver.pic_level, X86DriverPicLevel::PIC);
        assert_eq!(driver.output_file, Some(PathBuf::from("output")));
        assert!(driver.libraries.contains(&"pthread".to_string()));
    }

    #[test]
    fn test_x86_os_enum() {
        assert!(X86TripleOS::Linux.is_unix());
        assert!(X86TripleOS::Linux.is_elf());
        assert!(X86TripleOS::Darwin.is_macho());
        assert!(X86TripleOS::Win32.is_coff());
        assert!(!X86TripleOS::Unknown.is_unix());
    }

    #[test]
    fn test_x86_env_enum() {
        assert!(X86TripleEnvironment::GNU.is_gnu());
        assert!(X86TripleEnvironment::MSVC.is_msvc());
        assert!(X86TripleEnvironment::Musl.is_musl());
        assert!(!X86TripleEnvironment::Unknown.is_gnu());
    }

    #[test]
    fn test_driver_output_type_extension() {
        assert_eq!(X86DriverOutputType::Assembly.extension(), ".s");
        assert_eq!(X86DriverOutputType::Object.extension(), ".o");
        assert_eq!(X86DriverOutputType::SharedLibrary.extension(), ".so");
        assert_eq!(X86DriverOutputType::Executable.extension(), "");
    }

    #[test]
    fn test_driver_output_type_requires_linking() {
        assert!(X86DriverOutputType::Executable.requires_linking());
        assert!(X86DriverOutputType::SharedLibrary.requires_linking());
        assert!(!X86DriverOutputType::Object.requires_linking());
        assert!(!X86DriverOutputType::Assembly.requires_linking());
    }

    #[test]
    fn test_compilation_phase_all() {
        let all = X86CompilationPhase::all();
        assert_eq!(all.len(), 5);
        assert_eq!(all[0], X86CompilationPhase::Preprocess);
        assert_eq!(all[4], X86CompilationPhase::Link);
    }

    #[test]
    fn test_opt_level_as_str() {
        assert_eq!(X86DriverOptLevel::O0.as_str(), "-O0");
        assert_eq!(X86DriverOptLevel::O3.as_str(), "-O3");
        assert_eq!(X86DriverOptLevel::Os.as_str(), "-Os");
    }

    #[test]
    fn test_opt_level_is_optimizing() {
        assert!(X86DriverOptLevel::O3.is_optimizing());
        assert!(!X86DriverOptLevel::O0.is_optimizing());
    }

    #[test]
    fn test_lto_visibility() {
        assert_eq!(X86LTOVisibility::Default as i32, 0);
        assert_eq!(X86LTOVisibility::Hidden as i32, 1);
        assert_eq!(X86LTOVisibility::Protected as i32, 2);
    }

    #[test]
    fn test_linker_invocation_response_file() {
        let triple = X86TargetTriple::x86_64_windows_msvc();
        let mut inv = X86LinkerInvocation::new(X86LinkerFlavor::MSVCLink, &triple);
        inv.add_input(Path::new("test.obj"));
        inv.set_output(Path::new("test.exe"));
        let resp = inv.to_response_file();
        assert!(resp.contains("test.obj"));
        assert!(resp.contains("test.exe"));
    }

    #[test]
    fn test_coverage_setup_set_default_paths() {
        let mut setup = X86CoverageSetup::new();
        setup.profile_instr_generate = true;
        setup.set_default_paths();
        assert!(setup.coverage_dir.is_some());
        assert!(setup.coverage_data_file.is_some());
    }

    // ── Extended X86HostInfo tests ────────────────────────────────────────

    #[test]
    fn test_host_info_default() {
        let info = X86HostInfo::default();
        assert!(!info.vendor.is_empty());
        assert!(info.logical_processors > 0);
    }

    #[test]
    fn test_host_info_has_feature_sse() {
        let info = X86HostInfo::detect();
        assert!(info.has_feature("sse"));
        assert!(info.has_feature("sse2"));
    }

    #[test]
    fn test_host_info_has_feature_negative() {
        let info = X86HostInfo::detect();
        // No x86_64 CPU should have "avx999" as a feature
        assert!(!info.has_feature("avx999"));
    }

    #[test]
    fn test_host_info_max_vector_width_min() {
        let info = X86HostInfo::detect();
        assert!(info.max_vector_width_bits() >= 128);
    }

    #[test]
    fn test_host_info_has_avx512_detection() {
        let info = X86HostInfo::detect();
        // Whether or not AVX-512 is present, the field should be set correctly
        assert_eq!(info.has_avx512, info.features.contains("avx512f"));
    }

    #[test]
    fn test_host_info_has_amx_detection() {
        let info = X86HostInfo::detect();
        assert_eq!(info.has_amx, info.features.contains("amx-tile"));
    }

    #[test]
    fn test_arch_level_from_features_empty() {
        let feats = HashSet::new();
        assert_eq!(
            X86ArchitectureLevel::from_features(&feats),
            X86ArchitectureLevel::V1
        );
    }

    #[test]
    fn test_arch_level_from_features_v2_exact() {
        let feats: HashSet<String> = ["cx16", "lahf_lm", "popcnt", "sse4_1", "sse4_2", "ssse3"]
            .iter()
            .map(|s| s.to_string())
            .collect();
        assert_eq!(
            X86ArchitectureLevel::from_features(&feats),
            X86ArchitectureLevel::V2
        );
    }

    #[test]
    fn test_arch_level_display() {
        assert_eq!(format!("{}", X86ArchitectureLevel::V1), "x86-64");
        assert_eq!(format!("{}", X86ArchitectureLevel::V4), "x86-64-v4");
    }

    #[test]
    fn test_host_info_sched_model_detection() {
        let info = X86HostInfo::detect();
        assert!(!info.sched_model.is_empty());
        assert!(!info.uarch_codename.is_empty());
    }

    #[test]
    fn test_host_info_cache_defaults() {
        let info = X86HostInfo::detect();
        assert!(info.cache_l1_data_kb > 0);
        assert!(info.cache_l2_kb > 0);
        assert!(info.cache_line_size > 0);
    }

    // ── Extended X86TargetTriple tests ────────────────────────────────────

    #[test]
    fn test_triple_parse_amd64() {
        let t = X86TargetTriple::parse("amd64-unknown-linux-gnu");
        assert_eq!(t.arch, X86TripleArch::X86_64);
    }

    #[test]
    fn test_triple_parse_x64() {
        let t = X86TargetTriple::parse("x64-pc-windows-msvc");
        assert_eq!(t.arch, X86TripleArch::X86_64);
    }

    #[test]
    fn test_triple_parse_empty() {
        let t = X86TargetTriple::parse("");
        assert_eq!(t.arch, X86TripleArch::X86_64);
    }

    #[test]
    fn test_triple_parse_unknown_components() {
        let t = X86TargetTriple::parse("x86_64-foo-bar-baz");
        assert_eq!(t.arch, X86TripleArch::X86_64);
        assert_eq!(t.vendor, X86TripleVendor::Unknown);
        assert_eq!(t.os, X86TripleOS::Unknown);
    }

    #[test]
    fn test_triple_arch_pointer_width_64() {
        assert_eq!(X86TripleArch::X86_64.pointer_width_bits(), 64);
    }

    #[test]
    fn test_triple_arch_pointer_width_32() {
        assert_eq!(X86TripleArch::I386.pointer_width_bits(), 32);
    }

    #[test]
    fn test_triple_arch_pointer_width_x32() {
        assert_eq!(X86TripleArch::X32.pointer_width_bits(), 32);
    }

    #[test]
    fn test_triple_arch_is_64bit_core2() {
        assert!(X86TripleArch::Core2.is_64bit());
    }

    #[test]
    fn test_triple_arch_is_64bit_athlon64() {
        assert!(X86TripleArch::Athlon64.is_64bit());
    }

    #[test]
    fn test_triple_arch_is_64bit_skylake() {
        assert!(X86TripleArch::Skylake.is_64bit());
    }

    #[test]
    fn test_triple_vendor_from_str() {
        assert_eq!(X86TripleVendor::from_str("pc"), X86TripleVendor::PC);
        assert_eq!(X86TripleVendor::from_str("apple"), X86TripleVendor::Apple);
        assert_eq!(X86TripleVendor::from_str("amd"), X86TripleVendor::AMD);
        assert_eq!(X86TripleVendor::from_str("intel"), X86TripleVendor::Intel);
        assert_eq!(
            X86TripleVendor::from_str("foobar"),
            X86TripleVendor::Unknown
        );
    }

    #[test]
    fn test_triple_vendor_display() {
        assert_eq!(format!("{}", X86TripleVendor::PC), "pc");
        assert_eq!(format!("{}", X86TripleVendor::Apple), "apple");
    }

    #[test]
    fn test_triple_os_is_unix() {
        assert!(X86TripleOS::FreeBSD.is_unix());
        assert!(X86TripleOS::NetBSD.is_unix());
        assert!(X86TripleOS::OpenBSD.is_unix());
        assert!(X86TripleOS::Solaris.is_unix());
        assert!(!X86TripleOS::Win32.is_unix());
    }

    #[test]
    fn test_triple_os_is_elf() {
        assert!(X86TripleOS::FreeBSD.is_elf());
        assert!(X86TripleOS::DragonFly.is_elf());
        assert!(X86TripleOS::Haiku.is_elf());
        assert!(X86TripleOS::Fuchsia.is_elf());
        assert!(!X86TripleOS::Win32.is_elf());
    }

    #[test]
    fn test_triple_os_display() {
        assert_eq!(format!("{}", X86TripleOS::Linux), "linux");
        assert_eq!(format!("{}", X86TripleOS::Darwin), "darwin");
        assert_eq!(format!("{}", X86TripleOS::Win32), "win32");
    }

    #[test]
    fn test_triple_env_from_str_all() {
        assert_eq!(
            X86TripleEnvironment::from_str("gnu"),
            X86TripleEnvironment::GNU
        );
        assert_eq!(
            X86TripleEnvironment::from_str("gnueabi"),
            X86TripleEnvironment::GNUEABI
        );
        assert_eq!(
            X86TripleEnvironment::from_str("gnueabihf"),
            X86TripleEnvironment::GNUEABIHF
        );
        assert_eq!(
            X86TripleEnvironment::from_str("gnux32"),
            X86TripleEnvironment::GNUX32
        );
        assert_eq!(
            X86TripleEnvironment::from_str("musl"),
            X86TripleEnvironment::Musl
        );
        assert_eq!(
            X86TripleEnvironment::from_str("musleabi"),
            X86TripleEnvironment::Musleabi
        );
        assert_eq!(
            X86TripleEnvironment::from_str("msvc"),
            X86TripleEnvironment::MSVC
        );
        assert_eq!(
            X86TripleEnvironment::from_str("android"),
            X86TripleEnvironment::Android
        );
        assert_eq!(
            X86TripleEnvironment::from_str("itanium"),
            X86TripleEnvironment::Itanium
        );
        assert_eq!(
            X86TripleEnvironment::from_str("cygnus"),
            X86TripleEnvironment::Cygnus
        );
        assert_eq!(
            X86TripleEnvironment::from_str("coreclr"),
            X86TripleEnvironment::CoreCLR
        );
        assert_eq!(
            X86TripleEnvironment::from_str("unknown-xyz"),
            X86TripleEnvironment::Unknown
        );
    }

    #[test]
    fn test_triple_env_is_gnu() {
        assert!(X86TripleEnvironment::GNU.is_gnu());
        assert!(X86TripleEnvironment::GNUEABI.is_gnu());
        assert!(X86TripleEnvironment::GNUEABIHF.is_gnu());
        assert!(X86TripleEnvironment::GNUX32.is_gnu());
        assert!(!X86TripleEnvironment::MSVC.is_gnu());
        assert!(!X86TripleEnvironment::Musl.is_gnu());
    }

    #[test]
    fn test_triple_env_is_musl() {
        assert!(X86TripleEnvironment::Musl.is_musl());
        assert!(X86TripleEnvironment::Musleabi.is_musl());
        assert!(X86TripleEnvironment::Musleabihf.is_musl());
        assert!(!X86TripleEnvironment::GNU.is_musl());
    }

    #[test]
    fn test_triple_env_is_android() {
        assert!(X86TripleEnvironment::Android.is_android());
        assert!(X86TripleEnvironment::Androideabi.is_android());
        assert!(!X86TripleEnvironment::GNU.is_android());
    }

    #[test]
    fn test_triple_default_seh_linux() {
        let t = X86TargetTriple::x86_64_linux_gnu();
        assert!(!t.default_seh());
    }

    #[test]
    fn test_triple_default_seh_windows() {
        let t = X86TargetTriple::x86_64_windows_msvc();
        assert!(t.default_seh());
    }

    #[test]
    fn test_triple_default_dwarf_eh_linux() {
        let t = X86TargetTriple::x86_64_linux_gnu();
        assert!(t.default_dwarf_eh());
    }

    #[test]
    fn test_triple_default_crt_object_windows() {
        let t = X86TargetTriple::x86_64_windows_msvc();
        assert_eq!(t.default_crt_object(), Some("msvcrt"));
    }

    #[test]
    fn test_triple_default_crt_object_linux() {
        let t = X86TargetTriple::x86_64_linux_gnu();
        assert_eq!(t.default_crt_object(), None);
    }

    #[test]
    fn test_triple_x86_64_linux_musl_factory() {
        let t = X86TargetTriple::x86_64_linux_musl();
        assert_eq!(t.environment, X86TripleEnvironment::Musl);
        assert!(t.is_64bit);
    }

    #[test]
    fn test_triple_i686_linux_android_factory() {
        let t = X86TargetTriple::i686_linux_android();
        assert_eq!(t.environment, X86TripleEnvironment::Android);
    }

    #[test]
    fn test_triple_x86_64_linux_android_factory() {
        let t = X86TargetTriple::x86_64_linux_android();
        assert_eq!(t.environment, X86TripleEnvironment::Android);
        assert!(t.is_64bit);
    }

    #[test]
    fn test_triple_x86_64_linux_gnux32_factory() {
        let t = X86TargetTriple::x86_64_linux_gnux32();
        assert!(t.is_x32);
    }

    #[test]
    fn test_object_format_as_str() {
        assert_eq!(X86ObjectFormat::ELF.as_str(), "elf");
        assert_eq!(X86ObjectFormat::MachO.as_str(), "macho");
        assert_eq!(X86ObjectFormat::COFF.as_str(), "coff");
        assert_eq!(X86ObjectFormat::Wasm.as_str(), "wasm");
    }

    #[test]
    fn test_code_model_as_str() {
        assert_eq!(X86CodeModel::Tiny.as_str(), "tiny");
        assert_eq!(X86CodeModel::Small.as_str(), "small");
        assert_eq!(X86CodeModel::Kernel.as_str(), "kernel");
        assert_eq!(X86CodeModel::Medium.as_str(), "medium");
        assert_eq!(X86CodeModel::Large.as_str(), "large");
    }

    #[test]
    fn test_triple_default_code_model() {
        let t = X86TargetTriple::default();
        assert_eq!(t.default_code_model, X86CodeModel::Small);
    }

    // ── Extended X86DriverOptLevel tests ──────────────────────────────────

    #[test]
    fn test_opt_level_default() {
        let opt = X86DriverOptLevel::default();
        assert_eq!(opt, X86DriverOptLevel::O0);
    }

    #[test]
    fn test_opt_level_lto_default() {
        assert!(!X86DriverOptLevel::O0.lto_enabled_by_default());
        assert!(!X86DriverOptLevel::O2.lto_enabled_by_default());
    }

    // ── Extended X86DriverDebugInfo tests ─────────────────────────────────

    #[test]
    fn test_debug_info_default() {
        let di = X86DriverDebugInfo::default();
        assert!(!di.has_debug());
    }

    #[test]
    fn test_debug_info_has_debug() {
        assert!(X86DriverDebugInfo::Full.has_debug());
        assert!(X86DriverDebugInfo::Limited.has_debug());
        assert!(X86DriverDebugInfo::LineTablesOnly.has_debug());
        assert!(!X86DriverDebugInfo::None.has_debug());
    }

    // ── Extended X86DriverPicLevel tests ──────────────────────────────────

    #[test]
    fn test_pic_level_default() {
        let pic = X86DriverPicLevel::default();
        assert_eq!(pic, X86DriverPicLevel::Default);
    }

    // ── Extended X86DriverOutputType tests ────────────────────────────────

    #[test]
    fn test_output_type_extension_all() {
        assert_eq!(X86DriverOutputType::PreprocessedSource.extension(), ".i");
        assert_eq!(X86DriverOutputType::LLVMIR.extension(), ".ll");
        assert_eq!(X86DriverOutputType::LLVMBitcode.extension(), ".bc");
        assert_eq!(X86DriverOutputType::Assembly.extension(), ".s");
        assert_eq!(X86DriverOutputType::Object.extension(), ".o");
        assert_eq!(X86DriverOutputType::SharedLibrary.extension(), ".so");
        assert_eq!(X86DriverOutputType::Executable.extension(), "");
    }

    #[test]
    fn test_output_type_requires_linking_all() {
        assert!(X86DriverOutputType::Executable.requires_linking());
        assert!(X86DriverOutputType::SharedLibrary.requires_linking());
        assert!(!X86DriverOutputType::Object.requires_linking());
        assert!(!X86DriverOutputType::Assembly.requires_linking());
        assert!(!X86DriverOutputType::LLVMIR.requires_linking());
        assert!(!X86DriverOutputType::LLVMBitcode.requires_linking());
        assert!(!X86DriverOutputType::PreprocessedSource.requires_linking());
    }

    // ── Extended X86CompilationPhase tests ────────────────────────────────

    #[test]
    fn test_compilation_phase_name() {
        assert_eq!(X86CompilationPhase::Preprocess.name(), "preprocess");
        assert_eq!(X86CompilationPhase::Compile.name(), "compile");
        assert_eq!(X86CompilationPhase::Backend.name(), "backend");
        assert_eq!(X86CompilationPhase::Assemble.name(), "assemble");
        assert_eq!(X86CompilationPhase::Link.name(), "link");
    }

    #[test]
    fn test_compilation_phase_ordering() {
        let all = X86CompilationPhase::all();
        for i in 1..all.len() {
            assert!(all[i] > all[i - 1], "Phases must be ordered");
        }
    }

    // ── Extended X86ClangDriver tests ─────────────────────────────────────

    #[test]
    fn test_driver_set_output_type_preprocessed() {
        let mut driver = X86ClangDriver::new();
        driver.set_output_type(X86DriverOutputType::PreprocessedSource);
        assert_eq!(driver.phases.len(), 1);
        assert_eq!(driver.phases[0], X86CompilationPhase::Preprocess);
    }

    #[test]
    fn test_driver_set_output_type_llvm_ir() {
        let mut driver = X86ClangDriver::new();
        driver.set_output_type(X86DriverOutputType::LLVMIR);
        assert_eq!(driver.phases.len(), 2);
    }

    #[test]
    fn test_driver_set_output_type_object() {
        let mut driver = X86ClangDriver::new();
        driver.set_output_type(X86DriverOutputType::Object);
        assert_eq!(driver.phases.len(), 4);
    }

    #[test]
    fn test_driver_set_output_type_shared_library() {
        let mut driver = X86ClangDriver::new();
        driver.set_output_type(X86DriverOutputType::SharedLibrary);
        assert_eq!(driver.phases.len(), 5);
    }

    #[test]
    fn test_driver_enable_reproducer() {
        let mut driver = X86ClangDriver::new();
        driver.enable_reproducer(Path::new("/tmp/repro"));
        assert!(driver.reproducer.is_some());
    }

    #[test]
    fn test_driver_capture_for_reproducer_noop_when_none() {
        let driver = X86ClangDriver::new();
        // Should not panic when no reproducer is enabled
        driver.capture_for_reproducer();
    }

    #[test]
    fn test_driver_compile_no_inputs() {
        let driver = X86ClangDriver::new();
        let result = driver.compile();
        assert!(result.is_err());
    }

    #[test]
    fn test_driver_build_preprocess_command() {
        let driver = X86ClangDriver::x86_64_linux();
        let cmd = driver.build_preprocess_command(Path::new("test.c"), Path::new("test.i"));
        assert!(cmd.contains(&"-E".to_string()));
    }

    #[test]
    fn test_driver_build_backend_command() {
        let driver = X86ClangDriver::x86_64_linux();
        let cmd = driver.build_backend_command(Path::new("test.bc"), Path::new("test.o"));
        assert!(cmd.contains(&"-filetype=obj".to_string()));
    }

    #[test]
    fn test_driver_default_new_is_linux_64() {
        let driver = X86ClangDriver::new();
        assert_eq!(driver.triple.normalized, "x86_64-unknown-linux-gnu");
        assert!(driver.triple.is_64bit);
    }

    #[test]
    fn test_driver_default_is_not_dry_run() {
        let driver = X86ClangDriver::new();
        assert!(!driver.dry_run);
    }

    #[test]
    fn test_driver_build_assembler_invocation() {
        let driver = X86ClangDriver::x86_64_linux();
        let inv = driver.build_assembler_invocation(Path::new("test.s"), Path::new("test.o"));
        let cmd = inv.to_command();
        assert!(!cmd.is_empty());
    }

    // ── Extended X86DriverArgs parsing tests ──────────────────────────────

    #[test]
    fn test_driver_args_parse_flto_jobs() {
        let args = X86DriverArgs::parse(&["-flto-jobs=8".to_string(), "test.c".to_string()]);
        assert_eq!(args.flto_jobs, Some(8));
    }

    #[test]
    fn test_driver_args_parse_flto_jobs_separate() {
        let args = X86DriverArgs::parse(&[
            "-flto-jobs".to_string(),
            "4".to_string(),
            "test.c".to_string(),
        ]);
        assert_eq!(args.flto_jobs, Some(4));
    }

    #[test]
    fn test_driver_args_parse_fprofile_instr_generate_eq() {
        let args = X86DriverArgs::parse(&[
            "-fprofile-instr-generate=/tmp/prof".to_string(),
            "test.c".to_string(),
        ]);
        assert_eq!(args.fprofile_instr_generate, Some("/tmp/prof".to_string()));
    }

    #[test]
    fn test_driver_args_parse_fprofile_instr_generate_bare() {
        let args =
            X86DriverArgs::parse(&["-fprofile-instr-generate".to_string(), "test.c".to_string()]);
        assert_eq!(args.fprofile_instr_generate, Some(String::new()));
    }

    #[test]
    fn test_driver_args_parse_fprofile_instr_use_eq() {
        let args = X86DriverArgs::parse(&[
            "-fprofile-instr-use=prof.profdata".to_string(),
            "test.c".to_string(),
        ]);
        assert_eq!(args.fprofile_instr_use, Some("prof.profdata".to_string()));
    }

    #[test]
    fn test_driver_args_parse_fcs_profile_generate_eq() {
        let args = X86DriverArgs::parse(&[
            "-fcs-profile-generate=/tmp/cs".to_string(),
            "test.c".to_string(),
        ]);
        assert_eq!(args.fcs_profile_generate, Some("/tmp/cs".to_string()));
    }

    #[test]
    fn test_driver_args_parse_sanitize_recover() {
        let args = X86DriverArgs::parse(&[
            "-fsanitize-recover=undefined".to_string(),
            "test.c".to_string(),
        ]);
        assert_eq!(args.fsanitize_recover, Some("undefined".to_string()));
    }

    #[test]
    fn test_driver_args_parse_sanitize_trap() {
        let args = X86DriverArgs::parse(&[
            "-fsanitize-trap=undefined".to_string(),
            "test.c".to_string(),
        ]);
        assert_eq!(args.fsanitize_trap, Some("undefined".to_string()));
    }

    #[test]
    fn test_driver_args_parse_stdlib() {
        let args = X86DriverArgs::parse(&["-stdlib=libc++".to_string(), "test.c".to_string()]);
        assert_eq!(args.stdlib, Some("libc++".to_string()));
    }

    #[test]
    fn test_driver_args_parse_stdlib_separate() {
        let args = X86DriverArgs::parse(&[
            "-stdlib".to_string(),
            "libstdc++".to_string(),
            "test.c".to_string(),
        ]);
        assert_eq!(args.stdlib, Some("libstdc++".to_string()));
    }

    #[test]
    fn test_driver_args_parse_wl_flags() {
        let args = X86DriverArgs::parse(&[
            "-Wl,-rpath,/usr/local/lib".to_string(),
            "test.c".to_string(),
        ]);
        assert!(args.wl_flags.contains(&"-rpath".to_string()));
        assert!(args.wl_flags.contains(&"/usr/local/lib".to_string()));
    }

    #[test]
    fn test_driver_args_parse_wa_flags() {
        let args = X86DriverArgs::parse(&["-Wa,-mavx2".to_string(), "test.c".to_string()]);
        assert!(args.wa_flags.contains(&"-mavx2".to_string()));
    }

    #[test]
    fn test_driver_args_parse_xlinker() {
        let args = X86DriverArgs::parse(&[
            "-Xlinker".to_string(),
            "--no-undefined".to_string(),
            "test.c".to_string(),
        ]);
        assert!(args.xlinker_flags.contains(&"--no-undefined".to_string()));
    }

    #[test]
    fn test_driver_args_parse_xassembler() {
        let args = X86DriverArgs::parse(&[
            "-Xassembler".to_string(),
            "--divide".to_string(),
            "test.c".to_string(),
        ]);
        assert!(args.xassembler_flags.contains(&"--divide".to_string()));
    }

    #[test]
    fn test_driver_args_parse_rdynamic() {
        let args = X86DriverArgs::parse(&["-rdynamic".to_string(), "test.c".to_string()]);
        assert!(args.rdynamic);
    }

    #[test]
    fn test_driver_args_parse_nodefaultlibs() {
        let args = X86DriverArgs::parse(&["-nodefaultlibs".to_string(), "test.c".to_string()]);
        assert!(args.nodefaultlibs);
    }

    #[test]
    fn test_driver_args_parse_nostdlib() {
        let args = X86DriverArgs::parse(&["-nostdlib".to_string(), "test.c".to_string()]);
        assert!(args.nostdlib);
    }

    #[test]
    fn test_driver_args_parse_nostartfiles() {
        let args = X86DriverArgs::parse(&["-nostartfiles".to_string(), "test.c".to_string()]);
        assert!(args.nostartfiles);
    }

    #[test]
    fn test_driver_args_parse_nostdinc() {
        let args = X86DriverArgs::parse(&["-nostdinc".to_string(), "test.c".to_string()]);
        assert!(args.nostdinc);
    }

    #[test]
    fn test_driver_args_parse_nostdincxx() {
        let args = X86DriverArgs::parse(&["-nostdinc++".to_string(), "test.c".to_string()]);
        assert!(args.nostdincxx);
    }

    #[test]
    fn test_driver_args_parse_mfpmath() {
        let args = X86DriverArgs::parse(&[
            "-mfpmath".to_string(),
            "sse".to_string(),
            "test.c".to_string(),
        ]);
        assert_eq!(args.mfpmath, Some("sse".to_string()));
    }

    #[test]
    fn test_driver_args_parse_mregparm() {
        let args = X86DriverArgs::parse(&[
            "-mregparm".to_string(),
            "3".to_string(),
            "test.c".to_string(),
        ]);
        assert_eq!(args.mregparm, Some(3));
    }

    #[test]
    fn test_driver_args_parse_mstack_alignment() {
        let args = X86DriverArgs::parse(&[
            "-mstack-alignment".to_string(),
            "16".to_string(),
            "test.c".to_string(),
        ]);
        assert_eq!(args.mstack_alignment, Some(16));
    }

    #[test]
    fn test_driver_args_parse_mno_features() {
        let args = X86DriverArgs::parse(&[
            "-mno-sse".to_string(),
            "-mno-avx".to_string(),
            "test.c".to_string(),
        ]);
        assert!(args.mno_features.contains(&"sse".to_string()));
        assert!(args.mno_features.contains(&"avx".to_string()));
    }

    #[test]
    fn test_driver_args_parse_m_features() {
        let args = X86DriverArgs::parse(&[
            "-mavx2".to_string(),
            "-mbmi2".to_string(),
            "test.c".to_string(),
        ]);
        assert!(args.m_features.contains(&"avx2".to_string()));
        assert!(args.m_features.contains(&"bmi2".to_string()));
    }

    #[test]
    fn test_driver_args_parse_verbose() {
        let args = X86DriverArgs::parse(&["-v".to_string(), "test.c".to_string()]);
        assert!(args.v);
    }

    #[test]
    fn test_driver_args_parse_dry_run() {
        let args = X86DriverArgs::parse(&["-###".to_string(), "test.c".to_string()]);
        assert!(args.dry_run);
    }

    #[test]
    fn test_driver_args_parse_shared() {
        let args = X86DriverArgs::parse(&["-shared".to_string(), "test.c".to_string()]);
        assert!(args.shared);
    }

    #[test]
    fn test_driver_args_parse_static() {
        let args = X86DriverArgs::parse(&["-static".to_string(), "test.c".to_string()]);
        assert!(args.static_linking);
    }

    #[test]
    fn test_driver_args_parse_mx32_with_target() {
        let args = X86DriverArgs::parse(&["-mx32".to_string(), "test.c".to_string()]);
        assert!(args.mx32);
        assert_eq!(args.target, Some("x86_64-unknown-linux-gnux32".to_string()));
    }

    #[test]
    fn test_driver_args_to_clang_flags_full() {
        let mut args = X86DriverArgs::default();
        args.m32 = true;
        args.march = Some("haswell".to_string());
        args.mtune = Some("generic".to_string());
        args.fpic = true;
        args.fstackrealign = true;
        args.mregparm = Some(3);
        let flags = args.to_clang_flags();
        assert!(flags.contains(&"-m32".to_string()));
        assert!(flags.contains(&"-march=haswell".to_string()));
        assert!(flags.contains(&"-mtune=generic".to_string()));
        assert!(flags.contains(&"-fpic".to_string()));
        assert!(flags.contains(&"-mregparm=3".to_string()));
    }

    // ── Extended X86Multilib tests ────────────────────────────────────────

    #[test]
    fn test_multilib_variant_gcc_suffix() {
        assert_eq!(X86MultilibVariant::Default64.gcc_multilib_suffix(), "64");
        assert_eq!(X86MultilibVariant::M32.gcc_multilib_suffix(), "32");
        assert_eq!(X86MultilibVariant::MX32.gcc_multilib_suffix(), "x32");
    }

    #[test]
    fn test_multilib_include_paths() {
        let triple = X86TargetTriple::x86_64_linux_gnu();
        let m = X86Multilib::new(&triple);
        let paths = m.include_paths();
        // Should have some 64-bit include paths
        assert!(!paths.is_empty());
    }

    #[test]
    fn test_multilib_select_64bit() {
        let triple = X86TargetTriple::i386_linux_gnu();
        let mut m = X86Multilib::new(&triple);
        m.select_64bit();
        assert_eq!(m.active_variant, X86MultilibVariant::Default64);
    }

    // ── Extended X86SanitizerSetup tests ──────────────────────────────────

    #[test]
    fn test_sanitizer_setup_thread() {
        let mut setup = X86SanitizerSetup::new();
        setup.thread = true;
        assert!(setup.has_any());
        let libs = setup.linker_libraries();
        assert!(libs.contains(&"tsan".to_string()));
    }

    #[test]
    fn test_sanitizer_setup_memory() {
        let mut setup = X86SanitizerSetup::new();
        setup.memory = true;
        assert!(setup.has_any());
        let libs = setup.linker_libraries();
        assert!(libs.contains(&"msan".to_string()));
    }

    #[test]
    fn test_sanitizer_setup_leak() {
        let mut setup = X86SanitizerSetup::new();
        setup.leak = true;
        assert!(setup.has_any());
        let libs = setup.linker_libraries();
        assert!(libs.contains(&"lsan".to_string()));
    }

    #[test]
    fn test_sanitizer_setup_dataflow() {
        let mut setup = X86SanitizerSetup::new();
        setup.data_flow = true;
        assert!(setup.has_any());
        let libs = setup.linker_libraries();
        assert!(libs.contains(&"dfsan".to_string()));
    }

    #[test]
    fn test_sanitizer_setup_hwaddress() {
        let mut setup = X86SanitizerSetup::new();
        setup.hwaddress = true;
        assert!(setup.has_any());
        let libs = setup.linker_libraries();
        assert!(libs.contains(&"hwasan".to_string()));
    }

    #[test]
    fn test_sanitizer_setup_safe_stack() {
        let mut setup = X86SanitizerSetup::new();
        setup.safe_stack = true;
        assert!(setup.has_any());
    }

    #[test]
    fn test_sanitizer_setup_shadow_call_stack() {
        let mut setup = X86SanitizerSetup::new();
        setup.shadow_call_stack = true;
        assert!(setup.has_any());
    }

    #[test]
    fn test_sanitizer_setup_minimal_runtime() {
        let mut setup = X86SanitizerSetup::new();
        setup.minimal_runtime = true;
        let flags = setup.compiler_flags();
        // With no sanitizer enabled, flags should be empty even with minimal_runtime
        assert!(flags.is_empty());
    }

    #[test]
    fn test_sanitizer_setup_blacklist() {
        let mut setup = X86SanitizerSetup::new();
        setup.address = true;
        setup.blacklist_file = Some(PathBuf::from("/tmp/asan_blacklist.txt"));
        let flags = setup.compiler_flags();
        assert!(flags.iter().any(|f| f.contains("blacklist")));
    }

    #[test]
    fn test_sanitizer_setup_asan_options_detect_leaks() {
        let mut setup = X86SanitizerSetup::new();
        setup.address = true;
        let opts = setup.asan_options();
        assert!(opts.iter().any(|o| o.contains("detect_leaks")));
    }

    // ── Extended X86CoverageSetup tests ───────────────────────────────────

    #[test]
    fn test_coverage_setup_function_sections() {
        let mut args = X86DriverArgs::default();
        args.ffunction_sections = true;
        let setup = X86CoverageSetup::from_args(&args);
        assert!(setup.function_sections);
        let flags = setup.compiler_flags();
        assert!(flags.iter().any(|f| f.contains("ffunction-sections")));
        assert!(flags.iter().any(|f| f.contains("fdata-sections")));
    }

    #[test]
    fn test_coverage_setup_cs_profile_generate() {
        let mut args = X86DriverArgs::default();
        args.fcs_profile_generate = Some("/tmp/cs".to_string());
        let setup = X86CoverageSetup::from_args(&args);
        assert!(setup.cs_profile_generate.is_some());
    }

    #[test]
    fn test_coverage_setup_debug_info_for_profiling() {
        let mut setup = X86CoverageSetup::new();
        setup.coverage_mapping = true;
        setup.debug_info_for_profiling = true;
        let flags = setup.compiler_flags();
        assert!(flags.iter().any(|f| f == "-fdebug-info-for-profiling"));
    }

    #[test]
    fn test_coverage_setup_has_any_false() {
        let setup = X86CoverageSetup::new();
        assert!(!setup.has_any());
    }

    #[test]
    fn test_coverage_setup_has_any_true_with_coverage() {
        let mut setup = X86CoverageSetup::new();
        setup.coverage_mapping = true;
        assert!(setup.has_any());
    }

    #[test]
    fn test_coverage_setup_has_any_true_with_profile() {
        let mut setup = X86CoverageSetup::new();
        setup.profile_instr_use = Some(PathBuf::from("test.profdata"));
        assert!(setup.has_any());
    }

    // ── Extended X86LTOConfig tests ───────────────────────────────────────

    #[test]
    fn test_lto_config_detect_plugin() {
        let mut config = X86LTOConfig::new();
        config.detect_plugin();
        // Plugin detection may or may not find anything in test env
        // Just verify it doesn't panic
    }

    #[test]
    fn test_lto_config_compiler_flags_disabled() {
        let config = X86LTOConfig::new();
        assert!(config.compiler_flags().is_empty());
    }

    #[test]
    fn test_lto_config_compiler_flags_full() {
        let mut config = X86LTOConfig::new();
        config.enabled = true;
        let flags = config.compiler_flags();
        assert!(flags.contains(&"-flto".to_string()));
    }

    #[test]
    fn test_lto_config_compiler_flags_thin() {
        let mut config = X86LTOConfig::new();
        config.enabled = true;
        config.thin = true;
        let flags = config.compiler_flags();
        assert!(flags.contains(&"-flto=thin".to_string()));
    }

    #[test]
    fn test_lto_config_compiler_flags_with_opt_level() {
        let mut config = X86LTOConfig::new();
        config.enabled = true;
        config.lto_opt_level = Some(2);
        let flags = config.compiler_flags();
        assert!(flags.iter().any(|f| f.contains("-flto-O2")));
    }

    #[test]
    fn test_lto_config_linker_flags_new_pm() {
        let mut config = X86LTOConfig::new();
        config.enabled = true;
        config.new_pass_manager = true;
        let flags = config.linker_flags();
        assert!(flags.iter().any(|f| f.contains("new-pass-manager")));
    }

    #[test]
    fn test_lto_config_linker_flags_debug_info() {
        let mut config = X86LTOConfig::new();
        config.enabled = true;
        config.lto_debug_info = true;
        let flags = config.linker_flags();
        assert!(flags.iter().any(|f| f.contains("debug-info")));
    }

    #[test]
    fn test_lto_config_linker_flags_cache_dir() {
        let mut config = X86LTOConfig::new();
        config.enabled = true;
        config.cache_dir = Some(PathBuf::from("/tmp/lto-cache"));
        let flags = config.linker_flags();
        assert!(flags.iter().any(|f| f.contains("cache-dir")));
    }

    // ── Extended X86ToolchainPath tests ───────────────────────────────────

    #[test]
    fn test_toolchain_c_include_dirs() {
        let triple = X86TargetTriple::x86_64_linux_gnu();
        let tc = X86ToolchainPath::detect(&triple);
        let dirs = tc.c_include_dirs();
        // Should have at least /usr/include on most systems
        // Not asserting non-empty since CI may not have it
    }

    #[test]
    fn test_toolchain_cxx_include_dirs() {
        let triple = X86TargetTriple::x86_64_linux_gnu();
        let tc = X86ToolchainPath::detect(&triple);
        let dirs = tc.cxx_include_dirs();
        // C++ headers may not exist on all test machines
    }

    #[test]
    fn test_toolchain_all_include_dirs() {
        let triple = X86TargetTriple::x86_64_linux_gnu();
        let tc = X86ToolchainPath::detect(&triple);
        let dirs = tc.all_include_dirs();
        // Combined dirs should include both C and C++
    }

    #[test]
    fn test_toolchain_active_lib_dirs_64() {
        let triple = X86TargetTriple::x86_64_linux_gnu();
        let tc = X86ToolchainPath::detect(&triple);
        let dirs = tc.active_lib_dirs(X86MultilibVariant::Default64);
        // Should have at least some 64-bit lib dirs
    }

    #[test]
    fn test_toolchain_active_lib_dirs_32() {
        let triple = X86TargetTriple::x86_64_linux_gnu();
        let tc = X86ToolchainPath::detect(&triple);
        let dirs = tc.active_lib_dirs(X86MultilibVariant::M32);
        // 32-bit dirs may or may not exist
    }

    #[test]
    fn test_toolchain_crt_object_nonexistent() {
        let triple = X86TargetTriple::x86_64_linux_gnu();
        let tc = X86ToolchainPath::detect(&triple);
        let obj = tc.crt_object("nonexistent_crt.o");
        assert!(obj.is_none());
    }

    #[test]
    fn test_toolchain_resource_dir() {
        let triple = X86TargetTriple::x86_64_linux_gnu();
        let tc = X86ToolchainPath::detect(&triple);
        // Resource dir may be found or fallback
        assert!(tc.resource_dir().is_some());
    }

    // ── Extended X86HeaderSearch tests ────────────────────────────────────

    #[test]
    fn test_header_search_all_include_paths() {
        let triple = X86TargetTriple::x86_64_linux_gnu();
        let tc = X86ToolchainPath::detect(&triple);
        let hs = X86HeaderSearch::new(&triple, &tc);
        let paths = hs.all_include_paths();
        // Should have at least builtin includes
    }

    #[test]
    fn test_header_search_add_framework_path() {
        let triple = X86TargetTriple::x86_64_linux_gnu();
        let tc = X86ToolchainPath::detect(&triple);
        let mut hs = X86HeaderSearch::new(&triple, &tc);
        hs.add_framework_path(Path::new("/System/Library/Frameworks"));
        assert_eq!(hs.framework_includes.len(), 1);
    }

    // ── Extended X86StdLibSetup tests ─────────────────────────────────────

    #[test]
    fn test_stdlib_setup_new_bionic() {
        let triple = X86TargetTriple::x86_64_linux_android();
        let tc = X86ToolchainPath::detect(&triple);
        let setup = X86StdLibSetup::new(&triple, &tc);
        assert_eq!(setup.c_lib, X86CLibKind::Bionic);
    }

    #[test]
    fn test_stdlib_setup_new_darwin() {
        let triple = X86TargetTriple::x86_64_apple_darwin();
        let tc = X86ToolchainPath::detect(&triple);
        let setup = X86StdLibSetup::new(&triple, &tc);
        assert_eq!(setup.c_lib, X86CLibKind::LibSystem);
    }

    #[test]
    fn test_stdlib_setup_cxx_lib_android() {
        let triple = X86TargetTriple::x86_64_linux_android();
        let tc = X86ToolchainPath::detect(&triple);
        let setup = X86StdLibSetup::new(&triple, &tc);
        assert_eq!(setup.cxx_lib, X86CXXLibKind::AndroidCXX);
    }

    #[test]
    fn test_stdlib_setup_cxx_lib_msvc() {
        let triple = X86TargetTriple::x86_64_windows_msvc();
        let tc = X86ToolchainPath::detect(&triple);
        let setup = X86StdLibSetup::new(&triple, &tc);
        assert_eq!(setup.cxx_lib, X86CXXLibKind::Msvcprt);
    }

    #[test]
    fn test_stdlib_setup_nostdlib_disables_libraries() {
        let triple = X86TargetTriple::x86_64_linux_gnu();
        let tc = X86ToolchainPath::detect(&triple);
        let mut setup = X86StdLibSetup::new(&triple, &tc);
        setup.nostdlib = true;
        setup.setup_default_libraries();
        // With nostdlib, default libraries list should not grow
        // (it may still have whatever was added before)
    }

    #[test]
    fn test_stdlib_setup_crt_files() {
        let triple = X86TargetTriple::x86_64_linux_gnu();
        let tc = X86ToolchainPath::detect(&triple);
        let setup = X86StdLibSetup::new(&triple, &tc);
        let crt = setup.crt_startup_files();
        // CRT files may or may not be found in test environment
    }

    #[test]
    fn test_clib_kind_all_variants() {
        // Verify all CLibKind variants have reasonable defaults
        for kind in &[
            X86CLibKind::Glibc,
            X86CLibKind::Musl,
            X86CLibKind::Msvcrt,
            X86CLibKind::Bionic,
            X86CLibKind::LibSystem,
            X86CLibKind::Newlib,
            X86CLibKind::DietLibc,
            X86CLibKind::UClibc,
            X86CLibKind::Unknown,
        ] {
            let crt = kind.default_crt_object();
            assert!(!crt.is_empty());
            let lib = kind.default_c_lib();
            assert!(!lib.is_empty());
        }
    }

    // ── Extended X86LinkerInvocation tests ────────────────────────────────

    #[test]
    fn test_linker_invocation_set_entry() {
        let triple = X86TargetTriple::x86_64_linux_gnu();
        let mut inv = X86LinkerInvocation::new(X86LinkerFlavor::GnuLd, &triple);
        inv.set_entry("my_custom_start");
        let cmd = inv.to_command();
        assert!(cmd.contains(&"my_custom_start".to_string()));
    }

    #[test]
    fn test_linker_invocation_set_dynamic_linker() {
        let triple = X86TargetTriple::x86_64_linux_gnu();
        let mut inv = X86LinkerInvocation::new(X86LinkerFlavor::GnuLd, &triple);
        inv.set_dynamic_linker("/lib/custom-ld.so");
        let cmd = inv.to_command();
        assert!(cmd.iter().any(|a| a.contains("custom-ld.so")));
    }

    #[test]
    fn test_linker_invocation_allow_unresolved() {
        let triple = X86TargetTriple::x86_64_linux_gnu();
        let mut inv = X86LinkerInvocation::new(X86LinkerFlavor::GnuLd, &triple);
        inv.allow_unresolved = true;
        let cmd = inv.to_command();
        assert!(cmd.iter().any(|a| a.contains("shlib-undefined")));
    }

    #[test]
    fn test_linker_invocation_export_dynamic() {
        let triple = X86TargetTriple::x86_64_linux_gnu();
        let mut inv = X86LinkerInvocation::new(X86LinkerFlavor::GnuLd, &triple);
        inv.export_dynamic = true;
        let cmd = inv.to_command();
        assert!(cmd.contains(&"--export-dynamic".to_string()));
    }

    #[test]
    fn test_linker_invocation_strip() {
        let triple = X86TargetTriple::x86_64_linux_gnu();
        let mut inv = X86LinkerInvocation::new(X86LinkerFlavor::GnuLd, &triple);
        inv.strip = true;
        let cmd = inv.to_command();
        assert!(cmd.contains(&"-s".to_string()));
    }

    #[test]
    fn test_linker_invocation_soname() {
        let triple = X86TargetTriple::x86_64_linux_gnu();
        let mut inv = X86LinkerInvocation::new(X86LinkerFlavor::GnuLd, &triple);
        inv.shared = true;
        inv.soname = Some("libtest.so.1".to_string());
        let cmd = inv.to_command();
        assert!(cmd.iter().any(|a| a.contains("libtest.so.1")));
    }

    #[test]
    fn test_linker_invocation_emulation_32() {
        let triple = X86TargetTriple::i386_linux_gnu();
        let inv = X86LinkerInvocation::new(X86LinkerFlavor::GnuLd, &triple);
        let cmd = inv.to_command();
        assert!(cmd.iter().any(|a| a.contains("elf_i386")));
    }

    #[test]
    fn test_linker_invocation_emulation_x32() {
        let triple = X86TargetTriple::x86_64_linux_gnux32();
        let inv = X86LinkerInvocation::new(X86LinkerFlavor::GnuLd, &triple);
        let cmd = inv.to_command();
        assert!(cmd.iter().any(|a| a.contains("elf32_x86_64")));
    }

    #[test]
    fn test_linker_invocation_msvc_subsystem() {
        let triple = X86TargetTriple::x86_64_windows_msvc();
        let mut inv = X86LinkerInvocation::new(X86LinkerFlavor::MSVCLink, &triple);
        inv.subsystem = Some("WINDOWS".to_string());
        let cmd = inv.to_command();
        assert!(cmd.iter().any(|a| a.contains("WINDOWS")));
    }

    #[test]
    fn test_linker_invocation_msvc_win_entry() {
        let triple = X86TargetTriple::x86_64_windows_msvc();
        let mut inv = X86LinkerInvocation::new(X86LinkerFlavor::MSVCLink, &triple);
        inv.win_entry = Some("mainCRTStartup".to_string());
        let cmd = inv.to_command();
        assert!(cmd.iter().any(|a| a.contains("mainCRTStartup")));
    }

    // ── Extended X86AssemblerInvocation tests ─────────────────────────────

    #[test]
    fn test_assembler_invocation_avx_flag() {
        let triple = X86TargetTriple::x86_64_linux_gnu();
        let mut inv = X86AssemblerInvocation::new(&triple);
        inv.use_avx = true;
        let cmd = inv.to_command();
        assert!(cmd.iter().any(|a| a.contains("avx")));
    }

    #[test]
    fn test_assembler_invocation_debug_flag() {
        let triple = X86TargetTriple::x86_64_linux_gnu();
        let mut inv = X86AssemblerInvocation::new(&triple);
        inv.gen_debug = true;
        let cmd = inv.to_command();
        assert!(cmd.iter().any(|a| a == "-g" || a.contains("gdwarf")));
    }

    #[test]
    fn test_assembler_invocation_pic_flag() {
        let triple = X86TargetTriple::x86_64_linux_gnu();
        let mut inv = X86AssemblerInvocation::new(&triple);
        inv.pic = true;
        let cmd = inv.to_command();
        assert!(cmd.iter().any(|a| a.contains("position-independent")));
    }

    #[test]
    fn test_assembler_invocation_32bit() {
        let triple = X86TargetTriple::i386_linux_gnu();
        let mut inv = X86AssemblerInvocation::new(&triple);
        inv.integrated_as = false;
        let cmd = inv.to_command();
        assert!(cmd.contains(&"--32".to_string()));
    }

    #[test]
    fn test_assembler_invocation_x32() {
        let triple = X86TargetTriple::x86_64_linux_gnux32();
        let mut inv = X86AssemblerInvocation::new(&triple);
        inv.integrated_as = false;
        let cmd = inv.to_command();
        assert!(cmd.contains(&"--x32".to_string()));
    }

    // ── Integration / Smoke tests ─────────────────────────────────────────

    #[test]
    fn test_smoke_create_driver_and_inspect_state() {
        let driver = X86ClangDriver::x86_64_linux();
        assert!(driver.triple.is_64bit);
        assert!(driver.multilib.multilib_enabled);
        assert!(!driver.sanitizers.has_any());
        assert!(!driver.coverage.has_any());
        assert!(!driver.lto_config.is_enabled());
        assert_eq!(driver.linker_flavor, X86LinkerFlavor::GnuLd);
        assert_eq!(driver.opt_level, X86DriverOptLevel::O0);
    }

    #[test]
    fn test_smoke_windows_driver() {
        let driver = X86ClangDriver::x86_64_windows();
        assert_eq!(driver.triple.os, X86TripleOS::Win32);
        assert_eq!(driver.linker_flavor, X86LinkerFlavor::MSVCLink);
        assert_eq!(driver.stdlib.c_lib, X86CLibKind::Msvcrt);
    }

    #[test]
    fn test_smoke_i386_driver() {
        let driver = X86ClangDriver::i386_linux();
        assert!(!driver.triple.is_64bit);
        assert_eq!(driver.multilib.active_variant, X86MultilibVariant::M32);
        assert_eq!(driver.stdlib.c_lib, X86CLibKind::Glibc);
    }

    #[test]
    fn test_smoke_parse_all_common_flags() {
        let args = [
            "-target",
            "x86_64-unknown-linux-gnu",
            "-march=skylake",
            "-mcpu=native",
            "-mtune=generic",
            "-O2",
            "-g",
            "-fPIC",
            "-Wall",
            "-I/usr/include",
            "-isystem/usr/local/include",
            "-L/usr/lib64",
            "-lpthread",
            "-lm",
            "-DDEBUG",
            "-DNAME=value",
            "-UNDEBUG",
            "-fsanitize=address",
            "-flto=thin",
            "-fprofile-instr-generate",
            "-fuse-ld=lld",
            "-shared",
            "-o",
            "output.so",
            "input.c",
        ]
        .iter()
        .map(|s| s.to_string())
        .collect::<Vec<_>>();

        let parsed = X86DriverArgs::parse(&args);
        assert_eq!(parsed.target, Some("x86_64-unknown-linux-gnu".to_string()));
        assert_eq!(parsed.march, Some("skylake".to_string()));
        assert_eq!(parsed.mcpu, Some("native".to_string()));
        assert_eq!(parsed.opt_level, Some(X86DriverOptLevel::O2));
        assert!(parsed.fPIC);
        assert_eq!(parsed.fsanitize, Some("address".to_string()));
        assert_eq!(parsed.flto, Some("thin".to_string()));
        assert_eq!(parsed.fuse_ld, Some("lld".to_string()));
        assert!(parsed.shared);
        assert_eq!(parsed.output_file, Some("output.so".to_string()));
        assert!(parsed.input_files.contains(&"input.c".to_string()));
    }

    #[test]
    fn test_smoke_driver_complete_parse_and_flags_roundtrip() {
        let mut driver = X86ClangDriver::x86_64_linux();
        let args = vec![
            "-O2".to_string(),
            "-march=skylake".to_string(),
            "-flto=thin".to_string(),
            "-fsanitize=address".to_string(),
            "-fprofile-instr-generate".to_string(),
            "test.c".to_string(),
        ];
        driver.parse_args(&args);

        // Verify state after parsing
        assert_eq!(driver.opt_level, X86DriverOptLevel::O2);
        assert!(driver.sanitizers.address);
        assert!(driver.lto_config.is_enabled());
        assert!(driver.coverage.profile_instr_generate);

        // Build linker invocation
        let inv = driver.build_linker_invocation();
        assert!(!inv.to_command().is_empty());

        // Build compiler command
        let cmd = driver.build_compiler_command(Path::new("test.c"), Path::new("test.o"));
        assert!(!cmd.is_empty());
        assert!(cmd.contains(&"-target=x86_64-unknown-linux-gnu".to_string()));
    }

    #[test]
    fn test_smoke_x86_arch_from_str_all() {
        let test_cases = [
            ("i386", X86TripleArch::I386),
            ("i486", X86TripleArch::I486),
            ("i586", X86TripleArch::I586),
            ("i686", X86TripleArch::I686),
            ("x86_64", X86TripleArch::X86_64),
            ("amd64", X86TripleArch::X86_64),
            ("x86-64", X86TripleArch::X86_64),
            ("x64", X86TripleArch::X86_64),
            ("x32", X86TripleArch::X32),
        ];
        for (input, expected) in &test_cases {
            assert_eq!(
                X86TripleArch::from_str(input),
                *expected,
                "Failed for input: {}",
                input
            );
        }
    }

    #[test]
    fn test_smoke_x86_os_from_str_all() {
        let test_cases = [
            ("linux", X86TripleOS::Linux),
            ("darwin", X86TripleOS::Darwin),
            ("macosx", X86TripleOS::MacOSX),
            ("win32", X86TripleOS::Win32),
            ("windows", X86TripleOS::Win32),
            ("mingw32", X86TripleOS::Win32),
            ("freebsd", X86TripleOS::FreeBSD),
            ("netbsd", X86TripleOS::NetBSD),
            ("openbsd", X86TripleOS::OpenBSD),
            ("android", X86TripleOS::Android),
            ("emscripten", X86TripleOS::Emscripten),
            ("fuchsia", X86TripleOS::Fuchsia),
            ("wasi", X86TripleOS::WASI),
            ("hurd", X86TripleOS::Hurd),
        ];
        for (input, expected) in &test_cases {
            assert_eq!(
                X86TripleOS::from_str(input),
                *expected,
                "Failed for input: {}",
                input
            );
        }
    }

    #[test]
    fn test_smoke_linker_flavor_default_executable_all() {
        let flavors = [
            (X86LinkerFlavor::GnuLd, "ld"),
            (X86LinkerFlavor::Lld, "ld.lld"),
            (X86LinkerFlavor::DarwinLd, "ld"),
            (X86LinkerFlavor::MSVCLink, "link.exe"),
            (X86LinkerFlavor::LldLink, "lld-link"),
        ];
        for (flavor, expected) in &flavors {
            assert_eq!(
                flavor.default_executable(),
                *expected,
                "Failed for {:?}",
                flavor
            );
        }
    }

    // ── X86DriverJob tests ────────────────────────────────────────────────────

    #[test]
    fn test_driver_job_new() {
        let job = X86DriverJob::new(
            X86CompilationPhase::Compile,
            Path::new("test.c"),
            Path::new("test.o"),
        );
        assert_eq!(job.phase, X86CompilationPhase::Compile);
        assert_eq!(job.input, PathBuf::from("test.c"));
    }

    #[test]
    fn test_driver_job_add_arg() {
        let mut job = X86DriverJob::new(
            X86CompilationPhase::Compile,
            Path::new("test.c"),
            Path::new("test.o"),
        );
        job.add_arg("-O2");
        assert!(job.arguments.contains(&"-O2".to_string()));
    }

    #[test]
    fn test_driver_job_add_args() {
        let mut job = X86DriverJob::new(
            X86CompilationPhase::Compile,
            Path::new("test.c"),
            Path::new("test.o"),
        );
        job.add_args(&["-c".to_string(), "-O2".to_string()]);
        assert_eq!(job.arguments.len(), 2);
    }

    #[test]
    fn test_driver_job_to_shell_command() {
        let mut job = X86DriverJob::new(
            X86CompilationPhase::Compile,
            Path::new("test.c"),
            Path::new("test.o"),
        );
        job.add_arg("clang");
        job.add_arg("test.c");
        let cmd = job.to_shell_command();
        assert!(cmd.contains("clang"));
        assert!(cmd.contains("test.c"));
    }

    #[test]
    fn test_driver_job_list_new() {
        let list = X86DriverJobList::new();
        assert!(list.is_empty());
        assert_eq!(list.len(), 0);
    }

    #[test]
    fn test_driver_job_list_add_job() {
        let mut list = X86DriverJobList::new();
        let job = X86DriverJob::new(
            X86CompilationPhase::Compile,
            Path::new("test.c"),
            Path::new("test.o"),
        );
        list.add_job(job);
        assert_eq!(list.len(), 1);
    }

    #[test]
    fn test_driver_job_list_to_shell_script() {
        let mut list = X86DriverJobList::new();
        let job = X86DriverJob::new(
            X86CompilationPhase::Compile,
            Path::new("test.c"),
            Path::new("test.o"),
        );
        list.add_job(job);
        let script = list.to_shell_script();
        assert!(script.contains("#!/bin/sh"));
    }

    // ── X86PredefinedMacros tests ─────────────────────────────────────────────

    #[test]
    fn test_predefined_macros_x86_64_linux() {
        let triple = X86TargetTriple::x86_64_linux_gnu();
        let macros = X86PredefinedMacros::for_triple(&triple);
        let names: Vec<&str> = macros.macros.iter().map(|(n, _)| n.as_str()).collect();
        assert!(names.contains(&"__x86_64__"));
        assert!(names.contains(&"__linux__"));
        assert!(names.contains(&"__gnu_linux__"));
    }

    #[test]
    fn test_predefined_macros_i386_linux() {
        let triple = X86TargetTriple::i386_linux_gnu();
        let macros = X86PredefinedMacros::for_triple(&triple);
        let names: Vec<&str> = macros.macros.iter().map(|(n, _)| n.as_str()).collect();
        assert!(names.contains(&"__i386__"));
    }

    #[test]
    fn test_predefined_macros_windows() {
        let triple = X86TargetTriple::x86_64_windows_msvc();
        let macros = X86PredefinedMacros::for_triple(&triple);
        let names: Vec<&str> = macros.macros.iter().map(|(n, _)| n.as_str()).collect();
        assert!(names.contains(&"_WIN32"));
        assert!(names.contains(&"_WIN64"));
    }

    #[test]
    fn test_predefined_macros_darwin() {
        let triple = X86TargetTriple::x86_64_apple_darwin();
        let macros = X86PredefinedMacros::for_triple(&triple);
        let names: Vec<&str> = macros.macros.iter().map(|(n, _)| n.as_str()).collect();
        assert!(names.contains(&"__APPLE__"));
        assert!(names.contains(&"__MACH__"));
    }

    #[test]
    fn test_predefined_macros_to_clang_flags() {
        let triple = X86TargetTriple::x86_64_linux_gnu();
        let macros = X86PredefinedMacros::for_triple(&triple);
        let flags = macros.to_clang_flags();
        assert!(flags
            .iter()
            .any(|f| f.contains("__x86_64__") && f.starts_with("-D")));
    }

    // ── X86DiagnosticReport tests ─────────────────────────────────────────────

    #[test]
    fn test_diagnostic_report_driver() {
        let driver = X86ClangDriver::x86_64_linux();
        let report = driver.report();
        assert!(report.contains("Target:"));
        let short = driver.report_short();
        assert!(short.contains("Driver["));
    }

    #[test]
    fn test_diagnostic_report_triple() {
        let triple = X86TargetTriple::x86_64_linux_gnu();
        let report = triple.report();
        assert!(report.contains("x86_64"));
        let short = triple.report_short();
        assert_eq!(short, "x86_64-unknown-linux-gnu");
    }

    #[test]
    fn test_diagnostic_report_sanitizer_empty() {
        let san = X86SanitizerSetup::new();
        let report = san.report();
        assert!(report.contains("none"));
        let short = san.report_short();
        assert_eq!(short, "San[off]");
    }

    #[test]
    fn test_diagnostic_report_sanitizer_address() {
        let mut san = X86SanitizerSetup::new();
        san.address = true;
        let report = san.report();
        assert!(report.contains("addr"));
        let short = san.report_short();
        assert_eq!(short, "San[on]");
    }

    #[test]
    fn test_diagnostic_report_lto_disabled() {
        let lto = X86LTOConfig::default();
        let report = lto.report();
        assert_eq!(report, "LTO[off]");
        assert_eq!(lto.report_short(), "LTO[off]");
    }

    #[test]
    fn test_diagnostic_report_lto_thin() {
        let mut lto = X86LTOConfig::new();
        lto.enabled = true;
        lto.thin = true;
        assert_eq!(lto.report(), "LTO[thin]");
        assert_eq!(lto.report_short(), "LTO[on]");
    }

    #[test]
    fn test_diagnostic_report_lto_full() {
        let mut lto = X86LTOConfig::new();
        lto.enabled = true;
        assert_eq!(lto.report(), "LTO[full]");
        assert_eq!(lto.report_short(), "LTO[on]");
    }
}