llvm-native-core 0.1.16

//! Symbol table construction and management for ELF object files.
//!
//! Provides `ElfSymbolTable` — a builder for ELF symbol tables
//! (`.symtab` or `.dynsym`) with automatic string table generation
//! and serialization to raw `Elf64Sym` / `Elf32Sym` byte sequences.
//!
//! Clean-room implementation; no LLVM C++ source consulted.

use super::elf_types;
use elf_types::{
    st_info, st_other, SHN_ABS, SHN_UNDEF, STB_GLOBAL, STB_LOCAL, STB_WEAK, STT_FILE, STT_FUNC,
    STT_NOTYPE, STT_OBJECT, STT_SECTION, STV_DEFAULT,
};

// ============================================================================
// ElfSymbolVersion
// ============================================================================

/// A symbol version entry (for GNU-style symbol versioning).
///
/// When a symbol has a version, it appears as `name@VERSION` (hidden)
/// or `name@@VERSION` (default).
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct ElfSymbolVersion {
    /// Version name, e.g. `"GLIBC_2.2.5"`.
    pub name: String,
    /// If `true`, this is the default version (`@@`).
    /// If `false`, this is a hidden version (`@`).
    pub is_hidden: bool,
}

impl ElfSymbolVersion {
    /// Create a new symbol version.
    pub fn new(name: impl Into<String>, is_hidden: bool) -> Self {
        ElfSymbolVersion {
            name: name.into(),
            is_hidden,
        }
    }

    /// Create a default version (two `@` signs).
    pub fn default_version(name: impl Into<String>) -> Self {
        Self::new(name, false) // "is_hidden" false → default (two @ signs)
    }

    /// Create a hidden version (single `@` sign).
    pub fn hidden_version(name: impl Into<String>) -> Self {
        Self::new(name, true)
    }
}

// ============================================================================
// ElfSymbolEntry
// ============================================================================

/// A single entry in a symbol table.
///
/// This is the logical (in-memory) representation of an ELF symbol,
/// independent of 32-bit vs 64-bit layout.
#[derive(Debug, Clone, PartialEq)]
pub struct ElfSymbolEntry {
    /// Symbol name.
    pub name: String,
    /// Symbol value (address or section offset).
    pub value: u64,
    /// Symbol size in bytes.
    pub size: u64,
    /// Binding: `STB_LOCAL`, `STB_GLOBAL`, `STB_WEAK`, etc.
    pub binding: u8,
    /// Type: `STT_FUNC`, `STT_OBJECT`, `STT_SECTION`, `STT_FILE`, etc.
    pub sym_type: u8,
    /// Visibility: `STV_DEFAULT`, `STV_HIDDEN`, etc.
    pub visibility: u8,
    /// Section index (`SHN_UNDEF`, `SHN_ABS`, or a valid section index).
    pub section_index: u16,
    /// Optional symbol version.
    pub version: Option<ElfSymbolVersion>,
}

impl ElfSymbolEntry {
    /// Create a new symbol entry with all fields explicit.
    pub fn new(
        name: impl Into<String>,
        value: u64,
        size: u64,
        binding: u8,
        sym_type: u8,
        visibility: u8,
        section_index: u16,
    ) -> Self {
        ElfSymbolEntry {
            name: name.into(),
            value,
            size,
            binding,
            sym_type,
            visibility,
            section_index,
            version: None,
        }
    }

    /// Create a local symbol.
    pub fn local(
        name: impl Into<String>,
        value: u64,
        size: u64,
        sym_type: u8,
        section_index: u16,
    ) -> Self {
        Self::new(
            name,
            value,
            size,
            STB_LOCAL,
            sym_type,
            STV_DEFAULT,
            section_index,
        )
    }

    /// Create a global symbol.
    pub fn global(
        name: impl Into<String>,
        value: u64,
        size: u64,
        sym_type: u8,
        section_index: u16,
    ) -> Self {
        Self::new(
            name,
            value,
            size,
            STB_GLOBAL,
            sym_type,
            STV_DEFAULT,
            section_index,
        )
    }

    /// Create a weak symbol.
    pub fn weak(
        name: impl Into<String>,
        value: u64,
        size: u64,
        sym_type: u8,
        section_index: u16,
    ) -> Self {
        Self::new(
            name,
            value,
            size,
            STB_WEAK,
            sym_type,
            STV_DEFAULT,
            section_index,
        )
    }

    /// Create a STT_FILE symbol (typically index 1 in the symbol table).
    pub fn file_symbol(filename: impl Into<String>) -> Self {
        Self::new(filename, 0, 0, STB_LOCAL, STT_FILE, STV_DEFAULT, SHN_ABS)
    }

    /// Create a STT_SECTION symbol for a given section.
    pub fn section_symbol(section_index: u16) -> Self {
        Self::new("", 0, 0, STB_LOCAL, STT_SECTION, STV_DEFAULT, section_index)
    }

    /// Return the packed `st_info` byte.
    #[inline]
    pub fn info_byte(&self) -> u8 {
        st_info(self.binding, self.sym_type)
    }

    /// Return the packed `st_other` byte.
    #[inline]
    pub fn other_byte(&self) -> u8 {
        st_other(self.visibility)
    }

    /// Whether this is a local symbol (`STB_LOCAL` binding).
    #[inline]
    pub fn is_local(&self) -> bool {
        self.binding == STB_LOCAL
    }

    /// Whether this is a global symbol (`STB_GLOBAL` binding).
    #[inline]
    pub fn is_global(&self) -> bool {
        self.binding == STB_GLOBAL
    }

    /// Whether this is a weak symbol (`STB_WEAK` binding).
    #[inline]
    pub fn is_weak(&self) -> bool {
        self.binding == STB_WEAK
    }

    /// Whether this symbol is undefined (section index is `SHN_UNDEF`).
    #[inline]
    pub fn is_undefined(&self) -> bool {
        self.section_index == SHN_UNDEF
    }

    /// Set the version on this symbol.
    pub fn with_version(mut self, version: ElfSymbolVersion) -> Self {
        self.version = Some(version);
        self
    }

    /// Set the visibility on this symbol.
    pub fn with_visibility(mut self, visibility: u8) -> Self {
        self.visibility = visibility;
        self
    }
}

// ============================================================================
// ElfSymbolTable
// ============================================================================

/// A symbol table builder for ELF files.
///
/// Maintains a list of `ElfSymbolEntry` values and can build the
/// associated string table. Index 0 is always the null (undefined)
/// sentinel entry required by the ELF specification.
///
/// # Example
///
/// ```ignore
/// let mut symtab = ElfSymbolTable::new();
/// symtab.add_file_symbol("example.c");
/// symtab.add_global_symbol("main", 0x1000, 64, STT_FUNC, 1);
/// symtab.add_local_symbol("helper", 0x1100, 32, STT_FUNC, 1);
///
/// let strtab = symtab.build_strtab();
/// let raw_syms = symtab.build_symtab_entries(true); // 64-bit
/// ```
#[derive(Debug, Clone)]
pub struct ElfSymbolTable {
    /// Symbols, index 0 is the null entry.
    pub symbols: Vec<ElfSymbolEntry>,
    /// Whether this is a dynamic symbol table (`.dynsym`).
    pub is_dynamic: bool,
}

impl ElfSymbolTable {
    /// Create a new symbol table with only the null (index 0) entry.
    ///
    /// The null entry has:
    /// - empty name
    /// - value/size = 0
    /// - `STB_LOCAL` / `STT_NOTYPE`
    /// - `SHN_UNDEF` section index
    pub fn new() -> Self {
        let null_entry = ElfSymbolEntry {
            name: String::new(),
            value: 0,
            size: 0,
            binding: STB_LOCAL,
            sym_type: STT_NOTYPE,
            visibility: STV_DEFAULT,
            section_index: SHN_UNDEF,
            version: None,
        };

        ElfSymbolTable {
            symbols: vec![null_entry],
            is_dynamic: false,
        }
    }

    /// Create a new dynamic symbol table with the null entry.
    pub fn new_dynamic() -> Self {
        let mut t = Self::new();
        t.is_dynamic = true;
        t
    }

    /// Add a symbol to the table and return its index.
    ///
    /// This is the general-purpose method. Consider using
    /// `add_local_symbol`, `add_global_symbol`, etc. for convenience.
    pub fn add_symbol(&mut self, entry: ElfSymbolEntry) -> u32 {
        let index = self.symbols.len() as u32;
        self.symbols.push(entry);
        index
    }

    /// Add a local symbol (convenience wrapper).
    pub fn add_local_symbol(
        &mut self,
        name: impl Into<String>,
        value: u64,
        size: u64,
        sym_type: u8,
        section_index: u16,
    ) -> u32 {
        self.add_symbol(ElfSymbolEntry::local(
            name,
            value,
            size,
            sym_type,
            section_index,
        ))
    }

    /// Add a global symbol (convenience wrapper).
    pub fn add_global_symbol(
        &mut self,
        name: impl Into<String>,
        value: u64,
        size: u64,
        sym_type: u8,
        section_index: u16,
    ) -> u32 {
        self.add_symbol(ElfSymbolEntry::global(
            name,
            value,
            size,
            sym_type,
            section_index,
        ))
    }

    /// Add a weak symbol (convenience wrapper).
    pub fn add_weak_symbol(
        &mut self,
        name: impl Into<String>,
        value: u64,
        size: u64,
        sym_type: u8,
        section_index: u16,
    ) -> u32 {
        self.add_symbol(ElfSymbolEntry::weak(
            name,
            value,
            size,
            sym_type,
            section_index,
        ))
    }

    /// Add a `STT_FILE` symbol (source file reference, typically index 1).
    pub fn add_file_symbol(&mut self, filename: impl Into<String>) -> u32 {
        self.add_symbol(ElfSymbolEntry::file_symbol(filename))
    }

    /// Add a `STT_SECTION` symbol for the given section index.
    ///
    /// Section symbols are always local and have an empty name.
    pub fn add_section_symbol(&mut self, section_index: u16) -> u32 {
        self.add_symbol(ElfSymbolEntry::section_symbol(section_index))
    }

    /// Add a symbol with a GNU-style version.
    pub fn add_versioned_symbol(
        &mut self,
        mut entry: ElfSymbolEntry,
        version_name: impl Into<String>,
        is_default: bool,
    ) -> u32 {
        entry.version = Some(ElfSymbolVersion::new(version_name, !is_default));
        // ^ note: is_hidden = !is_default
        self.add_symbol(entry)
    }

    /// Get a symbol by index. Returns `None` if the index is out of bounds.
    pub fn get_symbol(&self, index: u32) -> Option<&ElfSymbolEntry> {
        self.symbols.get(index as usize)
    }

    /// Get a mutable reference to a symbol by index.
    pub fn get_symbol_mut(&mut self, index: u32) -> Option<&mut ElfSymbolEntry> {
        self.symbols.get_mut(index as usize)
    }

    /// Get the index of the first symbol with the given name.
    ///
    /// Returns `None` if no symbol with that name exists.
    pub fn get_symbol_index(&self, name: &str) -> Option<u32> {
        self.symbols
            .iter()
            .position(|s| s.name == name)
            .map(|i| i as u32)
    }

    /// Return the number of symbols (including the null entry at index 0).
    pub fn len(&self) -> usize {
        self.symbols.len()
    }

    /// Whether the table is empty (only the null entry exists).
    pub fn is_empty(&self) -> bool {
        self.symbols.len() <= 1
    }

    /// Count the number of local symbols (including the null entry).
    ///
    /// For the `sh_info` field of a `SHT_SYMTAB` section header, this
    /// should be set to the index of the first non-local symbol.
    /// This method returns that count.
    pub fn num_locals(&self) -> u32 {
        self.symbols
            .iter()
            .take_while(|s| s.binding == STB_LOCAL)
            .count() as u32
    }

    /// Index of the first global (non-local) symbol.
    ///
    /// This is the value typically written to `sh_info` of a symbol
    /// table section header. Returns the count of local symbols
    /// (equivalent to `num_locals()`).
    pub fn first_global(&self) -> u32 {
        self.num_locals()
    }

    /// Return an iterator over all symbols (including the null entry).
    pub fn iter(&self) -> impl Iterator<Item = &ElfSymbolEntry> {
        self.symbols.iter()
    }

    /// Return an iterator over global symbols only.
    pub fn globals(&self) -> impl Iterator<Item = &ElfSymbolEntry> {
        self.symbols
            .iter()
            .filter(|s| s.binding == STB_GLOBAL || s.binding == STB_WEAK)
    }

    /// Return an iterator over local symbols only.
    pub fn locals(&self) -> impl Iterator<Item = &ElfSymbolEntry> {
        self.symbols.iter().filter(|s| s.binding == STB_LOCAL)
    }

    // ------------------------------------------------------------------
    // String Table
    // ------------------------------------------------------------------

    /// Build the string table (`strtab`) from symbol names.
    ///
    /// The returned `Vec<u8>` starts with a NUL byte (string index 0 =
    /// the empty string, used by the null symbol entry) followed by
    /// each unique symbol name, NUL-terminated.
    ///
    /// Symbol names are deduplicated: identical names share the same
    /// string table offset.
    ///
    /// Returns the raw string table bytes.
    pub fn build_strtab(&self) -> Vec<u8> {
        let mut strtab: Vec<u8> = vec![0u8]; // index 0 = ""
        let mut offsets: std::collections::HashMap<String, u32> = std::collections::HashMap::new();

        for sym in self.symbols.iter() {
            if sym.name.is_empty() {
                continue;
            }
            // Deduplicate
            if offsets.contains_key(&sym.name) {
                continue;
            }
            let offset = strtab.len() as u32;
            offsets.insert(sym.name.clone(), offset);
            strtab.extend_from_slice(sym.name.as_bytes());
            strtab.push(0u8); // NUL terminator
        }

        strtab
    }

    /// Build a mapping from symbol index to string table offset.
    ///
    /// Returns a `Vec<u32>` where the `i`-th element is the string table
    /// offset for symbol `i`. Index 0 always maps to 0 (the NUL byte).
    pub fn build_stroff_map(&self) -> Vec<u32> {
        let strtab = self.build_strtab();
        let mut offsets: Vec<u32> = Vec::with_capacity(self.symbols.len());

        for sym in self.symbols.iter() {
            if sym.name.is_empty() {
                offsets.push(0);
            } else {
                // Find the offset inside the strtab by scanning
                let name_bytes = sym.name.as_bytes();
                // Search for name_bytes followed by NUL
                if let Some(pos) = strtab
                    .windows(name_bytes.len() + 1)
                    .position(|w| w[..name_bytes.len()] == *name_bytes && w[name_bytes.len()] == 0)
                {
                    offsets.push(pos as u32);
                } else {
                    offsets.push(0);
                }
            }
        }

        offsets
    }

    // ------------------------------------------------------------------
    // Serialization
    // ------------------------------------------------------------------

    /// Serialize the symbol table entries to raw bytes.
    ///
    /// When `is_64bit` is `true`, produces `Elf64Sym` entries (24 bytes each).
    /// When `is_64bit` is `false`, produces `Elf32Sym` entries (16 bytes each).
    ///
    /// All multi-byte fields are written in little-endian byte order.
    /// The string table must be built separately via `build_strtab()`
    /// — this method fills `st_name` with the correct string table offset.
    pub fn build_symtab_entries(&self, is_64bit: bool) -> Vec<u8> {
        let stroff = self.build_stroff_map();

        if is_64bit {
            self.build_symtab_entries_64(&stroff)
        } else {
            self.build_symtab_entries_32(&stroff)
        }
    }

    /// Build 64-bit symbol table entries (Elf64Sym, 24 bytes each).
    fn build_symtab_entries_64(&self, stroff: &[u32]) -> Vec<u8> {
        let entry_size = 24;
        let mut buf: Vec<u8> = Vec::with_capacity(self.symbols.len() * entry_size);

        for (i, sym) in self.symbols.iter().enumerate() {
            let name_off = stroff.get(i).copied().unwrap_or(0);

            // Elf64Sym layout (little-endian):
            // [0..4]   st_name:  u32 LE
            // [4]      st_info:  u8
            // [5]      st_other: u8
            // [6..8]   st_shndx: u16 LE
            // [8..16]  st_value: u64 LE
            // [16..24] st_size:  u64 LE
            buf.extend_from_slice(&name_off.to_le_bytes());
            buf.push(sym.info_byte());
            buf.push(sym.other_byte());
            buf.extend_from_slice(&sym.section_index.to_le_bytes());
            buf.extend_from_slice(&sym.value.to_le_bytes());
            buf.extend_from_slice(&sym.size.to_le_bytes());
        }

        buf
    }

    /// Build 32-bit symbol table entries (Elf32Sym, 16 bytes each).
    fn build_symtab_entries_32(&self, stroff: &[u32]) -> Vec<u8> {
        let entry_size = 16;
        let mut buf: Vec<u8> = Vec::with_capacity(self.symbols.len() * entry_size);

        for (i, sym) in self.symbols.iter().enumerate() {
            let name_off = stroff.get(i).copied().unwrap_or(0);

            // Elf32Sym layout (little-endian):
            // [0..4]   st_name:  u32 LE
            // [4..8]   st_value: u32 LE
            // [8..12]  st_size:  u32 LE
            // [12]     st_info:  u8
            // [13]     st_other: u8
            // [14..16] st_shndx: u16 LE
            buf.extend_from_slice(&name_off.to_le_bytes());
            buf.extend_from_slice(&(sym.value as u32).to_le_bytes());
            buf.extend_from_slice(&(sym.size as u32).to_le_bytes());
            buf.push(sym.info_byte());
            buf.push(sym.other_byte());
            buf.extend_from_slice(&sym.section_index.to_le_bytes());
        }

        buf
    }

    /// Return the size of each symbol entry in bytes for the given bitness.
    pub fn entry_size(is_64bit: bool) -> usize {
        if is_64bit {
            24
        } else {
            16
        }
    }

    /// Total size in bytes of the serialized symbol table.
    pub fn total_size(&self, is_64bit: bool) -> usize {
        self.symbols.len() * Self::entry_size(is_64bit)
    }
}

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

// ============================================================================
// Tests
// ============================================================================

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

    // ------------------------------------------------------------------
    // Null entry
    // ------------------------------------------------------------------

    #[test]
    fn test_new_table_has_null_entry() {
        let t = ElfSymbolTable::new();
        assert_eq!(t.len(), 1);
        let null = t.get_symbol(0).unwrap();
        assert!(null.name.is_empty());
        assert_eq!(null.value, 0);
        assert_eq!(null.size, 0);
        assert_eq!(null.binding, STB_LOCAL);
        assert_eq!(null.sym_type, STT_NOTYPE);
        assert_eq!(null.section_index, SHN_UNDEF);
    }

    #[test]
    fn test_new_dynamic_table() {
        let t = ElfSymbolTable::new_dynamic();
        assert!(t.is_dynamic);
        assert_eq!(t.len(), 1);
    }

    // ------------------------------------------------------------------
    // Adding symbols
    // ------------------------------------------------------------------

    #[test]
    fn test_add_local_symbol() {
        let mut t = ElfSymbolTable::new();
        let idx = t.add_local_symbol("local_func", 0x1000, 32, STT_FUNC, 1);
        assert_eq!(idx, 1);
        assert_eq!(t.len(), 2);
        let sym = t.get_symbol(1).unwrap();
        assert_eq!(sym.name, "local_func");
        assert_eq!(sym.value, 0x1000);
        assert_eq!(sym.size, 32);
        assert_eq!(sym.binding, STB_LOCAL);
        assert_eq!(sym.sym_type, STT_FUNC);
        assert_eq!(sym.section_index, 1);
    }

    #[test]
    fn test_add_global_symbol() {
        let mut t = ElfSymbolTable::new();
        let idx = t.add_global_symbol("main", 0x2000, 128, STT_FUNC, 2);
        assert_eq!(idx, 1);
        let sym = t.get_symbol(1).unwrap();
        assert_eq!(sym.name, "main");
        assert_eq!(sym.binding, STB_GLOBAL);
        assert_eq!(sym.sym_type, STT_FUNC);
    }

    #[test]
    fn test_add_weak_symbol() {
        let mut t = ElfSymbolTable::new();
        let idx = t.add_weak_symbol("weak_handler", 0x3000, 16, STT_FUNC, 3);
        let sym = t.get_symbol(idx).unwrap();
        assert_eq!(sym.binding, STB_WEAK);
        assert!(sym.is_weak());
        assert!(!sym.is_global());
        assert!(!sym.is_local());
    }

    #[test]
    fn test_add_file_symbol() {
        let mut t = ElfSymbolTable::new();
        let idx = t.add_file_symbol("example.c");
        let sym = t.get_symbol(idx).unwrap();
        assert_eq!(sym.name, "example.c");
        assert_eq!(sym.sym_type, STT_FILE);
        assert_eq!(sym.binding, STB_LOCAL);
        assert_eq!(sym.section_index, SHN_ABS);
    }

    #[test]
    fn test_add_section_symbol() {
        let mut t = ElfSymbolTable::new();
        let idx = t.add_section_symbol(5);
        let sym = t.get_symbol(idx).unwrap();
        assert!(sym.name.is_empty());
        assert_eq!(sym.sym_type, STT_SECTION);
        assert_eq!(sym.binding, STB_LOCAL);
        assert_eq!(sym.section_index, 5);
    }

    #[test]
    fn test_multiple_symbols_indexes() {
        let mut t = ElfSymbolTable::new();
        let a = t.add_local_symbol("a", 0, 0, STT_NOTYPE, SHN_UNDEF);
        let b = t.add_global_symbol("b", 0, 0, STT_NOTYPE, SHN_UNDEF);
        let c = t.add_global_symbol("c", 0, 0, STT_NOTYPE, SHN_UNDEF);
        assert_eq!(a, 1);
        assert_eq!(b, 2);
        assert_eq!(c, 3);
        assert_eq!(t.len(), 4); // null + a + b + c
    }

    // ------------------------------------------------------------------
    // Symbol lookup
    // ------------------------------------------------------------------

    #[test]
    fn test_get_symbol_by_index() {
        let mut t = ElfSymbolTable::new();
        t.add_global_symbol("foo", 0x100, 8, STT_OBJECT, 1);
        t.add_global_symbol("bar", 0x200, 8, STT_OBJECT, 2);

        assert!(t.get_symbol(0).is_some());
        assert!(t.get_symbol(1).is_some());
        assert!(t.get_symbol(2).is_some());
        assert!(t.get_symbol(3).is_none());
        assert!(t.get_symbol(999).is_none());
    }

    #[test]
    fn test_get_symbol_index_by_name() {
        let mut t = ElfSymbolTable::new();
        t.add_global_symbol("alpha", 0, 0, STT_NOTYPE, SHN_UNDEF);
        t.add_global_symbol("beta", 0, 0, STT_NOTYPE, SHN_UNDEF);
        t.add_global_symbol("gamma", 0, 0, STT_NOTYPE, SHN_UNDEF);

        assert_eq!(t.get_symbol_index("alpha"), Some(1));
        assert_eq!(t.get_symbol_index("beta"), Some(2));
        assert_eq!(t.get_symbol_index("gamma"), Some(3));
        assert_eq!(t.get_symbol_index("delta"), None);
        assert_eq!(t.get_symbol_index(""), Some(0)); // null entry
    }

    #[test]
    fn test_get_symbol_mut() {
        let mut t = ElfSymbolTable::new();
        t.add_global_symbol("mut_test", 0, 0, STT_NOTYPE, SHN_UNDEF);
        {
            let sym = t.get_symbol_mut(1).unwrap();
            sym.value = 0xDEADBEEF;
        }
        assert_eq!(t.get_symbol(1).unwrap().value, 0xDEADBEEF);
    }

    // ------------------------------------------------------------------
    // is_empty / len
    // ------------------------------------------------------------------

    #[test]
    fn test_is_empty() {
        let t = ElfSymbolTable::new();
        assert!(t.is_empty()); // only null entry
        let mut t2 = ElfSymbolTable::new();
        t2.add_global_symbol("x", 0, 0, STT_NOTYPE, SHN_UNDEF);
        assert!(!t2.is_empty());
    }

    // ------------------------------------------------------------------
    // num_locals / first_global
    // ------------------------------------------------------------------

    #[test]
    fn test_num_locals_only_null() {
        let t = ElfSymbolTable::new();
        assert_eq!(t.num_locals(), 1);
        assert_eq!(t.first_global(), 1);
    }

    #[test]
    fn test_num_locals_mixed() {
        let mut t = ElfSymbolTable::new();
        // Index 0: null (local)
        t.add_file_symbol("src.c"); // index 1: STT_FILE (local)
        t.add_section_symbol(1); // index 2: STT_SECTION (local)
        t.add_local_symbol("helper", 0, 0, STT_FUNC, 1); // index 3: local
        t.add_global_symbol("main", 0, 0, STT_FUNC, 1); // index 4: global
        t.add_global_symbol("other", 0, 0, STT_FUNC, 1); // index 5: global
        t.add_weak_symbol("weak_sym", 0, 0, STT_FUNC, 1); // index 6: weak

        assert_eq!(t.num_locals(), 4); // indices 0-3
        assert_eq!(t.first_global(), 4);
    }

    #[test]
    fn test_num_locals_all_local() {
        let mut t = ElfSymbolTable::new();
        t.add_file_symbol("a.c");
        t.add_section_symbol(1);
        t.add_local_symbol("f", 0, 0, STT_FUNC, 1);
        assert_eq!(t.num_locals(), 4);
    }

    #[test]
    fn test_num_locals_all_global() {
        let mut t = ElfSymbolTable::new();
        // only null (local)
        t.add_global_symbol("g", 0, 0, STT_FUNC, 1);
        t.add_global_symbol("h", 0, 0, STT_FUNC, 1);
        assert_eq!(t.num_locals(), 1); // only the null entry
    }

    // ------------------------------------------------------------------
    // Symbol iterators
    // ------------------------------------------------------------------

    #[test]
    fn test_iter_all() {
        let mut t = ElfSymbolTable::new();
        t.add_file_symbol("x.c");
        t.add_global_symbol("g", 0, 0, STT_FUNC, 1);

        let all: Vec<&str> = t.iter().map(|s| s.name.as_str()).collect();
        assert_eq!(all, vec!["", "x.c", "g"]);
    }

    #[test]
    fn test_globals_iterator() {
        let mut t = ElfSymbolTable::new();
        t.add_file_symbol("f.c");
        t.add_global_symbol("g1", 0, 0, STT_FUNC, 1);
        t.add_weak_symbol("w1", 0, 0, STT_FUNC, 1);
        t.add_local_symbol("l1", 0, 0, STT_FUNC, 1);
        t.add_global_symbol("g2", 0, 0, STT_FUNC, 1);

        let globals: Vec<&str> = t.globals().map(|s| s.name.as_str()).collect();
        assert_eq!(globals, vec!["g1", "w1", "g2"]);
    }

    #[test]
    fn test_locals_iterator() {
        let mut t = ElfSymbolTable::new();
        t.add_file_symbol("a.c");
        t.add_section_symbol(1);
        t.add_global_symbol("g", 0, 0, STT_FUNC, 1);

        let locals: Vec<&str> = t.locals().map(|s| s.name.as_str()).collect();
        // null (""), a.c, section symbol ("")
        assert_eq!(locals.len(), 3);
        assert_eq!(locals[0], "");
        assert_eq!(locals[1], "a.c");
        assert_eq!(locals[2], "");
    }

    // ------------------------------------------------------------------
    // String table construction
    // ------------------------------------------------------------------

    #[test]
    fn test_build_strtab_empty() {
        let t = ElfSymbolTable::new();
        let strtab = t.build_strtab();
        // Only the initial NUL byte
        assert_eq!(strtab, vec![0u8]);
    }

    #[test]
    fn test_build_strtab_single() {
        let mut t = ElfSymbolTable::new();
        t.add_global_symbol("main", 0, 0, STT_FUNC, 1);

        let strtab = t.build_strtab();
        // NUL + "main\0"
        let expected: Vec<u8> = {
            let mut v = vec![0u8];
            v.extend_from_slice(b"main");
            v.push(0u8);
            v
        };
        assert_eq!(strtab, expected);
    }

    #[test]
    fn test_build_strtab_multiple() {
        let mut t = ElfSymbolTable::new();
        t.add_global_symbol("main", 0, 0, STT_FUNC, 1);
        t.add_global_symbol("printf", 0, 0, STT_FUNC, SHN_UNDEF);
        t.add_local_symbol("helper", 0, 0, STT_FUNC, 1);

        let strtab = t.build_strtab();
        assert_eq!(strtab[0], 0u8);
        // Check that all names appear somewhere in the string table
        let s = String::from_utf8_lossy(&strtab);
        assert!(s.contains("main"));
        assert!(s.contains("printf"));
        assert!(s.contains("helper"));
        // Each should be NUL-terminated
        assert!(strtab.windows(5).any(|w| w == b"main\0"));
        assert!(strtab.windows(7).any(|w| w == b"printf\0"));
        assert!(strtab.windows(7).any(|w| w == b"helper\0"));
    }

    #[test]
    fn test_build_strtab_deduplicates() {
        let mut t = ElfSymbolTable::new();
        t.add_global_symbol("dup", 0x100, 0, STT_OBJECT, 1);
        t.add_global_symbol("dup", 0x200, 0, STT_OBJECT, 2); // same name
        t.add_global_symbol("uniq", 0x300, 0, STT_OBJECT, 3);

        let strtab = t.build_strtab();
        // "dup" should appear only once
        let dup_count = strtab.windows(4).filter(|w| *w == b"dup\0").count();
        assert_eq!(dup_count, 1);
    }

    // ------------------------------------------------------------------
    // String-table offset map
    // ------------------------------------------------------------------

    #[test]
    fn test_build_stroff_map() {
        let mut t = ElfSymbolTable::new();
        t.add_global_symbol("alpha", 0, 0, STT_FUNC, 1);
        t.add_global_symbol("beta", 0, 0, STT_FUNC, 1);

        let map = t.build_stroff_map();
        assert_eq!(map.len(), 3); // null + alpha + beta
        assert_eq!(map[0], 0); // null entry -> 0

        let strtab = t.build_strtab();
        // Verify offsets point into the strtab correctly
        for (i, &off) in map.iter().enumerate() {
            if i == 0 {
                assert_eq!(off, 0);
                assert_eq!(strtab[off as usize], 0u8);
            } else {
                let sym = t.get_symbol(i as u32).unwrap();
                let name = sym.name.as_bytes();
                assert_eq!(&strtab[off as usize..off as usize + name.len()], name);
                assert_eq!(strtab[off as usize + name.len()], 0u8); // NUL
            }
        }
    }

    // ------------------------------------------------------------------
    // Serialization: 64-bit
    // ------------------------------------------------------------------

    #[test]
    fn test_build_symtab_entries_64_empty() {
        let t = ElfSymbolTable::new();
        let bytes = t.build_symtab_entries(true);
        // Just the null entry: 24 bytes
        assert_eq!(bytes.len(), 24);
        // All zeros for the null entry
        assert!(bytes.iter().all(|&b| b == 0));
    }

    #[test]
    fn test_build_symtab_entries_64_single() {
        let mut t = ElfSymbolTable::new();
        t.add_global_symbol("main", 0x1000, 0x50, STT_FUNC, 3);

        let bytes = t.build_symtab_entries(true);
        assert_eq!(bytes.len(), 48); // 2 entries × 24 bytes

        // Check null entry (first 24 bytes = all zeros)
        assert_eq!(&bytes[0..24], &[0u8; 24]);

        // Check main entry (bytes 24..48)
        let entry = &bytes[24..48];

        // st_name: offset of "main" in strtab (should be 1, after initial NUL)
        let st_name = u32::from_le_bytes([entry[0], entry[1], entry[2], entry[3]]);
        assert_eq!(st_name, 1);

        // st_info: STB_GLOBAL | STT_FUNC = 0x12
        assert_eq!(entry[4], 0x12);

        // st_other: STV_DEFAULT = 0
        assert_eq!(entry[5], 0);

        // st_shndx: 3
        assert_eq!(u16::from_le_bytes([entry[6], entry[7]]), 3);

        // st_value: 0x1000
        assert_eq!(
            u64::from_le_bytes([
                entry[8], entry[9], entry[10], entry[11], entry[12], entry[13], entry[14],
                entry[15]
            ]),
            0x1000
        );

        // st_size: 0x50
        assert_eq!(
            u64::from_le_bytes([
                entry[16], entry[17], entry[18], entry[19], entry[20], entry[21], entry[22],
                entry[23]
            ]),
            0x50
        );
    }

    #[test]
    fn test_build_symtab_entries_64_with_versioned_symbol() {
        let mut t = ElfSymbolTable::new();
        let mut sym = ElfSymbolEntry::global("malloc", 0, 0, STT_FUNC, SHN_UNDEF);
        sym.version = Some(ElfSymbolVersion::default_version("GLIBC_2.2.5"));
        t.add_symbol(sym);

        let bytes = t.build_symtab_entries(true);
        // Version does not affect the raw Elf64Sym bytes
        assert_eq!(bytes.len(), 48);
    }

    // ------------------------------------------------------------------
    // Serialization: 32-bit
    // ------------------------------------------------------------------

    #[test]
    fn test_build_symtab_entries_32_empty() {
        let t = ElfSymbolTable::new();
        let bytes = t.build_symtab_entries(false);
        assert_eq!(bytes.len(), 16);
        assert!(bytes.iter().all(|&b| b == 0));
    }

    #[test]
    fn test_build_symtab_entries_32_single() {
        let mut t = ElfSymbolTable::new();
        t.add_global_symbol("fn32", 0xDEAD, 0x20, STT_FUNC, 4);

        let bytes = t.build_symtab_entries(false);
        assert_eq!(bytes.len(), 32); // 2 entries × 16 bytes

        // Check null entry (first 16 bytes = all zeros)
        assert_eq!(&bytes[0..16], &[0u8; 16]);

        // Check fn32 entry
        let entry = &bytes[16..32];

        // st_name: offset of "fn32" in strtab (should be 1)
        let st_name = u32::from_le_bytes([entry[0], entry[1], entry[2], entry[3]]);
        assert_eq!(st_name, 1);

        // st_value: 0xDEAD
        assert_eq!(
            u32::from_le_bytes([entry[4], entry[5], entry[6], entry[7]]),
            0xDEAD
        );

        // st_size: 0x20
        assert_eq!(
            u32::from_le_bytes([entry[8], entry[9], entry[10], entry[11]]),
            0x20
        );

        // st_info: STB_GLOBAL | STT_FUNC = 0x12
        assert_eq!(entry[12], 0x12);

        // st_other: 0
        assert_eq!(entry[13], 0);

        // st_shndx: 4
        assert_eq!(u16::from_le_bytes([entry[14], entry[15]]), 4);
    }

    // ------------------------------------------------------------------
    // entry_size / total_size
    // ------------------------------------------------------------------

    #[test]
    fn test_entry_size() {
        assert_eq!(ElfSymbolTable::entry_size(true), 24);
        assert_eq!(ElfSymbolTable::entry_size(false), 16);
    }

    #[test]
    fn test_total_size() {
        let mut t = ElfSymbolTable::new();
        t.add_global_symbol("a", 0, 0, STT_NOTYPE, SHN_UNDEF);
        t.add_global_symbol("b", 0, 0, STT_NOTYPE, SHN_UNDEF);
        // 3 symbols total (null + a + b)
        assert_eq!(t.total_size(true), 3 * 24);
        assert_eq!(t.total_size(false), 3 * 16);
    }

    // ------------------------------------------------------------------
    // ElfSymbolEntry helpers
    // ------------------------------------------------------------------

    #[test]
    fn test_entry_info_other_byte() {
        let entry = ElfSymbolEntry::global("g", 0, 0, STT_FUNC, 1);
        assert_eq!(entry.info_byte(), 0x12); // GLOBAL | FUNC
        assert_eq!(entry.other_byte(), 0x00); // DEFAULT visibility
    }

    #[test]
    fn test_entry_with_visibility() {
        let e =
            ElfSymbolEntry::global("g", 0, 0, STT_FUNC, 1).with_visibility(elf_types::STV_HIDDEN);
        assert_eq!(e.visibility, elf_types::STV_HIDDEN);
        assert_eq!(e.other_byte(), 0x02);
    }

    #[test]
    fn test_entry_with_version() {
        let e = ElfSymbolEntry::global("g", 0, 0, STT_FUNC, SHN_UNDEF)
            .with_version(ElfSymbolVersion::hidden_version("VER_1"));
        assert!(e.version.is_some());
        let v = e.version.as_ref().unwrap();
        assert_eq!(v.name, "VER_1");
        assert!(v.is_hidden);
    }

    #[test]
    fn test_entry_is_undefined() {
        let undef = ElfSymbolEntry::global("ext", 0, 0, STT_NOTYPE, SHN_UNDEF);
        assert!(undef.is_undefined());

        let defined = ElfSymbolEntry::global("local", 0x1000, 4, STT_OBJECT, 3);
        assert!(!defined.is_undefined());
    }

    // ------------------------------------------------------------------
    // ElfSymbolVersion
    // ------------------------------------------------------------------

    #[test]
    fn test_version_default() {
        let v = ElfSymbolVersion::default_version("GLIBC_2.2.5");
        assert_eq!(v.name, "GLIBC_2.2.5");
        assert!(!v.is_hidden); // default → not hidden → @@
    }

    #[test]
    fn test_version_hidden() {
        let v = ElfSymbolVersion::hidden_version("VER_2");
        assert_eq!(v.name, "VER_2");
        assert!(v.is_hidden); // hidden → single @
    }

    // ------------------------------------------------------------------
    // add_versioned_symbol convenience
    // ------------------------------------------------------------------

    #[test]
    fn test_add_versioned_symbol() {
        let mut t = ElfSymbolTable::new();
        let entry = ElfSymbolEntry::global("foo", 0, 0, STT_FUNC, SHN_UNDEF);
        let idx = t.add_versioned_symbol(entry, "GLIBC_2.17", true); // default version
        let sym = t.get_symbol(idx).unwrap();
        assert!(sym.version.is_some());
        // is_default=true → is_hidden=false
        assert!(!sym.version.as_ref().unwrap().is_hidden);
    }

    // ------------------------------------------------------------------
    // Default impl
    // ------------------------------------------------------------------

    #[test]
    fn test_default_creates_valid_table() {
        let t: ElfSymbolTable = Default::default();
        assert_eq!(t.len(), 1);
        assert!(!t.is_dynamic);
    }

    // ------------------------------------------------------------------
    // Large table stress test
    // ------------------------------------------------------------------

    #[test]
    fn test_large_table() {
        let mut t = ElfSymbolTable::new();
        t.add_file_symbol("large.c");

        for i in 0..500 {
            t.add_local_symbol(
                format!("local_{i}"),
                (i * 16) as u64,
                8,
                STT_OBJECT,
                (i % 10) as u16 + 1,
            );
        }

        for i in 0..200 {
            t.add_global_symbol(
                format!("global_{i}"),
                (i * 32) as u64,
                16,
                STT_FUNC,
                (i % 10) as u16 + 1,
            );
        }

        // Total symbols = 1 null + 1 file + 500 local + 200 global = 702
        assert_eq!(t.len(), 702);

        // Locals = null + file + 500 = 502
        assert_eq!(t.num_locals(), 502);
        assert_eq!(t.first_global(), 502);

        // Verify serialization sizes
        let bytes64 = t.build_symtab_entries(true);
        assert_eq!(bytes64.len(), 702 * 24);

        let bytes32 = t.build_symtab_entries(false);
        assert_eq!(bytes32.len(), 702 * 16);

        // String table should be non-empty
        let strtab = t.build_strtab();
        assert!(strtab.len() > 1);
        assert_eq!(strtab[0], 0u8);
    }
}