llvm-native-core 0.1.14

//! clang_sysroot_x86 — Complete sysroot management and cross-compilation module
//! for Clang on X86 targets.
//!
//! This module provides the full sysroot infrastructure for X86 target
//! compilation, including automatic sysroot detection, cross-compilation
//! toolchain management, multiarch library search, target triple parsing,
//! compiler runtime integration, resource directory management, and
//! cross-library support for glibc, musl, bionic, newlib, and picolibc.
//!
//! # Architecture
//!
//! ```text
//! X86SysrootManager          ← top-level sysroot orchestration
//!  ├── X86SysrootDetector    ← automatic sysroot detection
//!  ├── X86CrossCompilation   ← cross-compilation support
//!  ├── X86Multiarch          ← multiarch library paths
//!  ├── X86TripleParser       ← target triple parsing
//!  ├── X86CompilerRT         ← compiler runtime integration
//!  ├── X86ResourceDir        ← resource directory management
//!  └── X86CrossLibrary       ← cross-library support
//! ```
//!
//! # Platform Coverage
//!
//! - **Linux sysroot**: /, /usr, custom paths, GCC cross-installations
//! - **Android NDK**: platforms/android-*, sysroot/usr
//! - **macOS SDK**: Xcode.app SDKs (MacOSX, iOS, tvOS, watchOS)
//! - **Windows SDK**: Windows Kits\10, MinGW sysroot
//! - **Custom sysroot**: --sysroot= flag support
//!
//! # Cross-Compilation Models
//!
//! - Host → Target (standard cross-compilation)
//! - Canadian Cross (build on A, host on B, target on C)
//! - Emulation support (QEMU user mode, Wine)
//! - Cross-compilation pkg-config wrapper
//!
//! # Multiarch Support
//!
//! - Debian/Ubuntu: /usr/lib/x86_64-linux-gnu, /usr/lib/i386-linux-gnu, /usr/lib/x86_64-linux-gnux32
//! - RPM-based: /usr/lib64, /usr/lib
//! - Multiarch library search order
//!
//! Clean-room behavioural reconstruction from:
//! - Clang driver design documentation (published)
//! - GCC installation and cross-compilation documentation
//! - Debian Multiarch Specification
//! - Android NDK documentation
//! - Apple Xcode SDK documentation
//! - Microsoft Windows SDK documentation
//! - Musl cross-compilation documentation
//! - QEMU user-mode emulation documentation
//!
//! Zero LLVM/GCC source code consultation.

use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet, VecDeque};
use std::env;
use std::fmt;
use std::fs;
use std::io;
use std::path::{Path, PathBuf};
use std::process::Command as ProcessCommand;

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

// Re-imports for integration with sibling modules
use crate::clang::clang_sysroot::{
    GccInstallation, HeaderSearchEntry, IncludePathKind, Sysroot, VfsOverlay,
};
use crate::clang::clang_target::{
    ClangABI, ClangOptLevel, ClangTargetInfo, DebugInfoKind, TargetCodeGenInfo, TargetFlags,
};

// ═══════════════════════════════════════════════════════════════════════════════
// 1. X86 Sysroot Manager — Top-Level Orchestration
// ═══════════════════════════════════════════════════════════════════════════════

/// Complete sysroot manager for X86 targets.
///
/// The `X86SysrootManager` is the central entry point for all sysroot-related
/// operations. It coordinates sysroot detection, cross-compilation setup,
/// multiarch path resolution, compiler runtime selection, resource directory
/// management, and cross-library configuration.
///
/// # Examples
///
/// ```ignore
/// let manager = X86SysrootManager::new("x86_64-unknown-linux-gnu");
/// let sysroot = manager.detect_sysroot();
/// let include_paths = manager.build_include_paths(&sysroot);
/// let lib_paths = manager.build_library_paths(&sysroot);
/// ```
#[derive(Debug, Clone)]
pub struct X86SysrootManager {
    /// The target triple for which we manage sysroots.
    pub target_triple: String,
    /// Parsed target triple.
    pub triple: Triple,
    /// Explicitly provided sysroot path (from --sysroot=).
    pub explicit_sysroot: Option<PathBuf>,
    /// The detected sysroot detector subsystem.
    pub detector: X86SysrootDetector,
    /// Cross-compilation configuration.
    pub cross_compilation: X86CrossCompilation,
    /// Multiarch path resolver.
    pub multiarch: X86Multiarch,
    /// Target triple parser.
    pub triple_parser: X86TripleParser,
    /// Compiler runtime configuration.
    pub compiler_rt: X86CompilerRT,
    /// Resource directory manager.
    pub resource_dir: X86ResourceDir,
    /// Cross-library configuration.
    pub cross_library: X86CrossLibrary,
    /// Detected GCC installation.
    pub gcc_install: Option<GccInstallation>,
    /// Whether to use compiler-rt instead of libgcc.
    pub use_compiler_rt: bool,
    /// Whether to use libc++ instead of libstdc++.
    pub use_libcxx: bool,
    /// Whether this is a cross-compilation.
    pub is_cross: bool,
    /// Additional include paths (-I).
    pub extra_includes: Vec<PathBuf>,
    /// Additional library paths (-L).
    pub extra_libraries: Vec<PathBuf>,
    /// Environment variables to consider.
    pub env_vars: HashMap<String, String>,
}

impl X86SysrootManager {
    /// Create a new sysroot manager for the given target triple.
    pub fn new(triple_str: &str) -> Self {
        let triple = Triple::parse(triple_str);
        let detector = X86SysrootDetector::new(triple_str);
        let cross_compilation = X86CrossCompilation::new(triple_str);
        let multiarch = X86Multiarch::new(&triple);
        let triple_parser = X86TripleParser::new(triple_str);
        let compiler_rt = X86CompilerRT::new(&triple);
        let resource_dir = X86ResourceDir::new(&triple);
        let cross_library = X86CrossLibrary::new(&triple);

        let is_cross = cross_compilation.is_cross;

        // Collect relevant environment variables
        let mut env_vars = HashMap::new();
        for var in &[
            "C_INCLUDE_PATH",
            "CPLUS_INCLUDE_PATH",
            "CPATH",
            "LIBRARY_PATH",
            "LD_LIBRARY_PATH",
            "SYSROOT",
            "SDKROOT",
            "CROSS_COMPILE",
            "PKG_CONFIG_PATH",
            "PKG_CONFIG_SYSROOT_DIR",
            "ANDROID_NDK_HOME",
            "ANDROID_NDK_ROOT",
            "ANDROID_SDK_HOME",
            "NDK_HOME",
            "XCODE_PATH",
            "DEVELOPER_DIR",
            "WINDOWS_SDK_PATH",
            "MSVC_PATH",
        ] {
            if let Ok(val) = env::var(var) {
                env_vars.insert(var.to_string(), val);
            }
        }

        Self {
            target_triple: triple_str.to_string(),
            triple,
            explicit_sysroot: None,
            detector,
            cross_compilation,
            multiarch,
            triple_parser,
            compiler_rt,
            resource_dir,
            cross_library,
            gcc_install: None,
            use_compiler_rt: false,
            use_libcxx: false,
            is_cross,
            extra_includes: Vec::new(),
            extra_libraries: Vec::new(),
            env_vars,
        }
    }

    /// Create a manager with an explicit sysroot.
    pub fn with_sysroot(triple_str: &str, sysroot: PathBuf) -> Self {
        let mut manager = Self::new(triple_str);
        manager.explicit_sysroot = Some(sysroot.clone());
        manager.detector.forced_sysroot = Some(sysroot);
        manager
    }

    /// Create a manager configured for cross-compilation.
    pub fn for_cross(triple_str: &str, sysroot: PathBuf) -> Self {
        let mut manager = Self::with_sysroot(triple_str, sysroot);
        manager.is_cross = true;
        manager.use_compiler_rt = true;
        manager
    }

    /// Detect the appropriate sysroot for the target.
    pub fn detect_sysroot(&mut self) -> Sysroot {
        // If explicit sysroot was provided, use it
        if let Some(ref path) = self.explicit_sysroot {
            if path.exists() {
                return Sysroot::explicit(path.clone());
            }
        }

        // Use the detector to find the sysroot
        self.detector.detect()
    }

    /// Build the complete ordered list of include paths.
    pub fn build_include_paths(&mut self, sysroot: &Sysroot) -> Vec<HeaderSearchEntry> {
        let mut paths: Vec<HeaderSearchEntry> = Vec::new();

        // 1. User-specified -I paths (highest priority)
        for inc in &self.extra_includes {
            paths.push(HeaderSearchEntry::user(inc.clone()));
        }

        // 2. Resource directory (builtin headers)
        let resource_include = self.resource_dir.include_dir();
        if resource_include.exists() {
            paths.push(HeaderSearchEntry::resource(resource_include));
        }

        // 3. GCC installation includes (if detected)
        if let Some(ref gcc) = self.gcc_install {
            for p in gcc.c_include_paths() {
                paths.push(HeaderSearchEntry::system(p).with_from_gcc());
            }
        }

        // 4. C++ standard library includes
        if self.use_libcxx {
            let cxx = crate::clang::clang_sysroot::CxxStdLib::detect_libcxx(sysroot);
            for p in &cxx.include_paths {
                paths.push(HeaderSearchEntry::system(p.clone()));
            }
        }

        // 5. Environment variable paths (CPATH, C_INCLUDE_PATH, etc.)
        for (var, kind) in &[
            ("CPATH", IncludePathKind::User),
            ("C_INCLUDE_PATH", IncludePathKind::System),
            ("CPLUS_INCLUDE_PATH", IncludePathKind::System),
        ] {
            if let Some(val) = self.env_vars.get(*var) {
                for part in val.split(':') {
                    let p = PathBuf::from(part);
                    if p.is_dir() {
                        let entry = HeaderSearchEntry::new(p, *kind).with_from_env();
                        paths.push(entry);
                    }
                }
            }
        }

        // 6. System include paths from sysroot
        let usr_include = sysroot.usr_include();
        if usr_include.exists() {
            paths.push(HeaderSearchEntry::system(usr_include));
        }

        let usr_local_include = sysroot.usr_local_include();
        if usr_local_include.exists() {
            paths.push(HeaderSearchEntry::system(usr_local_include));
        }

        // 7. Android NDK specific includes
        if self.triple.os == OS::Linux && self.triple.environment == Environment::Android {
            let android_includes = self.detector.android_ndk_include_paths();
            for p in android_includes {
                paths.push(HeaderSearchEntry::system(p));
            }
        }

        // 8. macOS framework paths
        if self.triple.is_macho() {
            let frameworks = sysroot.system_library_frameworks();
            if frameworks.exists() {
                paths.push(HeaderSearchEntry::framework(frameworks));
            }
            let lib_frameworks = sysroot.library_frameworks();
            if lib_frameworks.exists() {
                paths.push(HeaderSearchEntry::framework(lib_frameworks));
            }
        }

        // 9. Cross-library include paths
        let cross_includes = self.cross_library.include_paths(sysroot);
        for p in cross_includes {
            paths.push(HeaderSearchEntry::system(p));
        }

        paths
    }

    /// Build the complete ordered list of library search paths.
    pub fn build_library_paths(&mut self, sysroot: &Sysroot) -> Vec<PathBuf> {
        let mut paths: Vec<PathBuf> = Vec::new();

        // 1. User-specified -L paths
        paths.extend(self.extra_libraries.clone());

        // 2. Multiarch library paths (Debian/Ubuntu style)
        let multiarch_paths = self.multiarch.library_paths(sysroot);
        paths.extend(multiarch_paths);

        // 3. Resource directory library paths
        paths.push(self.resource_dir.lib_dir());

        // 4. Sysroot standard library paths
        let usr_lib = sysroot.usr_lib();
        if usr_lib.exists() {
            paths.push(usr_lib);
        }

        let usr_local_lib = sysroot.path.join("usr").join("local").join("lib");
        if usr_local_lib.exists() {
            paths.push(usr_local_lib);
        }

        // 5. GCC library paths
        if let Some(ref gcc) = self.gcc_install {
            let gcc_lib = gcc.install_dir.clone();
            if gcc_lib.exists() {
                paths.push(gcc_lib);
            }
        }

        // 6. Cross-library paths
        let cross_libs = self.cross_library.library_paths(sysroot);
        paths.extend(cross_libs);

        // 7. Environment variable library paths
        if let Some(val) = self.env_vars.get("LIBRARY_PATH") {
            for part in val.split(':') {
                let p = PathBuf::from(part);
                if p.is_dir() {
                    paths.push(p);
                }
            }
        }

        paths
    }

    /// Detect GCC installation for this target.
    pub fn detect_gcc(&mut self) {
        self.gcc_install = Some(GccInstallation::detect(&self.triple));
    }

    /// Get the full set of compiler flags implied by this sysroot configuration.
    pub fn compiler_flags(&self) -> Vec<String> {
        let mut flags = Vec::new();

        // Sysroot flag
        if let Some(ref sysroot) = self.explicit_sysroot {
            flags.push(format!("--sysroot={}", sysroot.display()));
        }

        // Target triple
        flags.push(format!("-target {}", self.target_triple));

        // Compiler runtime selection
        if self.use_compiler_rt {
            flags.push("--rtlib=compiler-rt".to_string());
        }

        // C++ standard library selection
        if self.use_libcxx {
            flags.push("--stdlib=libc++".to_string());
        }

        // Resource directory
        flags.push(format!(
            "-resource-dir {}",
            self.resource_dir.path().display()
        ));

        // Include paths
        for inc in &self.extra_includes {
            flags.push(format!("-I{}", inc.display()));
        }

        // Library paths
        for lib in &self.extra_libraries {
            flags.push(format!("-L{}", lib.display()));
        }

        flags
    }

    /// Get the linker flags implied by this sysroot configuration.
    pub fn linker_flags(&self) -> Vec<String> {
        let mut flags = Vec::new();

        if self.use_compiler_rt {
            flags.push("--rtlib=compiler-rt".to_string());
            let builtins = self.compiler_rt.builtins_library_path();
            if let Some(ref path) = builtins {
                flags.push(path.to_string_lossy().to_string());
            }
        }

        if self.use_libcxx {
            flags.push("-lc++".to_string());
            flags.push("-lc++abi".to_string());
        }

        // Dynamic linker
        if let Some(linker) = self.dynamic_linker() {
            flags.push(format!("-dynamic-linker {}", linker));
        }

        flags
    }

    /// Get the dynamic linker path for this target.
    pub fn dynamic_linker(&self) -> Option<String> {
        self.multiarch.dynamic_linker(&self.triple)
    }

    /// Set the sysroot from a --sysroot= argument string.
    pub fn set_sysroot_arg(&mut self, arg: &str) {
        // Parse --sysroot=/path or --sysroot /path
        let path_str = if let Some(stripped) = arg.strip_prefix("--sysroot=") {
            stripped
        } else if arg == "--sysroot" {
            return; // Need next argument, handled externally
        } else {
            arg
        };
        let path = PathBuf::from(path_str);
        if path.exists() {
            self.explicit_sysroot = Some(path.clone());
            self.detector.forced_sysroot = Some(path);
        }
    }

    /// Determine whether this is a native (non-cross) compilation.
    pub fn is_native(&self) -> bool {
        !self.is_cross && self.cross_compilation.is_host_triple()
    }

    /// Check if the current host can execute binaries for this target.
    pub fn can_execute(&self) -> bool {
        self.cross_compilation.can_execute_natively()
    }

    /// Get the emulation command for this target (if needed).
    pub fn emulator(&self) -> Option<String> {
        self.cross_compilation.emulator_command()
    }

    /// Add a user include path (-I).
    pub fn add_include(&mut self, path: PathBuf) {
        if !self.extra_includes.contains(&path) {
            self.extra_includes.push(path);
        }
    }

    /// Add a user library path (-L).
    pub fn add_library(&mut self, path: PathBuf) {
        if !self.extra_libraries.contains(&path) {
            self.extra_libraries.push(path);
        }
    }

    /// Get the target-specific architecture directory name for multiarch.
    pub fn arch_directory_name(&self) -> String {
        self.multiarch
            .multiarch_dir
            .clone()
            .unwrap_or_else(|| self.target_triple.clone())
    }

    /// Get the recommended C standard library for this target.
    pub fn recommended_libc(&self) -> X86LibC {
        X86CrossLibrary::detect_libc_type(&self.triple)
    }

    /// Check if this target configuration is ready for compilation.
    pub fn is_ready(&self) -> bool {
        // Check that we have a valid sysroot or it's a native build
        if self.is_native() {
            return true;
        }
        // For cross-compilation, we need a sysroot
        self.explicit_sysroot.is_some()
            || self.detector.forced_sysroot.is_some()
            || self
                .gcc_install
                .as_ref()
                .map(|g| g.is_valid)
                .unwrap_or(false)
    }

    /// Get a summary of the current sysroot configuration.
    pub fn summary(&self) -> String {
        let mut s = String::new();
        s.push_str(&format!("Target: {}\n", self.target_triple));
        s.push_str(&format!("Arch: {:?}\n", self.triple.arch));
        s.push_str(&format!("OS: {:?}\n", self.triple.os));
        s.push_str(&format!("Environment: {:?}\n", self.triple.environment));
        s.push_str(&format!("Cross: {}\n", self.is_cross));
        s.push_str(&format!("Native: {}\n", self.is_native()));
        s.push_str(&format!(
            "Sysroot: {}\n",
            self.explicit_sysroot
                .as_ref()
                .map(|p| p.display().to_string())
                .unwrap_or_else(|| "auto-detect".to_string())
        ));
        s.push_str(&format!("Compiler-RT: {}\n", self.use_compiler_rt));
        s.push_str(&format!("libc++: {}\n", self.use_libcxx));
        s.push_str(&format!(
            "Multiarch: {}\n",
            self.multiarch.multiarch_dir.as_deref().unwrap_or("none")
        ));
        s.push_str(&format!(
            "Dynamic linker: {}\n",
            self.dynamic_linker().unwrap_or_else(|| "none".to_string())
        ));
        s
    }

    /// Detect available C++ standard libraries on the system.
    pub fn detect_cxx_libraries(&self) -> Vec<(String, PathBuf)> {
        let mut libs = Vec::new();

        // libstdc++
        if let Some(ref gcc) = self.gcc_install {
            if gcc.is_valid {
                let libstd = gcc.install_dir.join("libstdc++.so");
                if libstd.exists() {
                    libs.push(("libstdc++".to_string(), libstd));
                }
                let libstd_a = gcc.install_dir.join("libstdc++.a");
                if libstd_a.exists() {
                    libs.push(("libstdc++ (static)".to_string(), libstd_a));
                }
            }
        }

        // libc++
        for lib_dir in &[
            PathBuf::from("/usr/lib"),
            PathBuf::from("/usr/local/lib"),
            PathBuf::from("/usr/lib/x86_64-linux-gnu"),
        ] {
            let libcxx = lib_dir.join("libc++.so");
            if libcxx.exists() {
                libs.push(("libc++".to_string(), libcxx));
                break;
            }
            let libcxx_a = lib_dir.join("libc++.a");
            if libcxx_a.exists() {
                libs.push(("libc++ (static)".to_string(), libcxx_a));
                break;
            }
        }

        libs
    }

    /// Configure for LTO (Link-Time Optimization).
    pub fn configure_lto(&self) -> Vec<String> {
        let mut flags = Vec::new();
        flags.push("-flto=thin".to_string());
        flags.push("-flto-jobs=auto".to_string());
        if self.use_compiler_rt {
            flags.push("-fuse-ld=lld".to_string());
        }
        flags
    }

    /// Configure for sanitizer instrumentation.
    pub fn configure_sanitizers(&self, sanitizers: &[&str]) -> Vec<String> {
        let mut flags = Vec::new();
        if sanitizers.is_empty() {
            return flags;
        }
        let sanitize_list = sanitizers.join(",");
        flags.push(format!("-fsanitize={}", sanitize_list));
        flags.push("-fno-omit-frame-pointer".to_string());
        flags.push("-g".to_string());
        flags
    }

    /// Configure for code coverage instrumentation.
    pub fn configure_coverage(&self) -> Vec<String> {
        vec![
            "-fprofile-instr-generate".to_string(),
            "-fcoverage-mapping".to_string(),
        ]
    }

    /// Configure for PGO (Profile-Guided Optimization).
    pub fn configure_pgo(&self, profile_dir: &str) -> Vec<String> {
        vec![
            format!("-fprofile-instr-use={}", profile_dir),
            "-fprofile-sample-use".to_string(),
        ]
    }

    /// Configure for BOLT optimization.
    pub fn configure_bolt(&self, profile_file: &str) -> Vec<String> {
        vec![
            format!("-fbolt-use={}", profile_file),
            "-fbolt-target=x86-64".to_string(),
        ]
    }
}

/// Thread-safe sysroot cache for repeated lookups.
#[derive(Debug, Clone)]
pub struct X86SysrootCache {
    /// Cached sysroot results by target triple.
    cache: HashMap<String, Sysroot>,
    /// Cached GCC installations by target triple.
    gcc_cache: HashMap<String, GccInstallation>,
    /// Cached cross-library configurations.
    libc_cache: HashMap<String, X86CrossLibrary>,
    /// Maximum cache size.
    max_entries: usize,
}

impl X86SysrootCache {
    /// Create a new sysroot cache.
    pub fn new() -> Self {
        Self {
            cache: HashMap::new(),
            gcc_cache: HashMap::new(),
            libc_cache: HashMap::new(),
            max_entries: 64,
        }
    }

    /// Get or detect a sysroot for a target triple.
    pub fn get_sysroot(&mut self, triple: &str) -> Sysroot {
        if let Some(cached) = self.cache.get(triple) {
            return cached.clone();
        }

        let detector = X86SysrootDetector::new(triple);
        let sysroot = detector.detect();

        if self.cache.len() >= self.max_entries {
            // Evict oldest entry
            if let Some(key) = self.cache.keys().next().cloned() {
                self.cache.remove(&key);
            }
        }

        self.cache.insert(triple.to_string(), sysroot.clone());
        sysroot
    }

    /// Get or detect a GCC installation for a target triple.
    pub fn get_gcc(&mut self, triple: &Triple) -> GccInstallation {
        let key = triple.to_string();
        if let Some(cached) = self.gcc_cache.get(&key) {
            return cached.clone();
        }

        let gcc = GccInstallation::detect(triple);
        self.gcc_cache.insert(key, gcc.clone());
        gcc
    }

    /// Get or detect a cross-library configuration.
    pub fn get_libc(&mut self, triple: &Triple) -> X86CrossLibrary {
        let key = triple.to_string();
        if let Some(cached) = self.libc_cache.get(&key) {
            return cached.clone();
        }

        let libc = X86CrossLibrary::new(triple);
        self.libc_cache.insert(key, libc.clone());
        libc
    }

    /// Clear all cached entries.
    pub fn clear(&mut self) {
        self.cache.clear();
        self.gcc_cache.clear();
        self.libc_cache.clear();
    }

    /// Get the number of cached entries.
    pub fn len(&self) -> usize {
        self.cache.len() + self.gcc_cache.len() + self.libc_cache.len()
    }

    /// Check if the cache is empty.
    pub fn is_empty(&self) -> bool {
        self.len() == 0
    }
}

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

impl Default for X86SysrootManager {
    fn default() -> Self {
        Self::new("x86_64-unknown-linux-gnu")
    }
}

// ═══════════════════════════════════════════════════════════════════════════════
// 2. X86 Sysroot Detector — Automatic Sysroot Detection
// ═══════════════════════════════════════════════════════════════════════════════

/// Automatic sysroot detection for X86 targets.
///
/// Detects sysroots for:
/// - Linux: /, /usr, custom paths, GCC cross-installations
/// - Android NDK: platforms/android-*, sysroot/usr
/// - macOS SDK: Xcode.app SDK directories
/// - iOS, tvOS, watchOS SDKs
/// - Windows SDK: Windows Kits\10
/// - MinGW sysroot
/// - Custom --sysroot= specification
#[derive(Debug, Clone)]
pub struct X86SysrootDetector {
    /// The target triple for sysroot detection.
    pub target_triple: String,
    /// Parsed triple.
    pub triple: Triple,
    /// Forced sysroot path (overrides auto-detection).
    pub forced_sysroot: Option<PathBuf>,
    /// Whether to search for Xcode SDK on macOS.
    pub search_xcode: bool,
    /// Whether to search for Android NDK.
    pub search_android_ndk: bool,
    /// Whether to search for Windows SDK.
    pub search_windows_sdk: bool,
    /// Whether to search for MinGW sysroot.
    pub search_mingw: bool,
    /// Custom search paths for sysroots.
    pub custom_search_paths: Vec<PathBuf>,
    /// Whether strict checking (require sysroot to exist) is enabled.
    pub strict: bool,
    /// Whether to use environment variables for detection.
    pub use_env: bool,
}

impl X86SysrootDetector {
    /// Create a new sysroot detector for the given target triple.
    pub fn new(triple_str: &str) -> Self {
        let triple = Triple::parse(triple_str);
        let search_xcode = triple.is_macho()
            || triple.os == OS::IOS
            || triple.os == OS::TvOS
            || triple.os == OS::WatchOS
            || cfg!(target_os = "macos");
        let search_android_ndk = triple.environment == Environment::Android
            || triple.environment == Environment::Androideabi;
        let search_windows_sdk = triple.os == OS::Win32 || triple.environment == Environment::MSVC;
        let search_mingw = triple_str.contains("mingw") || triple_str.contains("windows-gnu");

        Self {
            target_triple: triple_str.to_string(),
            triple,
            forced_sysroot: None,
            search_xcode,
            search_android_ndk,
            search_windows_sdk,
            search_mingw,
            custom_search_paths: Vec::new(),
            strict: false,
            use_env: true,
        }
    }

    /// Detect the appropriate sysroot, returning a Sysroot object.
    pub fn detect(&self) -> Sysroot {
        // 1. Explicit sysroot overrides everything
        if let Some(ref forced) = self.forced_sysroot {
            if forced.exists() {
                return Sysroot::explicit(forced.clone());
            }
        }

        // 2. Check SYSROOT environment variable
        if self.use_env {
            if let Ok(sysroot_env) = env::var("SYSROOT") {
                let p = PathBuf::from(&sysroot_env);
                if p.exists() {
                    return Sysroot::cross(p);
                }
            }
            if let Ok(sdkroot) = env::var("SDKROOT") {
                let p = PathBuf::from(&sdkroot);
                if p.exists() {
                    return Sysroot::cross(p);
                }
            }
        }

        // 3. Custom search paths
        for custom in &self.custom_search_paths {
            if custom.exists() {
                return Sysroot::cross(custom.clone());
            }
        }

        // 4. Platform-specific detection
        if self.search_android_ndk {
            if let Some(ndk) = self.detect_android_ndk_sysroot() {
                return Sysroot::cross(ndk);
            }
        }

        if self.search_xcode {
            // Try macOS SDK first
            if let Some(sdk) = self.detect_macos_sdk() {
                return Sysroot::cross(sdk);
            }
            // Try iOS SDK
            if let Some(sdk) = self.detect_ios_sdk() {
                return Sysroot::cross(sdk);
            }
            // Try tvOS SDK
            if let Some(sdk) = self.detect_tvos_sdk() {
                return Sysroot::cross(sdk);
            }
            // Try watchOS SDK
            if let Some(sdk) = self.detect_watchos_sdk() {
                return Sysroot::cross(sdk);
            }
        }

        if self.search_windows_sdk {
            if let Some(sdk) = self.detect_windows_sdk() {
                return Sysroot::cross(sdk);
            }
        }

        if self.search_mingw {
            if let Some(mingw) = self.detect_mingw_sysroot() {
                return Sysroot::cross(mingw);
            }
        }

        // 5. GCC cross-installation detection
        if let Some(cross) = self.detect_gcc_cross_sysroot() {
            return Sysroot::cross(cross);
        }

        // 6. Host sysroot for native compilation (Linux)
        if self.is_host_triple() {
            return Sysroot::host();
        }

        // 7. General Linux sysroot with /usr
        if self.triple.os == OS::Linux {
            let usr = PathBuf::from("/usr");
            if usr.exists() {
                return Sysroot::cross(PathBuf::from("/"));
            }
        }

        // Fallback: empty (will be flagged as error by callers)
        Sysroot {
            path: PathBuf::new(),
            is_explicit: false,
            is_cross: true,
        }
    }

    /// Detect Android NDK sysroot.
    ///
    /// Searches for the Android NDK in common locations and identifies
    /// the appropriate platform sysroot for the target API level.
    pub fn detect_android_ndk_sysroot(&self) -> Option<PathBuf> {
        let ndk_homes = self.find_android_ndk_homes();

        for ndk_home in &ndk_homes {
            // NDK r23+ layout: toolchains/llvm/prebuilt/<host>/sysroot
            let sysroot_r23 = ndk_home
                .join("toolchains")
                .join("llvm")
                .join("prebuilt")
                .join(self.host_platform_tag())
                .join("sysroot");
            if sysroot_r23.exists() {
                return Some(sysroot_r23);
            }

            // Pre-r23 layout: sysroot/ or platforms/android-*/arch-*
            let sysroot_legacy = ndk_home.join("sysroot");
            if sysroot_legacy.exists() {
                // Check if usr/include exists within it
                let usr_include = sysroot_legacy.join("usr").join("include");
                if usr_include.exists() {
                    return Some(sysroot_legacy);
                }
            }

            // Platform-specific sysroot
            let android_arch = self.android_arch_name();
            let platforms_dir = ndk_home.join("platforms");
            if platforms_dir.exists() {
                // Find the highest API level platform
                if let Some(platform) = self.find_highest_android_platform(&platforms_dir) {
                    let arch_sysroot = platform.join(format!("arch-{}", android_arch));
                    if arch_sysroot.exists() {
                        return Some(arch_sysroot);
                    }
                }
            }
        }

        None
    }

    /// Find Android NDK home directories from environment and common paths.
    fn find_android_ndk_homes(&self) -> Vec<PathBuf> {
        let mut homes = Vec::new();

        // Environment variables
        for var in &["ANDROID_NDK_HOME", "ANDROID_NDK_ROOT", "NDK_HOME"] {
            if let Ok(val) = env::var(var) {
                let p = PathBuf::from(val);
                if p.exists() {
                    homes.push(p);
                }
            }
        }

        // Common paths
        let common_paths = [
            "/usr/local/android-ndk",
            "/opt/android-ndk",
            "/opt/android-sdk/ndk",
            "/opt/android-sdk/ndk-bundle",
            "/usr/lib/android-sdk/ndk",
            "/usr/lib/android-sdk/ndk-bundle",
            &format!("{}/Android/Sdk/ndk", env::var("HOME").unwrap_or_default()),
            &format!(
                "{}/Android/Sdk/ndk-bundle",
                env::var("HOME").unwrap_or_default()
            ),
        ];

        for path_str in &common_paths {
            let p = PathBuf::from(path_str);
            if p.exists() && !homes.contains(&p) {
                homes.push(p);
            }
        }

        // Look for numbered NDK versions
        for path_str in &common_paths {
            let base = PathBuf::from(path_str);
            let parent = base.parent().map(|p| p.to_path_buf());
            if let Some(parent) = parent {
                if let Ok(entries) = fs::read_dir(&parent) {
                    for entry in entries.flatten() {
                        let name = entry.file_name().to_string_lossy().to_string();
                        if name.starts_with("ndk") || name.starts_with("android-ndk") {
                            let p = entry.path();
                            if p.is_dir() && !homes.contains(&p) {
                                homes.push(p);
                            }
                        }
                    }
                }
            }
        }

        homes
    }

    /// Get the Android architecture name for the target.
    fn android_arch_name(&self) -> &'static str {
        match self.triple.arch {
            Arch::X86 => "x86",
            Arch::X86_64 => "x86_64",
            Arch::ARM => "arm",
            Arch::AArch64 => "arm64",
            Arch::Mips => "mips",
            Arch::Mips64 => "mips64",
            _ => "x86",
        }
    }

    /// Find the highest API level platform in the Android platforms directory.
    fn find_highest_android_platform(&self, platforms_dir: &Path) -> Option<PathBuf> {
        let mut platforms: Vec<(u32, PathBuf)> = Vec::new();

        if let Ok(entries) = fs::read_dir(platforms_dir) {
            for entry in entries.flatten() {
                let name = entry.file_name().to_string_lossy().to_string();
                // Platform directories are named "android-21", "android-33", etc.
                if let Some(level_str) = name.strip_prefix("android-") {
                    if let Ok(level) = level_str.parse::<u32>() {
                        platforms.push((level, entry.path()));
                    }
                }
            }
        }

        platforms.sort_by_key(|(level, _)| *level);
        platforms.last().map(|(_, path)| path.clone())
    }

    /// Get the host platform tag for NDK toolchain paths.
    fn host_platform_tag(&self) -> &'static str {
        if cfg!(target_os = "linux") {
            "linux-x86_64"
        } else if cfg!(target_os = "macos") {
            "darwin-x86_64"
        } else if cfg!(target_os = "windows") {
            "windows-x86_64"
        } else {
            "linux-x86_64"
        }
    }

    /// Get Android NDK include paths.
    pub fn android_ndk_include_paths(&self) -> Vec<PathBuf> {
        let mut paths = Vec::new();

        if let Some(sysroot) = self.detect_android_ndk_sysroot() {
            // Standard include paths within NDK sysroot
            let usr_include = sysroot.join("usr").join("include");
            if usr_include.exists() {
                paths.push(usr_include.clone());

                // Architecture-specific includes
                let arch_include = usr_include.join(self.android_arch_name());
                if arch_include.exists() {
                    paths.push(arch_include);
                }

                // Platform version specific
                let api_level = self.infer_android_api_level();
                let arch_include_api = usr_include
                    .join(self.android_arch_name())
                    .join(format!("android-{}", api_level));
                if arch_include_api.exists() {
                    paths.push(arch_include_api);
                }
            }

            // Standard C++ includes (if present)
            let cxx_include = sysroot.join("usr").join("include").join("c++");
            if cxx_include.exists() {
                if let Ok(entries) = fs::read_dir(&cxx_include) {
                    for entry in entries.flatten() {
                        if entry.path().is_dir() {
                            paths.push(entry.path());
                        }
                    }
                }
            }
        }

        paths
    }

    /// Infer the Android API level from environment or default.
    fn infer_android_api_level(&self) -> u32 {
        // Check ANDROID_PLATFORM or API level env vars
        if let Ok(platform) = env::var("ANDROID_PLATFORM") {
            if let Some(level_str) = platform.strip_prefix("android-") {
                if let Ok(level) = level_str.parse::<u32>() {
                    return level;
                }
            }
        }

        // Default API levels based on architecture
        match self.triple.arch {
            Arch::X86_64 => 21,
            Arch::AArch64 => 21,
            _ => 16, // Minimum for 32-bit
        }
    }

    /// Detect macOS SDK path from Xcode installation.
    pub fn detect_macos_sdk(&self) -> Option<PathBuf> {
        if !(self.triple.is_macos() || self.triple.os == OS::Darwin || self.triple.os == OS::MacOSX)
        {
            return None;
        }

        // Check SDKROOT environment variable
        if let Ok(sdkroot) = env::var("SDKROOT") {
            let p = PathBuf::from(&sdkroot);
            if p.exists() {
                return Some(p);
            }
        }

        // Find Xcode path
        let xcode_path = self.find_xcode_path()?;

        // Standard SDK location
        let sdk_dir = xcode_path
            .join("Contents")
            .join("Developer")
            .join("Platforms")
            .join("MacOSX.platform")
            .join("Developer")
            .join("SDKs");

        // Find the latest MacOSX.sdk
        self.find_latest_sdk(&sdk_dir, "MacOSX")
    }

    /// Detect iOS SDK path.
    pub fn detect_ios_sdk(&self) -> Option<PathBuf> {
        if self.triple.os != OS::IOS && !self.target_triple.contains("ios") {
            return None;
        }

        let xcode_path = self.find_xcode_path()?;
        let sdk_dir = xcode_path
            .join("Contents")
            .join("Developer")
            .join("Platforms")
            .join("iPhoneOS.platform")
            .join("Developer")
            .join("SDKs");

        self.find_latest_sdk(&sdk_dir, "iPhoneOS")
    }

    /// Detect tvOS SDK path.
    pub fn detect_tvos_sdk(&self) -> Option<PathBuf> {
        if self.triple.os != OS::TvOS && !self.target_triple.contains("tvos") {
            return None;
        }

        let xcode_path = self.find_xcode_path()?;
        let sdk_dir = xcode_path
            .join("Contents")
            .join("Developer")
            .join("Platforms")
            .join("AppleTVOS.platform")
            .join("Developer")
            .join("SDKs");

        self.find_latest_sdk(&sdk_dir, "AppleTVOS")
    }

    /// Detect watchOS SDK path.
    pub fn detect_watchos_sdk(&self) -> Option<PathBuf> {
        if self.triple.os != OS::WatchOS && !self.target_triple.contains("watchos") {
            return None;
        }

        let xcode_path = self.find_xcode_path()?;
        let sdk_dir = xcode_path
            .join("Contents")
            .join("Developer")
            .join("Platforms")
            .join("WatchOS.platform")
            .join("Developer")
            .join("SDKs");

        self.find_latest_sdk(&sdk_dir, "WatchOS")
    }

    /// Find the Xcode installation path.
    fn find_xcode_path(&self) -> Option<PathBuf> {
        // Check DEVELOPER_DIR environment variable
        if let Ok(dev_dir) = env::var("DEVELOPER_DIR") {
            let p = PathBuf::from(&dev_dir);
            if p.exists() {
                // This might be the Developer directory itself or the Xcode.app
                if p.ends_with("Developer") {
                    return p.parent().map(|p| p.to_path_buf());
                }
                return Some(p);
            }
        }

        // Check XCODE_PATH environment variable
        if let Ok(xcode_path) = env::var("XCODE_PATH") {
            let p = PathBuf::from(&xcode_path);
            if p.exists() {
                return Some(p);
            }
        }

        // Default Xcode location
        let default_xcode = PathBuf::from("/Applications/Xcode.app");
        if default_xcode.exists() {
            return Some(default_xcode);
        }

        // Try xcrun to locate Xcode
        if let Ok(output) = ProcessCommand::new("xcrun")
            .args(["--show-sdk-path"])
            .output()
        {
            if output.status.success() {
                let sdk_path = String::from_utf8_lossy(&output.stdout).trim().to_string();
                let sdk = PathBuf::from(&sdk_path);
                // Navigate up from SDK to Xcode.app
                // MacOSX.sdk -> SDKs -> Developer -> MacOSX.platform -> Platforms -> Developer -> Contents -> Xcode.app
                if let Some(xcode) = sdk
                    .parent() // SDKs
                    .and_then(|p| p.parent()) // Developer
                    .and_then(|p| p.parent()) // MacOSX.platform
                    .and_then(|p| p.parent()) // Platforms
                    .and_then(|p| p.parent()) // Developer
                    .and_then(|p| p.parent()) // Contents
                    .and_then(|p| p.parent())
                {
                    // Xcode.app
                    if xcode.exists() {
                        return Some(xcode.to_path_buf());
                    }
                }
            }
        }

        None
    }

    /// Find the latest SDK in a directory matching a prefix.
    fn find_latest_sdk(&self, sdk_dir: &Path, prefix: &str) -> Option<PathBuf> {
        if !sdk_dir.exists() {
            return None;
        }

        let mut sdks: Vec<(String, PathBuf)> = Vec::new();

        if let Ok(entries) = fs::read_dir(sdk_dir) {
            for entry in entries.flatten() {
                let name = entry.file_name().to_string_lossy().to_string();
                if name.starts_with(prefix) && name.ends_with(".sdk") {
                    sdks.push((name, entry.path()));
                }
            }
        }

        // Sort by version (higher version last)
        sdks.sort_by(|(a, _), (b, _)| {
            let va = Self::parse_sdk_version(a);
            let vb = Self::parse_sdk_version(b);
            va.partial_cmp(&vb).unwrap_or(std::cmp::Ordering::Equal)
        });

        sdks.last().map(|(_, path)| path.clone())
    }

    /// Parse a version string from an SDK name like "MacOSX14.5.sdk".
    fn parse_sdk_version(name: &str) -> Vec<u32> {
        // Extract version numbers from the SDK name
        let mut version = Vec::new();
        let mut current = String::new();

        for ch in name.chars() {
            if ch.is_ascii_digit() {
                current.push(ch);
            } else if !current.is_empty() {
                if let Ok(num) = current.parse::<u32>() {
                    version.push(num);
                }
                current.clear();
            }
        }

        if !current.is_empty() {
            if let Ok(num) = current.parse::<u32>() {
                version.push(num);
            }
        }

        version
    }

    /// Detect Windows SDK sysroot.
    pub fn detect_windows_sdk(&self) -> Option<PathBuf> {
        // Common Windows SDK locations
        let program_files_x86 =
            env::var("ProgramFiles(x86)").unwrap_or_else(|_| "C:\\Program Files (x86)".to_string());

        let sdk_candidates = [
            PathBuf::from(&program_files_x86)
                .join("Windows Kits")
                .join("10"),
            PathBuf::from("C:\\Program Files\\Windows Kits\\10"),
            PathBuf::from("C:\\Program Files (x86)\\Windows Kits\\10"),
        ];

        // Check WINDOWS_SDK_PATH env variable
        if let Ok(sdk_path) = env::var("WINDOWS_SDK_PATH") {
            let p = PathBuf::from(&sdk_path);
            if p.exists() {
                return Some(p);
            }
        }

        for candidate in &sdk_candidates {
            if candidate.exists() {
                // Look for Include directory with version
                let include_dir = candidate.join("Include");
                if include_dir.exists() {
                    if let Some(latest) = self.find_latest_windows_sdk_version(candidate) {
                        return Some(latest);
                    }
                }
                // Also check the base path works
                let um_dir = candidate.join("Include").join("um");
                if um_dir.exists() {
                    return Some(candidate.clone());
                }
            }
        }

        None
    }

    /// Find the latest Windows SDK version directory.
    fn find_latest_windows_sdk_version(&self, sdk_base: &Path) -> Option<PathBuf> {
        let include_dir = sdk_base.join("Include");
        if !include_dir.exists() {
            return None;
        }

        let mut versions: Vec<(Vec<u32>, PathBuf)> = Vec::new();

        if let Ok(entries) = fs::read_dir(&include_dir) {
            for entry in entries.flatten() {
                let name = entry.file_name().to_string_lossy().to_string();
                // Version directories like "10.0.22621.0"
                let parts: Vec<&str> = name.split('.').collect();
                if parts.len() >= 2 {
                    let nums: Vec<u32> =
                        parts.iter().filter_map(|s| s.parse::<u32>().ok()).collect();
                    if nums.len() >= 2 {
                        versions.push((nums, sdk_base.join("Include").join(&name)));
                    }
                }
            }
        }

        versions.sort_by(|(a, _), (b, _)| a.cmp(b));
        versions.last().map(|(_, path)| path.clone())
    }

    /// Detect MinGW sysroot.
    pub fn detect_mingw_sysroot(&self) -> Option<PathBuf> {
        let candidates = [
            PathBuf::from("/usr/x86_64-w64-mingw32"),
            PathBuf::from("/usr/i686-w64-mingw32"),
            PathBuf::from("/usr/x86_64-w64-mingw32/sys-root/mingw"),
            PathBuf::from("/usr/i686-w64-mingw32/sys-root/mingw"),
            PathBuf::from("/mingw64"),
            PathBuf::from("/mingw32"),
            PathBuf::from("C:\\msys64\\mingw64"),
            PathBuf::from("C:\\msys64\\mingw32"),
            PathBuf::from("C:\\mingw-w64\\x86_64-8.1.0-posix-seh-rt_v6-rev0\\mingw64"),
            PathBuf::from("C:\\mingw-w64\\i686-8.1.0-posix-dwarf-rt_v6-rev0\\mingw32"),
        ];

        for candidate in &candidates {
            if candidate.exists() {
                // Verify it has include and lib directories
                let include = candidate.join("include");
                let lib = candidate.join("lib");
                if include.exists() && lib.exists() {
                    return Some(candidate.clone());
                }
            }
        }

        // Check if gcc -print-sysroot provides the path
        if let Ok(output) = ProcessCommand::new("x86_64-w64-mingw32-gcc")
            .args(["-print-sysroot"])
            .output()
        {
            if output.status.success() {
                let path = String::from_utf8_lossy(&output.stdout).trim().to_string();
                let p = PathBuf::from(&path);
                if p.exists() {
                    return Some(p);
                }
            }
        }

        None
    }

    /// Detect GCC cross-compilation sysroot.
    pub fn detect_gcc_cross_sysroot(&self) -> Option<PathBuf> {
        // Try to run the cross-compiler's -print-sysroot
        let gcc_names = if self.triple.is_64bit() && self.triple.arch == Arch::X86_64 {
            vec![
                format!("{}-gcc", self.target_triple),
                "x86_64-linux-gnu-gcc".to_string(),
                "x86_64-linux-musl-gcc".to_string(),
                "x86_64-elf-gcc".to_string(),
            ]
        } else {
            vec![
                format!("{}-gcc", self.target_triple),
                "i686-linux-gnu-gcc".to_string(),
                "i386-linux-gnu-gcc".to_string(),
                "i686-elf-gcc".to_string(),
            ]
        };

        for gcc_name in &gcc_names {
            if let Ok(output) = ProcessCommand::new(gcc_name)
                .args(["-print-sysroot"])
                .output()
            {
                if output.status.success() {
                    let path = String::from_utf8_lossy(&output.stdout).trim().to_string();
                    if !path.is_empty() {
                        let p = PathBuf::from(&path);
                        if p.exists() {
                            return Some(p);
                        }
                    }
                }
            }
        }

        // Fallback: check common cross-compilation sysroot paths
        let cross_prefix = format!("/usr/{}", self.target_triple);
        let candidates = [
            PathBuf::from(&cross_prefix),
            PathBuf::from("/usr/cross"),
            PathBuf::from("/opt/cross"),
        ];

        for candidate in &candidates {
            if candidate.exists() {
                let include = candidate.join("include");
                let lib = candidate.join("lib");
                if include.exists() || lib.exists() {
                    return Some(candidate.clone());
                }
            }
        }

        None
    }

    /// Determine whether the target triple matches the host.
    pub fn is_host_triple(&self) -> bool {
        let host_triple = Self::detect_host_triple();
        // Normalize and compare
        let host_parsed = Triple::parse(&host_triple);

        // Architecture match
        if host_parsed.arch != self.triple.arch {
            return false;
        }

        // OS match (with some flexibility)
        match (host_parsed.os, self.triple.os) {
            (OS::Linux, OS::Linux) => true,
            (OS::Darwin, OS::Darwin) | (OS::Darwin, OS::MacOSX) | (OS::MacOSX, OS::Darwin) => true,
            (OS::Win32, OS::Win32) => true,
            (OS::FreeBSD, OS::FreeBSD) => true,
            _ => false,
        }
    }

    /// Detect the host triple.
    pub fn detect_host_triple() -> String {
        // Rust's cfg-based detection
        let arch = if cfg!(target_arch = "x86_64") {
            "x86_64"
        } else if cfg!(target_arch = "x86") {
            "i386"
        } else if cfg!(target_arch = "aarch64") {
            "aarch64"
        } else if cfg!(target_arch = "arm") {
            "arm"
        } else if cfg!(target_arch = "riscv64") {
            "riscv64"
        } else {
            "unknown"
        };

        let vendor = "unknown";

        let (os, env) = if cfg!(target_os = "linux") {
            if cfg!(target_env = "musl") {
                ("linux", "musl")
            } else if cfg!(target_env = "gnu") {
                ("linux", "gnu")
            } else {
                ("linux", "gnu")
            }
        } else if cfg!(target_os = "macos") {
            ("darwin", "unknown")
        } else if cfg!(target_os = "windows") {
            if cfg!(target_env = "msvc") {
                ("windows", "msvc")
            } else {
                ("windows", "gnu")
            }
        } else if cfg!(target_os = "freebsd") {
            ("freebsd", "unknown")
        } else {
            ("unknown", "unknown")
        };

        format!("{}-{}-{}-{}", arch, vendor, os, env)
    }

    /// List all detected sysroots for informational purposes.
    pub fn list_sysroots(&self) -> Vec<(String, PathBuf)> {
        let mut results = Vec::new();

        // Host sysroot
        results.push(("Host (native)".to_string(), PathBuf::from("/")));

        // Linux /usr
        let usr = PathBuf::from("/usr");
        if usr.exists() {
            results.push(("Linux /usr".to_string(), usr));
        }

        // Android NDK
        if let Some(ndk) = self.detect_android_ndk_sysroot() {
            results.push(("Android NDK".to_string(), ndk));
        }

        // macOS SDK
        if let Some(sdk) = self.detect_macos_sdk() {
            results.push(("macOS SDK".to_string(), sdk));
        }

        // iOS SDK
        if let Some(sdk) = self.detect_ios_sdk() {
            results.push(("iOS SDK".to_string(), sdk));
        }

        // Windows SDK
        if let Some(sdk) = self.detect_windows_sdk() {
            results.push(("Windows SDK".to_string(), sdk));
        }

        // MinGW
        if let Some(mingw) = self.detect_mingw_sysroot() {
            results.push(("MinGW".to_string(), mingw));
        }

        // Cross GCC sysroots
        if let Some(cross) = self.detect_gcc_cross_sysroot() {
            results.push(("GCC Cross".to_string(), cross));
        }

        results
    }
}

impl Default for X86SysrootDetector {
    fn default() -> Self {
        Self::new("x86_64-unknown-linux-gnu")
    }
}

// ═══════════════════════════════════════════════════════════════════════════════
// 3. X86 Cross-Compilation — Cross-Compilation Support
// ═══════════════════════════════════════════════════════════════════════════════

/// Cross-compilation configuration for X86 targets.
///
/// Handles:
/// - Host → Target triple mapping
/// - Cross-compilation toolchain detection
/// - Canadian cross support (build on A, host on B, target on C)
/// - Emulation support (QEMU user mode, Wine, Rosetta 2)
/// - Cross-compilation pkg-config wrapper
#[derive(Debug, Clone)]
pub struct X86CrossCompilation {
    /// The target triple being compiled for.
    pub target_triple: String,
    /// Parsed target triple.
    pub triple: Triple,
    /// The host triple (machine that will run the compiler).
    pub host_triple: String,
    /// The build triple (machine doing the compilation).
    pub build_triple: String,
    /// Whether this is a cross-compilation.
    pub is_cross: bool,
    /// Whether this is a Canadian cross.
    pub is_canadian_cross: bool,
    /// Detected cross-compilation toolchain prefix.
    pub toolchain_prefix: Option<String>,
    /// Path to the cross-compilation toolchain binaries.
    pub toolchain_bin_dir: Option<PathBuf>,
    /// Emulator command for running target binaries.
    pub emulator: Option<String>,
    /// Emulator arguments.
    pub emulator_args: Vec<String>,
    /// Cross-compilation pkg-config wrapper path.
    pub pkg_config_wrapper: Option<PathBuf>,
    /// Sysroot for cross-compilation.
    pub sysroot: Option<PathBuf>,
    /// Cross-compilation environment variables.
    pub cross_env: HashMap<String, String>,
}

impl X86CrossCompilation {
    /// Create a new cross-compilation configuration.
    pub fn new(triple_str: &str) -> Self {
        let triple = Triple::parse(triple_str);
        let host_triple = X86SysrootDetector::detect_host_triple();
        let build_triple = host_triple.clone();

        let is_cross = !Self::is_same_architecture(&triple, &Triple::parse(&host_triple));

        // Detect toolchain prefix for cross-compilation
        let toolchain_prefix = if is_cross {
            Self::detect_toolchain_prefix(triple_str)
        } else {
            None
        };

        // Detect emulator
        let (emulator, emulator_args) = Self::detect_emulator(&triple);

        // Detect pkg-config wrapper
        let pkg_config_wrapper = if is_cross {
            Self::detect_pkg_config_wrapper(triple_str)
        } else {
            None
        };

        let mut cross_env = HashMap::new();
        if is_cross {
            if let Ok(val) = env::var("CROSS_COMPILE") {
                cross_env.insert("CROSS_COMPILE".to_string(), val);
            }
            if let Ok(val) = env::var("PKG_CONFIG_SYSROOT_DIR") {
                cross_env.insert("PKG_CONFIG_SYSROOT_DIR".to_string(), val);
            }
            if let Ok(val) = env::var("PKG_CONFIG_PATH") {
                cross_env.insert("PKG_CONFIG_PATH".to_string(), val);
            }
        }

        Self {
            target_triple: triple_str.to_string(),
            triple,
            host_triple,
            build_triple,
            is_cross,
            is_canadian_cross: false,
            toolchain_prefix,
            toolchain_bin_dir: None,
            emulator,
            emulator_args,
            pkg_config_wrapper,
            sysroot: None,
            cross_env,
        }
    }

    /// Check if a cross-compilation triplet involves the same architecture.
    fn is_same_architecture(target: &Triple, host: &Triple) -> bool {
        if target.arch == host.arch && target.os == host.os {
            return true;
        }

        // 32-bit on 64-bit host is still native-ish
        if target.arch == Arch::X86 && host.arch == Arch::X86_64 {
            return target.os == host.os;
        }

        false
    }

    /// Detect the cross-compilation toolchain prefix.
    pub fn detect_toolchain_prefix(triple_str: &str) -> Option<String> {
        // Common cross-compilation prefixes
        let candidates = vec![
            format!("{}-", triple_str),
            triple_str.replace("unknown-", "").to_string() + "-",
        ];

        for prefix in &candidates {
            let gcc_name = format!("{}gcc", prefix);
            if which::which(&gcc_name).is_ok() {
                return Some(prefix.clone());
            }
            // Also check for clang
            let clang_name = format!("{}clang", prefix);
            if which::which(&clang_name).is_ok() {
                return Some(prefix.clone());
            }
        }

        None
    }

    /// Detect emulator for running target binaries.
    pub fn detect_emulator(triple: &Triple) -> (Option<String>, Vec<String>) {
        match triple.arch {
            Arch::X86 => {
                // i386 emulation on x86_64 host
                if cfg!(target_arch = "x86_64") {
                    // Native 32-bit execution on 64-bit Linux
                    if cfg!(target_os = "linux") && triple.os == OS::Linux {
                        return (None, Vec::new()); // Can run natively via multiarch
                    }
                }
                // QEMU user mode
                if which::which("qemu-i386").is_ok() {
                    return (Some("qemu-i386".to_string()), vec!["-L".to_string()]);
                }
                (None, Vec::new())
            }
            Arch::X86_64 => {
                // Wine for Windows targets
                if triple.os == OS::Win32 {
                    if which::which("wine64").is_ok() {
                        return (Some("wine64".to_string()), Vec::new());
                    }
                    if which::which("wine").is_ok() {
                        return (Some("wine".to_string()), Vec::new());
                    }
                }
                // QEMU user mode for Linux targets on non-x86_64 host
                if !cfg!(target_arch = "x86_64") && triple.os == OS::Linux {
                    if which::which("qemu-x86_64").is_ok() {
                        return (
                            Some("qemu-x86_64".to_string()),
                            vec!["-L".to_string(), "/usr/x86_64-linux-gnu".to_string()],
                        );
                    }
                }
                (None, Vec::new())
            }
            _ => {
                // Generic QEMU detection for other architectures
                let arch_name = triple.arch.as_str();
                let qemu_name = format!("qemu-{}", arch_name);
                if which::which(&qemu_name).is_ok() {
                    return (Some(qemu_name), vec!["-L".to_string()]);
                }
                (None, Vec::new())
            }
        }
    }

    /// Detect pkg-config wrapper for cross-compilation.
    pub fn detect_pkg_config_wrapper(triple_str: &str) -> Option<PathBuf> {
        let wrapper_names = vec![
            format!("{}-pkg-config", triple_str),
            format!("{}-pkgconfig", triple_str),
        ];

        for name in &wrapper_names {
            if let Ok(path) = which::which(name) {
                return Some(path);
            }
        }

        None
    }

    /// Get the host→target triple mapping for known transformations.
    pub fn host_to_target_mapping(&self) -> HashMap<String, Vec<String>> {
        let mut map = HashMap::new();

        // Common host → target mappings
        map.insert(
            "x86_64-unknown-linux-gnu".to_string(),
            vec![
                "x86_64-unknown-linux-gnu".to_string(),
                "x86_64-unknown-linux-musl".to_string(),
                "i386-unknown-linux-gnu".to_string(),
                "x86_64-unknown-linux-gnux32".to_string(),
                "x86_64-pc-windows-gnu".to_string(),
                "x86_64-pc-windows-msvc".to_string(),
                "i686-pc-windows-gnu".to_string(),
                "x86_64-apple-darwin".to_string(),
                "x86_64-unknown-freebsd".to_string(),
            ],
        );

        map.insert(
            "x86_64-apple-darwin".to_string(),
            vec![
                "x86_64-apple-darwin".to_string(),
                "x86_64-apple-ios".to_string(),
                "aarch64-apple-darwin".to_string(),
                "aarch64-apple-ios".to_string(),
            ],
        );

        map.insert(
            "x86_64-pc-windows-msvc".to_string(),
            vec![
                "x86_64-pc-windows-msvc".to_string(),
                "i686-pc-windows-msvc".to_string(),
                "aarch64-pc-windows-msvc".to_string(),
                "x86_64-pc-windows-gnu".to_string(),
            ],
        );

        map
    }

    /// Setup Canadian cross configuration (build on A, host on B, target on C).
    pub fn setup_canadian_cross(
        &mut self,
        build: &str,
        host: &str,
        target: &str,
    ) -> Result<(), String> {
        self.build_triple = build.to_string();
        self.host_triple = host.to_string();
        self.target_triple = target.to_string();
        self.triple = Triple::parse(target);
        self.is_cross = true;
        self.is_canadian_cross = true;

        // For Canadian cross, we need a toolchain that runs on 'build',
        // produces code for 'host', and whose compiler itself runs on 'host'
        // producing code for 'target'.

        // Detect the host→target compiler
        let host_target_prefix = format!("{}-{}-", host, target);
        self.toolchain_prefix = Self::detect_toolchain_prefix(&format!("{}-{}", host, target));

        Ok(())
    }

    /// Get the emulator command for running target binaries.
    pub fn emulator_command(&self) -> Option<String> {
        if let Some(ref emu) = self.emulator {
            let mut cmd = emu.clone();
            for arg in &self.emulator_args {
                cmd.push(' ');
                cmd.push_str(arg);
            }
            Some(cmd)
        } else {
            None
        }
    }

    /// Whether target binaries can be executed natively.
    pub fn can_execute_natively(&self) -> bool {
        if self.is_cross {
            return false;
        }

        // Check if host can run this target
        if self.triple.arch == Arch::X86 && cfg!(target_arch = "x86_64") {
            // 64-bit host can run 32-bit with multiarch
            return cfg!(target_os = "linux");
        }

        if self.triple.os == OS::Win32 {
            // Wine for Windows on non-Windows
            return cfg!(target_os = "windows") || self.emulator.is_some();
        }

        !self.is_cross
    }

    /// Check if the host triple matches the current host.
    pub fn is_host_triple(&self) -> bool {
        let current_host = X86SysrootDetector::detect_host_triple();
        self.host_triple == current_host
    }

    /// Get the recommended pkg-config command for cross-compilation.
    pub fn pkg_config_command(&self) -> String {
        if let Some(ref wrapper) = self.pkg_config_wrapper {
            return wrapper.to_string_lossy().to_string();
        }
        if let Some(ref prefix) = self.toolchain_prefix {
            return format!("{}pkg-config", prefix);
        }
        "pkg-config".to_string()
    }

    /// Set environment for cross-compilation pkg-config.
    pub fn pkg_config_env(&self) -> Vec<(String, String)> {
        let mut env_vars = Vec::new();

        if let Some(ref sysroot) = self.sysroot {
            env_vars.push((
                "PKG_CONFIG_SYSROOT_DIR".to_string(),
                sysroot.to_string_lossy().to_string(),
            ));
        }

        // Add cross-compilation library paths to pkg-config search
        if self.is_cross {
            let lib_paths = format!(
                "/usr/lib/{}/pkgconfig:/usr/share/pkgconfig",
                self.target_triple
            );
            env_vars.push(("PKG_CONFIG_LIBDIR".to_string(), lib_paths));
        }

        env_vars
    }

    /// List available cross-compilation toolchains on the system.
    pub fn list_toolchains() -> Vec<String> {
        let mut toolchains = Vec::new();

        // Search PATH for cross-compilation GCC and Clang binaries
        if let Ok(path) = env::var("PATH") {
            for dir in path.split(':') {
                let dir_path = PathBuf::from(dir);
                if let Ok(entries) = fs::read_dir(&dir_path) {
                    for entry in entries.flatten() {
                        let name = entry.file_name().to_string_lossy().to_string();
                        // Look for patterns like "x86_64-linux-gnu-gcc", "arm-linux-gnueabihf-gcc"
                        if (name.ends_with("-gcc") || name.ends_with("-clang"))
                            && name.contains("linux")
                        {
                            // Extract the prefix
                            let prefix = if name.ends_with("-gcc") {
                                name.strip_suffix("gcc").unwrap().to_string()
                            } else {
                                name.strip_suffix("clang").unwrap().to_string()
                            };
                            if !toolchains.contains(&prefix) {
                                toolchains.push(prefix);
                            }
                        }
                    }
                }
            }
        }

        toolchains.sort();
        toolchains.dedup();
        toolchains
    }
}

impl Default for X86CrossCompilation {
    fn default() -> Self {
        Self::new("x86_64-unknown-linux-gnu")
    }
}

// ────────────────────────────────────────────────────────────────────────────────
// X86CrossCompilation — Extended Cross-Compilation Features
// ────────────────────────────────────────────────────────────────────────────────

/// Remote build server configuration for distributed cross-compilation.
#[derive(Debug, Clone)]
pub struct X86RemoteBuildConfig {
    /// Remote build host (SSH target or distcc host).
    pub remote_host: Option<String>,
    /// Remote build user.
    pub remote_user: Option<String>,
    /// Remote sysroot path on the build server.
    pub remote_sysroot: Option<PathBuf>,
    /// Whether to use distcc for distributed compilation.
    pub use_distcc: bool,
    /// Whether to use icecream (icecc) for distributed compilation.
    pub use_icecc: bool,
    /// Number of parallel remote jobs.
    pub remote_jobs: u32,
    /// SSH options for remote execution.
    pub ssh_options: Vec<String>,
}

impl X86RemoteBuildConfig {
    pub fn new() -> Self {
        Self {
            remote_host: None,
            remote_user: None,
            remote_sysroot: None,
            use_distcc: false,
            use_icecc: false,
            remote_jobs: 4,
            ssh_options: Vec::new(),
        }
    }

    /// Configure for distcc-based distributed compilation.
    pub fn with_distcc(mut self, hosts: &[&str]) -> Self {
        self.use_distcc = true;
        // Set DISTCC_HOSTS for the distcc environment
        self.remote_host = Some(hosts.join(" ")).filter(|s| !s.is_empty());
        self
    }

    /// Configure for icecc-based distributed compilation.
    pub fn with_icecc(mut self) -> Self {
        self.use_icecc = true;
        self
    }

    /// Build the wrapper command for remote compilation.
    pub fn compiler_wrapper(&self) -> Option<String> {
        if self.use_distcc {
            Some("distcc".to_string())
        } else if self.use_icecc {
            Some("icecc".to_string())
        } else {
            None
        }
    }
}

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

/// Cross-compilation package manager integration.
#[derive(Debug, Clone)]
pub struct X86CrossPackageManager {
    /// Whether to use apt for cross-dependencies (Debian/Ubuntu).
    pub use_apt_cross: bool,
    /// Whether to use dnf for cross-dependencies (Fedora/RHEL).
    pub use_dnf_cross: bool,
    /// Whether to use pacman for cross-dependencies (Arch).
    pub use_pacman_cross: bool,
    /// Architecture suffix for cross packages.
    pub cross_arch_suffix: String,
}

impl X86CrossPackageManager {
    pub fn new(target_triple: &str) -> Self {
        let triple = Triple::parse(target_triple);
        let cross_arch_suffix = match triple.arch {
            Arch::X86_64 => ":amd64",
            Arch::X86 => ":i386",
            Arch::AArch64 => ":arm64",
            Arch::ARM => {
                if triple.environment == Environment::GNUEABIHF {
                    ":armhf"
                } else {
                    ":armel"
                }
            }
            Arch::RISCV64 => ":riscv64",
            _ => "",
        }
        .to_string();

        let use_apt_cross = which::which("apt-get").is_ok();
        let use_dnf_cross = which::which("dnf").is_ok();
        let use_pacman_cross = which::which("pacman").is_ok();

        Self {
            use_apt_cross,
            use_dnf_cross,
            use_pacman_cross,
            cross_arch_suffix,
        }
    }

    /// Get the command to install cross-compilation dependencies.
    pub fn install_cross_deps_command(&self) -> Option<String> {
        if self.use_apt_cross && !self.cross_arch_suffix.is_empty() {
            Some(format!(
                "dpkg --add-architecture {} && apt-get update && apt-get install -y crossbuild-essential{}",
                self.cross_arch_suffix.trim_start_matches(':'),
                self.cross_arch_suffix
            ))
        } else if self.use_dnf_cross {
            Some("dnf install -y gcc-c++-cross binutils-cross".to_string())
        } else if self.use_pacman_cross {
            Some("pacman -S --noconfirm cross-compiler".to_string())
        } else {
            None
        }
    }
}

/// QEMU user-mode emulation helper.
#[derive(Debug, Clone)]
pub struct X86QemuEmulation {
    /// Whether QEMU user mode is available.
    pub available: bool,
    /// QEMU binary path.
    pub qemu_binary: Option<PathBuf>,
    /// Whether binfmt_misc is configured for QEMU.
    pub binfmt_configured: bool,
    /// QEMU user mode flags.
    pub qemu_flags: Vec<String>,
    /// Architecture-specific QEMU binary name.
    pub qemu_arch_name: String,
}

impl X86QemuEmulation {
    /// Detect QEMU user-mode emulation for the given target architecture.
    pub fn detect(target_arch: Arch) -> Self {
        let qemu_arch_name = match target_arch {
            Arch::X86_64 => "x86_64",
            Arch::X86 => "i386",
            Arch::AArch64 => "aarch64",
            Arch::ARM => "arm",
            Arch::RISCV64 => "riscv64",
            Arch::RISCV32 => "riscv32",
            Arch::Mips => "mips",
            Arch::Mips64 => "mips64",
            Arch::Mipsel => "mipsel",
            Arch::Mips64el => "mips64el",
            Arch::PowerPC => "ppc",
            Arch::PowerPC64 => "ppc64",
            Arch::PowerPC64le => "ppc64le",
            Arch::Sparc => "sparc",
            Arch::Sparcv9 => "sparc64",
            Arch::SystemZ => "s390x",
            _ => target_arch.as_str(),
        }
        .to_string();

        let qemu_name = format!("qemu-{}", qemu_arch_name);
        let qemu_static_name = format!("qemu-{}-static", qemu_arch_name);

        let (available, qemu_binary) = if let Ok(path) = which::which(&qemu_static_name) {
            (true, Some(path))
        } else if let Ok(path) = which::which(&qemu_name) {
            (true, Some(path))
        } else {
            (false, None)
        };

        // Check binfmt_misc configuration
        let binfmt_configured = Path::new("/proc/sys/fs/binfmt_misc/qemu-x86_64").exists()
            || Path::new("/proc/sys/fs/binfmt_misc/qemu-i386").exists();

        let qemu_flags = vec![
            "-L".to_string(),
            format!("/usr/{}", qemu_arch_name),
            "-E".to_string(),
            format!("LD_LIBRARY_PATH=/usr/{}/lib", qemu_arch_name),
        ];

        Self {
            available,
            qemu_binary,
            binfmt_configured,
            qemu_flags,
            qemu_arch_name,
        }
    }

    /// Get the QEMU emulation command for running a target binary.
    pub fn emulation_command(&self, binary: &str) -> Option<String> {
        if let Some(ref qemu) = self.qemu_binary {
            let mut cmd = qemu.to_string_lossy().to_string();
            for flag in &self.qemu_flags {
                cmd.push(' ');
                cmd.push_str(flag);
            }
            cmd.push(' ');
            cmd.push_str(binary);
            Some(cmd)
        } else {
            None
        }
    }

    /// Check if transparent QEMU emulation (via binfmt_misc) is available.
    pub fn can_transparently_emulate(&self) -> bool {
        self.binfmt_configured
    }
}

// ═══════════════════════════════════════════════════════════════════════════════
// 4. X86 Multiarch — Multiarch Library Path Support
// ═══════════════════════════════════════════════════════════════════════════════

/// Multiarch library path resolver for X86 targets.
///
/// Handles:
/// - Debian/Ubuntu multiarch paths
///   - /usr/lib/x86_64-linux-gnu
///   - /usr/lib/i386-linux-gnu
///   - /usr/lib/x86_64-linux-gnux32
/// - RPM multiarch paths
///   - /usr/lib64, /usr/lib
/// - Multiarch library search order
/// - Dynamic linker detection
#[derive(Debug, Clone)]
pub struct X86Multiarch {
    /// The target triple.
    pub triple: Triple,
    /// Multiarch directory name (Debian-style).
    pub multiarch_dir: Option<String>,
    /// RPM-style library directory.
    pub rpm_lib_dir: Option<String>,
    /// Whether to prefer multiarch paths.
    pub prefer_multiarch: bool,
    /// Library search order.
    pub search_order: Vec<PathBuf>,
    /// Dynamic linker path.
    pub dynamic_linker_path: Option<String>,
    /// Whether the system is Debian/Ubuntu based.
    pub is_debian: bool,
    /// Whether the system is RPM based.
    pub is_rpm: bool,
}

impl X86Multiarch {
    /// Create a new multiarch resolver for the given target.
    pub fn new(triple: &Triple) -> Self {
        let multiarch_dir = Self::determine_multiarch_dir(triple);
        let rpm_lib_dir = Self::determine_rpm_lib_dir(triple);
        let is_debian = Self::detect_debian();
        let is_rpm = Self::detect_rpm();
        let dynamic_linker_path = Self::determine_dynamic_linker(triple);

        let mut search_order = Vec::new();
        if is_debian {
            if let Some(ref dir) = multiarch_dir {
                search_order.push(PathBuf::from("/usr/lib").join(dir));
            }
        }
        if is_rpm {
            if let Some(ref dir) = rpm_lib_dir {
                search_order.push(PathBuf::from(dir));
            }
        }
        // Fallback paths
        search_order.push(PathBuf::from("/usr/lib"));
        search_order.push(PathBuf::from("/usr/local/lib"));
        search_order.push(PathBuf::from("/lib"));

        Self {
            triple: triple.clone(),
            multiarch_dir,
            rpm_lib_dir,
            prefer_multiarch: is_debian,
            search_order,
            dynamic_linker_path,
            is_debian,
            is_rpm,
        }
    }

    /// Determine the Debian-style multiarch directory name for a triple.
    pub fn determine_multiarch_dir(triple: &Triple) -> Option<String> {
        match triple.arch {
            Arch::X86_64 => match triple.environment {
                Environment::GNUX32 => Some("x86_64-linux-gnux32".to_string()),
                Environment::GNU | Environment::GNUABI64 => Some("x86_64-linux-gnu".to_string()),
                Environment::Musl => Some("x86_64-linux-musl".to_string()),
                Environment::Android => Some("x86_64-linux-android".to_string()),
                _ => Some("x86_64-linux-gnu".to_string()),
            },
            Arch::X86 => match triple.environment {
                Environment::GNU | Environment::GNUEABI => Some("i386-linux-gnu".to_string()),
                Environment::Musl => Some("i386-linux-musl".to_string()),
                Environment::Android => Some("i686-linux-android".to_string()),
                _ => Some("i386-linux-gnu".to_string()),
            },
            Arch::AArch64 => match triple.environment {
                Environment::GNU => Some("aarch64-linux-gnu".to_string()),
                Environment::Musl => Some("aarch64-linux-musl".to_string()),
                Environment::Android => Some("aarch64-linux-android".to_string()),
                _ => Some("aarch64-linux-gnu".to_string()),
            },
            Arch::ARM => match triple.environment {
                Environment::GNUEABIHF => Some("arm-linux-gnueabihf".to_string()),
                Environment::GNUEABI => Some("arm-linux-gnueabi".to_string()),
                Environment::Musl => Some("arm-linux-musleabihf".to_string()),
                Environment::Android => Some("arm-linux-androideabi".to_string()),
                _ => Some("arm-linux-gnueabihf".to_string()),
            },
            Arch::RISCV64 => Some("riscv64-linux-gnu".to_string()),
            Arch::RISCV32 => Some("riscv32-linux-gnu".to_string()),
            Arch::PowerPC64le => Some("powerpc64le-linux-gnu".to_string()),
            Arch::Sparcv9 => Some("sparc64-linux-gnu".to_string()),
            Arch::SystemZ => Some("s390x-linux-gnu".to_string()),
            _ => None,
        }
    }

    /// Determine RPM-style library directory.
    fn determine_rpm_lib_dir(triple: &Triple) -> Option<String> {
        if triple.arch.is_64bit() {
            Some("/usr/lib64".to_string())
        } else {
            Some("/usr/lib".to_string())
        }
    }

    /// Detect if running on a Debian-based system.
    fn detect_debian() -> bool {
        Path::new("/etc/debian_version").exists()
            || Path::new("/etc/dpkg/origins/debian").exists()
            || Path::new("/usr/share/debconf").exists()
    }

    /// Detect if running on an RPM-based system.
    fn detect_rpm() -> bool {
        Path::new("/etc/redhat-release").exists()
            || Path::new("/etc/fedora-release").exists()
            || Path::new("/etc/centos-release").exists()
            || Path::new("/etc/SuSE-release").exists()
            || Path::new("/etc/os-release").exists() && {
                if let Ok(content) = fs::read_to_string("/etc/os-release") {
                    content.contains("rhel")
                        || content.contains("fedora")
                        || content.contains("centos")
                        || content.contains("suse")
                } else {
                    false
                }
            }
    }

    /// Determine the dynamic linker path for a target.
    pub fn determine_dynamic_linker(triple: &Triple) -> Option<String> {
        match triple.arch {
            Arch::X86_64 => match triple.environment {
                Environment::Musl => Some("/lib/ld-musl-x86_64.so.1".to_string()),
                Environment::Android => Some("/system/bin/linker64".to_string()),
                _ => Some("/lib64/ld-linux-x86-64.so.2".to_string()),
            },
            Arch::X86 => match triple.environment {
                Environment::Musl => Some("/lib/ld-musl-i386.so.1".to_string()),
                Environment::Android => Some("/system/bin/linker".to_string()),
                _ => Some("/lib/ld-linux.so.2".to_string()),
            },
            Arch::AArch64 => match triple.environment {
                Environment::Musl => Some("/lib/ld-musl-aarch64.so.1".to_string()),
                Environment::Android => Some("/system/bin/linker64".to_string()),
                _ => Some("/lib/ld-linux-aarch64.so.1".to_string()),
            },
            Arch::ARM => {
                if triple.environment == Environment::GNUEABIHF {
                    Some("/lib/ld-linux-armhf.so.3".to_string())
                } else {
                    Some("/lib/ld-linux.so.3".to_string())
                }
            }
            Arch::RISCV64 => Some("/lib/ld-linux-riscv64-lp64d.so.1".to_string()),
            Arch::PowerPC64le => Some("/lib64/ld64.so.2".to_string()),
            Arch::SystemZ => Some("/lib/ld64.so.1".to_string()),
            _ => None,
        }
    }

    /// Get the dynamic linker path for a given triple.
    pub fn dynamic_linker(&self, triple: &Triple) -> Option<String> {
        Self::determine_dynamic_linker(triple)
    }

    /// Build library search paths for a given sysroot.
    pub fn library_paths(&self, sysroot: &Sysroot) -> Vec<PathBuf> {
        let mut paths = Vec::new();

        // Multiarch paths first (preferred for Debian)
        if self.prefer_multiarch {
            if let Some(ref dir) = self.multiarch_dir {
                let multiarch_path = sysroot.path.join("usr").join("lib").join(dir);
                if multiarch_path.exists() {
                    paths.push(multiarch_path);
                }

                // Also check the lib directory variants
                let multiarch_lib = sysroot.path.join("lib").join(dir);
                if multiarch_lib.exists() {
                    paths.push(multiarch_lib);
                }
            }
        }

        // RPM-style paths
        if self.is_rpm {
            if let Some(ref dir) = self.rpm_lib_dir {
                let rpm_path = sysroot.path.join(dir.trim_start_matches('/'));
                if rpm_path.exists() {
                    paths.push(rpm_path);
                }
            }
        }

        // Standard system paths
        for lib_dir in &["usr/lib", "usr/local/lib", "lib"] {
            let p = sysroot.path.join(lib_dir);
            // Only add if not already present from multiarch
            if p.exists() && !paths.contains(&p) {
                paths.push(p);
            }
        }

        // GCC-specific library paths
        if let Some(ref dir) = self.multiarch_dir {
            let gcc_lib = sysroot.path.join("usr").join("lib").join("gcc").join(dir);
            if gcc_lib.exists() {
                // Add the version subdirectories
                if let Ok(entries) = fs::read_dir(&gcc_lib) {
                    for entry in entries.flatten() {
                        let p = entry.path();
                        if p.is_dir() {
                            paths.push(p);
                        }
                    }
                }
            }
        }

        paths
    }

    /// Get the multiarch include paths.
    pub fn include_paths(&self, sysroot: &Sysroot) -> Vec<PathBuf> {
        let mut paths = Vec::new();

        if let Some(ref dir) = self.multiarch_dir {
            // Multiarch-specific include directories
            let inc_dir = sysroot.path.join("usr").join("include").join(dir);
            if inc_dir.exists() {
                paths.push(inc_dir);
            }

            // GCC multiarch include
            let gcc_inc = sysroot
                .path
                .join("usr")
                .join("lib")
                .join("gcc")
                .join(dir)
                .join("include");
            if gcc_inc.exists() {
                paths.push(gcc_inc);
            }
        }

        paths
    }

    /// Normalize a library search path for multiarch.
    pub fn normalize_library_path(&self, path: &Path) -> PathBuf {
        // If we're on a Debian system and see /usr/lib, remap to multiarch
        if self.is_debian && self.prefer_multiarch {
            if let Some(ref dir) = self.multiarch_dir {
                let standard_lib = PathBuf::from("/usr/lib");
                if path.starts_with(&standard_lib) {
                    let multiarch_lib = standard_lib.join(dir);
                    if multiarch_lib.exists() {
                        return multiarch_lib;
                    }
                }
            }
        }
        path.to_path_buf()
    }

    /// Check if a path is a multiarch library path.
    pub fn is_multiarch_path(&self, path: &Path) -> bool {
        if let Some(ref dir) = self.multiarch_dir {
            path.to_string_lossy().contains(dir.as_str())
        } else {
            false
        }
    }

    /// Get all known multiarch tuples for the current system.
    pub fn known_multiarch_tuples() -> Vec<String> {
        let mut tuples = Vec::new();

        // Check /usr/lib for multiarch directories
        if let Ok(entries) = fs::read_dir("/usr/lib") {
            for entry in entries.flatten() {
                let name = entry.file_name().to_string_lossy().to_string();
                // Multiarch dirs typically follow the pattern <arch>-<os>-<env>
                if name.contains("-linux-") || name.contains("-gnu") {
                    if entry.path().is_dir() {
                        tuples.push(name);
                    }
                }
            }
        }

        tuples.sort();
        tuples
    }

    /// Get the recommended search order for multiarch paths.
    pub fn search_order_priority(&self) -> Vec<(&'static str, u32)> {
        let mut order = Vec::new();

        // Priority: multiarch > RPM > standard
        if self.is_debian {
            order.push(("multiarch", 1));
            order.push(("rpm", 2));
        } else if self.is_rpm {
            order.push(("rpm", 1));
            order.push(("multiarch", 2));
        }

        order.push(("standard", 3));
        order.push(("local", 4));
        order.push(("gcc", 5));

        order
    }

    /// Detect the specific Linux distribution for fine-tuned multiarch handling.
    pub fn detect_distribution() -> X86LinuxDistro {
        if Path::new("/etc/arch-release").exists() {
            return X86LinuxDistro::Arch;
        }
        if Path::new("/etc/gentoo-release").exists() {
            return X86LinuxDistro::Gentoo;
        }
        if Path::new("/etc/alpine-release").exists() {
            return X86LinuxDistro::Alpine;
        }
        if Path::new("/etc/nixos").exists() || Path::new("/nix/store").exists() {
            return X86LinuxDistro::NixOS;
        }
        if Path::new("/etc/openwrt_release").exists() {
            return X86LinuxDistro::OpenWrt;
        }
        if Path::new("/etc/SuSE-release").exists()
            || (Path::new("/etc/os-release").exists() && {
                if let Ok(content) = fs::read_to_string("/etc/os-release") {
                    content.contains("opensuse") || content.contains("suse")
                } else {
                    false
                }
            })
        {
            return X86LinuxDistro::OpenSUSE;
        }
        if Self::detect_debian() {
            return X86LinuxDistro::Debian;
        }
        if Self::detect_rpm() {
            // Distinguish Fedora from RHEL
            if Path::new("/etc/fedora-release").exists() {
                return X86LinuxDistro::Fedora;
            }
            return X86LinuxDistro::RHEL;
        }
        X86LinuxDistro::Unknown
    }

    /// Get multiarch tuple names for all architectures known to Debian/Ubuntu.
    pub fn all_debian_multiarch_tuples() -> Vec<&'static str> {
        vec![
            "x86_64-linux-gnu",
            "x86_64-linux-gnux32",
            "x86_64-linux-musl",
            "x86_64-linux-android",
            "i386-linux-gnu",
            "i386-linux-musl",
            "i686-linux-android",
            "aarch64-linux-gnu",
            "aarch64-linux-musl",
            "aarch64-linux-android",
            "arm-linux-gnueabi",
            "arm-linux-gnueabihf",
            "arm-linux-musleabi",
            "arm-linux-musleabihf",
            "arm-linux-androideabi",
            "riscv64-linux-gnu",
            "riscv32-linux-gnu",
            "powerpc64le-linux-gnu",
            "powerpc-linux-gnu",
            "sparc64-linux-gnu",
            "s390x-linux-gnu",
            "mips-linux-gnu",
            "mipsel-linux-gnu",
            "mips64-linux-gnuabi64",
            "mips64el-linux-gnuabi64",
        ]
    }

    /// Get the libc-specific suffix for a given triple on a multiarch system.
    pub fn libc_dir_suffix(triple: &Triple) -> &'static str {
        match triple.environment {
            Environment::Musl => "-musl",
            Environment::Android | Environment::Androideabi => "-android",
            _ => "-gnu",
        }
    }
}

/// Linux distribution identification for multiarch tuning.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum X86LinuxDistro {
    Unknown,
    Debian,
    RHEL,
    Fedora,
    OpenSUSE,
    Arch,
    Gentoo,
    Alpine,
    NixOS,
    OpenWrt,
}

impl X86LinuxDistro {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Unknown => "unknown",
            Self::Debian => "debian",
            Self::RHEL => "rhel",
            Self::Fedora => "fedora",
            Self::OpenSUSE => "opensuse",
            Self::Arch => "arch",
            Self::Gentoo => "gentoo",
            Self::Alpine => "alpine",
            Self::NixOS => "nixos",
            Self::OpenWrt => "openwrt",
        }
    }

    /// Whether this distro uses multiarch.
    pub fn uses_multiarch(&self) -> bool {
        matches!(self, Self::Debian)
    }

    /// Whether this distro uses /usr/lib64 for 64-bit.
    pub fn uses_lib64(&self) -> bool {
        matches!(
            self,
            Self::RHEL | Self::Fedora | Self::OpenSUSE | Self::Arch | Self::Gentoo
        )
    }
}

/// Ubuntu variant for fine-tuned multiarch (Debian-derivative).
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum UbuntuVariant {
    Vanilla,
    Kubuntu,
    Xubuntu,
    Lubuntu,
    UbuntuServer,
    UbuntuCore,
    LinuxMint,
    PopOS,
    Elementary,
}

impl X86LinuxDistro {
    /// Detect Ubuntu variant from /etc/os-release.
    pub fn detect_ubuntu_variant() -> Option<UbuntuVariant> {
        if let Ok(content) = fs::read_to_string("/etc/os-release") {
            let lower = content.to_lowercase();
            if lower.contains("kubuntu") {
                return Some(UbuntuVariant::Kubuntu);
            }
            if lower.contains("xubuntu") {
                return Some(UbuntuVariant::Xubuntu);
            }
            if lower.contains("lubuntu") {
                return Some(UbuntuVariant::Lubuntu);
            }
            if lower.contains("ubuntu-core") || lower.contains("ubuntu core") {
                return Some(UbuntuVariant::UbuntuCore);
            }
            if lower.contains("linux mint") || lower.contains("linuxmint") {
                return Some(UbuntuVariant::LinuxMint);
            }
            if lower.contains("pop") && lower.contains("os") {
                return Some(UbuntuVariant::PopOS);
            }
            if lower.contains("elementary") {
                return Some(UbuntuVariant::Elementary);
            }
            if lower.contains("ubuntu") {
                if lower.contains("server") {
                    return Some(UbuntuVariant::UbuntuServer);
                }
                return Some(UbuntuVariant::Vanilla);
            }
        }
        None
    }
}

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

// ═══════════════════════════════════════════════════════════════════════════════
// 5. X86 Triple Parser — Target Triple Parsing for X86
// ═══════════════════════════════════════════════════════════════════════════════

/// Extended target triple parser with X86-specific architecture names,
/// vendor detection, OS parsing, environment parsing, and object format inference.
#[derive(Debug, Clone)]
pub struct X86TripleParser {
    /// The original triple string.
    pub original: String,
    /// Parsed triple components.
    pub triple: Triple,
    /// Detailed architecture information.
    pub arch_info: X86ArchInfo,
    /// Detailed OS information.
    pub os_info: X86OsInfo,
    /// Inferred object format.
    pub object_format: X86ObjectFormat,
    /// Whether the triple is valid.
    pub is_valid: bool,
    /// Normalized triple string.
    pub normalized: String,
    /// Parse warnings.
    pub warnings: Vec<String>,
}

/// Detailed X86 architecture information.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct X86ArchInfo {
    /// Canonical architecture name.
    pub name: String,
    /// Architecture family (x86, x86_64).
    pub family: X86ArchFamily,
    /// Bit width (32 or 64).
    pub bit_width: u32,
    /// Whether this is an extended variant.
    pub is_extended: bool,
    /// CPU sub-arch (e.g., pentium4, athlon, core2).
    pub cpu_sub_arch: Option<String>,
    /// Whether SSE2 is guaranteed.
    pub has_sse2: bool,
    /// Default CPU for this architecture.
    pub default_cpu: &'static str,
    /// Default FPU.
    pub default_fpu: &'static str,
}

/// X86 architecture family.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum X86ArchFamily {
    /// 16-bit real mode
    X86_16,
    /// 32-bit protected mode (i386+)
    X86_32,
    /// 64-bit long mode (x86_64)
    X86_64,
    /// X32 ABI (64-bit registers, 32-bit pointers)
    X32,
}

/// Detailed OS information.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct X86OsInfo {
    /// Canonical OS name.
    pub name: String,
    /// Object format on this OS.
    pub default_object_format: X86ObjectFormat,
    /// Default C library on this OS.
    pub default_libc: X86LibC,
    /// Whether this OS supports multiarch.
    pub supports_multiarch: bool,
    /// System include directory pattern.
    pub include_pattern: String,
    /// System library directory pattern.
    pub lib_pattern: String,
}

/// Object format for X86 targets.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum X86ObjectFormat {
    /// ELF (Linux, BSD, etc.)
    ELF,
    /// Mach-O (macOS, iOS, etc.)
    MachO,
    /// PE/COFF (Windows)
    COFF,
    /// WASM
    Wasm,
    /// XCOFF (AIX)
    XCOFF,
}

/// C library variants for X86 targets.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum X86LibC {
    /// GNU C Library
    Glibc,
    /// musl libc
    Musl,
    /// Android Bionic
    Bionic,
    /// macOS libSystem
    LibSystem,
    /// Windows CRT
    Msvcrt,
    /// Universal C Runtime (Windows 10+)
    UCRT,
    /// Newlib
    Newlib,
    /// picolibc
    Picolibc,
    /// None (bare metal)
    None_,
}

impl X86TripleParser {
    /// Create a new X86 triple parser.
    pub fn new(triple_str: &str) -> Self {
        let triple = Triple::parse(triple_str);
        let arch_info = Self::parse_arch_details(&triple);
        let os_info = Self::parse_os_details(&triple);
        let object_format = Self::infer_object_format(&triple);
        let normalized = Self::normalize_triple(&triple);
        let is_valid = triple.arch != Arch::Unknown && triple.os != OS::Unknown;
        let warnings = Self::check_warnings(&triple);

        Self {
            original: triple_str.to_string(),
            triple,
            arch_info,
            os_info,
            object_format,
            is_valid,
            normalized,
            warnings,
        }
    }

    /// Parse detailed architecture information.
    pub fn parse_arch_details(triple: &Triple) -> X86ArchInfo {
        match triple.arch {
            Arch::X86_64 => X86ArchInfo {
                name: "x86_64".to_string(),
                family: X86ArchFamily::X86_64,
                bit_width: 64,
                is_extended: false,
                cpu_sub_arch: None,
                has_sse2: true, // SSE2 is baseline for x86_64
                default_cpu: "x86-64",
                default_fpu: "sse2",
            },
            Arch::X86 => X86ArchInfo {
                name: "i386".to_string(),
                family: X86ArchFamily::X86_32,
                bit_width: 32,
                is_extended: false,
                cpu_sub_arch: None,
                has_sse2: false,
                default_cpu: "i686",
                default_fpu: "x87",
            },
            _ => X86ArchInfo {
                name: triple.arch.as_str().to_string(),
                family: if triple.arch.is_64bit() {
                    X86ArchFamily::X86_64
                } else {
                    X86ArchFamily::X86_32
                },
                bit_width: if triple.arch.is_64bit() { 64 } else { 32 },
                is_extended: false,
                cpu_sub_arch: None,
                has_sse2: triple.arch.is_64bit(),
                default_cpu: "generic",
                default_fpu: "x87",
            },
        }
    }

    /// Parse detailed OS information.
    pub fn parse_os_details(triple: &Triple) -> X86OsInfo {
        match triple.os {
            OS::Linux => {
                let libc = match triple.environment {
                    Environment::Musl => X86LibC::Musl,
                    Environment::Android | Environment::Androideabi => X86LibC::Bionic,
                    _ => X86LibC::Glibc,
                };
                X86OsInfo {
                    name: "linux".to_string(),
                    default_object_format: X86ObjectFormat::ELF,
                    default_libc: libc,
                    supports_multiarch: true,
                    include_pattern: "/usr/include".to_string(),
                    lib_pattern: "/usr/lib".to_string(),
                }
            }
            OS::Darwin | OS::MacOSX => X86OsInfo {
                name: "darwin".to_string(),
                default_object_format: X86ObjectFormat::MachO,
                default_libc: X86LibC::LibSystem,
                supports_multiarch: false,
                include_pattern: "/usr/include".to_string(),
                lib_pattern: "/usr/lib".to_string(),
            },
            OS::IOS => X86OsInfo {
                name: "ios".to_string(),
                default_object_format: X86ObjectFormat::MachO,
                default_libc: X86LibC::LibSystem,
                supports_multiarch: false,
                include_pattern: "/usr/include".to_string(),
                lib_pattern: "/usr/lib".to_string(),
            },
            OS::TvOS => X86OsInfo {
                name: "tvos".to_string(),
                default_object_format: X86ObjectFormat::MachO,
                default_libc: X86LibC::LibSystem,
                supports_multiarch: false,
                include_pattern: "/usr/include".to_string(),
                lib_pattern: "/usr/lib".to_string(),
            },
            OS::WatchOS => X86OsInfo {
                name: "watchos".to_string(),
                default_object_format: X86ObjectFormat::MachO,
                default_libc: X86LibC::LibSystem,
                supports_multiarch: false,
                include_pattern: "/usr/include".to_string(),
                lib_pattern: "/usr/lib".to_string(),
            },
            OS::Win32 => {
                let libc = match triple.environment {
                    Environment::MSVC => X86LibC::Msvcrt,
                    Environment::GNU | Environment::Cygnus => X86LibC::Msvcrt,
                    _ => X86LibC::UCRT,
                };
                X86OsInfo {
                    name: "windows".to_string(),
                    default_object_format: X86ObjectFormat::COFF,
                    default_libc: libc,
                    supports_multiarch: false,
                    include_pattern: "/include".to_string(),
                    lib_pattern: "/lib".to_string(),
                }
            }
            OS::FreeBSD => X86OsInfo {
                name: "freebsd".to_string(),
                default_object_format: X86ObjectFormat::ELF,
                default_libc: X86LibC::Glibc,
                supports_multiarch: false,
                include_pattern: "/usr/include".to_string(),
                lib_pattern: "/usr/lib".to_string(),
            },
            OS::NetBSD => X86OsInfo {
                name: "netbsd".to_string(),
                default_object_format: X86ObjectFormat::ELF,
                default_libc: X86LibC::Glibc,
                supports_multiarch: false,
                include_pattern: "/usr/include".to_string(),
                lib_pattern: "/usr/lib".to_string(),
            },
            OS::OpenBSD => X86OsInfo {
                name: "openbsd".to_string(),
                default_object_format: X86ObjectFormat::ELF,
                default_libc: X86LibC::Glibc,
                supports_multiarch: false,
                include_pattern: "/usr/include".to_string(),
                lib_pattern: "/usr/lib".to_string(),
            },
            OS::Haiku => X86OsInfo {
                name: "haiku".to_string(),
                default_object_format: X86ObjectFormat::ELF,
                default_libc: X86LibC::Glibc,
                supports_multiarch: false,
                include_pattern: "/boot/system/develop/headers".to_string(),
                lib_pattern: "/boot/system/lib".to_string(),
            },
            OS::WASI => X86OsInfo {
                name: "wasi".to_string(),
                default_object_format: X86ObjectFormat::Wasm,
                default_libc: X86LibC::None_,
                supports_multiarch: false,
                include_pattern: "/include".to_string(),
                lib_pattern: "/lib".to_string(),
            },
            _ => X86OsInfo {
                name: "unknown".to_string(),
                default_object_format: X86ObjectFormat::ELF,
                default_libc: X86LibC::Glibc,
                supports_multiarch: false,
                include_pattern: "/usr/include".to_string(),
                lib_pattern: "/usr/lib".to_string(),
            },
        }
    }

    /// Infer the object format from a triple.
    pub fn infer_object_format(triple: &Triple) -> X86ObjectFormat {
        if triple.is_elf() {
            X86ObjectFormat::ELF
        } else if triple.is_macho() {
            X86ObjectFormat::MachO
        } else if triple.is_coff() {
            X86ObjectFormat::COFF
        } else if triple.os == OS::WASI {
            X86ObjectFormat::Wasm
        } else if triple.os == OS::AIX {
            X86ObjectFormat::XCOFF
        } else {
            X86ObjectFormat::ELF
        }
    }

    /// Normalize a triple string.
    pub fn normalize_triple(triple: &Triple) -> String {
        let arch_str = match triple.arch {
            Arch::X86 => "i386",
            _ => triple.arch.as_str(),
        };

        let vendor_str = triple.vendor.as_str();

        let os_str = triple.os.as_str();

        let env_str = match (triple.os, triple.environment) {
            (OS::Linux, Environment::GNU) => "gnu",
            (OS::Linux, Environment::Musl) => "musl",
            (OS::Linux, Environment::Android | Environment::Androideabi) => "android",
            (OS::Darwin | OS::MacOSX, _) => "",
            (OS::Win32, Environment::MSVC) => "msvc",
            (OS::Win32, Environment::GNU) => "mingw",
            _ => triple.environment.as_str(),
        };

        if env_str.is_empty() || env_str == "unknown" {
            format!("{}-{}-{}", arch_str, vendor_str, os_str)
        } else {
            format!("{}-{}-{}-{}", arch_str, vendor_str, os_str, env_str)
        }
    }

    /// Check for warnings about the triple.
    fn check_warnings(triple: &Triple) -> Vec<String> {
        let mut warnings = Vec::new();

        if triple.arch == Arch::Unknown {
            warnings.push(format!("Unknown architecture: {}", triple.arch.as_str()));
        }

        if triple.os == OS::Unknown {
            warnings.push(format!("Unknown OS: {}", triple.os.as_str()));
        }

        // Check for unusual combinations
        if triple.arch == Arch::X86_64 && triple.os == OS::IOS {
            warnings.push("x86_64-ios is deprecated; use arm64 for iOS targets".to_string());
        }

        warnings
    }

    /// Parse architecture from an extended set of X86 names.
    pub fn parse_x86_arch(name: &str) -> Option<X86ArchInfo> {
        let info = match name {
            // 32-bit X86 variants
            "i386" => X86ArchInfo {
                name: name.to_string(),
                family: X86ArchFamily::X86_32,
                bit_width: 32,
                is_extended: false,
                cpu_sub_arch: Some(name.to_string()),
                has_sse2: false,
                default_cpu: "i386",
                default_fpu: "x87",
            },
            "i486" => X86ArchInfo {
                name: name.to_string(),
                family: X86ArchFamily::X86_32,
                bit_width: 32,
                is_extended: false,
                cpu_sub_arch: Some(name.to_string()),
                has_sse2: false,
                default_cpu: "i486",
                default_fpu: "x87",
            },
            "i586" => X86ArchInfo {
                name: name.to_string(),
                family: X86ArchFamily::X86_32,
                bit_width: 32,
                is_extended: false,
                cpu_sub_arch: Some(name.to_string()),
                has_sse2: false,
                default_cpu: "i586",
                default_fpu: "x87",
            },
            "i686" => X86ArchInfo {
                name: "i686".to_string(),
                family: X86ArchFamily::X86_32,
                bit_width: 32,
                is_extended: false,
                cpu_sub_arch: Some("i686".to_string()),
                has_sse2: false,
                default_cpu: "i686",
                default_fpu: "x87",
            },
            "pentium" => X86ArchInfo {
                name: "pentium".to_string(),
                family: X86ArchFamily::X86_32,
                bit_width: 32,
                is_extended: true,
                cpu_sub_arch: Some("pentium".to_string()),
                has_sse2: false,
                default_cpu: "pentium",
                default_fpu: "x87",
            },
            "pentium2" | "pentiumii" => X86ArchInfo {
                name: "pentium2".to_string(),
                family: X86ArchFamily::X86_32,
                bit_width: 32,
                is_extended: true,
                cpu_sub_arch: Some("pentium2".to_string()),
                has_sse2: false,
                default_cpu: "pentium2",
                default_fpu: "x87",
            },
            "pentium3" | "pentiumiii" => X86ArchInfo {
                name: "pentium3".to_string(),
                family: X86ArchFamily::X86_32,
                bit_width: 32,
                is_extended: true,
                cpu_sub_arch: Some("pentium3".to_string()),
                has_sse2: false,
                default_cpu: "pentium3",
                default_fpu: "sse",
            },
            "pentium4" | "pentiumiv" => X86ArchInfo {
                name: "pentium4".to_string(),
                family: X86ArchFamily::X86_32,
                bit_width: 32,
                is_extended: true,
                cpu_sub_arch: Some("pentium4".to_string()),
                has_sse2: true,
                default_cpu: "pentium4",
                default_fpu: "sse2",
            },
            "pentium-m" | "pentiumm" => X86ArchInfo {
                name: "pentium-m".to_string(),
                family: X86ArchFamily::X86_32,
                bit_width: 32,
                is_extended: true,
                cpu_sub_arch: Some("pentium-m".to_string()),
                has_sse2: true,
                default_cpu: "pentium-m",
                default_fpu: "sse2",
            },
            "athlon" | "athlon-xp" => X86ArchInfo {
                name: "athlon".to_string(),
                family: X86ArchFamily::X86_32,
                bit_width: 32,
                is_extended: true,
                cpu_sub_arch: Some("athlon".to_string()),
                has_sse2: false,
                default_cpu: "athlon",
                default_fpu: "x87",
            },
            "athlon64" | "athlon-fx" => X86ArchInfo {
                name: "athlon64".to_string(),
                family: X86ArchFamily::X86_64,
                bit_width: 64,
                is_extended: true,
                cpu_sub_arch: Some("athlon64".to_string()),
                has_sse2: true,
                default_cpu: "athlon64",
                default_fpu: "sse2",
            },
            "k8" | "opteron" => X86ArchInfo {
                name: "k8".to_string(),
                family: X86ArchFamily::X86_64,
                bit_width: 64,
                is_extended: true,
                cpu_sub_arch: Some("k8".to_string()),
                has_sse2: true,
                default_cpu: "k8",
                default_fpu: "sse2",
            },
            "k8-sse3" | "opteron-sse3" => X86ArchInfo {
                name: "k8-sse3".to_string(),
                family: X86ArchFamily::X86_64,
                bit_width: 64,
                is_extended: true,
                cpu_sub_arch: Some("k8-sse3".to_string()),
                has_sse2: true,
                default_cpu: "k8-sse3",
                default_fpu: "sse2",
            },
            "amdfam10" | "barcelona" => X86ArchInfo {
                name: "amdfam10".to_string(),
                family: X86ArchFamily::X86_64,
                bit_width: 64,
                is_extended: true,
                cpu_sub_arch: Some("amdfam10".to_string()),
                has_sse2: true,
                default_cpu: "amdfam10",
                default_fpu: "sse2",
            },
            "btver1" => X86ArchInfo {
                name: "btver1".to_string(),
                family: X86ArchFamily::X86_64,
                bit_width: 64,
                is_extended: true,
                cpu_sub_arch: Some("btver1".to_string()),
                has_sse2: true,
                default_cpu: "btver1",
                default_fpu: "sse2",
            },
            "btver2" => X86ArchInfo {
                name: "btver2".to_string(),
                family: X86ArchFamily::X86_64,
                bit_width: 64,
                is_extended: true,
                cpu_sub_arch: Some("btver2".to_string()),
                has_sse2: true,
                default_cpu: "btver2",
                default_fpu: "sse2",
            },
            "bdver1" | "bulldozer" => X86ArchInfo {
                name: "bdver1".to_string(),
                family: X86ArchFamily::X86_64,
                bit_width: 64,
                is_extended: true,
                cpu_sub_arch: Some("bdver1".to_string()),
                has_sse2: true,
                default_cpu: "bdver1",
                default_fpu: "sse2",
            },
            "bdver2" | "piledriver" => X86ArchInfo {
                name: "bdver2".to_string(),
                family: X86ArchFamily::X86_64,
                bit_width: 64,
                is_extended: true,
                cpu_sub_arch: Some("bdver2".to_string()),
                has_sse2: true,
                default_cpu: "bdver2",
                default_fpu: "sse2",
            },
            "bdver3" | "steamroller" => X86ArchInfo {
                name: "bdver3".to_string(),
                family: X86ArchFamily::X86_64,
                bit_width: 64,
                is_extended: true,
                cpu_sub_arch: Some("bdver3".to_string()),
                has_sse2: true,
                default_cpu: "bdver3",
                default_fpu: "sse2",
            },
            "bdver4" | "excavator" => X86ArchInfo {
                name: "bdver4".to_string(),
                family: X86ArchFamily::X86_64,
                bit_width: 64,
                is_extended: true,
                cpu_sub_arch: Some("bdver4".to_string()),
                has_sse2: true,
                default_cpu: "bdver4",
                default_fpu: "sse2",
            },
            "znver1" | "zen" => X86ArchInfo {
                name: "znver1".to_string(),
                family: X86ArchFamily::X86_64,
                bit_width: 64,
                is_extended: true,
                cpu_sub_arch: Some("znver1".to_string()),
                has_sse2: true,
                default_cpu: "znver1",
                default_fpu: "sse2",
            },
            "znver2" | "zen2" => X86ArchInfo {
                name: "znver2".to_string(),
                family: X86ArchFamily::X86_64,
                bit_width: 64,
                is_extended: true,
                cpu_sub_arch: Some("znver2".to_string()),
                has_sse2: true,
                default_cpu: "znver2",
                default_fpu: "sse2",
            },
            "znver3" | "zen3" => X86ArchInfo {
                name: "znver3".to_string(),
                family: X86ArchFamily::X86_64,
                bit_width: 64,
                is_extended: true,
                cpu_sub_arch: Some("znver3".to_string()),
                has_sse2: true,
                default_cpu: "znver3",
                default_fpu: "sse2",
            },
            "znver4" | "zen4" => X86ArchInfo {
                name: "znver4".to_string(),
                family: X86ArchFamily::X86_64,
                bit_width: 64,
                is_extended: true,
                cpu_sub_arch: Some("znver4".to_string()),
                has_sse2: true,
                default_cpu: "znver4",
                default_fpu: "sse2",
            },
            "znver5" | "zen5" => X86ArchInfo {
                name: "znver5".to_string(),
                family: X86ArchFamily::X86_64,
                bit_width: 64,
                is_extended: true,
                cpu_sub_arch: Some("znver5".to_string()),
                has_sse2: true,
                default_cpu: "znver5",
                default_fpu: "sse2",
            },
            // Intel Core variants
            "core2" | "core2duo" | "penryn" => X86ArchInfo {
                name: "core2".to_string(),
                family: X86ArchFamily::X86_64,
                bit_width: 64,
                is_extended: true,
                cpu_sub_arch: Some("core2".to_string()),
                has_sse2: true,
                default_cpu: "core2",
                default_fpu: "sse2",
            },
            "nehalem" | "corei7" | "core-i7" => X86ArchInfo {
                name: "nehalem".to_string(),
                family: X86ArchFamily::X86_64,
                bit_width: 64,
                is_extended: true,
                cpu_sub_arch: Some("nehalem".to_string()),
                has_sse2: true,
                default_cpu: "nehalem",
                default_fpu: "sse2",
            },
            "westmere" => X86ArchInfo {
                name: "westmere".to_string(),
                family: X86ArchFamily::X86_64,
                bit_width: 64,
                is_extended: true,
                cpu_sub_arch: Some("westmere".to_string()),
                has_sse2: true,
                default_cpu: "westmere",
                default_fpu: "sse2",
            },
            "sandybridge" | "sandy-bridge" | "corei7-2" => X86ArchInfo {
                name: "sandybridge".to_string(),
                family: X86ArchFamily::X86_64,
                bit_width: 64,
                is_extended: true,
                cpu_sub_arch: Some("sandybridge".to_string()),
                has_sse2: true,
                default_cpu: "sandybridge",
                default_fpu: "sse2",
            },
            "ivybridge" | "ivy-bridge" | "corei7-3" => X86ArchInfo {
                name: "ivybridge".to_string(),
                family: X86ArchFamily::X86_64,
                bit_width: 64,
                is_extended: true,
                cpu_sub_arch: Some("ivybridge".to_string()),
                has_sse2: true,
                default_cpu: "ivybridge",
                default_fpu: "sse2",
            },
            "haswell" | "corei7-4" => X86ArchInfo {
                name: "haswell".to_string(),
                family: X86ArchFamily::X86_64,
                bit_width: 64,
                is_extended: true,
                cpu_sub_arch: Some("haswell".to_string()),
                has_sse2: true,
                default_cpu: "haswell",
                default_fpu: "sse2",
            },
            "broadwell" | "corei7-5" => X86ArchInfo {
                name: "broadwell".to_string(),
                family: X86ArchFamily::X86_64,
                bit_width: 64,
                is_extended: true,
                cpu_sub_arch: Some("broadwell".to_string()),
                has_sse2: true,
                default_cpu: "broadwell",
                default_fpu: "sse2",
            },
            "skylake" | "skylake-client" | "corei7-6" => X86ArchInfo {
                name: "skylake".to_string(),
                family: X86ArchFamily::X86_64,
                bit_width: 64,
                is_extended: true,
                cpu_sub_arch: Some("skylake".to_string()),
                has_sse2: true,
                default_cpu: "skylake",
                default_fpu: "sse2",
            },
            "skylake-avx512" => X86ArchInfo {
                name: "skylake-avx512".to_string(),
                family: X86ArchFamily::X86_64,
                bit_width: 64,
                is_extended: true,
                cpu_sub_arch: Some("skylake-avx512".to_string()),
                has_sse2: true,
                default_cpu: "skylake-avx512",
                default_fpu: "sse2",
            },
            "cannonlake" => X86ArchInfo {
                name: "cannonlake".to_string(),
                family: X86ArchFamily::X86_64,
                bit_width: 64,
                is_extended: true,
                cpu_sub_arch: Some("cannonlake".to_string()),
                has_sse2: true,
                default_cpu: "cannonlake",
                default_fpu: "sse2",
            },
            "icelake-client" | "icelake" => X86ArchInfo {
                name: "icelake-client".to_string(),
                family: X86ArchFamily::X86_64,
                bit_width: 64,
                is_extended: true,
                cpu_sub_arch: Some("icelake-client".to_string()),
                has_sse2: true,
                default_cpu: "icelake-client",
                default_fpu: "sse2",
            },
            "icelake-server" => X86ArchInfo {
                name: "icelake-server".to_string(),
                family: X86ArchFamily::X86_64,
                bit_width: 64,
                is_extended: true,
                cpu_sub_arch: Some("icelake-server".to_string()),
                has_sse2: true,
                default_cpu: "icelake-server",
                default_fpu: "sse2",
            },
            "tigerlake" => X86ArchInfo {
                name: "tigerlake".to_string(),
                family: X86ArchFamily::X86_64,
                bit_width: 64,
                is_extended: true,
                cpu_sub_arch: Some("tigerlake".to_string()),
                has_sse2: true,
                default_cpu: "tigerlake",
                default_fpu: "sse2",
            },
            "sapphirerapids" => X86ArchInfo {
                name: "sapphirerapids".to_string(),
                family: X86ArchFamily::X86_64,
                bit_width: 64,
                is_extended: true,
                cpu_sub_arch: Some("sapphirerapids".to_string()),
                has_sse2: true,
                default_cpu: "sapphirerapids",
                default_fpu: "sse2",
            },
            "alderlake" => X86ArchInfo {
                name: "alderlake".to_string(),
                family: X86ArchFamily::X86_64,
                bit_width: 64,
                is_extended: true,
                cpu_sub_arch: Some("alderlake".to_string()),
                has_sse2: true,
                default_cpu: "alderlake",
                default_fpu: "sse2",
            },
            "raptorlake" => X86ArchInfo {
                name: "raptorlake".to_string(),
                family: X86ArchFamily::X86_64,
                bit_width: 64,
                is_extended: true,
                cpu_sub_arch: Some("raptorlake".to_string()),
                has_sse2: true,
                default_cpu: "raptorlake",
                default_fpu: "sse2",
            },
            "meteorlake" => X86ArchInfo {
                name: "meteorlake".to_string(),
                family: X86ArchFamily::X86_64,
                bit_width: 64,
                is_extended: true,
                cpu_sub_arch: Some("meteorlake".to_string()),
                has_sse2: true,
                default_cpu: "meteorlake",
                default_fpu: "sse2",
            },
            "graniterapids" => X86ArchInfo {
                name: "graniterapids".to_string(),
                family: X86ArchFamily::X86_64,
                bit_width: 64,
                is_extended: true,
                cpu_sub_arch: Some("graniterapids".to_string()),
                has_sse2: true,
                default_cpu: "graniterapids",
                default_fpu: "sse2",
            },
            "arrowlake" | "arrowlake-s" => X86ArchInfo {
                name: "arrowlake".to_string(),
                family: X86ArchFamily::X86_64,
                bit_width: 64,
                is_extended: true,
                cpu_sub_arch: Some("arrowlake".to_string()),
                has_sse2: true,
                default_cpu: "arrowlake",
                default_fpu: "sse2",
            },
            "lunarlake" => X86ArchInfo {
                name: "lunarlake".to_string(),
                family: X86ArchFamily::X86_64,
                bit_width: 64,
                is_extended: true,
                cpu_sub_arch: Some("lunarlake".to_string()),
                has_sse2: true,
                default_cpu: "lunarlake",
                default_fpu: "sse2",
            },
            "pantherlake" => X86ArchInfo {
                name: "pantherlake".to_string(),
                family: X86ArchFamily::X86_64,
                bit_width: 64,
                is_extended: true,
                cpu_sub_arch: Some("pantherlake".to_string()),
                has_sse2: true,
                default_cpu: "pantherlake",
                default_fpu: "sse2",
            },
            // Intel Atom variants
            "bonnell" | "atom" => X86ArchInfo {
                name: "bonnell".to_string(),
                family: X86ArchFamily::X86_32,
                bit_width: 32,
                is_extended: true,
                cpu_sub_arch: Some("bonnell".to_string()),
                has_sse2: true,
                default_cpu: "bonnell",
                default_fpu: "sse2",
            },
            "silvermont" => X86ArchInfo {
                name: "silvermont".to_string(),
                family: X86ArchFamily::X86_64,
                bit_width: 64,
                is_extended: true,
                cpu_sub_arch: Some("silvermont".to_string()),
                has_sse2: true,
                default_cpu: "silvermont",
                default_fpu: "sse2",
            },
            "goldmont" => X86ArchInfo {
                name: "goldmont".to_string(),
                family: X86ArchFamily::X86_64,
                bit_width: 64,
                is_extended: true,
                cpu_sub_arch: Some("goldmont".to_string()),
                has_sse2: true,
                default_cpu: "goldmont",
                default_fpu: "sse2",
            },
            "goldmont-plus" => X86ArchInfo {
                name: "goldmont-plus".to_string(),
                family: X86ArchFamily::X86_64,
                bit_width: 64,
                is_extended: true,
                cpu_sub_arch: Some("goldmont-plus".to_string()),
                has_sse2: true,
                default_cpu: "goldmont-plus",
                default_fpu: "sse2",
            },
            "tremont" => X86ArchInfo {
                name: "tremont".to_string(),
                family: X86ArchFamily::X86_64,
                bit_width: 64,
                is_extended: true,
                cpu_sub_arch: Some("tremont".to_string()),
                has_sse2: true,
                default_cpu: "tremont",
                default_fpu: "sse2",
            },
            "gracemont" => X86ArchInfo {
                name: "gracemont".to_string(),
                family: X86ArchFamily::X86_64,
                bit_width: 64,
                is_extended: true,
                cpu_sub_arch: Some("gracemont".to_string()),
                has_sse2: true,
                default_cpu: "gracemont",
                default_fpu: "sse2",
            },
            "crestmont" => X86ArchInfo {
                name: "crestmont".to_string(),
                family: X86ArchFamily::X86_64,
                bit_width: 64,
                is_extended: true,
                cpu_sub_arch: Some("crestmont".to_string()),
                has_sse2: true,
                default_cpu: "crestmont",
                default_fpu: "sse2",
            },
            "skymont" => X86ArchInfo {
                name: "skymont".to_string(),
                family: X86ArchFamily::X86_64,
                bit_width: 64,
                is_extended: true,
                cpu_sub_arch: Some("skymont".to_string()),
                has_sse2: true,
                default_cpu: "skymont",
                default_fpu: "sse2",
            },
            // X86-64 generic
            "x86-64" | "x86_64" | "amd64" | "x64" => X86ArchInfo {
                name: "x86-64".to_string(),
                family: X86ArchFamily::X86_64,
                bit_width: 64,
                is_extended: false,
                cpu_sub_arch: None,
                has_sse2: true,
                default_cpu: "x86-64",
                default_fpu: "sse2",
            },
            // x32
            "x32" | "x86_64-x32" => X86ArchInfo {
                name: "x32".to_string(),
                family: X86ArchFamily::X32,
                bit_width: 32,
                is_extended: true,
                cpu_sub_arch: Some("x32".to_string()),
                has_sse2: true,
                default_cpu: "x86-64",
                default_fpu: "sse2",
            },
            // Intel Xeon Phi (Knights Landing, Knights Mill)
            "knl" | "knightslanding" => X86ArchInfo {
                name: "knl".to_string(),
                family: X86ArchFamily::X86_64,
                bit_width: 64,
                is_extended: true,
                cpu_sub_arch: Some("knl".to_string()),
                has_sse2: true,
                default_cpu: "knl",
                default_fpu: "sse2",
            },
            "knm" | "knightsmill" => X86ArchInfo {
                name: "knm".to_string(),
                family: X86ArchFamily::X86_64,
                bit_width: 64,
                is_extended: true,
                cpu_sub_arch: Some("knm".to_string()),
                has_sse2: true,
                default_cpu: "knm",
                default_fpu: "sse2",
            },
            // VIA/Centaur CPUs
            "c3" => X86ArchInfo {
                name: "c3".to_string(),
                family: X86ArchFamily::X86_32,
                bit_width: 32,
                is_extended: true,
                cpu_sub_arch: Some("c3".to_string()),
                has_sse2: false,
                default_cpu: "c3",
                default_fpu: "x87",
            },
            "c3-2" => X86ArchInfo {
                name: "c3-2".to_string(),
                family: X86ArchFamily::X86_32,
                bit_width: 32,
                is_extended: true,
                cpu_sub_arch: Some("c3-2".to_string()),
                has_sse2: true,
                default_cpu: "c3-2",
                default_fpu: "sse2",
            },
            "c7" => X86ArchInfo {
                name: "c7".to_string(),
                family: X86ArchFamily::X86_64,
                bit_width: 64,
                is_extended: true,
                cpu_sub_arch: Some("c7".to_string()),
                has_sse2: true,
                default_cpu: "c7",
                default_fpu: "sse2",
            },
            // AMD Geode (embedded)
            "geode" => X86ArchInfo {
                name: "geode".to_string(),
                family: X86ArchFamily::X86_32,
                bit_width: 32,
                is_extended: true,
                cpu_sub_arch: Some("geode".to_string()),
                has_sse2: false,
                default_cpu: "geode",
                default_fpu: "x87",
            },
            // WinChip
            "winchip-c6" => X86ArchInfo {
                name: "winchip-c6".to_string(),
                family: X86ArchFamily::X86_32,
                bit_width: 32,
                is_extended: true,
                cpu_sub_arch: Some("winchip-c6".to_string()),
                has_sse2: false,
                default_cpu: "winchip-c6",
                default_fpu: "x87",
            },
            "winchip2" => X86ArchInfo {
                name: "winchip2".to_string(),
                family: X86ArchFamily::X86_32,
                bit_width: 32,
                is_extended: true,
                cpu_sub_arch: Some("winchip2".to_string()),
                has_sse2: false,
                default_cpu: "winchip2",
                default_fpu: "x87",
            },
            // Intel variant names
            "pentiumpro" => X86ArchInfo {
                name: "pentiumpro".to_string(),
                family: X86ArchFamily::X86_32,
                bit_width: 32,
                is_extended: true,
                cpu_sub_arch: Some("pentiumpro".to_string()),
                has_sse2: false,
                default_cpu: "pentiumpro",
                default_fpu: "x87",
            },
            "prescott" => X86ArchInfo {
                name: "prescott".to_string(),
                family: X86ArchFamily::X86_32,
                bit_width: 32,
                is_extended: true,
                cpu_sub_arch: Some("prescott".to_string()),
                has_sse2: true,
                default_cpu: "prescott",
                default_fpu: "sse2",
            },
            "nocona" => X86ArchInfo {
                name: "nocona".to_string(),
                family: X86ArchFamily::X86_64,
                bit_width: 64,
                is_extended: true,
                cpu_sub_arch: Some("nocona".to_string()),
                has_sse2: true,
                default_cpu: "nocona",
                default_fpu: "sse2",
            },
            "rocketlake" => X86ArchInfo {
                name: "rocketlake".to_string(),
                family: X86ArchFamily::X86_64,
                bit_width: 64,
                is_extended: true,
                cpu_sub_arch: Some("rocketlake".to_string()),
                has_sse2: true,
                default_cpu: "rocketlake",
                default_fpu: "sse2",
            },
            "cooperlake" => X86ArchInfo {
                name: "cooperlake".to_string(),
                family: X86ArchFamily::X86_64,
                bit_width: 64,
                is_extended: true,
                cpu_sub_arch: Some("cooperlake".to_string()),
                has_sse2: true,
                default_cpu: "cooperlake",
                default_fpu: "sse2",
            },
            "cascadelake" => X86ArchInfo {
                name: "cascadelake".to_string(),
                family: X86ArchFamily::X86_64,
                bit_width: 64,
                is_extended: true,
                cpu_sub_arch: Some("cascadelake".to_string()),
                has_sse2: true,
                default_cpu: "cascadelake",
                default_fpu: "sse2",
            },
            "emeraldrapids" => X86ArchInfo {
                name: "emeraldrapids".to_string(),
                family: X86ArchFamily::X86_64,
                bit_width: 64,
                is_extended: true,
                cpu_sub_arch: Some("emeraldrapids".to_string()),
                has_sse2: true,
                default_cpu: "emeraldrapids",
                default_fpu: "sse2",
            },
            "sierraforest" => X86ArchInfo {
                name: "sierraforest".to_string(),
                family: X86ArchFamily::X86_64,
                bit_width: 64,
                is_extended: true,
                cpu_sub_arch: Some("sierraforest".to_string()),
                has_sse2: true,
                default_cpu: "sierraforest",
                default_fpu: "sse2",
            },
            _ => return None,
        };

        Some(info)
    }

    /// Parse vendor from a string, with X86-specific extensions.
    pub fn parse_x86_vendor(name: &str) -> Option<Vendor> {
        match name.to_lowercase().as_str() {
            "pc" => Some(Vendor::PC),
            "unknown" => Some(Vendor::Unknown),
            "apple" => Some(Vendor::Apple),
            "ibm" => Some(Vendor::IBM),
            "intel" => Some(Vendor::Unknown), // Normalized to unknown
            "amd" => Some(Vendor::AMD),
            "nvidia" => Some(Vendor::Nvidia),
            "img" | "imagination" | "mips" => Some(Vendor::Imagination),
            "scei" | "sony" | "ps" => Some(Vendor::SCEI),
            "fsl" | "freescale" | "nxp" => Some(Vendor::Freescale),
            "mti" => Some(Vendor::Mips),
            "ti" | "texas" | "texasinstruments" => Some(Vendor::Unknown),
            "qcom" | "qualcomm" => Some(Vendor::Unknown),
            "samsung" => Some(Vendor::Unknown),
            "marvell" | "cavium" => Some(Vendor::Unknown),
            "broadcom" => Some(Vendor::Unknown),
            "allwinner" => Some(Vendor::Unknown),
            "rockchip" => Some(Vendor::Unknown),
            "mediatek" => Some(Vendor::Unknown),
            "hisilicon" | "huawei" => Some(Vendor::Unknown),
            "ampere" => Some(Vendor::Unknown),
            "phytium" => Some(Vendor::Unknown),
            _ => None,
        }
    }

    /// Parse OS from a string, with X86-specific extensions.
    pub fn parse_x86_os(name: &str) -> Option<OS> {
        match name.to_lowercase().as_str() {
            "linux" => Some(OS::Linux),
            "darwin" | "macosx" | "macos" => Some(OS::Darwin),
            "windows" | "win32" => Some(OS::Win32),
            "freebsd" => Some(OS::FreeBSD),
            "netbsd" => Some(OS::NetBSD),
            "openbsd" => Some(OS::OpenBSD),
            "haiku" => Some(OS::Haiku),
            "solaris" | "sunos" => Some(OS::Unknown),
            "android" => Some(OS::Linux),
            "ios" => Some(OS::IOS),
            "tvos" => Some(OS::TvOS),
            "watchos" => Some(OS::WatchOS),
            "wasi" => Some(OS::WASI),
            "fuchsia" => Some(OS::Fuchsia),
            "aix" => Some(OS::AIX),
            "hurd" => Some(OS::Hurd),
            _ => None,
        }
    }

    /// Parse environment from a string.
    pub fn parse_x86_env(name: &str) -> Option<Environment> {
        match name.to_lowercase().as_str() {
            "gnu" => Some(Environment::GNU),
            "gnueabi" => Some(Environment::GNUEABI),
            "gnueabihf" => Some(Environment::GNUEABIHF),
            "gnuabi64" => Some(Environment::GNUABI64),
            "gnux32" => Some(Environment::GNUX32),
            "musl" | "musleabi" | "musleabihf" => Some(Environment::Musl),
            "android" => Some(Environment::Android),
            "androideabi" => Some(Environment::Androideabi),
            "msvc" => Some(Environment::MSVC),
            "mingw" | "mingw32" => Some(Environment::GNU),
            "cygwin" => Some(Environment::Cygnus),
            _ => None,
        }
    }

    /// Get the full target CPU list for autocomplete/documentation.
    pub fn known_x86_cpus() -> Vec<&'static str> {
        vec![
            // Generic
            "i386",
            "i486",
            "i586",
            "i686",
            "pentium",
            "pentium-mmx",
            "pentiumpro",
            "pentium2",
            "pentium3",
            "pentium3m",
            "pentium-m",
            "pentium4",
            "pentium4m",
            "prescott",
            "nocona",
            // Intel Core
            "core2",
            "penryn",
            "nehalem",
            "westmere",
            "sandybridge",
            "ivybridge",
            "haswell",
            "broadwell",
            "skylake",
            "skylake-avx512",
            "cannonlake",
            "icelake-client",
            "icelake-server",
            "cascadelake",
            "cooperlake",
            "tigerlake",
            "rocketlake",
            "alderlake",
            "raptorlake",
            "meteorlake",
            "arrowlake",
            "lunarlake",
            "pantherlake",
            "sapphirerapids",
            "emeraldrapids",
            "graniterapids",
            "sierraforest",
            // Intel Atom
            "bonnell",
            "silvermont",
            "goldmont",
            "goldmont-plus",
            "tremont",
            "gracemont",
            "crestmont",
            "skymont",
            // Intel Xeon Phi
            "knl",
            "knm",
            // AMD
            "k6",
            "k6-2",
            "k6-3",
            "athlon",
            "athlon-tbird",
            "athlon-4",
            "athlon-xp",
            "athlon-mp",
            "k8",
            "opteron",
            "athlon64",
            "athlon-fx",
            "k8-sse3",
            "opteron-sse3",
            "amdfam10",
            "barcelona",
            "btver1",
            "btver2",
            "bdver1",
            "bdver2",
            "bdver3",
            "bdver4",
            "znver1",
            "znver2",
            "znver3",
            "znver4",
            "znver5",
            // VIA
            "c3",
            "c3-2",
            "c7",
            // Generic
            "x86-64",
            "x86-64-v2",
            "x86-64-v3",
            "x86-64-v4",
            // Geode
            "geode",
            // WinChip
            "winchip-c6",
            "winchip2",
        ]
    }

    /// Get the default target features for a given CPU on X86.
    pub fn default_features_for_cpu(cpu: &str) -> Vec<&'static str> {
        match cpu {
            "i386" | "i486" => vec!["+cmov"],
            "i586" => vec!["+cmov", "+mmx"],
            "i686" => vec!["+cmov", "+mmx", "+sse"],
            "pentium4" | "prescott" | "nocona" => {
                vec!["+cmov", "+mmx", "+sse", "+sse2", "+sse3"]
            }
            "core2" | "penryn" => {
                vec![
                    "+cmov", "+mmx", "+sse", "+sse2", "+sse3", "+ssse3", "+sse4.1",
                ]
            }
            "nehalem" | "westmere" => {
                vec![
                    "+cmov", "+mmx", "+sse", "+sse2", "+sse3", "+ssse3", "+sse4.1", "+sse4.2",
                    "+popcnt",
                ]
            }
            "sandybridge" | "ivybridge" => {
                vec![
                    "+cmov", "+mmx", "+sse", "+sse2", "+sse3", "+ssse3", "+sse4.1", "+sse4.2",
                    "+popcnt", "+avx",
                ]
            }
            "haswell" | "broadwell" => {
                vec![
                    "+cmov", "+mmx", "+sse", "+sse2", "+sse3", "+ssse3", "+sse4.1", "+sse4.2",
                    "+popcnt", "+avx", "+avx2", "+fma", "+bmi", "+bmi2", "+lzcnt", "+movbe",
                ]
            }
            "skylake" | "skylake-avx512" | "cannonlake" => {
                vec![
                    "+cmov",
                    "+mmx",
                    "+sse",
                    "+sse2",
                    "+sse3",
                    "+ssse3",
                    "+sse4.1",
                    "+sse4.2",
                    "+popcnt",
                    "+avx",
                    "+avx2",
                    "+fma",
                    "+bmi",
                    "+bmi2",
                    "+lzcnt",
                    "+movbe",
                    "+avx512f",
                    "+avx512cd",
                    "+avx512bw",
                    "+avx512dq",
                    "+avx512vl",
                ]
            }
            "icelake-client" | "icelake-server" | "tigerlake" | "rocketlake" => {
                vec![
                    "+cmov",
                    "+mmx",
                    "+sse",
                    "+sse2",
                    "+sse3",
                    "+ssse3",
                    "+sse4.1",
                    "+sse4.2",
                    "+popcnt",
                    "+avx",
                    "+avx2",
                    "+fma",
                    "+bmi",
                    "+bmi2",
                    "+lzcnt",
                    "+movbe",
                    "+avx512f",
                    "+avx512cd",
                    "+avx512bw",
                    "+avx512dq",
                    "+avx512vl",
                    "+avx512ifma",
                    "+avx512vbmi",
                    "+avx512vbmi2",
                    "+avx512vnni",
                    "+avx512bitalg",
                    "+avx512vpopcntdq",
                    "+gfni",
                    "+vaes",
                    "+vpclmulqdq",
                ]
            }
            "alderlake" | "raptorlake" | "meteorlake" | "arrowlake" | "lunarlake" => {
                vec![
                    "+cmov",
                    "+mmx",
                    "+sse",
                    "+sse2",
                    "+sse3",
                    "+ssse3",
                    "+sse4.1",
                    "+sse4.2",
                    "+popcnt",
                    "+avx",
                    "+avx2",
                    "+fma",
                    "+bmi",
                    "+bmi2",
                    "+lzcnt",
                    "+movbe",
                    "+avx512f",
                    "+avx512cd",
                    "+avx512bw",
                    "+avx512dq",
                    "+avx512vl",
                    "+avx512ifma",
                    "+avx512vbmi",
                    "+avx512vbmi2",
                    "+avx512vnni",
                    "+avx512bitalg",
                    "+avx512vpopcntdq",
                    "+gfni",
                    "+vaes",
                    "+vpclmulqdq",
                    "+avxvnni",
                    "+avx512fp16",
                ]
            }
            "znver1" => {
                vec![
                    "+cmov",
                    "+mmx",
                    "+sse",
                    "+sse2",
                    "+sse3",
                    "+ssse3",
                    "+sse4.1",
                    "+sse4.2",
                    "+popcnt",
                    "+avx",
                    "+avx2",
                    "+fma",
                    "+bmi",
                    "+bmi2",
                    "+lzcnt",
                    "+movbe",
                    "+clzero",
                    "+adx",
                    "+rdseed",
                    "+sha",
                    "+xsavec",
                    "+xsaves",
                    "+clflushopt",
                ]
            }
            "znver2" => {
                vec![
                    "+cmov",
                    "+mmx",
                    "+sse",
                    "+sse2",
                    "+sse3",
                    "+ssse3",
                    "+sse4.1",
                    "+sse4.2",
                    "+popcnt",
                    "+avx",
                    "+avx2",
                    "+fma",
                    "+bmi",
                    "+bmi2",
                    "+lzcnt",
                    "+movbe",
                    "+clzero",
                    "+adx",
                    "+rdseed",
                    "+sha",
                    "+xsavec",
                    "+xsaves",
                    "+clflushopt",
                    "+clwb",
                    "+mwaitx",
                    "+rdpru",
                ]
            }
            "znver3" => {
                vec![
                    "+cmov",
                    "+mmx",
                    "+sse",
                    "+sse2",
                    "+sse3",
                    "+ssse3",
                    "+sse4.1",
                    "+sse4.2",
                    "+popcnt",
                    "+avx",
                    "+avx2",
                    "+fma",
                    "+bmi",
                    "+bmi2",
                    "+lzcnt",
                    "+movbe",
                    "+clzero",
                    "+adx",
                    "+rdseed",
                    "+sha",
                    "+xsavec",
                    "+xsaves",
                    "+clflushopt",
                    "+clwb",
                    "+mwaitx",
                    "+rdpru",
                    "+vaes",
                    "+vpclmulqdq",
                    "+shstk",
                    "+invpcid",
                ]
            }
            "znver4" => {
                vec![
                    "+cmov",
                    "+mmx",
                    "+sse",
                    "+sse2",
                    "+sse3",
                    "+ssse3",
                    "+sse4.1",
                    "+sse4.2",
                    "+popcnt",
                    "+avx",
                    "+avx2",
                    "+fma",
                    "+bmi",
                    "+bmi2",
                    "+lzcnt",
                    "+movbe",
                    "+clzero",
                    "+adx",
                    "+rdseed",
                    "+sha",
                    "+xsavec",
                    "+xsaves",
                    "+clflushopt",
                    "+clwb",
                    "+mwaitx",
                    "+rdpru",
                    "+vaes",
                    "+vpclmulqdq",
                    "+shstk",
                    "+invpcid",
                    "+avx512f",
                    "+avx512cd",
                    "+avx512bw",
                    "+avx512dq",
                    "+avx512vl",
                    "+avx512ifma",
                    "+avx512vbmi",
                    "+avx512vbmi2",
                    "+avx512vnni",
                    "+avx512bitalg",
                    "+avx512vpopcntdq",
                    "+gfni",
                ]
            }
            "znver5" => {
                vec![
                    "+cmov",
                    "+mmx",
                    "+sse",
                    "+sse2",
                    "+sse3",
                    "+ssse3",
                    "+sse4.1",
                    "+sse4.2",
                    "+popcnt",
                    "+avx",
                    "+avx2",
                    "+fma",
                    "+bmi",
                    "+bmi2",
                    "+lzcnt",
                    "+movbe",
                    "+clzero",
                    "+adx",
                    "+rdseed",
                    "+sha",
                    "+xsavec",
                    "+xsaves",
                    "+clflushopt",
                    "+clwb",
                    "+mwaitx",
                    "+rdpru",
                    "+vaes",
                    "+vpclmulqdq",
                    "+shstk",
                    "+invpcid",
                    "+avx512f",
                    "+avx512cd",
                    "+avx512bw",
                    "+avx512dq",
                    "+avx512vl",
                    "+avx512ifma",
                    "+avx512vbmi",
                    "+avx512vbmi2",
                    "+avx512vnni",
                    "+avx512bitalg",
                    "+avx512vpopcntdq",
                    "+gfni",
                    "+avx512fp16",
                    "+avxvnni",
                ]
            }
            "x86-64" | "x86-64-v2" => {
                vec![
                    "+cmov", "+mmx", "+sse", "+sse2", "+sse3", "+ssse3", "+sse4.1", "+sse4.2",
                    "+popcnt",
                ]
            }
            "x86-64-v3" => {
                vec![
                    "+cmov", "+mmx", "+sse", "+sse2", "+sse3", "+ssse3", "+sse4.1", "+sse4.2",
                    "+popcnt", "+avx", "+avx2", "+fma", "+bmi", "+bmi2", "+lzcnt", "+movbe",
                ]
            }
            "x86-64-v4" => {
                vec![
                    "+cmov",
                    "+mmx",
                    "+sse",
                    "+sse2",
                    "+sse3",
                    "+ssse3",
                    "+sse4.1",
                    "+sse4.2",
                    "+popcnt",
                    "+avx",
                    "+avx2",
                    "+fma",
                    "+bmi",
                    "+bmi2",
                    "+lzcnt",
                    "+movbe",
                    "+avx512f",
                    "+avx512cd",
                    "+avx512bw",
                    "+avx512dq",
                    "+avx512vl",
                ]
            }
            _ => vec!["+cmov", "+mmx", "+sse", "+sse2"],
        }
    }
}

impl Default for X86TripleParser {
    fn default() -> Self {
        Self::new("x86_64-unknown-linux-gnu")
    }
}

// ═══════════════════════════════════════════════════════════════════════════════
// 6. X86 Compiler RT — Compiler Runtime Integration
// ═══════════════════════════════════════════════════════════════════════════════

/// Compiler runtime (compiler-rt) integration for X86 targets.
///
/// Handles:
/// - compiler-rt builtins library path detection
/// - libgcc detection and fallback
/// - Runtime library selection per target
/// - Sanitizer runtime paths
/// - Profile runtime paths
#[derive(Debug, Clone)]
pub struct X86CompilerRT {
    /// Target triple.
    pub triple: Triple,
    /// Resource directory containing compiler-rt.
    pub resource_dir: Option<PathBuf>,
    /// Whether compiler-rt is available.
    pub has_compiler_rt: bool,
    /// Whether libgcc is available as fallback.
    pub has_libgcc: bool,
    /// Preferred runtime library.
    pub preferred_runtime: X86RuntimeLib,
    /// Builtins library path.
    pub builtins_path: Option<PathBuf>,
    /// Sanitizer runtime paths.
    pub sanitizer_paths: HashMap<String, PathBuf>,
    /// Profile runtime path.
    pub profile_path: Option<PathBuf>,
}

/// Runtime library selection.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum X86RuntimeLib {
    /// compiler-rt builtins
    CompilerRT,
    /// libgcc
    LibGcc,
    /// Auto-detect
    Auto,
}

impl X86CompilerRT {
    /// Create a new compiler-rt configuration.
    pub fn new(triple: &Triple) -> Self {
        let resource_dir = Self::detect_resource_dir();
        let has_compiler_rt = Self::check_compiler_rt_available(triple, resource_dir.as_deref());
        let has_libgcc = Self::check_libgcc_available(triple);
        let builtins_path = if has_compiler_rt {
            Self::find_builtins_library(triple, resource_dir.as_deref())
        } else if has_libgcc {
            Self::find_libgcc_path(triple)
        } else {
            None
        };

        Self {
            triple: triple.clone(),
            resource_dir,
            has_compiler_rt,
            has_libgcc,
            preferred_runtime: X86RuntimeLib::Auto,
            builtins_path,
            sanitizer_paths: Self::find_sanitizer_runtimes(triple),
            profile_path: Self::find_profile_runtime(triple),
        }
    }

    /// Detect the Clang resource directory.
    pub fn detect_resource_dir() -> Option<PathBuf> {
        // Try to get the resource directory from clang
        if let Ok(output) = ProcessCommand::new("clang")
            .args(["-print-resource-dir"])
            .output()
        {
            if output.status.success() {
                let path = String::from_utf8_lossy(&output.stdout).trim().to_string();
                let p = PathBuf::from(&path);
                if p.exists() {
                    return Some(p);
                }
            }
        }

        // Common Clang resource directories
        let candidates = [
            PathBuf::from("/usr/lib/clang"),
            PathBuf::from("/usr/local/lib/clang"),
            PathBuf::from("/opt/clang/lib/clang"),
        ];

        for candidate in &candidates {
            if let Ok(entries) = fs::read_dir(candidate) {
                for entry in entries.flatten() {
                    let path = entry.path();
                    if path.is_dir() {
                        // Version directories
                        let name = entry.file_name().to_string_lossy().to_string();
                        if name.chars().next().map_or(false, |c| c.is_ascii_digit()) {
                            return Some(path);
                        }
                    }
                }
            }
        }

        None
    }

    /// Check if compiler-rt is available for the given triple.
    pub fn check_compiler_rt_available(triple: &Triple, resource_dir: Option<&Path>) -> bool {
        if let Some(res_dir) = resource_dir {
            let lib_dir = res_dir.join("lib");
            if lib_dir.exists() {
                // Look for the platform-specific directory
                let triple_dir = lib_dir.join(triple.to_string());
                if triple_dir.exists() {
                    // Check for the builtins library
                    let builtins_name = Self::builtins_library_name(triple);
                    let builtins_path = triple_dir.join(&builtins_name);
                    return builtins_path.exists();
                }

                // Also check the linux subdirectory
                let linux_dir = lib_dir.join("linux");
                if linux_dir.exists() {
                    let builtins_name = Self::builtins_library_name(triple);
                    let builtins_path = linux_dir.join(&builtins_name);
                    return builtins_path.exists();
                }
            }
        }

        // Check if we can use compiler-rt via clang
        if let Ok(output) = ProcessCommand::new("clang")
            .args(["--rtlib=compiler-rt", "-print-libgcc-file-name"])
            .output()
        {
            if output.status.success() {
                let path = String::from_utf8_lossy(&output.stdout).trim().to_string();
                if !path.is_empty() {
                    return true;
                }
            }
        }

        false
    }

    /// Check if libgcc is available for the given triple.
    pub fn check_libgcc_available(triple: &Triple) -> bool {
        if let Ok(output) = ProcessCommand::new("gcc")
            .args(["-print-libgcc-file-name"])
            .output()
        {
            if output.status.success() {
                let path = String::from_utf8_lossy(&output.stdout).trim().to_string();
                if !path.is_empty() && Path::new(&path).exists() {
                    return true;
                }
            }
        }

        // Check common libgcc paths
        let libgcc_candidates = [
            format!("/usr/lib/gcc/{}/libgcc.a", triple.to_string()),
            format!("/usr/lib/gcc/{}/libgcc_s.so", triple.to_string()),
        ];

        for candidate in &libgcc_candidates {
            if Path::new(candidate).exists() {
                return true;
            }
        }

        false
    }

    /// Get the builtins library name for a target.
    pub fn builtins_library_name(triple: &Triple) -> String {
        format!("libclang_rt.builtins-{}.a", triple.arch.as_str())
    }

    /// Find the builtins library path.
    pub fn find_builtins_library(triple: &Triple, resource_dir: Option<&Path>) -> Option<PathBuf> {
        let lib_name = Self::builtins_library_name(triple);

        if let Some(res_dir) = resource_dir {
            let search_paths = vec![
                res_dir.join("lib").join(triple.to_string()).join(&lib_name),
                res_dir.join("lib").join("linux").join(&lib_name),
                res_dir.join("lib").join(&lib_name),
            ];

            for path in &search_paths {
                if path.exists() {
                    return Some(path.clone());
                }
            }
        }

        // Search in common compiler-rt locations
        let common_paths = vec![
            format!("/usr/lib/clang/18/lib/linux/{}", lib_name),
            format!("/usr/lib/llvm-18/lib/clang/18/lib/linux/{}", lib_name),
            format!("/usr/lib/clang/17/lib/linux/{}", lib_name),
            format!("/usr/lib/llvm-17/lib/clang/17/lib/linux/{}", lib_name),
        ];

        for path_str in &common_paths {
            let p = PathBuf::from(path_str);
            if p.exists() {
                return Some(p);
            }
        }

        None
    }

    /// Find the libgcc path.
    pub fn find_libgcc_path(triple: &Triple) -> Option<PathBuf> {
        if let Ok(output) = ProcessCommand::new("gcc")
            .args([
                &format!("-target{}", triple.to_string()),
                "-print-libgcc-file-name",
            ])
            .output()
        {
            if output.status.success() {
                let path = String::from_utf8_lossy(&output.stdout).trim().to_string();
                let p = PathBuf::from(&path);
                if p.exists() {
                    return Some(p);
                }
            }
        }

        None
    }

    /// Get the builtins library path.
    pub fn builtins_library_path(&self) -> Option<PathBuf> {
        self.builtins_path.clone()
    }

    /// Get the compiler-rt library path for a specific component.
    pub fn compiler_rt_library(&self, component: &str) -> Option<PathBuf> {
        if let Some(ref res_dir) = self.resource_dir {
            let lib_name = format!("libclang_rt.{}-{}.a", component, self.triple.arch.as_str());
            let search_paths = vec![
                res_dir
                    .join("lib")
                    .join(self.triple.to_string())
                    .join(&lib_name),
                res_dir.join("lib").join("linux").join(&lib_name),
            ];

            for path in &search_paths {
                if path.exists() {
                    return Some(path.clone());
                }
            }
        }

        None
    }

    /// Find sanitizer runtime paths.
    pub fn find_sanitizer_runtimes(triple: &Triple) -> HashMap<String, PathBuf> {
        let mut paths = HashMap::new();

        let sanitizers = [
            "asan",             // AddressSanitizer
            "ubsan_standalone", // UndefinedBehaviorSanitizer
            "lsan",             // LeakSanitizer
            "tsan",             // ThreadSanitizer
            "msan",             // MemorySanitizer
            "dfsan",            // DataFlowSanitizer
            "hwasan",           // Hardware-assisted AddressSanitizer
            "memprof",          // Memory Profiler
            "xray",             // XRay instrumentation
            "fuzzer",           // libFuzzer
            "scudo_standalone", // Scudo hardened allocator
            "gwp_asan",         // GWP-ASan
        ];

        if let Some(res_dir) = Self::detect_resource_dir() {
            let lib_dir = res_dir.join("lib").join("linux");
            for sanitizer in &sanitizers {
                let lib_name = format!("libclang_rt.{}-{}.a", sanitizer, triple.arch.as_str());
                let path = lib_dir.join(&lib_name);
                if path.exists() {
                    paths.insert(sanitizer.to_string(), path);
                }
            }
        }

        paths
    }

    /// Find the profile runtime path.
    pub fn find_profile_runtime(triple: &Triple) -> Option<PathBuf> {
        if let Some(res_dir) = Self::detect_resource_dir() {
            let lib_name = format!("libclang_rt.profile-{}.a", triple.arch.as_str());
            let path = res_dir.join("lib").join("linux").join(&lib_name);
            if path.exists() {
                return Some(path);
            }
        }
        None
    }

    /// Select the best available runtime library.
    pub fn select_runtime(&self) -> X86RuntimeLib {
        match self.preferred_runtime {
            X86RuntimeLib::CompilerRT => X86RuntimeLib::CompilerRT,
            X86RuntimeLib::LibGcc => X86RuntimeLib::LibGcc,
            X86RuntimeLib::Auto => {
                if self.has_compiler_rt {
                    X86RuntimeLib::CompilerRT
                } else if self.has_libgcc {
                    X86RuntimeLib::LibGcc
                } else {
                    // Default to libgcc as universal fallback
                    X86RuntimeLib::LibGcc
                }
            }
        }
    }

    /// Get the linker flags for the selected runtime library.
    pub fn linker_flags(&self) -> Vec<String> {
        let mut flags = Vec::new();

        match self.select_runtime() {
            X86RuntimeLib::CompilerRT => {
                flags.push("--rtlib=compiler-rt".to_string());
                if let Some(ref path) = self.builtins_path {
                    flags.push(path.to_string_lossy().to_string());
                }
            }
            X86RuntimeLib::LibGcc => {
                flags.push("--rtlib=libgcc".to_string());
            }
            X86RuntimeLib::Auto => {
                // Use whatever the compiler defaults to
            }
        }

        flags
    }

    /// Check if the target needs libgcc_eh for exception handling.
    pub fn needs_libgcc_eh(triple: &Triple) -> bool {
        // Linux glibc targets use libgcc_s for unwinding
        if triple.os == OS::Linux && triple.environment == Environment::GNU {
            return true;
        }

        // MinGW targets need libgcc_eh
        if triple.os == OS::Win32 && triple.environment == Environment::GNU {
            return true;
        }

        false
    }

    /// Get the list of runtime libraries to link for this target.
    pub fn runtime_libraries(&self) -> Vec<String> {
        let mut libs = Vec::new();

        match self.select_runtime() {
            X86RuntimeLib::CompilerRT => {
                libs.push("clang_rt.builtins".to_string());
                if Self::needs_libgcc_eh(&self.triple) {
                    libs.push("unwind".to_string());
                }
            }
            X86RuntimeLib::LibGcc => {
                libs.push("gcc".to_string());
                if Self::needs_libgcc_eh(&self.triple) {
                    libs.push("gcc_eh".to_string());
                }
            }
            X86RuntimeLib::Auto => {}
        }

        libs
    }

    /// Detect the presence of Control Flow Integrity (CFI) runtime.
    pub fn has_cfi(&self) -> bool {
        if let Some(ref res_dir) = self.resource_dir {
            let cfi_name = format!("libclang_rt.cfi-{}.a", self.triple.arch.as_str());
            let cfi_path = res_dir.join("lib").join("linux").join(&cfi_name);
            return cfi_path.exists();
        }
        false
    }

    /// Detect the presence of Shadow Call Stack (SCS) runtime.
    pub fn has_shadow_call_stack(&self) -> bool {
        if let Some(ref res_dir) = self.resource_dir {
            let scs_name = format!("libclang_rt.scs-{}.a", self.triple.arch.as_str());
            let scs_path = res_dir.join("lib").join("linux").join(&scs_name);
            return scs_path.exists();
        }
        false
    }

    /// Detect the presence of SafeStack runtime.
    pub fn has_safestack(&self) -> bool {
        if let Some(ref res_dir) = self.resource_dir {
            let ss_name = format!("libclang_rt.safestack-{}.a", self.triple.arch.as_str());
            let ss_path = res_dir.join("lib").join("linux").join(&ss_name);
            return ss_path.exists();
        }
        false
    }

    /// Get all compiler-rt components with their availability.
    pub fn available_components(&self) -> HashMap<String, bool> {
        let mut components = HashMap::new();

        let component_names = vec![
            ("builtins", true),  // Always needed
            ("asan", true),      // AddressSanitizer
            ("asan_cxx", false), // ASan C++ interceptor
            ("ubsan_standalone", true),
            ("ubsan_minimal", false),
            ("lsan", true),
            ("tsan", true),
            ("msan", true),
            ("dfsan", true),
            ("hwasan", true),
            ("memprof", true),
            ("xray", true),
            ("xray-basic", false),
            ("xray-fdr", false),
            ("fuzzer", true),
            ("fuzzer_no_main", false),
            ("scudo_standalone", true),
            ("scudo_minimal", false),
            ("gwp_asan", true),
            ("profile", true),
            ("cfi", true),
            ("cfi_diag", false),
            ("dd", true), // Data flow detector
            ("safestack", true),
            ("stats", false),
            ("stats_client", false),
            ("orc", false), // ORC JIT runtime
            ("shadowcallstack", true),
        ];

        if let Some(ref res_dir) = self.resource_dir {
            let lib_dir = res_dir.join("lib").join("linux");
            for (name, _default_available) in &component_names {
                let lib_name = format!("libclang_rt.{}-{}.a", name, self.triple.arch.as_str());
                let path = lib_dir.join(&lib_name);
                components.insert(name.to_string(), path.exists());
            }
        } else {
            for (name, default_available) in &component_names {
                components.insert(name.to_string(), *default_available);
            }
        }

        components
    }

    /// Check if this X86 target supports hardware-assisted ASan (HWASan).
    pub fn supports_hwasan(triple: &Triple) -> bool {
        // HWASan requires AArch64 with top-byte-ignore, not available on X86
        // But checking for documentation purposes
        matches!(triple.arch, Arch::AArch64)
    }

    /// Check if Memory Tagging Extension (MTE) is available.
    pub fn supports_mte(triple: &Triple) -> bool {
        matches!(triple.arch, Arch::AArch64)
    }

    /// Get recommended sanitizer flags for the target.
    pub fn recommended_sanitizer_flags(&self) -> Vec<String> {
        let mut flags = Vec::new();

        // AddressSanitizer recommendations
        if self.sanitizer_paths.contains_key("asan") {
            flags.push("-fsanitize=address".to_string());
            flags.push("-fno-omit-frame-pointer".to_string());
            flags.push("-fno-optimize-sibling-calls".to_string());
        }

        // UndefinedBehaviorSanitizer recommendations
        if self.sanitizer_paths.contains_key("ubsan_standalone") {
            flags.push("-fsanitize=undefined".to_string());
            flags.push("-fno-sanitize-recover=all".to_string());
        }

        flags
    }

    /// Detect the version of compiler-rt installed.
    pub fn detect_compiler_rt_version() -> Option<String> {
        if let Some(res_dir) = Self::detect_resource_dir() {
            // The parent of the resource dir is the version directory
            if let Some(version_dir) = res_dir.parent() {
                return version_dir
                    .file_name()
                    .map(|n| n.to_string_lossy().to_string());
            }
            // The resource dir itself might be the version (e.g., .../clang/18)
            return res_dir.file_name().map(|n| n.to_string_lossy().to_string());
        }
        None
    }
}

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

// ═══════════════════════════════════════════════════════════════════════════════
// 7. X86 Resource Dir — Resource Directory Management
// ═══════════════════════════════════════════════════════════════════════════════

/// Resource directory management for Clang on X86.
///
/// Handles:
/// - Clang resource directory structure
/// - Include paths relative to resource dir
/// - Library paths relative to resource dir
/// - Versioned resource directories
/// - Builtin headers location
#[derive(Debug, Clone)]
pub struct X86ResourceDir {
    /// The target triple.
    pub triple: Triple,
    /// Resource directory path.
    pub path: PathBuf,
    /// Clang version string.
    pub clang_version: String,
    /// Whether the resource directory exists.
    pub is_valid: bool,
    /// Sub-paths within the resource directory.
    pub include_subdir: PathBuf,
    pub lib_subdir: PathBuf,
    pub share_subdir: PathBuf,
}

impl X86ResourceDir {
    /// Create a new resource directory manager.
    pub fn new(triple: &Triple) -> Self {
        let (path, version) = Self::detect_resource_dir();
        let include_subdir = path.join("include");
        let lib_subdir = path.join("lib");
        let share_subdir = path.join("share");
        let is_valid = path.exists();

        Self {
            triple: triple.clone(),
            path,
            clang_version: version,
            is_valid,
            include_subdir,
            lib_subdir,
            share_subdir,
        }
    }

    /// Detect the Clang resource directory from the installed Clang.
    pub fn detect_resource_dir() -> (PathBuf, String) {
        // Try clang -print-resource-dir
        if let Ok(output) = ProcessCommand::new("clang")
            .args(["-print-resource-dir"])
            .output()
        {
            if output.status.success() {
                let path = String::from_utf8_lossy(&output.stdout).trim().to_string();
                let p = PathBuf::from(&path);
                if p.exists() {
                    // Extract version from path (e.g., .../clang/18 -> "18")
                    let version = p
                        .parent()
                        .and_then(|p| p.file_name())
                        .map(|n| n.to_string_lossy().to_string())
                        .unwrap_or_else(|| "unknown".to_string());

                    return (p, version);
                }
            }
        }

        // Try to find versioned clang directories
        let search_bases = vec![
            PathBuf::from("/usr/lib/clang"),
            PathBuf::from("/usr/local/lib/clang"),
            PathBuf::from("/opt/clang/lib/clang"),
            PathBuf::from("/usr/lib/llvm"),
            PathBuf::from("/usr/lib/llvm-18/lib/clang"),
            PathBuf::from("/usr/lib/llvm-17/lib/clang"),
            PathBuf::from("/usr/lib/llvm-16/lib/clang"),
            PathBuf::from("/usr/lib/llvm-15/lib/clang"),
            PathBuf::from("/usr/lib/llvm-14/lib/clang"),
        ];

        for base in &search_bases {
            // Try direct version subdirectories
            for version_dir in Self::find_version_dirs(base) {
                let p = version_dir.clone();
                if p.join("include").exists() && p.join("lib").exists() {
                    let version = p
                        .file_name()
                        .map(|n| n.to_string_lossy().to_string())
                        .unwrap_or_default();
                    return (p, version);
                }
            }
        }

        // Fallback: construct a default path
        let default_path = PathBuf::from("/usr/lib/clang/18");
        (default_path, "18".to_string())
    }

    /// Find version directories under a base path.
    fn find_version_dirs(base: &Path) -> Vec<PathBuf> {
        let mut dirs = Vec::new();

        if let Ok(entries) = fs::read_dir(base) {
            for entry in entries.flatten() {
                let name = entry.file_name().to_string_lossy().to_string();
                // Version directories are typically just numbers
                if name.chars().all(|c| c.is_ascii_digit() || c == '.') {
                    if entry.path().is_dir() {
                        dirs.push(entry.path());
                    }
                }
            }
        }

        // Sort by numeric version (descending)
        dirs.sort_by(|a, b| {
            let va = a
                .file_name()
                .and_then(|n| n.to_str())
                .and_then(|s| s.parse::<f64>().ok());
            let vb = b
                .file_name()
                .and_then(|n| n.to_str())
                .and_then(|s| s.parse::<f64>().ok());
            vb.partial_cmp(&va).unwrap_or(std::cmp::Ordering::Equal)
        });

        dirs
    }

    /// Get the resource directory path.
    pub fn path(&self) -> &Path {
        &self.path
    }

    /// Get the include directory within the resource dir.
    pub fn include_dir(&self) -> PathBuf {
        self.include_subdir.clone()
    }

    /// Get the library directory within the resource dir.
    pub fn lib_dir(&self) -> PathBuf {
        self.lib_subdir.clone()
    }

    /// Get the share directory within the resource dir.
    pub fn share_dir(&self) -> PathBuf {
        self.share_subdir.clone()
    }

    /// Get the builtin headers directory.
    pub fn builtin_headers_dir(&self) -> PathBuf {
        self.include_dir()
    }

    /// Get the target-specific library directory.
    pub fn target_lib_dir(&self) -> PathBuf {
        self.lib_dir().join(self.triple.to_string())
    }

    /// Get the configuration directory.
    pub fn config_dir(&self) -> PathBuf {
        self.share_dir()
    }

    /// Get the full include path for a header relative to the resource dir.
    pub fn include_path(&self, header: &str) -> PathBuf {
        self.include_dir().join(header)
    }

    /// Check if a specific builtin header exists.
    pub fn has_builtin_header(&self, header: &str) -> bool {
        self.include_path(header).exists()
    }

    /// List available builtin headers.
    pub fn list_builtin_headers(&self) -> Vec<String> {
        let mut headers = Vec::new();
        let inc_dir = self.include_dir();

        if let Ok(entries) = fs::read_dir(&inc_dir) {
            for entry in entries.flatten() {
                let name = entry.file_name().to_string_lossy().to_string();
                if name.ends_with(".h") {
                    headers.push(name);
                }
            }
        }

        headers.sort();
        headers
    }

    /// List common builtin headers that ship with Clang.
    pub fn expected_builtin_headers() -> Vec<&'static str> {
        vec![
            "__clang_cuda_builtin_vars.h",
            "__clang_cuda_cmath.h",
            "__clang_cuda_complex_builtins.h",
            "__clang_cuda_device_functions.h",
            "__clang_cuda_intrinsics.h",
            "__clang_cuda_libdevice_declares.h",
            "__clang_cuda_math.h",
            "__clang_cuda_math_forward_declares.h",
            "__clang_cuda_runtime_wrapper.h",
            "__clang_hip_cmath.h",
            "__clang_hip_libdevice_declares.h",
            "__clang_hip_math.h",
            "__clang_hip_runtime_wrapper.h",
            "__stdarg_va_arg.h",
            "__stddef_max_align_t.h",
            "__stddef_null.h",
            "__stddef_offsetof.h",
            "__stddef_ptrdiff_t.h",
            "__stddef_rsize_t.h",
            "__stddef_size_t.h",
            "__stddef_unreachable.h",
            "__stddef_wchar_t.h",
            "__stddef_wint_t.h",
            "__wmmintrin_aes.h",
            "__wmmintrin_pclmul.h",
            "adxintrin.h",
            "altivec.h",
            "ammintrin.h",
            "arm_acle.h",
            "arm_cmse.h",
            "arm_fp16.h",
            "arm_mve.h",
            "arm_neon.h",
            "arm_sve.h",
            "armintr.h",
            "avx2intrin.h",
            "avx512bf16intrin.h",
            "avx512bitalgintrin.h",
            "avx512bwintrin.h",
            "avx512cdintrin.h",
            "avx512dqintrin.h",
            "avx512erintrin.h",
            "avx512fintrin.h",
            "avx512fp16intrin.h",
            "avx512ifmaintrin.h",
            "avx512pfintrin.h",
            "avx512vbmi2intrin.h",
            "avx512vbmiintrin.h",
            "avx512vlbwintrin.h",
            "avx512vldqintrin.h",
            "avx512vlintrin.h",
            "avx512vnniintrin.h",
            "avx512vp2intersectintrin.h",
            "avx512vpopcntdqintrin.h",
            "avxintrin.h",
            "bmi2intrin.h",
            "bmiintrin.h",
            "cetintrin.h",
            "cldemoteintrin.h",
            "clflushoptintrin.h",
            "clwbintrin.h",
            "clzerointrin.h",
            "cpuid.h",
            "crc32intrin.h",
            "emmintrin.h",
            "enqcmdintrin.h",
            "f16cintrin.h",
            "float.h",
            "fma4intrin.h",
            "fmaintrin.h",
            "fxsrintrin.h",
            "gfniintrin.h",
            "hresetintrin.h",
            "ia32intrin.h",
            "immintrin.h",
            "intrin.h",
            "inttypes.h",
            "invpcidintrin.h",
            "iso646.h",
            "keylockerintrin.h",
            "limits.h",
            "lwpintrin.h",
            "lzcntintrin.h",
            "mm3dnow.h",
            "mm_malloc.h",
            "mmintrin.h",
            "movdirintrin.h",
            "mwaitxintrin.h",
            "nmmintrin.h",
            "opencl-c-base.h",
            "opencl-c.h",
            "pconfigintrin.h",
            "pkuintrin.h",
            "pmmintrin.h",
            "popcntintrin.h",
            "prfchwintrin.h",
            "ptwriteintrin.h",
            "rdseedintrin.h",
            "rtmintrin.h",
            "s390intrin.h",
            "serializeintrin.h",
            "sgxintrin.h",
            "shaintrin.h",
            "smmintrin.h",
            "stdalign.h",
            "stdarg.h",
            "stdatomic.h",
            "stdbool.h",
            "stddef.h",
            "stdint.h",
            "stdnoreturn.h",
            "tbmintrin.h",
            "tmmintrin.h",
            "tsxldtrkintrin.h",
            "uintrintrin.h",
            "vaesintrin.h",
            "varargs.h",
            "vpclmulqdqintrin.h",
            "waitpkgintrin.h",
            "wbnoinvdintrin.h",
            "wmmintrin.h",
            "x86intrin.h",
            "xmmintrin.h",
            "xopintrin.h",
            "xsavecintrin.h",
            "xsavesintrin.h",
            "xtestintrin.h",
        ]
    }

    /// Get the path to a specific sanitizer runtime library.
    pub fn sanitizer_library_path(&self, sanitizer: &str) -> Option<PathBuf> {
        let arch = self.triple.arch.as_str();
        let lib_name = format!("libclang_rt.{}-{}.a", sanitizer, arch);
        let path = self.target_lib_dir().join(&lib_name);

        if path.exists() {
            Some(path)
        } else {
            // Also check the linux subdirectory
            let linux_path = self.lib_dir().join("linux").join(&lib_name);
            if linux_path.exists() {
                Some(linux_path)
            } else {
                None
            }
        }
    }

    /// Get the compiler-rt builtins library path.
    pub fn builtins_path(&self) -> Option<PathBuf> {
        self.sanitizer_library_path("builtins")
    }

    /// Check if the resource directory contains the expected structure.
    pub fn validate(&self) -> Vec<String> {
        let mut issues = Vec::new();

        if !self.path.exists() {
            issues.push(format!(
                "Resource directory does not exist: {}",
                self.path.display()
            ));
            return issues;
        }

        if !self.include_dir().exists() {
            issues.push("Include directory missing in resource dir".to_string());
        }

        if !self.lib_dir().exists() {
            issues.push("Library directory missing in resource dir".to_string());
        }

        // Check for essential builtin headers
        let essential_headers = ["stddef.h", "stdarg.h", "stdbool.h", "stdint.h", "float.h"];
        for header in &essential_headers {
            if !self.has_builtin_header(header) {
                issues.push(format!("Missing essential header: {}", header));
            }
        }

        issues
    }
}

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

// ═══════════════════════════════════════════════════════════════════════════════
// 8. X86 Cross-Library — Cross-Library Support
// ═══════════════════════════════════════════════════════════════════════════════

/// Cross-library support for X86 cross-compilation.
///
/// Handles:
/// - glibc cross-installation paths and configuration
/// - musl cross-compilation toolchain
/// - Bionic (Android libc) cross paths
/// - Newlib cross paths (bare-metal/embedded)
/// - picolibc cross paths (small-footprint C library)
#[derive(Debug, Clone)]
pub struct X86CrossLibrary {
    /// The target triple.
    pub triple: Triple,
    /// Detected C library type.
    pub libc_type: X86LibC,
    /// Whether a cross-installed C library was found.
    pub found: bool,
    /// Cross-library root path.
    pub root_path: Option<PathBuf>,
    /// Include paths for the cross library.
    pub include_dirs: Vec<PathBuf>,
    /// Library paths for the cross library.
    pub library_dirs: Vec<PathBuf>,
    /// Startup objects directory.
    pub crt_dir: Option<PathBuf>,
    /// Dynamic linker path.
    pub dynamic_linker: Option<String>,
    /// Library version if known.
    pub version: Option<String>,
}

impl X86CrossLibrary {
    /// Create a new cross-library configuration.
    pub fn new(triple: &Triple) -> Self {
        let libc_type = Self::detect_libc_type(triple);
        let (root_path, found) = Self::find_cross_library(triple, libc_type);
        let include_dirs = Self::find_include_dirs(triple, libc_type, root_path.as_deref());
        let library_dirs = Self::find_library_dirs(triple, libc_type, root_path.as_deref());
        let crt_dir = Self::find_crt_dir(triple, libc_type, root_path.as_deref());
        let dynamic_linker = Self::detect_dynamic_linker(triple, libc_type);
        let version = Self::detect_libc_version(triple, libc_type, root_path.as_deref());

        Self {
            triple: triple.clone(),
            libc_type,
            found,
            root_path,
            include_dirs,
            library_dirs,
            crt_dir,
            dynamic_linker,
            version,
        }
    }

    /// Detect the C library type from the target triple.
    pub fn detect_libc_type(triple: &Triple) -> X86LibC {
        match triple.environment {
            Environment::Musl => X86LibC::Musl,
            Environment::Android | Environment::Androideabi => X86LibC::Bionic,
            _ => match triple.os {
                OS::Linux => X86LibC::Glibc,
                OS::Darwin | OS::MacOSX | OS::IOS | OS::TvOS | OS::WatchOS => X86LibC::LibSystem,
                OS::Win32 => match triple.environment {
                    Environment::MSVC => X86LibC::Msvcrt,
                    _ => X86LibC::UCRT,
                },
                _ => X86LibC::Glibc,
            },
        }
    }

    /// Find the cross-library installation root.
    pub fn find_cross_library(triple: &Triple, libc_type: X86LibC) -> (Option<PathBuf>, bool) {
        match libc_type {
            X86LibC::Glibc => Self::find_glibc_cross(triple),
            X86LibC::Musl => Self::find_musl_cross(triple),
            X86LibC::Bionic => Self::find_bionic_cross(triple),
            X86LibC::Newlib => Self::find_newlib_cross(triple),
            X86LibC::Picolibc => Self::find_picolibc_cross(triple),
            X86LibC::LibSystem => (None, true), // macOS has it built-in
            X86LibC::Msvcrt | X86LibC::UCRT => (None, true), // Windows CRT is system
            X86LibC::None_ => (None, false),
        }
    }

    // ── glibc cross-installation ──────────────────────────────────────────

    /// Find a cross-installed glibc for the target.
    pub fn find_glibc_cross(triple: &Triple) -> (Option<PathBuf>, bool) {
        // Common cross-compilation directories
        let candidates = vec![
            format!("/usr/{}", triple.to_string()),
            format!("/usr/cross/{}", triple.to_string()),
            format!("/opt/cross/{}", triple.to_string()),
            format!("/usr/{}/sys-root", triple.to_string()),
        ];

        for candidate in &candidates {
            let p = PathBuf::from(candidate);
            if p.exists() {
                // Check for glibc-specific files
                let libc_so = p.join("lib").join("libc.so.6");
                let libc_a = p.join("lib").join("libc.a");
                let include = p.join("include").join("stdio.h");

                if (libc_so.exists() || libc_a.exists()) && include.exists() {
                    return (Some(p), true);
                }
            }
        }

        // Check GCC sysroot for cross-compilation
        if let Ok(output) = ProcessCommand::new("gcc")
            .args([&format!("-target={}", triple.to_string()), "-print-sysroot"])
            .output()
        {
            if output.status.success() {
                let path = String::from_utf8_lossy(&output.stdout).trim().to_string();
                let p = PathBuf::from(&path);
                if p.exists() && p.join("usr").join("lib").exists() {
                    return (Some(p), true);
                }
            }
        }

        // Native glibc (host compilation)
        if !Self::is_cross_target(triple) {
            return (Some(PathBuf::from("/")), true);
        }

        (None, false)
    }

    /// Detect glibc version from the installation.
    pub fn detect_glibc_version(root: Option<&Path>) -> Option<String> {
        let lib_dir = if let Some(r) = root {
            r.join("lib")
        } else {
            PathBuf::from("/lib")
        };

        // Try to read from libc.so.6 (which is a linker script containing version)
        let libc_so = lib_dir.join("libc.so.6");
        if let Ok(content) = fs::read_to_string(&libc_so) {
            for line in content.lines() {
                if line.contains("GLIBC_") {
                    if let Some(version) = line.split("GLIBC_").nth(1) {
                        return Some(version.trim().to_string());
                    }
                }
            }
        }

        // Try running /lib/libc.so.6 (it prints version info)
        if let Ok(output) = ProcessCommand::new(&libc_so).output() {
            let stdout = String::from_utf8_lossy(&output.stdout);
            for line in stdout.lines() {
                if line.contains("GNU C Library") {
                    // Extract version from line like "GNU C Library (GNU libc) stable release version 2.35."
                    let parts: Vec<&str> = line.split_whitespace().collect();
                    for (i, part) in parts.iter().enumerate() {
                        if *part == "version" && i + 1 < parts.len() {
                            let v = parts[i + 1].trim_end_matches('.');
                            return Some(v.to_string());
                        }
                    }
                }
                if line.contains("release version") {
                    if let Some(idx) = line.find("release version") {
                        let rest = &line[idx + "release version".len()..];
                        let v = rest.trim().trim_end_matches('.');
                        return Some(v.to_string());
                    }
                }
            }
        }

        None
    }

    /// Check if the given triple is a cross-compilation target.
    fn is_cross_target(triple: &Triple) -> bool {
        let host_triple = X86SysrootDetector::detect_host_triple();
        let host = Triple::parse(&host_triple);
        triple.arch != host.arch || triple.os != host.os
    }

    // ── musl cross-compilation ────────────────────────────────────────────

    /// Find a musl cross-compilation installation.
    pub fn find_musl_cross(triple: &Triple) -> (Option<PathBuf>, bool) {
        let arch_dir = match triple.arch {
            Arch::X86_64 => "x86_64",
            Arch::X86 => "i386",
            _ => triple.arch.as_str(),
        };

        let candidates = vec![
            format!("/usr/{}-linux-musl", arch_dir),
            format!("/usr/{}-linux-musl-cross", arch_dir),
            format!("/opt/musl/{}-linux-musl", arch_dir),
            format!("/opt/{}-linux-musl-cross", arch_dir),
            format!("/usr/local/musl/{}-linux-musl", arch_dir),
            format!("/usr/local/{}-linux-musl", arch_dir),
            // musl-cross-make output
            format!("/opt/cross/{}-linux-musl", arch_dir),
            format!("/usr/local/musl-cross/{}-linux-musl", arch_dir),
        ];

        for candidate in &candidates {
            let p = PathBuf::from(candidate);
            if p.exists() {
                let include = p.join("include").join("stdio.h");
                let lib = p.join("lib").join("libc.a");
                if include.exists() && lib.exists() {
                    return (Some(p), true);
                }
            }
        }

        // Check if musl-gcc wrapper provides the path
        let wrapper_names = vec![format!("{}-linux-musl-gcc", arch_dir), format!("musl-gcc")];

        for wrapper in &wrapper_names {
            if let Ok(output) = ProcessCommand::new(wrapper)
                .args(["-print-sysroot"])
                .output()
            {
                if output.status.success() {
                    let path = String::from_utf8_lossy(&output.stdout).trim().to_string();
                    let p = PathBuf::from(&path);
                    if p.exists() {
                        return (Some(p), true);
                    }
                }
            }
        }

        (None, false)
    }

    /// Detect musl version.
    pub fn detect_musl_version(root: Option<&Path>) -> Option<String> {
        let include_dir = if let Some(r) = root {
            r.join("include")
        } else {
            PathBuf::from("/usr/include")
        };

        // musl puts version in features.h or version.h
        for header in &["version.h", "features.h"] {
            let path = include_dir.join(header);
            if let Ok(content) = fs::read_to_string(&path) {
                for line in content.lines() {
                    if line.contains("VERSION") && line.contains("\"") {
                        // Look for quoted version string
                        if let Some(start) = line.find('"') {
                            if let Some(end) = line[start + 1..].find('"') {
                                let version = &line[start + 1..start + 1 + end];
                                return Some(version.to_string());
                            }
                        }
                    }
                }
            }
        }

        // Try running musl libc.so
        let libc_so = if let Some(r) = root {
            r.join("lib").join("libc.so")
        } else {
            PathBuf::from("/lib/libc.so")
        };

        if let Ok(output) = ProcessCommand::new(&libc_so).output() {
            let stdout = String::from_utf8_lossy(&output.stdout);
            for line in stdout.lines() {
                if line.contains("musl libc") {
                    if let Some(idx) = line.find("Version") {
                        let rest = &line[idx + "Version".len()..];
                        return Some(rest.trim().to_string());
                    }
                }
            }
        }

        None
    }

    // ── Bionic (Android libc) cross ───────────────────────────────────────

    /// Find a Bionic (Android) cross-library installation.
    pub fn find_bionic_cross(triple: &Triple) -> (Option<PathBuf>, bool) {
        let detector = X86SysrootDetector::new(&triple.to_string());
        if let Some(ndk_sysroot) = detector.detect_android_ndk_sysroot() {
            return (Some(ndk_sysroot), true);
        }

        // Check common Android NDK paths
        let android_arch = match triple.arch {
            Arch::X86_64 => "x86_64",
            Arch::X86 => "x86",
            Arch::AArch64 => "arm64",
            Arch::ARM => "arm",
            _ => "x86",
        };

        let candidates = vec![
            format!(
                "/usr/android-ndk/platforms/android-21/arch-{}",
                android_arch
            ),
            format!(
                "/opt/android-ndk/platforms/android-21/arch-{}",
                android_arch
            ),
        ];

        for candidate in &candidates {
            let p = PathBuf::from(candidate);
            if p.exists() {
                return (Some(p), true);
            }
        }

        (None, false)
    }

    /// Detect Bionic (Android) version.
    pub fn detect_bionic_version(root: Option<&Path>) -> Option<String> {
        let usr_include = if let Some(r) = root {
            r.join("usr").join("include")
        } else {
            PathBuf::from("/usr/include")
        };

        // Android puts API level in android/api-level.h
        let api_header = usr_include.join("android").join("api-level.h");
        if let Ok(content) = fs::read_to_string(&api_header) {
            for line in content.lines() {
                if line.contains("__ANDROID_API__") {
                    let parts: Vec<&str> = line.split_whitespace().collect();
                    if let Some(val) = parts.last() {
                        return Some(val.to_string());
                    }
                }
            }
        }

        None
    }

    // ── Newlib cross ──────────────────────────────────────────────────────

    /// Find a Newlib cross-compilation installation.
    pub fn find_newlib_cross(triple: &Triple) -> (Option<PathBuf>, bool) {
        let arch_name = triple.arch.as_str();

        let candidates = vec![
            format!("/usr/{}-elf", arch_name),
            format!("/opt/cross/{}-elf", arch_name),
            format!("/usr/local/{}-elf", arch_name),
        ];

        for candidate in &candidates {
            let p = PathBuf::from(candidate);
            if p.exists() {
                let include = p.join("include").join("stdio.h");
                let lib = p.join("lib").join("libc.a");
                if include.exists() && lib.exists() {
                    return (Some(p), true);
                }
            }
        }

        (None, false)
    }

    /// Detect Newlib version.
    pub fn detect_newlib_version(root: Option<&Path>) -> Option<String> {
        let include_dir = if let Some(r) = root {
            r.join("include")
        } else {
            PathBuf::from("/usr/include")
        };

        let newlib_h = include_dir.join("_newlib_version.h");
        if let Ok(content) = fs::read_to_string(&newlib_h) {
            for line in content.lines() {
                if line.contains("_NEWLIB_VERSION") && line.contains("\"") {
                    if let Some(start) = line.find('"') {
                        if let Some(end) = line[start + 1..].find('"') {
                            return Some(line[start + 1..start + 1 + end].to_string());
                        }
                    }
                }
            }
        }

        // Try from newlib.h
        let newlib_header = include_dir.join("newlib.h");
        if let Ok(content) = fs::read_to_string(&newlib_header) {
            for line in content.lines() {
                if line.contains("_NEWLIB_VERSION") || line.contains("__NEWLIB__") {
                    let parts: Vec<&str> = line.split_whitespace().collect();
                    if let Some(val) = parts.last() {
                        let v = val.trim_matches('"');
                        return Some(v.to_string());
                    }
                }
            }
        }

        None
    }

    // ── picolibc cross ────────────────────────────────────────────────────

    /// Find a picolibc cross-compilation installation.
    pub fn find_picolibc_cross(triple: &Triple) -> (Option<PathBuf>, bool) {
        let arch_name = triple.arch.as_str();

        let candidates = vec![
            format!("/usr/lib/picolibc/{}-elf", arch_name),
            format!("/opt/picolibc/{}-elf", arch_name),
            format!("/usr/local/picolibc/{}-elf", arch_name),
            format!("/usr/{}-elf/lib/picolibc", arch_name),
            // picolibc is often installed alongside the toolchain
            format!("/usr/lib/gcc/{}-elf/picolibc", arch_name),
        ];

        for candidate in &candidates {
            let p = PathBuf::from(candidate);
            if p.exists() {
                let include = p.join("include").join("stdio.h");
                if include.exists() {
                    return (Some(p), true);
                }
            }
        }

        // Check via picolibc.specs or picolibc ld script
        let specs_candidates = vec![
            PathBuf::from("/usr/lib/picolibc.specs"),
            PathBuf::from("/usr/local/lib/picolibc.specs"),
        ];

        for spec in &specs_candidates {
            if spec.exists() {
                // Parent of the specs file is usually the picolibc root
                if let Some(parent) = spec.parent() {
                    let include = parent.join("include").join("stdio.h");
                    if include.exists() {
                        return (Some(parent.to_path_buf()), true);
                    }
                }
            }
        }

        (None, false)
    }

    /// Detect picolibc version.
    pub fn detect_picolibc_version(root: Option<&Path>) -> Option<String> {
        let include_dir = if let Some(r) = root {
            r.join("include")
        } else {
            PathBuf::from("/usr/include")
        };

        let picolibc_h = include_dir.join("picolibc.h");
        if let Ok(content) = fs::read_to_string(&picolibc_h) {
            for line in content.lines() {
                if line.contains("PICOLIBC_VERSION") || line.contains("__PICOLIBC_VERSION__") {
                    if let Some(start) = line.find('"') {
                        if let Some(end) = line[start + 1..].find('"') {
                            return Some(line[start + 1..start + 1 + end].to_string());
                        }
                    }
                }
            }
        }

        // Try version.h
        let version_h = include_dir.join("version.h");
        if let Ok(content) = fs::read_to_string(&version_h) {
            for line in content.lines() {
                if line.contains("PICOLIBC") && line.contains("VERSION") {
                    let parts: Vec<&str> = line.split_whitespace().collect();
                    if let Some(val) = parts.last() {
                        return Some(val.trim_matches('"').to_string());
                    }
                }
            }
        }

        None
    }

    // ── Generic helpers ───────────────────────────────────────────────────

    /// Find include directories for the cross library.
    pub fn find_include_dirs(
        triple: &Triple,
        libc_type: X86LibC,
        root: Option<&Path>,
    ) -> Vec<PathBuf> {
        let base = match root {
            Some(r) => r.to_path_buf(),
            None => PathBuf::from("/"),
        };

        let mut dirs = Vec::new();

        match libc_type {
            X86LibC::Glibc | X86LibC::Musl | X86LibC::None_ | X86LibC::LibSystem => {
                // Standard include paths
                let candidates = vec![
                    base.join("usr").join("include"),
                    base.join("include"),
                    base.join("usr").join("local").join("include"),
                ];
                for p in candidates {
                    if p.exists() && !dirs.contains(&p) {
                        dirs.push(p);
                    }
                }

                // Multiarch include paths
                if libc_type == X86LibC::Glibc {
                    let multiarch = X86Multiarch::new(triple);
                    let sysroot = Sysroot::cross(base.clone());
                    let ma_paths = multiarch.include_paths(&sysroot);
                    for p in ma_paths {
                        if !dirs.contains(&p) {
                            dirs.push(p);
                        }
                    }
                }
            }
            X86LibC::Bionic => {
                dirs.push(base.join("usr").join("include"));
                if let Some(arch) = Self::android_arch_for_triple(triple) {
                    dirs.push(base.join("usr").join("include").join(arch));
                }
            }
            X86LibC::Msvcrt | X86LibC::UCRT => {
                dirs.push(base.join("include"));
                dirs.push(base.join("Include"));
                // ucrt subdirectories
                if libc_type == X86LibC::UCRT {
                    dirs.push(base.join("Include").join("ucrt"));
                }
            }
            X86LibC::Newlib | X86LibC::Picolibc => {
                dirs.push(base.join("include"));
                // Machine-specific includes
                let machine_dir = base.join("include").join("machine");
                if machine_dir.exists() {
                    dirs.push(machine_dir);
                }
                let sys_dir = base.join("include").join("sys");
                if sys_dir.exists() {
                    dirs.push(sys_dir);
                }
            }
        }

        dirs
    }

    /// Find library directories for the cross library.
    pub fn find_library_dirs(
        triple: &Triple,
        libc_type: X86LibC,
        root: Option<&Path>,
    ) -> Vec<PathBuf> {
        let base = match root {
            Some(r) => r.to_path_buf(),
            None => PathBuf::from("/"),
        };

        let mut dirs = Vec::new();

        match libc_type {
            X86LibC::Glibc | X86LibC::Musl | X86LibC::None_ | X86LibC::LibSystem => {
                let candidates = vec![
                    base.join("usr").join("lib"),
                    base.join("lib"),
                    base.join("usr").join("local").join("lib"),
                    base.join("usr").join("lib64"),
                    base.join("lib64"),
                ];
                for p in candidates {
                    if p.exists() && !dirs.contains(&p) {
                        dirs.push(p);
                    }
                }
            }
            X86LibC::Bionic => {
                dirs.push(base.join("usr").join("lib"));
                // Architecture-specific
                if let Some(arch) = Self::android_arch_for_triple(triple) {
                    dirs.push(base.join("usr").join("lib").join(arch));
                }
            }
            X86LibC::Msvcrt | X86LibC::UCRT => {
                dirs.push(base.join("lib"));
                dirs.push(base.join("Lib"));
                let arch_dir = if triple.arch.is_64bit() { "x64" } else { "x86" };
                dirs.push(base.join("Lib").join(arch_dir));
            }
            X86LibC::Newlib | X86LibC::Picolibc => {
                dirs.push(base.join("lib"));
                // Variant directories
                for variant in &["", "nano", "pic"] {
                    let vdir = base.join("lib").join(variant);
                    if vdir.exists() && !dirs.contains(&vdir) {
                        dirs.push(vdir);
                    }
                }
            }
        }

        dirs
    }

    /// Find CRT (startup objects) directory.
    pub fn find_crt_dir(
        triple: &Triple,
        libc_type: X86LibC,
        root: Option<&Path>,
    ) -> Option<PathBuf> {
        let base = match root {
            Some(r) => r.to_path_buf(),
            None => PathBuf::from("/"),
        };

        match libc_type {
            X86LibC::Glibc => {
                let candidates = vec![
                    base.join("usr").join("lib"),
                    base.join("usr").join("lib64"),
                    base.join("lib"),
                    base.join("lib64"),
                ];
                for p in candidates {
                    let crt1 = p.join("crt1.o");
                    if crt1.exists() {
                        return Some(p);
                    }
                }
                None
            }
            X86LibC::Musl => {
                let candidates = vec![base.join("lib"), base.join("usr").join("lib")];
                for p in candidates {
                    let crt1 = p.join("crt1.o");
                    if crt1.exists() {
                        return Some(p);
                    }
                    // musl uses crt1.o or Scrt1.o
                    let scrt1 = p.join("Scrt1.o");
                    if scrt1.exists() {
                        return Some(p);
                    }
                }
                None
            }
            X86LibC::Bionic => {
                let candidates = vec![base.join("usr").join("lib")];
                for p in candidates {
                    let crtbegin = p.join("crtbegin_dynamic.o");
                    if crtbegin.exists() {
                        return Some(p);
                    }
                }
                None
            }
            X86LibC::Newlib | X86LibC::Picolibc => {
                let candidates = vec![base.join("lib")];
                for p in candidates {
                    let crt0 = p.join("crt0.o");
                    if crt0.exists() {
                        return Some(p);
                    }
                }
                None
            }
            _ => None,
        }
    }

    /// Detect the dynamic linker path for the given libc.
    pub fn detect_dynamic_linker(triple: &Triple, libc_type: X86LibC) -> Option<String> {
        match libc_type {
            X86LibC::Glibc => X86Multiarch::determine_dynamic_linker(triple),
            X86LibC::Musl => {
                let arch_dir = match triple.arch {
                    Arch::X86_64 => "x86_64",
                    Arch::X86 => "i386",
                    _ => triple.arch.as_str(),
                };
                Some(format!("/lib/ld-musl-{}.so.1", arch_dir))
            }
            X86LibC::Bionic => {
                if triple.arch.is_64bit() {
                    Some("/system/bin/linker64".to_string())
                } else {
                    Some("/system/bin/linker".to_string())
                }
            }
            _ => None,
        }
    }

    /// Detect the version of the installed C library.
    pub fn detect_libc_version(
        triple: &Triple,
        libc_type: X86LibC,
        root: Option<&Path>,
    ) -> Option<String> {
        match libc_type {
            X86LibC::Glibc => Self::detect_glibc_version(root),
            X86LibC::Musl => Self::detect_musl_version(root),
            X86LibC::Bionic => Self::detect_bionic_version(root),
            X86LibC::Newlib => Self::detect_newlib_version(root),
            X86LibC::Picolibc => Self::detect_picolibc_version(root),
            _ => None,
        }
    }

    /// Get the Android architecture name from a triple.
    fn android_arch_for_triple(triple: &Triple) -> Option<String> {
        match triple.arch {
            Arch::X86 => Some("i686".to_string()),
            Arch::X86_64 => Some("x86_64".to_string()),
            Arch::ARM => Some("arm".to_string()),
            Arch::AArch64 => Some("aarch64".to_string()),
            _ => None,
        }
    }

    /// Get include paths for the detected cross library.
    pub fn include_paths(&self, _sysroot: &Sysroot) -> Vec<PathBuf> {
        self.include_dirs.clone()
    }

    /// Get library paths for the detected cross library.
    pub fn library_paths(&self, _sysroot: &Sysroot) -> Vec<PathBuf> {
        self.library_dirs.clone()
    }

    /// Check if this is a cross-compilation setup.
    pub fn is_cross(&self) -> bool {
        Self::is_cross_target(&self.triple)
    }

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

        match self.libc_type {
            X86LibC::Glibc => {
                // Default, no special flags needed
            }
            X86LibC::Musl => {
                flags.push("-D_LARGEFILE64_SOURCE".to_string());
                flags.push("-D_XOPEN_SOURCE=700".to_string());
            }
            X86LibC::Bionic => {
                flags.push("-D__ANDROID__".to_string());
                flags.push("-DANDROID".to_string());
            }
            X86LibC::Newlib => {
                flags.push("-ffreestanding".to_string());
                flags.push("-nostdlib".to_string());
            }
            X86LibC::Picolibc => {
                flags.push("-ffreestanding".to_string());
                flags.push("-specs=picolibc.specs".to_string());
            }
            X86LibC::None_ => {
                flags.push("-ffreestanding".to_string());
                flags.push("-nostdlib".to_string());
            }
            _ => {}
        }

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

        flags
    }

    /// Get the recommended linker flags for this cross library.
    pub fn linker_flags(&self) -> Vec<String> {
        let mut flags = Vec::new();

        match self.libc_type {
            X86LibC::Glibc => {
                flags.push("-lc".to_string());
                flags.push("-lgcc_s".to_string());
            }
            X86LibC::Musl => {
                flags.push("-lc".to_string());
            }
            X86LibC::Bionic => {
                flags.push("-lc".to_string());
                flags.push("-ldl".to_string());
                flags.push("-lm".to_string());
            }
            X86LibC::Newlib => {
                flags.push("-lc".to_string());
                flags.push("-lnosys".to_string());
            }
            X86LibC::Picolibc => {
                flags.push("-lc".to_string());
                flags.push("-lgcc".to_string());
            }
            X86LibC::None_ => {
                flags.push("-nostdlib".to_string());
            }
            _ => {}
        }

        if let Some(ref linker) = self.dynamic_linker {
            flags.push(format!("-Wl,--dynamic-linker={}", linker));
        }

        flags
    }

    /// Get all CRT (C runtime) objects needed for linking.
    pub fn crt_objects(&self, is_shared: bool, is_pie: bool) -> Vec<String> {
        let mut objects = Vec::new();
        let crt_prefix = self
            .crt_dir
            .as_ref()
            .map(|p| p.to_string_lossy().to_string());

        match self.libc_type {
            X86LibC::Glibc => {
                if let Some(ref prefix) = crt_prefix {
                    if is_shared {
                        objects.push(format!("{}/crti.o", prefix));
                        objects.push(format!("{}/crtbeginS.o", prefix));
                    } else if is_pie {
                        objects.push(format!("{}/Scrt1.o", prefix));
                        objects.push(format!("{}/crti.o", prefix));
                        objects.push(format!("{}/crtbeginS.o", prefix));
                    } else {
                        objects.push(format!("{}/crt1.o", prefix));
                        objects.push(format!("{}/crti.o", prefix));
                        objects.push(format!("{}/crtbegin.o", prefix));
                    }
                }
            }
            X86LibC::Musl => {
                if let Some(ref prefix) = crt_prefix {
                    if is_shared {
                        objects.push(format!("{}/rcrt1.o", prefix));
                        objects.push(format!("{}/crtbeginS.o", prefix));
                    } else if is_pie {
                        objects.push(format!("{}/Scrt1.o", prefix));
                        objects.push(format!("{}/crti.o", prefix));
                        objects.push(format!("{}/crtbeginS.o", prefix));
                    } else {
                        objects.push(format!("{}/crt1.o", prefix));
                        objects.push(format!("{}/crti.o", prefix));
                        objects.push(format!("{}/crtbegin.o", prefix));
                    }
                }
            }
            X86LibC::Bionic => {
                if let Some(ref prefix) = crt_prefix {
                    objects.push(format!("{}/crtbegin_dynamic.o", prefix));
                    objects.push(format!("{}/crtend_android.o", prefix));
                }
            }
            X86LibC::Newlib | X86LibC::Picolibc => {
                if let Some(ref prefix) = crt_prefix {
                    objects.push(format!("{}/crt0.o", prefix));
                }
            }
            _ => {}
        }

        objects
    }

    /// Get end CRT objects (linked after user objects).
    pub fn crt_end_objects(&self) -> Vec<String> {
        let mut objects = Vec::new();

        if let Some(ref crt_dir) = self.crt_dir {
            let prefix = crt_dir.to_string_lossy();
            match self.libc_type {
                X86LibC::Glibc | X86LibC::Musl => {
                    objects.push(format!("{}/crtend.o", prefix));
                    objects.push(format!("{}/crtn.o", prefix));
                }
                X86LibC::Bionic => {
                    objects.push(format!("{}/crtend_android.o", prefix));
                }
                _ => {}
            }
        }

        objects
    }

    /// Detect standard library headers for this C library.
    pub fn standard_headers_available(&self) -> Vec<String> {
        let mut headers = Vec::new();

        let std_headers = vec![
            "stdio.h",
            "stdlib.h",
            "string.h",
            "math.h",
            "time.h",
            "signal.h",
            "setjmp.h",
            "errno.h",
            "assert.h",
            "ctype.h",
            "locale.h",
            "stddef.h",
            "stdint.h",
            "stdbool.h",
            "stdarg.h",
            "limits.h",
            "float.h",
            "unistd.h",
            "fcntl.h",
            "pthread.h",
            "dlfcn.h",
        ];

        for inc_dir in &self.include_dirs {
            for header in &std_headers {
                let path = inc_dir.join(header);
                if path.exists() {
                    headers.push(header.to_string());
                }
            }
        }

        headers.sort();
        headers.dedup();
        headers
    }

    /// Get the path to libc.so (or libc.a for static) for this target.
    pub fn libc_path(&self) -> Option<PathBuf> {
        for lib_dir in &self.library_dirs {
            // Dynamic
            let libc_so = lib_dir.join("libc.so.6");
            if libc_so.exists() {
                return Some(libc_so);
            }
            let libc_so_sym = lib_dir.join("libc.so");
            if libc_so_sym.exists() {
                return Some(libc_so_sym);
            }
            // Static
            let libc_a = lib_dir.join("libc.a");
            if libc_a.exists() {
                return Some(libc_a);
            }
        }
        None
    }

    /// Get the path to libm.so/libm.a for this target.
    pub fn libm_path(&self) -> Option<PathBuf> {
        for lib_dir in &self.library_dirs {
            let libm_so = lib_dir.join("libm.so.6");
            if libm_so.exists() {
                return Some(libm_so);
            }
            let libm_so_sym = lib_dir.join("libm.so");
            if libm_so_sym.exists() {
                return Some(libm_so_sym);
            }
            let libm_a = lib_dir.join("libm.a");
            if libm_a.exists() {
                return Some(libm_a);
            }
        }
        None
    }

    /// Get the path to libpthread for this target.
    pub fn libpthread_path(&self) -> Option<PathBuf> {
        for lib_dir in &self.library_dirs {
            // Modern glibc: pthread is integrated into libc
            let libpthread_so = lib_dir.join("libpthread.so");
            if libpthread_so.exists() {
                return Some(libpthread_so);
            }
            let libpthread_a = lib_dir.join("libpthread.a");
            if libpthread_a.exists() {
                return Some(libpthread_a);
            }
            // musl: pthread integrated
            // Check if libc contains pthread symbols
            let libc_so = lib_dir.join("libc.so");
            if libc_so.exists() {
                return Some(libc_so); // pthread is in libc
            }
        }
        None
    }

    /// Validate that the cross-library installation is complete.
    pub fn validate(&self) -> Vec<String> {
        let mut issues = Vec::new();

        if !self.found {
            issues.push(format!(
                "Cross-library not found for {}",
                self.triple.to_string()
            ));
            return issues;
        }

        // Check include directories
        if self.include_dirs.is_empty() {
            issues.push("No include directories found".to_string());
        } else {
            let mut has_stdio = false;
            for inc_dir in &self.include_dirs {
                if inc_dir.join("stdio.h").exists() {
                    has_stdio = true;
                    break;
                }
            }
            if !has_stdio {
                issues.push("stdio.h not found in include directories".to_string());
            }
        }

        // Check library directories
        if self.library_dirs.is_empty() {
            issues.push("No library directories found".to_string());
        }

        // Check CRT directory for non-freestanding targets
        if self.libc_type != X86LibC::None_ && self.crt_dir.is_none() {
            issues.push("CRT directory not found (startup objects missing)".to_string());
        }

        issues
    }

    /// Check if this configuration supports shared libraries.
    pub fn supports_shared_libraries(&self) -> bool {
        match self.libc_type {
            X86LibC::Glibc | X86LibC::Musl | X86LibC::Bionic | X86LibC::LibSystem => true,
            X86LibC::Newlib | X86LibC::Picolibc | X86LibC::None_ => false,
            X86LibC::Msvcrt | X86LibC::UCRT => true,
        }
    }

    /// Check if this configuration supports static linking.
    pub fn supports_static_linking(&self) -> bool {
        // Check if libc.a exists
        self.libc_path()
            .map(|p| p.extension().map(|e| e == "a").unwrap_or(false))
            .unwrap_or(false)
    }

    /// Check if this configuration supports PIE (Position Independent Executables).
    pub fn supports_pie(&self) -> bool {
        match self.libc_type {
            X86LibC::Glibc | X86LibC::Musl => true,
            X86LibC::Bionic => {
                // Android 5.0+ (API 21) supports PIE
                if let Some(ref root) = self.root_path {
                    // Check if Scrt1.o exists (indicates PIE support)
                    if let Some(ref crt) = self.crt_dir {
                        crt.join("Scrt1.o").exists()
                    } else {
                        false
                    }
                } else {
                    true // Assume modern Android
                }
            }
            _ => false,
        }
    }
}

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

// ═══════════════════════════════════════════════════════════════════════════════
// 9. Tests
// ═══════════════════════════════════════════════════════════════════════════════

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

    // ──────────────── X86SysrootManager tests ─────────────────────

    #[test]
    fn test_sysroot_manager_new() {
        let manager = X86SysrootManager::new("x86_64-unknown-linux-gnu");
        assert_eq!(manager.target_triple, "x86_64-unknown-linux-gnu");
        assert_eq!(manager.triple.arch, Arch::X86_64);
        assert_eq!(manager.triple.os, OS::Linux);
    }

    #[test]
    fn test_sysroot_manager_with_sysroot() {
        let manager =
            X86SysrootManager::with_sysroot("i386-unknown-linux-gnu", PathBuf::from("/custom"));
        assert_eq!(manager.explicit_sysroot, Some(PathBuf::from("/custom")));
        assert_eq!(manager.triple.arch, Arch::X86);
    }

    #[test]
    fn test_sysroot_manager_for_cross() {
        let manager = X86SysrootManager::for_cross(
            "x86_64-unknown-linux-musl",
            PathBuf::from("/musl-sysroot"),
        );
        assert!(manager.is_cross);
        assert!(manager.use_compiler_rt);
        assert_eq!(
            manager.explicit_sysroot,
            Some(PathBuf::from("/musl-sysroot"))
        );
    }

    #[test]
    fn test_sysroot_manager_default_triple() {
        let manager = X86SysrootManager::default();
        assert_eq!(manager.target_triple, "x86_64-unknown-linux-gnu");
    }

    #[test]
    fn test_sysroot_manager_set_sysroot_arg() {
        let mut manager = X86SysrootManager::new("x86_64-unknown-linux-gnu");
        manager.set_sysroot_arg("--sysroot=/test/path");
        assert_eq!(manager.explicit_sysroot, Some(PathBuf::from("/test/path")));
    }

    #[test]
    fn test_sysroot_manager_compiler_flags() {
        let mut manager = X86SysrootManager::new("x86_64-unknown-linux-gnu");
        manager.explicit_sysroot = Some(PathBuf::from("/test"));
        manager.use_compiler_rt = true;
        let flags = manager.compiler_flags();
        assert!(flags.iter().any(|f| f.contains("--sysroot=")));
        assert!(flags.iter().any(|f| f.contains("-target")));
        assert!(flags.iter().any(|f| f.contains("compiler-rt")));
    }

    #[test]
    fn test_sysroot_manager_is_native() {
        let manager = X86SysrootManager::new("x86_64-unknown-linux-gnu");
        // On x86_64 Linux, should be native
        if cfg!(target_arch = "x86_64") && cfg!(target_os = "linux") {
            assert!(manager.is_native());
        }
    }

    #[test]
    fn test_sysroot_manager_dynamic_linker() {
        let manager = X86SysrootManager::new("x86_64-unknown-linux-gnu");
        let linker = manager.dynamic_linker();
        assert!(linker.is_some());
        let linker_str = linker.unwrap();
        assert!(linker_str.contains("ld-linux"));
    }

    // ──────────────── X86SysrootDetector tests ────────────────────

    #[test]
    fn test_sysroot_detector_new() {
        let detector = X86SysrootDetector::new("x86_64-unknown-linux-gnu");
        assert_eq!(detector.target_triple, "x86_64-unknown-linux-gnu");
        assert!(!detector.search_android_ndk);
        assert!(!detector.search_windows_sdk);
    }

    #[test]
    fn test_sysroot_detector_android() {
        let detector = X86SysrootDetector::new("i686-linux-android");
        assert!(detector.search_android_ndk);
    }

    #[test]
    fn test_sysroot_detector_windows() {
        let detector = X86SysrootDetector::new("x86_64-pc-windows-msvc");
        assert!(detector.search_windows_sdk);
    }

    #[test]
    fn test_sysroot_detector_macos() {
        let detector = X86SysrootDetector::new("x86_64-apple-darwin");
        assert!(detector.search_xcode);
    }

    #[test]
    fn test_sysroot_detector_ios() {
        let detector = X86SysrootDetector::new("x86_64-apple-ios");
        assert!(detector.search_xcode);
    }

    #[test]
    fn test_sysroot_detector_host_triple() {
        let detector = X86SysrootDetector::new("x86_64-unknown-linux-gnu");
        let result = detector.is_host_triple();
        // This will be true only on x86_64 Linux
        if cfg!(target_arch = "x86_64") && cfg!(target_os = "linux") {
            assert!(result);
        }
    }

    #[test]
    fn test_sysroot_detector_detect_host_triple() {
        let host = X86SysrootDetector::detect_host_triple();
        assert!(!host.is_empty());
        assert!(host.contains("-"));
    }

    #[test]
    fn test_sysroot_detector_android_arch_name() {
        // x86_64
        let detector = X86SysrootDetector::new("x86_64-linux-android");
        assert_eq!(detector.android_arch_name(), "x86_64");

        // i386
        let detector = X86SysrootDetector::new("i686-linux-android");
        assert_eq!(detector.android_arch_name(), "x86");
    }

    #[test]
    fn test_sysroot_detector_host_platform_tag() {
        let detector = X86SysrootDetector::new("x86_64-unknown-linux-gnu");
        let tag = detector.host_platform_tag();
        if cfg!(target_os = "linux") {
            assert!(tag.contains("linux"));
        } else if cfg!(target_os = "macos") {
            assert!(tag.contains("darwin"));
        } else if cfg!(target_os = "windows") {
            assert!(tag.contains("windows"));
        }
    }

    #[test]
    fn test_parse_sdk_version() {
        let v = X86SysrootDetector::parse_sdk_version("MacOSX14.5.sdk");
        assert_eq!(v, vec![14, 5]);

        let v = X86SysrootDetector::parse_sdk_version("iPhoneOS17.0.sdk");
        assert_eq!(v, vec![17, 0]);

        let v = X86SysrootDetector::parse_sdk_version("MacOSX.sdk");
        assert!(v.is_empty());
    }

    #[test]
    fn test_sysroot_detector_default() {
        let detector = X86SysrootDetector::default();
        assert_eq!(detector.target_triple, "x86_64-unknown-linux-gnu");
    }

    #[test]
    fn test_sysroot_detector_detect_host() {
        let detector = X86SysrootDetector::new("x86_64-unknown-linux-gnu");
        let sysroot = detector.detect();
        // On Linux host, should return "/" for native
        if cfg!(target_os = "linux") {
            assert_eq!(sysroot.path, PathBuf::from("/"));
            assert!(!sysroot.is_explicit);
        }
    }

    #[test]
    fn test_sysroot_detector_forced() {
        let mut detector = X86SysrootDetector::new("x86_64-unknown-linux-gnu");
        detector.forced_sysroot = Some(PathBuf::from("/custom/sysroot"));
        // Can't assert the return because /custom/sysroot doesn't exist,
        // but the struct should have the forced path set
        assert_eq!(
            detector.forced_sysroot,
            Some(PathBuf::from("/custom/sysroot"))
        );
    }

    // ──────────────── X86CrossCompilation tests ───────────────────

    #[test]
    fn test_cross_compilation_new() {
        let cc = X86CrossCompilation::new("x86_64-unknown-linux-gnu");
        assert_eq!(cc.target_triple, "x86_64-unknown-linux-gnu");
        assert!(!cc.is_canadian_cross);
    }

    #[test]
    fn test_cross_compilation_is_cross() {
        // Cross to ARM from x86_64
        let cc = X86CrossCompilation::new("aarch64-unknown-linux-gnu");
        if cfg!(target_arch = "x86_64") {
            assert!(cc.is_cross);
        }
    }

    #[test]
    fn test_cross_compilation_native() {
        let cc = X86CrossCompilation::new("x86_64-unknown-linux-gnu");
        if cfg!(target_arch = "x86_64") && cfg!(target_os = "linux") {
            assert!(!cc.is_cross);
        }
    }

    #[test]
    fn test_cross_compilation_32bit_on_64bit() {
        let cc = X86CrossCompilation::new("i386-unknown-linux-gnu");
        // 32-bit on 64-bit Linux is considered "not cross"
        if cfg!(target_arch = "x86_64") && cfg!(target_os = "linux") {
            assert!(!cc.is_cross);
        }
    }

    #[test]
    fn test_cross_compilation_emulator_x86_64_windows() {
        let cc = X86CrossCompilation::new("x86_64-pc-windows-msvc");
        if cfg!(target_os = "linux") {
            // May have Wine
            let emu = cc.emulator;
            // At minimum, the emulator field should be set
            if let Some(ref emu) = emu {
                assert!(emu.contains("wine"));
            }
        }
    }

    #[test]
    fn test_cross_compilation_emulator_x86_windows() {
        let cc = X86CrossCompilation::new("i686-pc-windows-msvc");
        // Should try to find Wine
        let _ = cc.emulator_command();
    }

    #[test]
    fn test_cross_compilation_canadian_setup() {
        let mut cc = X86CrossCompilation::new("x86_64-unknown-linux-gnu");
        let result = cc.setup_canadian_cross(
            "x86_64-apple-darwin",
            "aarch64-unknown-linux-gnu",
            "arm-unknown-linux-gnueabihf",
        );
        assert!(result.is_ok());
        assert!(cc.is_canadian_cross);
        assert_eq!(cc.build_triple, "x86_64-apple-darwin");
        assert_eq!(cc.host_triple, "aarch64-unknown-linux-gnu");
    }

    #[test]
    fn test_cross_compilation_host_to_target_mapping() {
        let cc = X86CrossCompilation::new("x86_64-unknown-linux-gnu");
        let map = cc.host_to_target_mapping();
        assert!(map.contains_key("x86_64-unknown-linux-gnu"));
        let targets = &map["x86_64-unknown-linux-gnu"];
        assert!(targets.contains(&"x86_64-unknown-linux-gnu".to_string()));
        assert!(targets.contains(&"x86_64-unknown-linux-musl".to_string()));
    }

    #[test]
    fn test_cross_compilation_pkg_config_command() {
        let cc = X86CrossCompilation::new("x86_64-unknown-linux-gnu");
        let cmd = cc.pkg_config_command();
        assert!(!cmd.is_empty());
    }

    #[test]
    fn test_cross_compilation_pkg_config_env() {
        let mut cc = X86CrossCompilation::new("arm-unknown-linux-gnueabihf");
        cc.sysroot = Some(PathBuf::from("/sysroot"));
        let env = cc.pkg_config_env();
        assert!(env.iter().any(|(k, _)| k == "PKG_CONFIG_SYSROOT_DIR"));
    }

    #[test]
    fn test_cross_compilation_default() {
        let cc = X86CrossCompilation::default();
        assert_eq!(cc.target_triple, "x86_64-unknown-linux-gnu");
    }

    // ──────────────── X86Multiarch tests ─────────────────────────

    #[test]
    fn test_multiarch_new_x86_64() {
        let triple = Triple::parse("x86_64-unknown-linux-gnu");
        let ma = X86Multiarch::new(&triple);
        assert_eq!(ma.multiarch_dir, Some("x86_64-linux-gnu".to_string()));
    }

    #[test]
    fn test_multiarch_new_i386() {
        let triple = Triple::parse("i386-unknown-linux-gnu");
        let ma = X86Multiarch::new(&triple);
        assert_eq!(ma.multiarch_dir, Some("i386-linux-gnu".to_string()));
    }

    #[test]
    fn test_multiarch_new_x32() {
        let triple = Triple::parse("x86_64-unknown-linux-gnux32");
        let ma = X86Multiarch::new(&triple);
        assert_eq!(ma.multiarch_dir, Some("x86_64-linux-gnux32".to_string()));
    }

    #[test]
    fn test_multiarch_musl() {
        let triple = Triple::parse("x86_64-unknown-linux-musl");
        let ma = X86Multiarch::new(&triple);
        assert_eq!(ma.multiarch_dir, Some("x86_64-linux-musl".to_string()));
    }

    #[test]
    fn test_multiarch_android() {
        let triple = Triple::parse("x86_64-linux-android");
        let ma = X86Multiarch::new(&triple);
        assert_eq!(ma.multiarch_dir, Some("x86_64-linux-android".to_string()));
    }

    #[test]
    fn test_multiarch_aarch64() {
        let triple = Triple::parse("aarch64-unknown-linux-gnu");
        let ma = X86Multiarch::new(&triple);
        assert_eq!(ma.multiarch_dir, Some("aarch64-linux-gnu".to_string()));
    }

    #[test]
    fn test_multiarch_armhf() {
        let triple = Triple::parse("arm-unknown-linux-gnueabihf");
        let ma = X86Multiarch::new(&triple);
        assert_eq!(ma.multiarch_dir, Some("arm-linux-gnueabihf".to_string()));
    }

    #[test]
    fn test_multiarch_arm() {
        let triple = Triple::parse("arm-unknown-linux-gnueabi");
        let ma = X86Multiarch::new(&triple);
        assert_eq!(ma.multiarch_dir, Some("arm-linux-gnueabi".to_string()));
    }

    #[test]
    fn test_multiarch_dynamic_linker_x86_64() {
        let triple = Triple::parse("x86_64-unknown-linux-gnu");
        let linker = X86Multiarch::determine_dynamic_linker(&triple);
        assert_eq!(linker, Some("/lib64/ld-linux-x86-64.so.2".to_string()));
    }

    #[test]
    fn test_multiarch_dynamic_linker_i386() {
        let triple = Triple::parse("i386-unknown-linux-gnu");
        let linker = X86Multiarch::determine_dynamic_linker(&triple);
        assert_eq!(linker, Some("/lib/ld-linux.so.2".to_string()));
    }

    #[test]
    fn test_multiarch_dynamic_linker_musl() {
        let triple = Triple::parse("x86_64-unknown-linux-musl");
        let linker = X86Multiarch::determine_dynamic_linker(&triple);
        assert_eq!(linker, Some("/lib/ld-musl-x86_64.so.1".to_string()));
    }

    #[test]
    fn test_multiarch_dynamic_linker_android() {
        let triple = Triple::parse("x86_64-linux-android");
        let linker = X86Multiarch::determine_dynamic_linker(&triple);
        assert_eq!(linker, Some("/system/bin/linker64".to_string()));
    }

    #[test]
    fn test_multiarch_dynamic_linker_android32() {
        let triple = Triple::parse("i686-linux-android");
        let linker = X86Multiarch::determine_dynamic_linker(&triple);
        assert_eq!(linker, Some("/system/bin/linker".to_string()));
    }

    #[test]
    fn test_multiarch_dynamic_linker_aarch64() {
        let triple = Triple::parse("aarch64-unknown-linux-gnu");
        let linker = X86Multiarch::determine_dynamic_linker(&triple);
        assert_eq!(linker, Some("/lib/ld-linux-aarch64.so.1".to_string()));
    }

    #[test]
    fn test_multiarch_dynamic_linker_armhf() {
        let triple = Triple::parse("arm-unknown-linux-gnueabihf");
        let linker = X86Multiarch::determine_dynamic_linker(&triple);
        assert_eq!(linker, Some("/lib/ld-linux-armhf.so.3".to_string()));
    }

    #[test]
    fn test_multiarch_default() {
        let ma = X86Multiarch::default();
        assert_eq!(ma.multiarch_dir, Some("x86_64-linux-gnu".to_string()));
    }

    #[test]
    fn test_multiarch_is_multiarch_path() {
        let triple = Triple::parse("x86_64-unknown-linux-gnu");
        let ma = X86Multiarch::new(&triple);
        assert!(ma.is_multiarch_path(Path::new("/usr/lib/x86_64-linux-gnu")));
        assert!(!ma.is_multiarch_path(Path::new("/usr/lib")));
    }

    #[test]
    fn test_multiarch_normalize_path() {
        let triple = Triple::parse("x86_64-unknown-linux-gnu");
        let ma = X86Multiarch::new(&triple);
        let normalized = ma.normalize_library_path(Path::new("/usr/lib"));
        // On Debian, should map to multiarch path
        if ma.is_debian && ma.prefer_multiarch {
            assert!(normalized.to_string_lossy().contains("x86_64-linux-gnu"));
        }
    }

    // ──────────────── X86TripleParser tests ──────────────────────

    #[test]
    fn test_triple_parser_new() {
        let parser = X86TripleParser::new("x86_64-unknown-linux-gnu");
        assert!(parser.is_valid);
        assert_eq!(parser.arch_info.family, X86ArchFamily::X86_64);
        assert_eq!(parser.arch_info.bit_width, 64);
        assert!(parser.arch_info.has_sse2);
    }

    #[test]
    fn test_triple_parser_i386() {
        let parser = X86TripleParser::new("i386-unknown-linux-gnu");
        assert!(parser.is_valid);
        assert_eq!(parser.arch_info.family, X86ArchFamily::X86_32);
        assert_eq!(parser.arch_info.bit_width, 32);
        assert!(!parser.arch_info.has_sse2);
    }

    #[test]
    fn test_triple_parser_normalize() {
        let parser = X86TripleParser::new("amd64-unknown-linux");
        // amd64 normalizes to x86_64
        assert!(parser.normalized.contains("x86_64"));
    }

    #[test]
    fn test_triple_parser_object_format_elf() {
        let triple = Triple::parse("x86_64-unknown-linux-gnu");
        let fmt = X86TripleParser::infer_object_format(&triple);
        assert_eq!(fmt, X86ObjectFormat::ELF);
    }

    #[test]
    fn test_triple_parser_object_format_macho() {
        let triple = Triple::parse("x86_64-apple-darwin");
        let fmt = X86TripleParser::infer_object_format(&triple);
        assert_eq!(fmt, X86ObjectFormat::MachO);
    }

    #[test]
    fn test_triple_parser_object_format_coff() {
        let triple = Triple::parse("x86_64-pc-windows-msvc");
        let fmt = X86TripleParser::infer_object_format(&triple);
        assert_eq!(fmt, X86ObjectFormat::COFF);
    }

    #[test]
    fn test_triple_parser_parse_x86_arch_basic() {
        let info = X86TripleParser::parse_x86_arch("i686").unwrap();
        assert_eq!(info.family, X86ArchFamily::X86_32);
        assert_eq!(info.bit_width, 32);
        assert!(!info.has_sse2);
    }

    #[test]
    fn test_triple_parser_parse_x86_arch_pentium4() {
        let info = X86TripleParser::parse_x86_arch("pentium4").unwrap();
        assert!(info.has_sse2);
        assert_eq!(info.cpu_sub_arch, Some("pentium4".to_string()));
    }

    #[test]
    fn test_triple_parser_parse_x86_arch_athlon() {
        let info = X86TripleParser::parse_x86_arch("athlon64").unwrap();
        assert_eq!(info.family, X86ArchFamily::X86_64);
        assert!(info.has_sse2);
    }

    #[test]
    fn test_triple_parser_parse_x86_arch_zen() {
        for cpu in &["znver1", "znver2", "znver3", "znver4", "znver5"] {
            let info = X86TripleParser::parse_x86_arch(cpu).unwrap();
            assert_eq!(info.family, X86ArchFamily::X86_64);
            assert!(info.has_sse2);
        }
    }

    #[test]
    fn test_triple_parser_parse_x86_arch_core() {
        for cpu in &[
            "core2",
            "nehalem",
            "sandybridge",
            "haswell",
            "skylake",
            "icelake-client",
            "tigerlake",
            "alderlake",
            "raptorlake",
            "meteorlake",
        ] {
            let info = X86TripleParser::parse_x86_arch(cpu).unwrap();
            assert_eq!(info.family, X86ArchFamily::X86_64);
            assert!(info.has_sse2);
        }
    }

    #[test]
    fn test_triple_parser_parse_x86_arch_atom() {
        for cpu in &[
            "silvermont",
            "goldmont",
            "goldmont-plus",
            "tremont",
            "gracemont",
        ] {
            let info = X86TripleParser::parse_x86_arch(cpu).unwrap();
            assert_eq!(info.family, X86ArchFamily::X86_64);
            assert!(info.has_sse2);
        }
    }

    #[test]
    fn test_triple_parser_parse_x86_arch_x32() {
        let info = X86TripleParser::parse_x86_arch("x32").unwrap();
        assert_eq!(info.family, X86ArchFamily::X32);
        assert_eq!(info.bit_width, 32);
    }

    #[test]
    fn test_triple_parser_parse_x86_arch_invalid() {
        assert!(X86TripleParser::parse_x86_arch("nonexistentcpu").is_none());
    }

    #[test]
    fn test_triple_parser_parse_x86_vendor() {
        assert_eq!(X86TripleParser::parse_x86_vendor("pc"), Some(Vendor::PC));
        assert_eq!(
            X86TripleParser::parse_x86_vendor("apple"),
            Some(Vendor::Apple)
        );
        assert_eq!(
            X86TripleParser::parse_x86_vendor("unknown"),
            Some(Vendor::Unknown)
        );
    }

    #[test]
    fn test_triple_parser_parse_x86_os() {
        assert_eq!(X86TripleParser::parse_x86_os("linux"), Some(OS::Linux));
        assert_eq!(X86TripleParser::parse_x86_os("darwin"), Some(OS::Darwin));
        assert_eq!(X86TripleParser::parse_x86_os("windows"), Some(OS::Win32));
        assert_eq!(X86TripleParser::parse_x86_os("freebsd"), Some(OS::FreeBSD));
        assert_eq!(X86TripleParser::parse_x86_os("haiku"), Some(OS::Haiku));
    }

    #[test]
    fn test_triple_parser_parse_x86_env() {
        assert_eq!(
            X86TripleParser::parse_x86_env("gnu"),
            Some(Environment::GNU)
        );
        assert_eq!(
            X86TripleParser::parse_x86_env("musl"),
            Some(Environment::Musl)
        );
        assert_eq!(
            X86TripleParser::parse_x86_env("msvc"),
            Some(Environment::MSVC)
        );
        assert_eq!(
            X86TripleParser::parse_x86_env("android"),
            Some(Environment::Android)
        );
    }

    #[test]
    fn test_triple_parser_known_cpus() {
        let cpus = X86TripleParser::known_x86_cpus();
        assert!(cpus.contains(&"x86-64"));
        assert!(cpus.contains(&"skylake"));
        assert!(cpus.contains(&"znver4"));
        assert!(cpus.len() > 30);
    }

    #[test]
    fn test_triple_parser_default_features() {
        let features = X86TripleParser::default_features_for_cpu("haswell");
        assert!(features.contains(&"+avx"));
        assert!(features.contains(&"+avx2"));
        assert!(features.contains(&"+sse2"));

        let features = X86TripleParser::default_features_for_cpu("i686");
        assert!(features.contains(&"+sse"));
        assert!(features.contains(&"+mmx"));

        let features = X86TripleParser::default_features_for_cpu("znver3");
        assert!(features.contains(&"+avx2"));
    }

    #[test]
    fn test_triple_parser_default() {
        let parser = X86TripleParser::default();
        assert!(parser.is_valid);
        assert_eq!(parser.triple.arch, Arch::X86_64);
    }

    // ──────────────── X86CompilerRT tests ────────────────────────

    #[test]
    fn test_compiler_rt_new() {
        let triple = Triple::parse("x86_64-unknown-linux-gnu");
        let crt = X86CompilerRT::new(&triple);
        assert_eq!(crt.triple.arch, Arch::X86_64);
    }

    #[test]
    fn test_compiler_rt_builtins_library_name() {
        let triple = Triple::parse("x86_64-unknown-linux-gnu");
        let name = X86CompilerRT::builtins_library_name(&triple);
        assert!(name.contains("builtins"));
        assert!(name.contains("x86_64"));

        let triple = Triple::parse("i386-unknown-linux-gnu");
        let name = X86CompilerRT::builtins_library_name(&triple);
        assert!(name.contains("i386"));
    }

    #[test]
    fn test_compiler_rt_select_runtime_auto() {
        let triple = Triple::parse("x86_64-unknown-linux-gnu");
        let mut crt = X86CompilerRT::new(&triple);
        crt.preferred_runtime = X86RuntimeLib::Auto;
        let selected = crt.select_runtime();
        // Should pick whichever is available
        assert!(selected == X86RuntimeLib::CompilerRT || selected == X86RuntimeLib::LibGcc);
    }

    #[test]
    fn test_compiler_rt_select_runtime_forced() {
        let triple = Triple::parse("x86_64-unknown-linux-gnu");
        let mut crt = X86CompilerRT::new(&triple);
        crt.preferred_runtime = X86RuntimeLib::CompilerRT;
        assert_eq!(crt.select_runtime(), X86RuntimeLib::CompilerRT);

        crt.preferred_runtime = X86RuntimeLib::LibGcc;
        assert_eq!(crt.select_runtime(), X86RuntimeLib::LibGcc);
    }

    #[test]
    fn test_compiler_rt_needs_libgcc_eh() {
        let triple = Triple::parse("x86_64-unknown-linux-gnu");
        assert!(X86CompilerRT::needs_libgcc_eh(&triple));

        let triple = Triple::parse("x86_64-unknown-linux-musl");
        assert!(!X86CompilerRT::needs_libgcc_eh(&triple));
    }

    #[test]
    fn test_compiler_rt_runtime_libraries() {
        let triple = Triple::parse("x86_64-unknown-linux-gnu");
        let mut crt = X86CompilerRT::new(&triple);
        crt.preferred_runtime = X86RuntimeLib::CompilerRT;
        let libs = crt.runtime_libraries();
        assert!(libs.iter().any(|l| l.contains("builtins")));

        crt.preferred_runtime = X86RuntimeLib::LibGcc;
        let libs = crt.runtime_libraries();
        assert!(libs.contains(&"gcc".to_string()));
    }

    #[test]
    fn test_compiler_rt_linker_flags() {
        let triple = Triple::parse("x86_64-unknown-linux-gnu");
        let mut crt = X86CompilerRT::new(&triple);
        crt.preferred_runtime = X86RuntimeLib::CompilerRT;
        let flags = crt.linker_flags();
        assert!(flags.iter().any(|f| f.contains("compiler-rt")));
    }

    #[test]
    fn test_compiler_rt_default() {
        let crt = X86CompilerRT::default();
        assert_eq!(crt.triple.arch, Arch::X86_64);
    }

    // ──────────────── X86ResourceDir tests ───────────────────────

    #[test]
    fn test_resource_dir_new() {
        let triple = Triple::parse("x86_64-unknown-linux-gnu");
        let rd = X86ResourceDir::new(&triple);
        // Resource dir path should be set (even if it doesn't exist)
        assert!(!rd.path.as_os_str().is_empty());
    }

    #[test]
    fn test_resource_dir_expected_headers() {
        let headers = X86ResourceDir::expected_builtin_headers();
        assert!(headers.contains(&"stddef.h"));
        assert!(headers.contains(&"stdarg.h"));
        assert!(headers.contains(&"stdint.h"));
        assert!(headers.contains(&"float.h"));
        assert!(headers.contains(&"stdbool.h"));
        assert!(headers.contains(&"x86intrin.h"));
    }

    #[test]
    fn test_resource_dir_path_methods() {
        let triple = Triple::parse("x86_64-unknown-linux-gnu");
        let rd = X86ResourceDir::new(&triple);
        let path = rd.path();
        let inc = rd.include_dir();
        let lib = rd.lib_dir();

        assert!(inc.ends_with("include"));
        assert!(lib.ends_with("lib"));
        assert_eq!(inc, rd.builtin_headers_dir());
    }

    #[test]
    fn test_resource_dir_validate() {
        let triple = Triple::parse("x86_64-unknown-linux-gnu");
        let rd = X86ResourceDir::new(&triple);
        let issues = rd.validate();
        // May or may not have issues depending on whether clang is installed
        // Just check it returns a Vec
        assert!(issues.len() >= 0);
    }

    #[test]
    fn test_resource_dir_default() {
        let rd = X86ResourceDir::default();
        assert!(!rd.path.as_os_str().is_empty());
    }

    #[test]
    fn test_resource_dir_target_lib_dir() {
        let triple = Triple::parse("x86_64-unknown-linux-gnu");
        let rd = X86ResourceDir::new(&triple);
        let target_lib = rd.target_lib_dir();
        assert!(target_lib.to_string_lossy().contains("x86_64"));
    }

    // ──────────────── X86CrossLibrary tests ──────────────────────

    #[test]
    fn test_cross_library_new() {
        let triple = Triple::parse("x86_64-unknown-linux-gnu");
        let cl = X86CrossLibrary::new(&triple);
        assert_eq!(cl.libc_type, X86LibC::Glibc);
    }

    #[test]
    fn test_cross_library_detect_libc_glibc() {
        let triple = Triple::parse("x86_64-unknown-linux-gnu");
        assert_eq!(X86CrossLibrary::detect_libc_type(&triple), X86LibC::Glibc);
    }

    #[test]
    fn test_cross_library_detect_libc_musl() {
        let triple = Triple::parse("x86_64-unknown-linux-musl");
        assert_eq!(X86CrossLibrary::detect_libc_type(&triple), X86LibC::Musl);
    }

    #[test]
    fn test_cross_library_detect_libc_bionic() {
        let triple = Triple::parse("x86_64-linux-android");
        assert_eq!(X86CrossLibrary::detect_libc_type(&triple), X86LibC::Bionic);
    }

    #[test]
    fn test_cross_library_detect_libc_darwin() {
        let triple = Triple::parse("x86_64-apple-darwin");
        assert_eq!(
            X86CrossLibrary::detect_libc_type(&triple),
            X86LibC::LibSystem
        );
    }

    #[test]
    fn test_cross_library_detect_libc_msvc() {
        let triple = Triple::parse("x86_64-pc-windows-msvc");
        assert_eq!(X86CrossLibrary::detect_libc_type(&triple), X86LibC::Msvcrt);
    }

    #[test]
    fn test_cross_library_dynamic_linker_glibc() {
        let triple = Triple::parse("x86_64-unknown-linux-gnu");
        let linker = X86CrossLibrary::detect_dynamic_linker(&triple, X86LibC::Glibc);
        assert_eq!(linker, Some("/lib64/ld-linux-x86-64.so.2".to_string()));
    }

    #[test]
    fn test_cross_library_dynamic_linker_musl() {
        let triple = Triple::parse("x86_64-unknown-linux-musl");
        let linker = X86CrossLibrary::detect_dynamic_linker(&triple, X86LibC::Musl);
        assert_eq!(linker, Some("/lib/ld-musl-x86_64.so.1".to_string()));
    }

    #[test]
    fn test_cross_library_dynamic_linker_bionic() {
        let triple = Triple::parse("x86_64-linux-android");
        let linker = X86CrossLibrary::detect_dynamic_linker(&triple, X86LibC::Bionic);
        assert_eq!(linker, Some("/system/bin/linker64".to_string()));

        let triple = Triple::parse("i686-linux-android");
        let linker = X86CrossLibrary::detect_dynamic_linker(&triple, X86LibC::Bionic);
        assert_eq!(linker, Some("/system/bin/linker".to_string()));
    }

    #[test]
    fn test_cross_library_is_cross() {
        let triple = Triple::parse("x86_64-unknown-linux-gnu");
        let cl = X86CrossLibrary::new(&triple);
        // Is cross if target doesn't match host
        if cfg!(target_arch = "x86_64") && cfg!(target_os = "linux") {
            assert!(!cl.is_cross());
        }
    }

    #[test]
    fn test_cross_library_compiler_flags_musl() {
        let triple = Triple::parse("x86_64-unknown-linux-musl");
        let cl = X86CrossLibrary::new(&triple);
        let flags = cl.compiler_flags();
        assert!(flags.iter().any(|f| f.contains("_LARGEFILE64_SOURCE")));
    }

    #[test]
    fn test_cross_library_compiler_flags_newlib() {
        let triple = Triple::parse("i686-elf");
        let cl = X86CrossLibrary::new(&triple);
        let flags = cl.compiler_flags();
        assert!(flags.iter().any(|f| f == "-ffreestanding"));
        assert!(flags.iter().any(|f| f == "-nostdlib"));
    }

    #[test]
    fn test_cross_library_default() {
        let cl = X86CrossLibrary::default();
        assert_eq!(cl.libc_type, X86LibC::Glibc);
    }

    #[test]
    fn test_cross_library_include_paths() {
        let triple = Triple::parse("x86_64-unknown-linux-gnu");
        let cl = X86CrossLibrary::new(&triple);
        let sysroot = Sysroot::host();
        let paths = cl.include_paths(&sysroot);
        assert!(!paths.is_empty());
    }

    #[test]
    fn test_cross_library_library_paths() {
        let triple = Triple::parse("x86_64-unknown-linux-gnu");
        let cl = X86CrossLibrary::new(&triple);
        let sysroot = Sysroot::host();
        let paths = cl.library_paths(&sysroot);
        assert!(!paths.is_empty());
    }

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

    #[test]
    fn test_full_linux_glibc_pipeline() {
        let mut manager = X86SysrootManager::new("x86_64-unknown-linux-gnu");
        manager.detect_gcc();

        let sysroot = manager.detect_sysroot();
        let includes = manager.build_include_paths(&sysroot);
        let libs = manager.build_library_paths(&sysroot);

        // Should have at least some paths (resource dir, /usr/include, etc.)
        let total_paths = includes.len() + libs.len();
        // Even on minimal systems, we should find at least the resource dir
        if cfg!(target_os = "linux") {
            assert!(total_paths > 0);
        }
    }

    #[test]
    fn test_full_android_pipeline() {
        let manager = X86SysrootManager::new("x86_64-linux-android");
        assert_eq!(manager.triple.environment, Environment::Android);
        // Android targets use Bionic libc
        let cl = X86CrossLibrary::new(&manager.triple);
        assert_eq!(cl.libc_type, X86LibC::Bionic);
    }

    #[test]
    fn test_full_cross_compilation_pipeline() {
        let mut cc = X86CrossCompilation::new("aarch64-unknown-linux-gnu");
        let result = cc.setup_canadian_cross(
            "x86_64-unknown-linux-gnu",
            "x86_64-unknown-linux-gnu",
            "aarch64-unknown-linux-gnu",
        );
        assert!(result.is_ok());
        assert!(cc.is_canadian_cross);
    }

    #[test]
    fn test_multiarch_search_order() {
        let triple = Triple::parse("x86_64-unknown-linux-gnu");
        let ma = X86Multiarch::new(&triple);

        let sysroot = Sysroot::host();
        let paths = ma.library_paths(&sysroot);
        // Should have standard paths
        assert!(!paths.is_empty());

        let order = ma.search_order_priority();
        assert!(!order.is_empty());
    }

    #[test]
    fn test_triple_roundtrip() {
        let triples = vec![
            "x86_64-unknown-linux-gnu",
            "i386-unknown-linux-gnu",
            "x86_64-unknown-linux-musl",
            "x86_64-pc-windows-msvc",
            "x86_64-apple-darwin",
            "i686-linux-android",
        ];

        for triple_str in triples {
            let parser = X86TripleParser::new(triple_str);
            assert!(parser.is_valid, "{} should be valid", triple_str);
        }
    }

    #[test]
    fn test_compiler_rt_integration() {
        let triple = Triple::parse("x86_64-unknown-linux-gnu");
        let crt = X86CompilerRT::new(&triple);

        // Check we get a valid builtins library name
        let name = X86CompilerRT::builtins_library_name(&triple);
        assert!(name.contains("builtins"));

        // Check runtime selection
        let mut crt = X86CompilerRT::new(&triple);
        crt.preferred_runtime = X86RuntimeLib::CompilerRT;
        let libs = crt.runtime_libraries();
        assert!(!libs.is_empty());
    }

    #[test]
    fn test_resource_dir_integration() {
        let triple = Triple::parse("x86_64-unknown-linux-gnu");
        let rd = X86ResourceDir::new(&triple);

        // Verify expected headers list is non-trivial
        let headers = X86ResourceDir::expected_builtin_headers();
        assert!(headers.len() > 50, "Should have many builtin headers");
    }

    #[test]
    fn test_cross_library_all_libcs() {
        let test_cases = vec![
            ("x86_64-unknown-linux-gnu", X86LibC::Glibc),
            ("x86_64-unknown-linux-musl", X86LibC::Musl),
            ("x86_64-linux-android", X86LibC::Bionic),
            ("x86_64-apple-darwin", X86LibC::LibSystem),
            ("x86_64-pc-windows-msvc", X86LibC::Msvcrt),
        ];

        for (triple_str, expected_libc) in test_cases {
            let triple = Triple::parse(triple_str);
            let libc = X86CrossLibrary::detect_libc_type(&triple);
            assert_eq!(
                libc, expected_libc,
                "Wrong libc for {}: expected {:?}, got {:?}",
                triple_str, expected_libc, libc
            );
        }
    }

    #[test]
    fn test_x86_triple_parser_all_modern_cpus() {
        let modern_cpus = vec![
            "znver1",
            "znver2",
            "znver3",
            "znver4",
            "znver5",
            "alderlake",
            "raptorlake",
            "meteorlake",
            "arrowlake",
            "lunarlake",
            "pantherlake",
            "sapphirerapids",
            "graniterapids",
            "crestmont",
            "skymont",
        ];

        for cpu in modern_cpus {
            let info = X86TripleParser::parse_x86_arch(cpu);
            assert!(info.is_some(), "CPU {} should be recognized", cpu);
            let info = info.unwrap();
            assert!(info.has_sse2, "CPU {} should have SSE2", cpu);
            assert_eq!(info.family, X86ArchFamily::X86_64);
        }
    }

    #[test]
    fn test_x86_64_v_levels() {
        for cpu in &["x86-64", "x86-64-v2", "x86-64-v3", "x86-64-v4"] {
            let features = X86TripleParser::default_features_for_cpu(cpu);
            assert!(features.contains(&"+sse2"));

            let info = X86TripleParser::parse_x86_arch(cpu);
            assert!(info.is_some(), "CPU {} should be recognized", cpu);
        }
    }

    #[test]
    fn test_cross_compilation_toolchain_list() {
        let toolchains = X86CrossCompilation::list_toolchains();
        // May be empty if no cross toolchains installed, but should not panic
        let _ = toolchains.len();
    }

    #[test]
    fn test_multiarch_known_tuples() {
        let tuples = X86Multiarch::known_multiarch_tuples();
        // May be empty, but should not panic
        let _ = tuples.len();
    }

    #[test]
    fn test_sysroot_manager_env_vars() {
        let manager = X86SysrootManager::new("x86_64-unknown-linux-gnu");
        // Environment variables should be collected at construction
        // (at minimum, should have the HashMap initialized)
        let _ = manager.env_vars.len();
    }

    #[test]
    fn test_sysroot_detector_custom_search_paths() {
        let mut detector = X86SysrootDetector::new("x86_64-unknown-linux-gnu");
        detector
            .custom_search_paths
            .push(PathBuf::from("/tmp/nonexistent"));
        assert_eq!(detector.custom_search_paths.len(), 1);
    }

    #[test]
    fn test_cross_library_crt_dir() {
        let triple = Triple::parse("x86_64-unknown-linux-gnu");
        let cl = X86CrossLibrary::new(&triple);
        // glibc should find crt dir on a Linux system
        if cfg!(target_os = "linux") {
            let crt = cl.crt_dir;
            // May or may not find it depending on system, but should not panic
            let _ = crt;
        }
    }

    #[test]
    fn test_x86_libc_display() {
        // LibC variants should be distinguishable
        let variants = vec![
            X86LibC::Glibc,
            X86LibC::Musl,
            X86LibC::Bionic,
            X86LibC::LibSystem,
            X86LibC::Msvcrt,
            X86LibC::UCRT,
            X86LibC::Newlib,
            X86LibC::Picolibc,
            X86LibC::None_,
        ];
        assert_eq!(variants.len(), 9);
    }

    #[test]
    fn test_x86_arch_family_display() {
        let families = vec![
            X86ArchFamily::X86_16,
            X86ArchFamily::X86_32,
            X86ArchFamily::X86_64,
            X86ArchFamily::X32,
        ];
        assert_eq!(families.len(), 4);
    }

    #[test]
    fn test_x86_object_format_display() {
        let formats = vec![
            X86ObjectFormat::ELF,
            X86ObjectFormat::MachO,
            X86ObjectFormat::COFF,
            X86ObjectFormat::Wasm,
            X86ObjectFormat::XCOFF,
        ];
        assert_eq!(formats.len(), 5);
    }

    // ──────────────── Extended Cross-Compilation Feature tests ─────

    #[test]
    fn test_remote_build_config_new() {
        let config = X86RemoteBuildConfig::new();
        assert!(!config.use_distcc);
        assert!(!config.use_icecc);
        assert_eq!(config.remote_jobs, 4);
    }

    #[test]
    fn test_remote_build_config_distcc() {
        let config = X86RemoteBuildConfig::new().with_distcc(&["host1", "host2"]);
        assert!(config.use_distcc);
        assert_eq!(config.compiler_wrapper(), Some("distcc".to_string()));
    }

    #[test]
    fn test_remote_build_config_icecc() {
        let config = X86RemoteBuildConfig::new().with_icecc();
        assert!(config.use_icecc);
        assert_eq!(config.compiler_wrapper(), Some("icecc".to_string()));
    }

    #[test]
    fn test_remote_build_config_no_wrapper() {
        let config = X86RemoteBuildConfig::new();
        assert_eq!(config.compiler_wrapper(), None);
    }

    #[test]
    fn test_cross_package_manager_new() {
        let pm = X86CrossPackageManager::new("x86_64-unknown-linux-gnu");
        assert!(pm.cross_arch_suffix.contains("amd64"));

        let pm = X86CrossPackageManager::new("i386-unknown-linux-gnu");
        assert!(pm.cross_arch_suffix.contains("i386"));

        let pm = X86CrossPackageManager::new("aarch64-unknown-linux-gnu");
        assert!(pm.cross_arch_suffix.contains("arm64"));
    }

    #[test]
    fn test_cross_package_manager_install_command() {
        let pm = X86CrossPackageManager::new("x86_64-unknown-linux-gnu");
        let cmd = pm.install_cross_deps_command();
        // May or may not return a command depending on detected package manager
        if let Some(cmd) = cmd {
            assert!(!cmd.is_empty());
        }
    }

    #[test]
    fn test_qemu_emulation_detect_x86_64() {
        let qemu = X86QemuEmulation::detect(Arch::X86_64);
        assert_eq!(qemu.qemu_arch_name, "x86_64");
    }

    #[test]
    fn test_qemu_emulation_detect_i386() {
        let qemu = X86QemuEmulation::detect(Arch::X86);
        assert_eq!(qemu.qemu_arch_name, "i386");
    }

    #[test]
    fn test_qemu_emulation_detect_arm() {
        let qemu = X86QemuEmulation::detect(Arch::ARM);
        assert_eq!(qemu.qemu_arch_name, "arm");
    }

    #[test]
    fn test_qemu_emulation_detect_aarch64() {
        let qemu = X86QemuEmulation::detect(Arch::AArch64);
        assert_eq!(qemu.qemu_arch_name, "aarch64");
    }

    #[test]
    fn test_qemu_emulation_detect_riscv64() {
        let qemu = X86QemuEmulation::detect(Arch::RISCV64);
        assert_eq!(qemu.qemu_arch_name, "riscv64");
    }

    #[test]
    fn test_qemu_emulation_command() {
        let qemu = X86QemuEmulation::detect(Arch::AArch64);
        let cmd = qemu.emulation_command("/test/binary");
        if qemu.available {
            assert!(cmd.is_some());
            let cmd_str = cmd.unwrap();
            assert!(cmd_str.contains("/test/binary"));
        }
    }

    // ──────────────── Multiarch Distribution Tests ────────────────

    #[test]
    fn test_multiarch_detect_distribution() {
        let distro = X86Multiarch::detect_distribution();
        // Should return something (at least Unknown)
        let _ = distro.as_str();
    }

    #[test]
    fn test_multiarch_all_debian_tuples() {
        let tuples = X86Multiarch::all_debian_multiarch_tuples();
        assert!(tuples.len() > 10, "Should have many Debian tuples");
        assert!(tuples.contains(&"x86_64-linux-gnu"));
        assert!(tuples.contains(&"i386-linux-gnu"));
        assert!(tuples.contains(&"aarch64-linux-gnu"));
    }

    #[test]
    fn test_multiarch_libc_dir_suffix() {
        let triple = Triple::parse("x86_64-unknown-linux-gnu");
        assert_eq!(X86Multiarch::libc_dir_suffix(&triple), "-gnu");

        let triple = Triple::parse("x86_64-unknown-linux-musl");
        assert_eq!(X86Multiarch::libc_dir_suffix(&triple), "-musl");

        let triple = Triple::parse("x86_64-linux-android");
        assert_eq!(X86Multiarch::libc_dir_suffix(&triple), "-android");
    }

    #[test]
    fn test_linux_distro_as_str() {
        let distros = vec![
            X86LinuxDistro::Debian,
            X86LinuxDistro::RHEL,
            X86LinuxDistro::Fedora,
            X86LinuxDistro::Arch,
            X86LinuxDistro::Gentoo,
            X86LinuxDistro::Alpine,
            X86LinuxDistro::NixOS,
        ];
        for distro in distros {
            let s = distro.as_str();
            assert!(!s.is_empty());
            assert_ne!(s, "unknown");
        }
    }

    #[test]
    fn test_linux_distro_uses_multiarch() {
        assert!(X86LinuxDistro::Debian.uses_multiarch());
        assert!(!X86LinuxDistro::RHEL.uses_multiarch());
        assert!(!X86LinuxDistro::Arch.uses_multiarch());
    }

    #[test]
    fn test_linux_distro_uses_lib64() {
        assert!(X86LinuxDistro::RHEL.uses_lib64());
        assert!(X86LinuxDistro::Fedora.uses_lib64());
        assert!(X86LinuxDistro::Arch.uses_lib64());
        assert!(X86LinuxDistro::Gentoo.uses_lib64());
    }

    #[test]
    fn test_ubuntu_variant_detection() {
        let variant = X86LinuxDistro::detect_ubuntu_variant();
        // May or may not be Ubuntu
        let _ = variant;
    }

    // ──────────────── Extended Compiler RT tests ──────────────────

    #[test]
    fn test_compiler_rt_available_components() {
        let triple = Triple::parse("x86_64-unknown-linux-gnu");
        let crt = X86CompilerRT::new(&triple);
        let components = crt.available_components();
        // Should have at least builtins
        assert!(components.contains_key("builtins"));
        assert!(components.contains_key("asan"));
        assert!(components.contains_key("ubsan_standalone"));
    }

    #[test]
    fn test_compiler_rt_hwasan_support() {
        let triple = Triple::parse("x86_64-unknown-linux-gnu");
        assert!(!X86CompilerRT::supports_hwasan(&triple));

        let triple = Triple::parse("aarch64-unknown-linux-gnu");
        assert!(X86CompilerRT::supports_hwasan(&triple));
    }

    #[test]
    fn test_compiler_rt_mte_support() {
        let triple = Triple::parse("x86_64-unknown-linux-gnu");
        assert!(!X86CompilerRT::supports_mte(&triple));

        let triple = Triple::parse("aarch64-unknown-linux-gnu");
        assert!(X86CompilerRT::supports_mte(&triple));
    }

    #[test]
    fn test_compiler_rt_recommended_sanitizer_flags() {
        let triple = Triple::parse("x86_64-unknown-linux-gnu");
        let crt = X86CompilerRT::new(&triple);
        let flags = crt.recommended_sanitizer_flags();
        // May or may not have sanitizer paths (depends on installation)
        let _ = flags;
    }

    #[test]
    fn test_compiler_rt_version_detection() {
        let version = X86CompilerRT::detect_compiler_rt_version();
        // May or may not be installed
        let _ = version;
    }

    #[test]
    fn test_compiler_rt_safestack() {
        let triple = Triple::parse("x86_64-unknown-linux-gnu");
        let crt = X86CompilerRT::new(&triple);
        let has_ss = crt.has_safestack();
        let has_cfi = crt.has_cfi();
        let has_scs = crt.has_shadow_call_stack();
        // These may or may not be present
        let _ = (has_ss, has_cfi, has_scs);
    }

    // ──────────────── Extended Cross-Library tests ────────────────

    #[test]
    fn test_cross_library_crt_objects_glibc() {
        let triple = Triple::parse("x86_64-unknown-linux-gnu");
        let cl = X86CrossLibrary::new(&triple);
        let objects = cl.crt_objects(false, false);
        if cl.found && cl.crt_dir.is_some() {
            assert!(objects.iter().any(|o| o.contains("crt1.o")));
        }
    }

    #[test]
    fn test_cross_library_crt_objects_pie() {
        let triple = Triple::parse("x86_64-unknown-linux-gnu");
        let cl = X86CrossLibrary::new(&triple);
        let objects = cl.crt_objects(false, true);
        if cl.found && cl.crt_dir.is_some() {
            assert!(objects.iter().any(|o| o.contains("Scrt1.o")));
        }
    }

    #[test]
    fn test_cross_library_crt_end_objects() {
        let triple = Triple::parse("x86_64-unknown-linux-gnu");
        let cl = X86CrossLibrary::new(&triple);
        let objects = cl.crt_end_objects();
        if cl.found && cl.crt_dir.is_some() {
            assert!(objects.iter().any(|o| o.contains("crtend.o")));
            assert!(objects.iter().any(|o| o.contains("crtn.o")));
        }
    }

    #[test]
    fn test_cross_library_standard_headers() {
        let triple = Triple::parse("x86_64-unknown-linux-gnu");
        let cl = X86CrossLibrary::new(&triple);
        let headers = cl.standard_headers_available();
        if cfg!(target_os = "linux") && cl.found {
            assert!(headers.contains(&"stdio.h".to_string()));
        }
    }

    #[test]
    fn test_cross_library_libc_path() {
        let triple = Triple::parse("x86_64-unknown-linux-gnu");
        let cl = X86CrossLibrary::new(&triple);
        let path = cl.libc_path();
        if cfg!(target_os = "linux") && cl.found {
            assert!(path.is_some());
        }
    }

    #[test]
    fn test_cross_library_libm_path() {
        let triple = Triple::parse("x86_64-unknown-linux-gnu");
        let cl = X86CrossLibrary::new(&triple);
        let path = cl.libm_path();
        if cfg!(target_os = "linux") && cl.found {
            assert!(path.is_some());
        }
    }

    #[test]
    fn test_cross_library_libpthread_path() {
        let triple = Triple::parse("x86_64-unknown-linux-gnu");
        let cl = X86CrossLibrary::new(&triple);
        let path = cl.libpthread_path();
        if cfg!(target_os = "linux") && cl.found {
            assert!(path.is_some());
        }
    }

    #[test]
    fn test_cross_library_validate() {
        let triple = Triple::parse("x86_64-unknown-linux-gnu");
        let cl = X86CrossLibrary::new(&triple);
        let issues = cl.validate();
        if !cl.found {
            assert!(!issues.is_empty());
        }
    }

    #[test]
    fn test_cross_library_supports_shared() {
        let triple = Triple::parse("x86_64-unknown-linux-gnu");
        let cl = X86CrossLibrary::new(&triple);
        assert!(cl.supports_shared_libraries());

        let triple = Triple::parse("x86_64-unknown-linux-musl");
        let cl = X86CrossLibrary::new(&triple);
        assert!(cl.supports_shared_libraries());

        let triple = Triple::parse("i686-elf");
        let cl = X86CrossLibrary::new(&triple);
        assert!(!cl.supports_shared_libraries());
    }

    #[test]
    fn test_cross_library_supports_pie() {
        let triple = Triple::parse("x86_64-unknown-linux-gnu");
        let cl = X86CrossLibrary::new(&triple);
        assert!(cl.supports_pie());

        let triple = Triple::parse("x86_64-unknown-linux-musl");
        let cl = X86CrossLibrary::new(&triple);
        assert!(cl.supports_pie());
    }

    // ──────────────── Additional Triple Parser tests ──────────────

    #[test]
    fn test_triple_parser_amd_athlon_variants() {
        for cpu in &[
            "athlon",
            "athlon64",
            "athlon-fx",
            "k8",
            "opteron",
            "k8-sse3",
            "amdfam10",
            "barcelona",
            "btver1",
            "btver2",
            "bdver1",
            "bdver2",
            "bdver3",
            "bdver4",
        ] {
            let info = X86TripleParser::parse_x86_arch(cpu);
            assert!(info.is_some(), "CPU {} should be recognized", cpu);
            assert!(info.unwrap().has_sse2, "CPU {} should have SSE2", cpu);
        }
    }

    #[test]
    fn test_triple_parser_atom_variants() {
        for cpu in &[
            "silvermont",
            "goldmont",
            "goldmont-plus",
            "tremont",
            "gracemont",
            "crestmont",
            "skymont",
        ] {
            let info = X86TripleParser::parse_x86_arch(cpu);
            assert!(info.is_some(), "CPU {} should be recognized", cpu);
            assert!(info.unwrap().has_sse2);
        }
    }

    #[test]
    fn test_triple_parser_x86_64_v_level_features() {
        // v2 should have SSE4.2 + POPCNT + CX16
        let f2 = X86TripleParser::default_features_for_cpu("x86-64-v2");
        assert!(f2.contains(&"+sse4.2"));
        assert!(f2.contains(&"+popcnt"));

        // v3 should have AVX2 + BMI + FMA
        let f3 = X86TripleParser::default_features_for_cpu("x86-64-v3");
        assert!(f3.contains(&"+avx2"));
        assert!(f3.contains(&"+bmi2"));

        // v4 should have AVX-512
        let f4 = X86TripleParser::default_features_for_cpu("x86-64-v4");
        assert!(f4.contains(&"+avx512f"));
        assert!(f4.contains(&"+avx512vl"));
    }

    #[test]
    fn test_triple_parser_znver_variants_features() {
        for (cpu, expected_avx2) in &[
            ("znver1", true),
            ("znver2", true),
            ("znver3", true),
            ("znver4", true),
            ("znver5", true),
        ] {
            let features = X86TripleParser::default_features_for_cpu(cpu);
            let has_avx2 = features.contains(&"+avx2");
            assert_eq!(has_avx2, *expected_avx2, "{} avx2 mismatch", cpu);
        }
    }

    #[test]
    fn test_triple_parser_intel_core_features() {
        // Sandybridge should have AVX but not AVX2
        let f_sb = X86TripleParser::default_features_for_cpu("sandybridge");
        assert!(f_sb.contains(&"+avx"));
        assert!(!f_sb.contains(&"+avx2"));

        // Haswell should have AVX2
        let f_hw = X86TripleParser::default_features_for_cpu("haswell");
        assert!(f_hw.contains(&"+avx2"));

        // Skylake should have AVX-512 options
        let f_skx = X86TripleParser::default_features_for_cpu("skylake-avx512");
        assert!(f_skx.contains(&"+avx512f"));
    }

    #[test]
    fn test_triple_parser_os_details_linux() {
        let triple = Triple::parse("x86_64-unknown-linux-gnu");
        let os = X86TripleParser::parse_os_details(&triple);
        assert_eq!(os.default_object_format, X86ObjectFormat::ELF);
        assert!(os.supports_multiarch);
    }

    #[test]
    fn test_triple_parser_os_details_darwin() {
        let triple = Triple::parse("x86_64-apple-darwin");
        let os = X86TripleParser::parse_os_details(&triple);
        assert_eq!(os.default_object_format, X86ObjectFormat::MachO);
        assert_eq!(os.default_libc, X86LibC::LibSystem);
    }

    #[test]
    fn test_triple_parser_os_details_windows_msvc() {
        let triple = Triple::parse("x86_64-pc-windows-msvc");
        let os = X86TripleParser::parse_os_details(&triple);
        assert_eq!(os.default_object_format, X86ObjectFormat::COFF);
    }

    #[test]
    fn test_triple_parser_os_details_haiku() {
        let triple = Triple::parse("x86_64-unknown-haiku");
        let os = X86TripleParser::parse_os_details(&triple);
        assert_eq!(os.default_object_format, X86ObjectFormat::ELF);
    }

    #[test]
    fn test_triple_parser_os_details_wasi() {
        let triple = Triple::parse("wasm32-unknown-wasi");
        let os = X86TripleParser::parse_os_details(&triple);
        assert_eq!(os.default_object_format, X86ObjectFormat::Wasm);
    }

    // ──────────────── Resource Dir Extended Tests ─────────────────

    #[test]
    fn test_resource_dir_sanitizer_library() {
        let triple = Triple::parse("x86_64-unknown-linux-gnu");
        let rd = X86ResourceDir::new(&triple);
        let path = rd.sanitizer_library_path("asan");
        // May or may not exist
        let _ = path;
    }

    #[test]
    fn test_resource_dir_builtins_path() {
        let triple = Triple::parse("x86_64-unknown-linux-gnu");
        let rd = X86ResourceDir::new(&triple);
        let path = rd.builtins_path();
        // May or may not exist
        let _ = path;
    }

    #[test]
    fn test_resource_dir_has_builtin_header() {
        let triple = Triple::parse("x86_64-unknown-linux-gnu");
        let rd = X86ResourceDir::new(&triple);
        let has_stddef = rd.has_builtin_header("stddef.h");
        // May or may not be installed
        let _ = has_stddef;
    }

    #[test]
    fn test_resource_dir_list_builtin_headers() {
        let triple = Triple::parse("x86_64-unknown-linux-gnu");
        let rd = X86ResourceDir::new(&triple);
        let headers = rd.list_builtin_headers();
        // May be empty if not installed
        let _ = headers.len();
    }

    // ──────────────── Edge Case Tests ─────────────────────────────

    #[test]
    fn test_edge_case_unknown_architecture() {
        let parser = X86TripleParser::new("unknown-unknown-unknown");
        assert!(!parser.is_valid);
        assert!(!parser.warnings.is_empty());
    }

    #[test]
    fn test_edge_case_empty_triple() {
        let manager = X86SysrootManager::new("");
        assert_eq!(manager.triple.arch, Arch::Unknown);
    }

    #[test]
    fn test_edge_case_all_cpu_names_valid_arch_family() {
        let cpus = X86TripleParser::known_x86_cpus();
        for cpu in &cpus {
            if let Some(info) = X86TripleParser::parse_x86_arch(cpu) {
                assert!(
                    info.family == X86ArchFamily::X86_32
                        || info.family == X86ArchFamily::X86_64
                        || info.family == X86ArchFamily::X32,
                    "CPU {} has unexpected family {:?}",
                    cpu,
                    info.family
                );
            }
        }
    }

    #[test]
    fn test_edge_case_cross_compilation_non_x86() {
        let cc = X86CrossCompilation::new("sparc64-unknown-linux-gnu");
        assert!(cc.is_cross); // Should be cross from x86_64
    }

    #[test]
    fn test_edge_case_multiarch_mips() {
        let triple = Triple::parse("mips-unknown-linux-gnu");
        let ma = X86Multiarch::new(&triple);
        assert_eq!(
            ma.multiarch_dir,
            None // MIPS is in the Debian tuple list but not in the main match
        );
    }

    #[test]
    fn test_edge_case_android_x86_32bit() {
        let detector = X86SysrootDetector::new("i686-linux-android");
        assert!(detector.search_android_ndk);
        assert_eq!(detector.android_arch_name(), "x86");
    }

    #[test]
    fn test_edge_case_mingw_detection_flag() {
        let detector = X86SysrootDetector::new("x86_64-w64-mingw32");
        assert!(detector.search_mingw);
    }

    #[test]
    fn test_edge_case_tvos_triple() {
        let detector = X86SysrootDetector::new("x86_64-apple-tvos");
        assert!(detector.search_xcode);
    }

    #[test]
    fn test_edge_case_watchos_triple() {
        let detector = X86SysrootDetector::new("x86_64-apple-watchos");
        assert!(detector.search_xcode);
    }

    // ──────────────── SysrootCache tests ─────────────────────────

    #[test]
    fn test_sysroot_cache_new() {
        let cache = X86SysrootCache::new();
        assert!(cache.is_empty());
        assert_eq!(cache.len(), 0);
    }

    #[test]
    fn test_sysroot_cache_get_sysroot() {
        let mut cache = X86SysrootCache::new();
        let sysroot = cache.get_sysroot("x86_64-unknown-linux-gnu");
        // Should cache the result
        assert!(!cache.is_empty());
        // Second call should return cached version
        let sysroot2 = cache.get_sysroot("x86_64-unknown-linux-gnu");
        assert_eq!(sysroot.path, sysroot2.path);
    }

    #[test]
    fn test_sysroot_cache_get_gcc() {
        let mut cache = X86SysrootCache::new();
        let triple = Triple::parse("x86_64-unknown-linux-gnu");
        let gcc = cache.get_gcc(&triple);
        // GCC may or may not be found
        let _ = gcc.is_valid;
        // Second call returns cached
        let gcc2 = cache.get_gcc(&triple);
        assert_eq!(gcc.is_valid, gcc2.is_valid);
    }

    #[test]
    fn test_sysroot_cache_get_libc() {
        let mut cache = X86SysrootCache::new();
        let triple = Triple::parse("x86_64-unknown-linux-gnu");
        let libc = cache.get_libc(&triple);
        assert_eq!(libc.libc_type, X86LibC::Glibc);
        // Second call returns cached
        let libc2 = cache.get_libc(&triple);
        assert_eq!(libc2.libc_type, X86LibC::Glibc);
    }

    #[test]
    fn test_sysroot_cache_clear() {
        let mut cache = X86SysrootCache::new();
        cache.get_sysroot("x86_64-unknown-linux-gnu");
        assert!(!cache.is_empty());
        cache.clear();
        assert!(cache.is_empty());
    }

    #[test]
    fn test_sysroot_cache_multiple_triples() {
        let mut cache = X86SysrootCache::new();
        cache.get_sysroot("x86_64-unknown-linux-gnu");
        cache.get_sysroot("i386-unknown-linux-gnu");
        cache.get_sysroot("aarch64-unknown-linux-gnu");
        assert!(cache.len() >= 3);
    }

    #[test]
    fn test_sysroot_cache_default() {
        let cache = X86SysrootCache::default();
        assert!(cache.is_empty());
    }

    // ──────────────── SysrootManager Extended Tests ──────────────

    #[test]
    fn test_sysroot_manager_add_include() {
        let mut manager = X86SysrootManager::new("x86_64-unknown-linux-gnu");
        manager.add_include(PathBuf::from("/custom/include"));
        assert_eq!(manager.extra_includes.len(), 1);
        // Adding same path twice should not duplicate
        manager.add_include(PathBuf::from("/custom/include"));
        assert_eq!(manager.extra_includes.len(), 1);
    }

    #[test]
    fn test_sysroot_manager_add_library() {
        let mut manager = X86SysrootManager::new("x86_64-unknown-linux-gnu");
        manager.add_library(PathBuf::from("/custom/lib"));
        assert_eq!(manager.extra_libraries.len(), 1);
        manager.add_library(PathBuf::from("/custom/lib"));
        assert_eq!(manager.extra_libraries.len(), 1);
    }

    #[test]
    fn test_sysroot_manager_arch_directory_name() {
        let manager = X86SysrootManager::new("x86_64-unknown-linux-gnu");
        let dir = manager.arch_directory_name();
        assert!(dir.contains("x86_64"));
    }

    #[test]
    fn test_sysroot_manager_recommended_libc() {
        let manager = X86SysrootManager::new("x86_64-unknown-linux-gnu");
        assert_eq!(manager.recommended_libc(), X86LibC::Glibc);

        let manager = X86SysrootManager::new("x86_64-unknown-linux-musl");
        assert_eq!(manager.recommended_libc(), X86LibC::Musl);
    }

    #[test]
    fn test_sysroot_manager_is_ready() {
        let manager = X86SysrootManager::new("x86_64-unknown-linux-gnu");
        let ready = manager.is_ready();
        // Native should be ready
        if cfg!(target_arch = "x86_64") && cfg!(target_os = "linux") {
            assert!(ready);
        }
    }

    #[test]
    fn test_sysroot_manager_summary() {
        let manager = X86SysrootManager::new("x86_64-unknown-linux-gnu");
        let summary = manager.summary();
        assert!(summary.contains("x86_64"));
        assert!(summary.contains("Target:"));
        assert!(summary.contains("Arch:"));
    }

    #[test]
    fn test_sysroot_manager_detect_cxx_libraries() {
        let mut manager = X86SysrootManager::new("x86_64-unknown-linux-gnu");
        manager.detect_gcc();
        let libs = manager.detect_cxx_libraries();
        // May or may not find libs
        let _ = libs;
    }

    #[test]
    fn test_sysroot_manager_configure_lto() {
        let manager = X86SysrootManager::new("x86_64-unknown-linux-gnu");
        let flags = manager.configure_lto();
        assert!(flags.iter().any(|f| f.contains("lto")));
    }

    #[test]
    fn test_sysroot_manager_configure_sanitizers() {
        let manager = X86SysrootManager::new("x86_64-unknown-linux-gnu");
        let flags = manager.configure_sanitizers(&["address", "undefined"]);
        assert!(flags.iter().any(|f| f.contains("sanitize")));
        assert!(flags.iter().any(|f| f.contains("address")));
    }

    #[test]
    fn test_sysroot_manager_configure_sanitizers_empty() {
        let manager = X86SysrootManager::new("x86_64-unknown-linux-gnu");
        let flags = manager.configure_sanitizers(&[]);
        assert!(flags.is_empty());
    }

    #[test]
    fn test_sysroot_manager_configure_coverage() {
        let manager = X86SysrootManager::new("x86_64-unknown-linux-gnu");
        let flags = manager.configure_coverage();
        assert!(flags.iter().any(|f| f.contains("coverage")));
    }

    #[test]
    fn test_sysroot_manager_configure_pgo() {
        let manager = X86SysrootManager::new("x86_64-unknown-linux-gnu");
        let flags = manager.configure_pgo("/path/to/profiles");
        assert!(flags.iter().any(|f| f.contains("/path/to/profiles")));
    }

    #[test]
    fn test_sysroot_manager_configure_bolt() {
        let manager = X86SysrootManager::new("x86_64-unknown-linux-gnu");
        let flags = manager.configure_bolt("/path/to/perf.data");
        assert!(flags.iter().any(|f| f.contains("/path/to/perf.data")));
    }

    // ──────────────── Additional CPU variant tests ───────────────

    #[test]
    fn test_triple_parser_xeon_phi() {
        for cpu in &["knl", "knightslanding", "knm", "knightsmill"] {
            let info = X86TripleParser::parse_x86_arch(cpu);
            assert!(info.is_some(), "CPU {} should be recognized", cpu);
            assert!(info.unwrap().has_sse2);
        }
    }

    #[test]
    fn test_triple_parser_via_cpus() {
        let c3 = X86TripleParser::parse_x86_arch("c3").unwrap();
        assert!(!c3.has_sse2);
        assert_eq!(c3.family, X86ArchFamily::X86_32);

        let c3_2 = X86TripleParser::parse_x86_arch("c3-2").unwrap();
        assert!(c3_2.has_sse2);

        let c7 = X86TripleParser::parse_x86_arch("c7").unwrap();
        assert_eq!(c7.family, X86ArchFamily::X86_64);
    }

    #[test]
    fn test_triple_parser_geode() {
        let info = X86TripleParser::parse_x86_arch("geode").unwrap();
        assert_eq!(info.family, X86ArchFamily::X86_32);
        assert!(!info.has_sse2);
    }

    #[test]
    fn test_triple_parser_winchip() {
        for cpu in &["winchip-c6", "winchip2"] {
            let info = X86TripleParser::parse_x86_arch(cpu);
            assert!(info.is_some(), "CPU {} should be recognized", cpu);
            assert!(!info.unwrap().has_sse2);
        }
    }

    #[test]
    fn test_triple_parser_prescott_nocona() {
        let prescott = X86TripleParser::parse_x86_arch("prescott").unwrap();
        assert!(prescott.has_sse2);
        assert_eq!(prescott.family, X86ArchFamily::X86_32);

        let nocona = X86TripleParser::parse_x86_arch("nocona").unwrap();
        assert_eq!(nocona.family, X86ArchFamily::X86_64);
    }

    #[test]
    fn test_triple_parser_intel_server_cpus() {
        for cpu in &["cascadelake", "cooperlake", "emeraldrapids", "sierraforest"] {
            let info = X86TripleParser::parse_x86_arch(cpu);
            assert!(info.is_some(), "CPU {} should be recognized", cpu);
            assert!(info.unwrap().has_sse2);
        }
    }

    #[test]
    fn test_triple_parser_extended_vendor_names() {
        for vendor in &[
            "pc",
            "apple",
            "ibm",
            "amd",
            "nvidia",
            "sony",
            "freescale",
            "qualcomm",
            "samsung",
            "marvell",
            "broadcom",
            "allwinner",
            "rockchip",
            "mediatek",
            "hisilicon",
            "ampere",
            "phytium",
        ] {
            let result = X86TripleParser::parse_x86_vendor(vendor);
            assert!(result.is_some(), "Vendor '{}' should be recognized", vendor);
        }
    }
}