llvm-native-core 0.1.10

//! ELF file writer/emitter — produces valid ELF32 and ELF64 object files,
//! executables, and shared libraries.
//!
//! Clean-room reimplementation from the ELF specification
//! (System V gABI, AMD64 supplement, ELF-64 Object File Format).

use crate::elf::elf_symbols::ElfSymbolTable;
use crate::elf::elf_types::{
    elf_r_info, elf_r_info32, ElfClass, ElfEndian, ElfMachine, ElfOsAbi, EI_CLASS, EI_DATA,
    EI_MAG0, EI_MAG1, EI_MAG2, EI_MAG3, EI_NIDENT, EI_OSABI, EI_VERSION, ELF_MAGIC, EM_386,
    EM_AARCH64, EM_ARM, EM_PPC64, EM_RISCV, EM_X86_64, ET_DYN, ET_EXEC, ET_REL, EV_CURRENT, PF_R,
    PF_W, PF_X, PT_LOAD, PT_NOTE, PT_NULL, PT_PHDR, SECTION_NAME_SHSTRTAB, SHF_ALLOC,
    SHF_EXECINSTR, SHF_WRITE, SHT_NOBITS, SHT_NOTE, SHT_NULL, SHT_PROGBITS, SHT_REL, SHT_RELA,
    SHT_STRTAB, SHT_SYMTAB,
};

use std::collections::HashMap;

// ============================================================================
// ElfRelocation
// ============================================================================

/// A relocation entry to be applied to a section.
#[derive(Debug, Clone, PartialEq)]
pub struct ElfRelocation {
    /// Where to apply the relocation (section offset or virtual address).
    pub offset: u64,
    /// Symbol table index.
    pub symbol_index: u32,
    /// Relocation type (e.g., `R_X86_64_*`).
    pub rel_type: u32,
    /// Addend for RELA-type relocations.
    pub addend: i64,
    /// `true` = RELA (with explicit addend), `false` = REL (implicit addend at site).
    pub is_rela: bool,
}

impl ElfRelocation {
    /// Create a RELA relocation entry.
    pub fn rela(offset: u64, symbol_index: u32, rel_type: u32, addend: i64) -> Self {
        ElfRelocation {
            offset,
            symbol_index,
            rel_type,
            addend,
            is_rela: true,
        }
    }

    /// Create a REL relocation entry (no explicit addend).
    pub fn rel(offset: u64, symbol_index: u32, rel_type: u32) -> Self {
        ElfRelocation {
            offset,
            symbol_index,
            rel_type,
            addend: 0,
            is_rela: false,
        }
    }
}

// ============================================================================
// ElfPhdrInfo
// ============================================================================

/// Information for a program header (segment descriptor).
#[derive(Debug, Clone, PartialEq)]
pub struct ElfPhdrInfo {
    /// Segment type (`PT_LOAD`, `PT_DYNAMIC`, `PT_NOTE`, etc.).
    pub segment_type: u32,
    /// Segment flags (`PF_X`, `PF_W`, `PF_R`).
    pub flags: u32,
    /// File offset of the segment data.
    pub offset: u64,
    /// Virtual address of the segment in memory.
    pub vaddr: u64,
    /// Physical address of the segment.
    pub paddr: u64,
    /// Size of the segment in the file image.
    pub filesz: u64,
    /// Size of the segment in memory.
    pub memsz: u64,
    /// Required alignment of the segment.
    pub align: u64,
}

impl ElfPhdrInfo {
    /// Create a new program header entry.
    pub fn new(
        segment_type: u32,
        flags: u32,
        offset: u64,
        vaddr: u64,
        filesz: u64,
        memsz: u64,
        align: u64,
    ) -> Self {
        ElfPhdrInfo {
            segment_type,
            flags,
            offset,
            vaddr,
            paddr: vaddr,
            filesz,
            memsz,
            align,
        }
    }

    /// Create a `PT_LOAD` segment.
    pub fn load(flags: u32, offset: u64, vaddr: u64, filesz: u64, memsz: u64, align: u64) -> Self {
        Self::new(PT_LOAD, flags, offset, vaddr, filesz, memsz, align)
    }
}

// ============================================================================
// ElfNote
// ============================================================================

/// An ELF note entry.
#[derive(Debug, Clone, PartialEq)]
pub struct ElfNote {
    /// Note owner name (e.g., "GNU").
    pub name: String,
    /// Note type.
    pub note_type: u32,
    /// Note descriptor data.
    pub desc: Vec<u8>,
}

impl ElfNote {
    /// Create a new note.
    pub fn new(name: impl Into<String>, note_type: u32, desc: Vec<u8>) -> Self {
        ElfNote {
            name: name.into(),
            note_type,
            desc,
        }
    }
}

// ============================================================================
// ElfSection
// ============================================================================

/// A section in the ELF file.
#[derive(Debug, Clone)]
pub struct ElfSection {
    /// Section name.
    pub name: String,
    /// Section type (`SHT_PROGBITS`, `SHT_SYMTAB`, etc.).
    pub section_type: u32,
    /// Section flags (`SHF_WRITE`, `SHF_ALLOC`, `SHF_EXECINSTR`, etc.).
    pub flags: u64,
    /// Virtual address of the section in memory.
    pub addr: u64,
    /// Section content data.
    pub data: Vec<u8>,
    /// Link to another section (interpretation depends on section type).
    pub link: u32,
    /// Additional section information.
    pub info: u32,
    /// Required alignment of the section (0 or 1 = no alignment).
    pub addralign: u64,
    /// Size of each entry if the section holds a table of fixed-size entries.
    pub entsize: u64,
}

impl ElfSection {
    /// Create a new section.
    pub fn new(
        name: impl Into<String>,
        data: Vec<u8>,
        section_type: u32,
        flags: u64,
        addralign: u64,
    ) -> Self {
        ElfSection {
            name: name.into(),
            section_type,
            flags,
            addr: 0,
            data,
            link: 0,
            info: 0,
            addralign,
            entsize: 0,
        }
    }
}

// ============================================================================
// ElfWriter
// ============================================================================

/// ELF file writer/emitter.
///
/// Produces valid ELF32 and ELF64 object files (`.o`), executables, and
/// shared libraries.
///
/// # Example
///
/// ```ignore
/// let mut writer = ElfWriter::new_elf64_rel(ElfMachine::X86_64);
/// let text_idx = writer.add_section(".text", code_bytes, SHT_PROGBITS,
///                                    SHF_ALLOC | SHF_EXECINSTR, 16);
/// let data = writer.write();
/// ```
pub struct ElfWriter {
    /// ELF class: 32-bit or 64-bit.
    pub class: ElfClass,
    /// Endianness.
    pub endian: ElfEndian,
    /// OS/ABI identification.
    pub os_abi: ElfOsAbi,
    /// Target machine architecture.
    pub machine: ElfMachine,
    /// File type (`ET_REL`, `ET_EXEC`, `ET_DYN`).
    pub file_type: u16,
    /// Entry point address.
    pub entry: u64,
    /// Processor-specific flags.
    pub flags: u32,

    // Internal state
    sections: Vec<ElfSection>,
    shstrtab: Vec<u8>,
    shstrtab_name_offsets: HashMap<String, u32>,
    symtab: Option<ElfSymbolTable>,
    program_headers: Vec<ElfPhdrInfo>,
    notes: Vec<ElfNote>,
    /// Relocations: each entry is (section_index, vec of relocations).
    relocations: Vec<(u32, Vec<ElfRelocation>)>,

    // Track reserved section indices
    symtab_section_index: Option<u32>,
    strtab_section_index: Option<u32>,
    shstrtab_section_index: Option<u32>,
    null_section_added: bool,
}

impl ElfWriter {
    // ------------------------------------------------------------------
    // Constructor
    // ------------------------------------------------------------------

    /// Create a new `ElfWriter` with the given ELF parameters.
    pub fn new(
        class: ElfClass,
        endian: ElfEndian,
        os_abi: ElfOsAbi,
        machine: ElfMachine,
        file_type: u16,
    ) -> Self {
        ElfWriter {
            class,
            endian,
            os_abi,
            machine,
            file_type,
            entry: 0,
            flags: 0,
            sections: Vec::new(),
            shstrtab: Vec::new(),
            shstrtab_name_offsets: HashMap::new(),
            symtab: None,
            program_headers: Vec::new(),
            notes: Vec::new(),
            relocations: Vec::new(),
            symtab_section_index: None,
            strtab_section_index: None,
            shstrtab_section_index: None,
            null_section_added: false,
        }
    }

    // ------------------------------------------------------------------
    // Convenience constructors
    // ------------------------------------------------------------------

    /// Create for 64-bit ELF relocatable object.
    pub fn new_elf64_rel(machine: ElfMachine) -> Self {
        Self::new(
            ElfClass::Elf64,
            ElfEndian::Little,
            ElfOsAbi::SystemV,
            machine,
            ET_REL,
        )
    }

    /// Create for 32-bit ELF relocatable object.
    pub fn new_elf32_rel(machine: ElfMachine) -> Self {
        Self::new(
            ElfClass::Elf32,
            ElfEndian::Little,
            ElfOsAbi::SystemV,
            machine,
            ET_REL,
        )
    }

    /// Create for 64-bit ELF executable.
    pub fn new_elf64_exec(machine: ElfMachine, entry: u64) -> Self {
        let mut w = Self::new(
            ElfClass::Elf64,
            ElfEndian::Little,
            ElfOsAbi::SystemV,
            machine,
            ET_EXEC,
        );
        w.entry = entry;
        w
    }

    /// Create for 64-bit ELF shared object.
    pub fn new_elf64_shared(machine: ElfMachine) -> Self {
        Self::new(
            ElfClass::Elf64,
            ElfEndian::Little,
            ElfOsAbi::SystemV,
            machine,
            ET_DYN,
        )
    }

    // ------------------------------------------------------------------
    // Configuration
    // ------------------------------------------------------------------

    /// Set the entry point address.
    pub fn set_entry(&mut self, addr: u64) {
        self.entry = addr;
    }

    // ------------------------------------------------------------------
    // Section management
    // ------------------------------------------------------------------

    /// Ensure section 0 is a `SHT_NULL` section.
    ///
    /// If section 0 has already been added (or any section exists at index 0),
    /// this is a no-op. Otherwise, a null section is inserted at index 0.
    pub fn add_null_section(&mut self) {
        if self.null_section_added {
            return;
        }
        if !self.sections.is_empty() {
            // If sections already exist but first is not null, don't override.
            // We just mark null as added.
            self.null_section_added = true;
            return;
        }
        let null_sec = ElfSection::new("", Vec::new(), SHT_NULL, 0, 0);
        self.sections.push(null_sec);
        self.null_section_added = true;
    }

    /// Add a section and return its index (0-based).
    ///
    /// Section 0 is automatically added as `SHT_NULL` if not already present.
    pub fn add_section(
        &mut self,
        name: impl Into<String>,
        data: Vec<u8>,
        section_type: u32,
        flags: u64,
        addralign: u64,
    ) -> u32 {
        self.add_null_section();

        let name = name.into();
        let sec = ElfSection::new(&name, data, section_type, flags, addralign);
        let idx = self.sections.len() as u32;
        self.sections.push(sec);
        idx
    }

    /// Add the symbol table. This also adds the `.symtab` and `.strtab` sections.
    ///
    /// Returns the symbol table section index.
    pub fn add_symbol_table(&mut self, symtab: ElfSymbolTable) -> u32 {
        // Build the string table from symbol names
        let strtab_data = symtab.build_strtab();

        // Add .strtab section first
        let strtab_idx = self.add_section(".strtab", strtab_data, SHT_STRTAB, 0, 1);

        // Build symbol table entries
        let is_64bit = self.class.is_64bit();
        let symtab_data = symtab.build_symtab_entries(is_64bit);
        let entsize = if is_64bit { 24u64 } else { 16u64 };

        // Add .symtab section
        let mut symtab_idx = self.add_section(".symtab", symtab_data, SHT_SYMTAB, 0, 1);

        // Set sh_link (.symtab -> .strtab) and sh_entsize
        {
            let sec = &mut self.sections[symtab_idx as usize];
            sec.link = strtab_idx;
            sec.entsize = entsize;
            // sh_info = index of first non-local symbol
            sec.info = symtab.first_global() as u32;
        }

        self.symtab = Some(symtab);
        self.symtab_section_index = Some(symtab_idx);
        self.strtab_section_index = Some(strtab_idx);

        symtab_idx
    }

    /// Add a program header (segment).
    pub fn add_program_header(&mut self, phdr: ElfPhdrInfo) {
        self.program_headers.push(phdr);
    }

    /// Add a note.
    pub fn add_note(&mut self, note: ElfNote) {
        self.notes.push(note);
    }

    /// Add a relocation to a specific section.
    ///
    /// Relocations are collected and emitted into a corresponding
    /// `.relaNAME` or `.relNAME` section during `write()`.
    pub fn add_relocation(&mut self, section_index: u32, reloc: ElfRelocation) {
        // Find or create the relocation list for this section
        for (idx, relocs) in self.relocations.iter_mut() {
            if *idx == section_index {
                relocs.push(reloc);
                return;
            }
        }
        self.relocations.push((section_index, vec![reloc]));
    }

    // ------------------------------------------------------------------
    // String table helpers
    // ------------------------------------------------------------------

    /// Get or add a string to the internal string table buffer.
    fn add_strtab_string(&mut self, s: &str) -> u32 {
        if s.is_empty() {
            return 0;
        }
        if let Some(&off) = self.shstrtab_name_offsets.get(s) {
            return off;
        }
        let off = self.shstrtab.len() as u32;
        self.shstrtab_name_offsets.insert(s.to_string(), off);
        self.shstrtab.extend_from_slice(s.as_bytes());
        self.shstrtab.push(0u8);
        off
    }

    /// Build the section header string table (`.shstrtab`).
    ///
    /// This collects all section names, builds the string table, and
    /// ensures the shstrtab section includes its own name.
    pub fn build_shstrtab(&mut self) {
        // Ensure section 0 exists
        self.add_null_section();

        // Reset shstrtab
        self.shstrtab.clear();
        self.shstrtab_name_offsets.clear();
        self.shstrtab.push(0u8); // index 0 = NUL

        // Collect all section names (including .shstrtab itself)
        let mut names: Vec<String> = Vec::new();
        for sec in &self.sections {
            if !sec.name.is_empty() {
                names.push(sec.name.clone());
            }
        }

        // Also add names for relocation sections that will be created
        for (sec_idx, relocs) in &self.relocations {
            if relocs.is_empty() {
                continue;
            }
            let first_reloc = &relocs[0];
            let target_name = self
                .sections
                .get(*sec_idx as usize)
                .map(|s| s.name.as_str())
                .unwrap_or("");
            let prefix = if first_reloc.is_rela { ".rela" } else { ".rel" };
            let reloc_name = format!("{}{}", prefix, target_name);
            names.push(reloc_name);
        }

        // Also add names for note sections if any
        if !self.notes.is_empty() {
            names.push(".note".to_string());
        }

        // Ensure .shstrtab is in the list
        let shstrtab_name = SECTION_NAME_SHSTRTAB.to_string();
        if !names.contains(&shstrtab_name) {
            names.push(shstrtab_name);
        }

        // Build string table
        for name in &names {
            self.add_strtab_string(name);
        }
    }

    // ------------------------------------------------------------------
    // Compute offsets
    // ------------------------------------------------------------------

    /// Align an offset up to the given alignment.
    fn align_up(offset: u64, align: u64) -> u64 {
        if align <= 1 {
            return offset;
        }
        (offset + align - 1) & !(align - 1)
    }

    /// Compute the file offset where section data begins.
    fn data_start_offset(&self) -> u64 {
        let ehdr_size = self.ehdr_size();
        let phdr_size = self.phdr_total_size();
        ehdr_size + phdr_size
    }

    /// Size of the ELF header in bytes.
    fn ehdr_size(&self) -> u64 {
        if self.class.is_64bit() {
            64
        } else {
            52
        }
    }

    /// Total size of all program headers.
    fn phdr_total_size(&self) -> u64 {
        if self.program_headers.is_empty() {
            return 0;
        }
        let entry_size = if self.class.is_64bit() { 56u64 } else { 32u64 };
        self.program_headers.len() as u64 * entry_size
    }

    /// Size of one section header.
    fn shdr_entry_size(&self) -> u64 {
        if self.class.is_64bit() {
            64
        } else {
            40
        }
    }

    /// Get all sections including auto-generated relocation and note sections.
    fn all_sections(&self) -> Vec<(usize, &ElfSection)> {
        // We return indices into the internal sections vec, plus
        // synthetic sections for relocations and notes.
        // For offset computation, we need a flat list.
        // Strategy: return pairs of (original_index_or_special, section_ref)
        // But we need to know the data. Let's do this differently.
        // Just iterate and build temporary sections.

        // Actually, let's handle this in write() directly.
        Vec::new() // placeholder
    }

    // ------------------------------------------------------------------
    // Write methods
    // ------------------------------------------------------------------

    /// Write the ELF identification bytes (`e_ident`).
    fn write_e_ident(&self) -> Vec<u8> {
        let mut ident = vec![0u8; EI_NIDENT];
        ident[EI_MAG0] = ELF_MAGIC[0];
        ident[EI_MAG1] = ELF_MAGIC[1];
        ident[EI_MAG2] = ELF_MAGIC[2];
        ident[EI_MAG3] = ELF_MAGIC[3];
        ident[EI_CLASS] = self.class.to_u8();
        ident[EI_DATA] = self.endian.to_u8();
        ident[EI_VERSION] = EV_CURRENT as u8;
        ident[EI_OSABI] = self.os_abi.to_u8();
        // EI_ABIVERSION = 0 (already zero)
        // EI_PAD = 0 (already zero)
        ident
    }

    /// Helper: write u16 in the configured endianness.
    fn write_u16(&self, v: u16) -> [u8; 2] {
        match self.endian {
            ElfEndian::Little => v.to_le_bytes(),
            ElfEndian::Big => v.to_be_bytes(),
        }
    }

    /// Helper: write u32 in the configured endianness.
    fn write_u32(&self, v: u32) -> [u8; 4] {
        match self.endian {
            ElfEndian::Little => v.to_le_bytes(),
            ElfEndian::Big => v.to_be_bytes(),
        }
    }

    /// Helper: write u64 in the configured endianness.
    fn write_u64(&self, v: u64) -> [u8; 8] {
        match self.endian {
            ElfEndian::Little => v.to_le_bytes(),
            ElfEndian::Big => v.to_be_bytes(),
        }
    }

    /// Helper: write i32 in the configured endianness.
    fn write_i32(&self, v: i32) -> [u8; 4] {
        match self.endian {
            ElfEndian::Little => v.to_le_bytes(),
            ElfEndian::Big => v.to_be_bytes(),
        }
    }

    /// Helper: write i64 in the configured endianness.
    fn write_i64(&self, v: i64) -> [u8; 8] {
        match self.endian {
            ElfEndian::Little => v.to_le_bytes(),
            ElfEndian::Big => v.to_be_bytes(),
        }
    }

    /// Emit the complete ELF file as a byte vector.
    pub fn write(&mut self) -> Vec<u8> {
        // Build the section header string table
        self.build_shstrtab();

        // Ensure we have a .shstrtab section
        let shstrtab_idx = self.ensure_shstrtab_section();

        // Build relocation sections
        let mut reloc_sections: Vec<(u32, Vec<u8>, ElfSection)> = Vec::new();

        for (sec_idx, relocs) in &self.relocations {
            if relocs.is_empty() {
                continue;
            }
            let first_reloc = &relocs[0];
            let target_name = self
                .sections
                .get(*sec_idx as usize)
                .map(|s| s.name.as_str())
                .unwrap_or("");
            let prefix = if first_reloc.is_rela { ".rela" } else { ".rel" };
            let reloc_name = format!("{}{}", prefix, target_name);
            let section_type = if first_reloc.is_rela {
                SHT_RELA
            } else {
                SHT_REL
            };

            let is_64 = self.class.is_64bit();
            let entsize = if is_64 {
                if first_reloc.is_rela {
                    24u64
                } else {
                    16u64
                }
            } else {
                if first_reloc.is_rela {
                    12u64
                } else {
                    8u64
                }
            };

            // Generate relocation section data
            let reloc_data = self.write_relocations_raw(relocs);

            let mut reloc_sec = ElfSection::new(reloc_name, reloc_data, section_type, 0, 8);
            reloc_sec.entsize = entsize;
            reloc_sec.link = self.symtab_section_index.unwrap_or(0);
            reloc_sec.info = *sec_idx;

            reloc_sections.push((*sec_idx, Vec::new(), reloc_sec));
        }

        // Build note section if any notes exist
        let note_section: Option<ElfSection> = if !self.notes.is_empty() {
            let note_data = self.write_notes_raw();
            Some(ElfSection::new(".note", note_data, SHT_NOTE, 0, 4))
        } else {
            None
        };

        // Compute offsets
        // Layout:
        //   [ELF Header]
        //   [Program Headers]
        //   [Section Data 0]  (null, no data)
        //   [Section Data 1]
        //   ...
        //   [Relocation Sections]
        //   [Note Section]
        //   [.shstrtab]       (placed last for easy extension)
        //   [Section Headers]

        let ehdr_size = self.ehdr_size();
        let phdr_size = self.phdr_total_size();

        let mut current_offset = ehdr_size + phdr_size;
        let mut section_offsets: Vec<u64> = Vec::new();

        // Compute offsets for regular sections
        for (i, sec) in self.sections.iter().enumerate() {
            if sec.addralign > 1 {
                current_offset = Self::align_up(current_offset, sec.addralign);
            }
            section_offsets.push(current_offset);
            if sec.section_type != SHT_NOBITS && sec.section_type != SHT_NULL {
                current_offset += sec.data.len() as u64;
            }
            // SHT_NOBITS occupies no space in the file
        }

        // Compute offsets for relocation sections
        let mut reloc_section_offsets: Vec<u64> = Vec::new();
        for (_, _, reloc_sec) in &reloc_sections {
            if reloc_sec.addralign > 1 {
                current_offset = Self::align_up(current_offset, reloc_sec.addralign);
            }
            reloc_section_offsets.push(current_offset);
            current_offset += reloc_sec.data.len() as u64;
        }

        // Note section offset
        let note_offset = if note_section.is_some() {
            let off = current_offset;
            current_offset += note_section.as_ref().unwrap().data.len() as u64;
            off
        } else {
            0
        };

        // .shstrtab section offset
        if self.shstrtab_section_index.is_none() {
            // We need to add the shstrtab section
            // It will be a synthetic section at the end
        }
        // Update shstrtab data in the section
        if let Some(idx) = self.shstrtab_section_index {
            let sec = &mut self.sections[idx as usize];
            sec.data = self.shstrtab.clone();
        }

        // Recompute with shstrtab data included
        current_offset = ehdr_size + phdr_size;
        section_offsets.clear();

        for (i, sec) in self.sections.iter().enumerate() {
            if sec.addralign > 1 {
                current_offset = Self::align_up(current_offset, sec.addralign);
            }
            section_offsets.push(current_offset);
            if sec.section_type != SHT_NOBITS && sec.section_type != SHT_NULL && i != 0 {
                current_offset += sec.data.len() as u64;
            }
            // For index 0, SHT_NULL has no data
        }

        // Relocation section offsets (recompute)
        reloc_section_offsets.clear();
        for (_, _, reloc_sec) in &reloc_sections {
            if reloc_sec.addralign > 1 {
                current_offset = Self::align_up(current_offset, reloc_sec.addralign);
            }
            reloc_section_offsets.push(current_offset);
            current_offset += reloc_sec.data.len() as u64;
        }

        // Note section offset (recompute)
        let note_offset_final = if note_section.is_some() {
            let off = current_offset;
            current_offset += note_section.as_ref().unwrap().data.len() as u64;
            off
        } else {
            0
        };

        // Section header table offset (aligned to 8 for 64-bit, 4 for 32-bit)
        let shdr_align = if self.class.is_64bit() { 8u64 } else { 4u64 };
        current_offset = Self::align_up(current_offset, shdr_align);
        let shoff = current_offset;

        // Total sections: existing + relocation + note + shstrtab (if not already present)
        let total_sections =
            self.sections.len() + reloc_sections.len() + note_section.iter().count();

        // Start building the output
        let mut buf: Vec<u8> = Vec::new();

        // 1. ELF header
        buf.extend_from_slice(&self.write_elf_header_raw(
            phdr_size,
            shoff,
            shstrtab_idx,
            total_sections as u16,
        ));

        // 2. Program headers
        if !self.program_headers.is_empty() {
            buf.resize(ehdr_size as usize + phdr_size as usize, 0);
            let phdr_data = self.write_program_headers_raw();
            // Write into the reserved space
            let start = ehdr_size as usize;
            buf[start..start + phdr_data.len()].copy_from_slice(&phdr_data);
        }

        // 3. Section data
        for (i, sec) in self.sections.iter().enumerate() {
            let off = section_offsets[i] as usize;
            if buf.len() < off {
                buf.resize(off, 0);
            }
            if sec.section_type != SHT_NOBITS && sec.section_type != SHT_NULL {
                if buf.len() < off + sec.data.len() {
                    buf.resize(off + sec.data.len(), 0);
                }
                buf[off..off + sec.data.len()].copy_from_slice(&sec.data);
            }
        }

        // 4. Relocation section data
        for (j, (_, _, reloc_sec)) in reloc_sections.iter().enumerate() {
            let off = reloc_section_offsets[j] as usize;
            if buf.len() < off {
                buf.resize(off, 0);
            }
            if buf.len() < off + reloc_sec.data.len() {
                buf.resize(off + reloc_sec.data.len(), 0);
            }
            buf[off..off + reloc_sec.data.len()].copy_from_slice(&reloc_sec.data);
        }

        // 5. Note section data
        if let Some(ref note_sec) = note_section {
            let off = note_offset_final as usize;
            if buf.len() < off {
                buf.resize(off, 0);
            }
            if buf.len() < off + note_sec.data.len() {
                buf.resize(off + note_sec.data.len(), 0);
            }
            buf[off..off + note_sec.data.len()].copy_from_slice(&note_sec.data);
        }

        // 6. Section headers
        // Make sure shoff is correct
        let shoff_actual = buf.len() as u64;
        if shoff_actual < shoff {
            buf.resize(shoff as usize, 0);
        }

        let shdr_start = buf.len();
        let shdr_data = self.write_section_headers_raw(
            &section_offsets,
            &reloc_sections,
            &reloc_section_offsets,
            &note_section,
            note_offset_final,
            shstrtab_idx,
        );
        buf.extend_from_slice(&shdr_data);

        // Patch the ELF header with correct shoff and shnum if needed
        let shoff_field_offset = if self.class.is_64bit() { 0x28 } else { 0x20 };
        let shnum_field_offset = if self.class.is_64bit() { 0x3C } else { 0x30 };

        let shoff_bytes = if self.class.is_64bit() {
            self.write_u64(shdr_start as u64).to_vec()
        } else {
            self.write_u32(shdr_start as u32).to_vec()
        };
        let shnum_bytes = self.write_u16(total_sections as u16).to_vec();

        // Patch shoff
        let soff = shoff_field_offset as usize;
        buf[soff..soff + shoff_bytes.len()].copy_from_slice(&shoff_bytes);

        // Patch shnum
        let snum = shnum_field_offset as usize;
        buf[snum..snum + 2].copy_from_slice(&shnum_bytes);

        buf
    }

    /// Ensure the .shstrtab section exists and return its index.
    fn ensure_shstrtab_section(&mut self) -> u32 {
        if let Some(idx) = self.shstrtab_section_index {
            return idx;
        }

        // Check if a section named ".shstrtab" already exists
        for (i, sec) in self.sections.iter().enumerate() {
            if sec.name == SECTION_NAME_SHSTRTAB {
                let idx = i as u32;
                self.shstrtab_section_index = Some(idx);
                // Update its data
                self.sections[i].data = self.shstrtab.clone();
                return idx;
            }
        }

        // Add the shstrtab section
        let data = self.shstrtab.clone();
        let idx = self.add_section(SECTION_NAME_SHSTRTAB, data, SHT_STRTAB, 0, 1);
        self.shstrtab_section_index = Some(idx);
        idx
    }

    /// Write raw relocation data for a list of relocations.
    fn write_relocations_raw(&self, relocs: &[ElfRelocation]) -> Vec<u8> {
        let mut buf = Vec::new();
        let is_64 = self.class.is_64bit();

        for reloc in relocs {
            if is_64 {
                if reloc.is_rela {
                    // Elf64Rela: 24 bytes
                    buf.extend_from_slice(&self.write_u64(reloc.offset));
                    buf.extend_from_slice(
                        &self.write_u64(elf_r_info(
                            reloc.symbol_index as u64,
                            reloc.rel_type as u64,
                        )),
                    );
                    buf.extend_from_slice(&self.write_i64(reloc.addend));
                } else {
                    // Elf64Rel: 16 bytes
                    buf.extend_from_slice(&self.write_u64(reloc.offset));
                    buf.extend_from_slice(
                        &self.write_u64(elf_r_info(
                            reloc.symbol_index as u64,
                            reloc.rel_type as u64,
                        )),
                    );
                }
            } else {
                if reloc.is_rela {
                    // Elf32Rela: 12 bytes
                    buf.extend_from_slice(&self.write_u32(reloc.offset as u32));
                    buf.extend_from_slice(
                        &self.write_u32(elf_r_info32(reloc.symbol_index, reloc.rel_type)),
                    );
                    buf.extend_from_slice(&self.write_i32(reloc.addend as i32));
                } else {
                    // Elf32Rel: 8 bytes
                    buf.extend_from_slice(&self.write_u32(reloc.offset as u32));
                    buf.extend_from_slice(
                        &self.write_u32(elf_r_info32(reloc.symbol_index, reloc.rel_type)),
                    );
                }
            }
        }

        buf
    }

    /// Write raw note data.
    fn write_notes_raw(&self) -> Vec<u8> {
        let mut buf = Vec::new();

        for note in &self.notes {
            let name_bytes = note.name.as_bytes();
            let name_len = name_bytes.len() as u32;
            let desc_len = note.desc.len() as u32;

            // ElfNhdr
            buf.extend_from_slice(&self.write_u32(name_len));
            buf.extend_from_slice(&self.write_u32(desc_len));
            buf.extend_from_slice(&self.write_u32(note.note_type));

            // Name (padded to 4-byte alignment)
            buf.extend_from_slice(name_bytes);
            let name_padding = (4 - (name_len as usize % 4)) % 4;
            for _ in 0..name_padding {
                buf.push(0u8);
            }

            // Descriptor (padded to 4-byte alignment)
            buf.extend_from_slice(&note.desc);
            let desc_padding = (4 - (desc_len as usize % 4)) % 4;
            for _ in 0..desc_padding {
                buf.push(0u8);
            }
        }

        buf
    }

    /// Write raw ELF header.
    fn write_elf_header_raw(
        &self,
        phdr_size: u64,
        shoff: u64,
        shstrndx: u32,
        shnum: u16,
    ) -> Vec<u8> {
        let mut buf = Vec::new();
        let e_ident = self.write_e_ident();

        if self.class.is_64bit() {
            // Elf64Ehdr: 64 bytes
            buf.extend_from_slice(&e_ident);
            buf.extend_from_slice(&self.write_u16(self.file_type));
            buf.extend_from_slice(&self.write_u16(self.machine.to_u16()));
            buf.extend_from_slice(&self.write_u32(EV_CURRENT));
            buf.extend_from_slice(&self.write_u64(self.entry));
            buf.extend_from_slice(&self.write_u64(if phdr_size > 0 {
                self.ehdr_size()
            } else {
                0
            }));
            buf.extend_from_slice(&self.write_u64(shoff));
            buf.extend_from_slice(&self.write_u32(self.flags));
            buf.extend_from_slice(&self.write_u16(64)); // e_ehsize
            buf.extend_from_slice(&self.write_u16(if phdr_size > 0 { 56 } else { 0 })); // e_phentsize
            buf.extend_from_slice(&self.write_u16(self.program_headers.len() as u16)); // e_phnum
            buf.extend_from_slice(&self.write_u16(64)); // e_shentsize
            buf.extend_from_slice(&self.write_u16(shnum)); // e_shnum
            buf.extend_from_slice(&self.write_u16(shstrndx as u16)); // e_shstrndx
        } else {
            // Elf32Ehdr: 52 bytes
            buf.extend_from_slice(&e_ident);
            buf.extend_from_slice(&self.write_u16(self.file_type));
            buf.extend_from_slice(&self.write_u16(self.machine.to_u16()));
            buf.extend_from_slice(&self.write_u32(EV_CURRENT));
            buf.extend_from_slice(&self.write_u32(self.entry as u32));
            buf.extend_from_slice(&self.write_u32(if phdr_size > 0 { 52 } else { 0 })); // e_phoff
            buf.extend_from_slice(&self.write_u32(shoff as u32)); // e_shoff
            buf.extend_from_slice(&self.write_u32(self.flags));
            buf.extend_from_slice(&self.write_u16(52)); // e_ehsize
            buf.extend_from_slice(&self.write_u16(if phdr_size > 0 { 32 } else { 0 })); // e_phentsize
            buf.extend_from_slice(&self.write_u16(self.program_headers.len() as u16)); // e_phnum
            buf.extend_from_slice(&self.write_u16(40)); // e_shentsize
            buf.extend_from_slice(&self.write_u16(shnum)); // e_shnum
            buf.extend_from_slice(&self.write_u16(shstrndx as u16)); // e_shstrndx
        }

        buf
    }

    /// Write raw program headers.
    fn write_program_headers_raw(&self) -> Vec<u8> {
        let mut buf = Vec::new();

        for phdr in &self.program_headers {
            if self.class.is_64bit() {
                buf.extend_from_slice(&self.write_u32(phdr.segment_type));
                buf.extend_from_slice(&self.write_u32(phdr.flags));
                buf.extend_from_slice(&self.write_u64(phdr.offset));
                buf.extend_from_slice(&self.write_u64(phdr.vaddr));
                buf.extend_from_slice(&self.write_u64(phdr.paddr));
                buf.extend_from_slice(&self.write_u64(phdr.filesz));
                buf.extend_from_slice(&self.write_u64(phdr.memsz));
                buf.extend_from_slice(&self.write_u64(phdr.align));
            } else {
                buf.extend_from_slice(&self.write_u32(phdr.segment_type));
                buf.extend_from_slice(&self.write_u32(phdr.offset as u32));
                buf.extend_from_slice(&self.write_u32(phdr.vaddr as u32));
                buf.extend_from_slice(&self.write_u32(phdr.paddr as u32));
                buf.extend_from_slice(&self.write_u32(phdr.filesz as u32));
                buf.extend_from_slice(&self.write_u32(phdr.memsz as u32));
                buf.extend_from_slice(&self.write_u32(phdr.flags));
                buf.extend_from_slice(&self.write_u32(phdr.align as u32));
            }
        }

        buf
    }

    /// Write raw section headers.
    fn write_section_headers_raw(
        &self,
        section_offsets: &[u64],
        reloc_sections: &[(u32, Vec<u8>, ElfSection)],
        reloc_offsets: &[u64],
        note_section: &Option<ElfSection>,
        note_offset: u64,
        shstrtab_idx: u32,
    ) -> Vec<u8> {
        let mut buf = Vec::new();

        // Compute string table offsets for section names
        let name_offsets: HashMap<String, u32> = self.shstrtab_name_offsets.clone();

        let get_name_offset = |name: &str| -> u32 {
            if name.is_empty() {
                return 0;
            }
            name_offsets.get(name).copied().unwrap_or(0)
        };

        let is_64 = self.class.is_64bit();

        // Write regular sections
        for (i, sec) in self.sections.iter().enumerate() {
            let name_off = get_name_offset(&sec.name);
            let offset = section_offsets.get(i).copied().unwrap_or(0);
            let size = if sec.section_type == SHT_NOBITS {
                sec.data.len() as u64
            } else if sec.section_type == SHT_NULL {
                0
            } else {
                sec.data.len() as u64
            };

            if is_64 {
                buf.extend_from_slice(&self.write_u32(name_off));
                buf.extend_from_slice(&self.write_u32(sec.section_type));
                buf.extend_from_slice(&self.write_u64(sec.flags));
                buf.extend_from_slice(&self.write_u64(sec.addr));
                buf.extend_from_slice(&self.write_u64(offset));
                buf.extend_from_slice(&self.write_u64(size));
                buf.extend_from_slice(&self.write_u32(sec.link));
                buf.extend_from_slice(&self.write_u32(sec.info));
                buf.extend_from_slice(&self.write_u64(sec.addralign));
                buf.extend_from_slice(&self.write_u64(sec.entsize));
            } else {
                buf.extend_from_slice(&self.write_u32(name_off));
                buf.extend_from_slice(&self.write_u32(sec.section_type));
                buf.extend_from_slice(&self.write_u32(sec.flags as u32));
                buf.extend_from_slice(&self.write_u32(sec.addr as u32));
                buf.extend_from_slice(&self.write_u32(offset as u32));
                buf.extend_from_slice(&self.write_u32(size as u32));
                buf.extend_from_slice(&self.write_u32(sec.link));
                buf.extend_from_slice(&self.write_u32(sec.info));
                buf.extend_from_slice(&self.write_u32(sec.addralign as u32));
                buf.extend_from_slice(&self.write_u32(sec.entsize as u32));
            }
        }

        // Write relocation section headers
        let reg_count = self.sections.len();
        for (j, (target_idx, _, reloc_sec)) in reloc_sections.iter().enumerate() {
            let name_off = get_name_offset(&reloc_sec.name);
            let offset = reloc_offsets.get(j).copied().unwrap_or(0);

            if is_64 {
                buf.extend_from_slice(&self.write_u32(name_off));
                buf.extend_from_slice(&self.write_u32(reloc_sec.section_type));
                buf.extend_from_slice(&self.write_u64(reloc_sec.flags));
                buf.extend_from_slice(&self.write_u64(reloc_sec.addr));
                buf.extend_from_slice(&self.write_u64(offset));
                buf.extend_from_slice(&self.write_u64(reloc_sec.data.len() as u64));
                buf.extend_from_slice(&self.write_u32(reloc_sec.link));
                buf.extend_from_slice(&self.write_u32(reloc_sec.info));
                buf.extend_from_slice(&self.write_u64(reloc_sec.addralign));
                buf.extend_from_slice(&self.write_u64(reloc_sec.entsize));
            } else {
                buf.extend_from_slice(&self.write_u32(name_off));
                buf.extend_from_slice(&self.write_u32(reloc_sec.section_type));
                buf.extend_from_slice(&self.write_u32(reloc_sec.flags as u32));
                buf.extend_from_slice(&self.write_u32(reloc_sec.addr as u32));
                buf.extend_from_slice(&self.write_u32(offset as u32));
                buf.extend_from_slice(&self.write_u32(reloc_sec.data.len() as u32));
                buf.extend_from_slice(&self.write_u32(reloc_sec.link));
                buf.extend_from_slice(&self.write_u32(reloc_sec.info));
                buf.extend_from_slice(&self.write_u32(reloc_sec.addralign as u32));
                buf.extend_from_slice(&self.write_u32(reloc_sec.entsize as u32));
            }
        }

        // Write note section header
        if let Some(ns) = note_section {
            let name_off = get_name_offset(&ns.name);
            let size = ns.data.len() as u64;

            if is_64 {
                buf.extend_from_slice(&self.write_u32(name_off));
                buf.extend_from_slice(&self.write_u32(ns.section_type));
                buf.extend_from_slice(&self.write_u64(ns.flags));
                buf.extend_from_slice(&self.write_u64(ns.addr));
                buf.extend_from_slice(&self.write_u64(note_offset));
                buf.extend_from_slice(&self.write_u64(size));
                buf.extend_from_slice(&self.write_u32(ns.link));
                buf.extend_from_slice(&self.write_u32(ns.info));
                buf.extend_from_slice(&self.write_u64(ns.addralign));
                buf.extend_from_slice(&self.write_u64(ns.entsize));
            } else {
                buf.extend_from_slice(&self.write_u32(name_off));
                buf.extend_from_slice(&self.write_u32(ns.section_type));
                buf.extend_from_slice(&self.write_u32(ns.flags as u32));
                buf.extend_from_slice(&self.write_u32(ns.addr as u32));
                buf.extend_from_slice(&self.write_u32(note_offset as u32));
                buf.extend_from_slice(&self.write_u32(size as u32));
                buf.extend_from_slice(&self.write_u32(ns.link));
                buf.extend_from_slice(&self.write_u32(ns.info));
                buf.extend_from_slice(&self.write_u32(ns.addralign as u32));
                buf.extend_from_slice(&self.write_u32(ns.entsize as u32));
            }
        }

        buf
    }

    // ------------------------------------------------------------------
    // Public write methods (for individual components)
    // ------------------------------------------------------------------

    /// Emit the ELF header (`Elf64Ehdr` or `Elf32Ehdr`).
    pub fn write_elf_header(&self) -> Vec<u8> {
        // For standalone use, use dummy values
        let phdr_size = if self.program_headers.is_empty() {
            0u64
        } else {
            self.phdr_total_size()
        };
        self.write_elf_header_raw(phdr_size, 0, 0, 0)
    }

    /// Emit all section headers.
    pub fn write_section_headers(&self) -> Vec<u8> {
        // Build minimal data for the call
        let mut offsets = Vec::new();
        for _ in &self.sections {
            offsets.push(0u64);
        }
        let empty_relocs: Vec<(u32, Vec<u8>, ElfSection)> = Vec::new();
        let empty_offsets: Vec<u64> = Vec::new();
        self.write_section_headers_raw(&offsets, &empty_relocs, &empty_offsets, &None, 0, 0)
    }

    /// Emit section contents in order.
    pub fn write_section_data(&self) -> Vec<u8> {
        let mut buf = Vec::new();
        for sec in &self.sections {
            if sec.section_type != SHT_NOBITS && sec.section_type != SHT_NULL {
                buf.extend_from_slice(&sec.data);
            }
        }
        buf
    }

    /// Emit symbol table entries.
    pub fn write_symtab(&self) -> Vec<u8> {
        if let Some(ref symtab) = self.symtab {
            symtab.build_symtab_entries(self.class.is_64bit())
        } else {
            Vec::new()
        }
    }

    /// Emit the string table section data.
    pub fn write_strtab(&self) -> Vec<u8> {
        if let Some(ref symtab) = self.symtab {
            symtab.build_strtab()
        } else {
            vec![0u8]
        }
    }

    /// Emit RELA/REL entries for a given section.
    pub fn write_relocations(&self, section: &ElfSection) -> Vec<u8> {
        // Find the section index
        let sec_idx = self
            .sections
            .iter()
            .position(|s| std::ptr::eq(s as *const _, section as *const _))
            .map(|i| i as u32);

        if let Some(idx) = sec_idx {
            for (sid, relocs) in &self.relocations {
                if *sid == idx {
                    return self.write_relocations_raw(relocs);
                }
            }
        }
        Vec::new()
    }

    /// Emit program headers.
    pub fn write_program_headers(&self) -> Vec<u8> {
        self.write_program_headers_raw()
    }

    /// Emit notes.
    pub fn write_notes(&self) -> Vec<u8> {
        self.write_notes_raw()
    }
}

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

#[cfg(test)]
mod tests {
    use super::*;
    use crate::elf::elf_types::{
        SECTION_NAME_BSS, SECTION_NAME_DATA, SECTION_NAME_RODATA, SECTION_NAME_TEXT, SHF_ALLOC,
        SHF_EXECINSTR, SHF_WRITE, SHT_NOBITS, SHT_PROGBITS, SHT_RELA, SHT_STRTAB, SHT_SYMTAB,
        STB_GLOBAL, STB_LOCAL, STT_FUNC, STT_NOTYPE, STT_OBJECT,
    };

    // ------------------------------------------------------------------
    // Helper: parse a little-endian u16 from bytes
    // ------------------------------------------------------------------
    fn read_u16_le(bytes: &[u8], offset: usize) -> u16 {
        u16::from_le_bytes([bytes[offset], bytes[offset + 1]])
    }

    fn read_u32_le(bytes: &[u8], offset: usize) -> u32 {
        u32::from_le_bytes([
            bytes[offset],
            bytes[offset + 1],
            bytes[offset + 2],
            bytes[offset + 3],
        ])
    }

    fn read_u64_le(bytes: &[u8], offset: usize) -> u64 {
        u64::from_le_bytes([
            bytes[offset],
            bytes[offset + 1],
            bytes[offset + 2],
            bytes[offset + 3],
            bytes[offset + 4],
            bytes[offset + 5],
            bytes[offset + 6],
            bytes[offset + 7],
        ])
    }

    // ------------------------------------------------------------------
    // Test: Empty ELF object creation
    // ------------------------------------------------------------------

    #[test]
    fn test_empty_elf64_object() {
        let mut writer = ElfWriter::new_elf64_rel(ElfMachine::X86_64);
        writer.add_null_section();
        let data = writer.write();

        // Should be non-empty and start with ELF magic
        assert!(data.len() > 64);
        assert_eq!(&data[0..4], &ELF_MAGIC);

        // Check e_ident
        assert_eq!(data[4], 2); // ELFCLASS64
        assert_eq!(data[5], 1); // ELFDATA2LSB
        assert_eq!(data[6], 1); // EV_CURRENT

        // Check e_type = ET_REL
        assert_eq!(read_u16_le(&data, 16), ET_REL);

        // Check e_machine = EM_X86_64
        assert_eq!(read_u16_le(&data, 18), EM_X86_64);
    }

    #[test]
    fn test_empty_elf32_object() {
        let mut writer = ElfWriter::new_elf32_rel(ElfMachine::X86);
        let data = writer.write();

        assert!(data.len() >= 52);
        assert_eq!(&data[0..4], &ELF_MAGIC);
        assert_eq!(data[4], 1); // ELFCLASS32
        assert_eq!(data[5], 1); // ELFDATA2LSB
        assert_eq!(read_u16_le(&data, 16), ET_REL);
        assert_eq!(read_u16_le(&data, 18), EM_386);
    }

    // ------------------------------------------------------------------
    // Test: Object with .text section
    // ------------------------------------------------------------------

    #[test]
    fn test_elf64_with_text_section() {
        let mut writer = ElfWriter::new_elf64_rel(ElfMachine::X86_64);
        let code = vec![0x90u8; 16]; // 16 NOPs
        let text_idx = writer.add_section(
            ".text",
            code.clone(),
            SHT_PROGBITS,
            SHF_ALLOC | SHF_EXECINSTR,
            16,
        );

        let data = writer.write();
        assert!(data.len() > 100);

        // Section index should be 1 (after null section)
        assert_eq!(text_idx, 1);

        // Verify .text data appears in the output
        // Find the code bytes somewhere after the ELF header
        let found = data.windows(16).any(|w| w == code.as_slice());
        assert!(found, "Expected to find .text data in ELF output");
    }

    // ------------------------------------------------------------------
    // Test: Object with .data, .rodata, .bss sections
    // ------------------------------------------------------------------

    #[test]
    fn test_elf64_with_data_sections() {
        let mut writer = ElfWriter::new_elf64_rel(ElfMachine::X86_64);

        let text_data = vec![0xCCu8; 32];
        let rodata_data = vec![0xAAu8; 16];
        let data_data = vec![0xBBu8; 8];
        let bss_size = 64usize;

        writer.add_section(
            ".text",
            text_data.clone(),
            SHT_PROGBITS,
            SHF_ALLOC | SHF_EXECINSTR,
            16,
        );
        writer.add_section(".rodata", rodata_data.clone(), SHT_PROGBITS, SHF_ALLOC, 8);
        writer.add_section(
            ".data",
            data_data.clone(),
            SHT_PROGBITS,
            SHF_ALLOC | SHF_WRITE,
            8,
        );
        writer.add_section(
            ".bss",
            vec![0u8; bss_size],
            SHT_NOBITS,
            SHF_ALLOC | SHF_WRITE,
            16,
        );

        let data = writer.write();

        // BSS should take NO space in file (SHT_NOBITS)
        // All other sections should be present
        assert!(data.len() > 150);
    }

    // ------------------------------------------------------------------
    // Test: Object with symbol table
    // ------------------------------------------------------------------

    #[test]
    fn test_elf64_with_symbol_table() {
        let mut writer = ElfWriter::new_elf64_rel(ElfMachine::X86_64);

        // Add a .text section first
        let text_idx = writer.add_section(
            ".text",
            vec![0x90u8; 16],
            SHT_PROGBITS,
            SHF_ALLOC | SHF_EXECINSTR,
            16,
        );

        // Build a symbol table
        let mut symtab = ElfSymbolTable::new();
        symtab.add_file_symbol("test.c");
        symtab.add_global_symbol("main", 0, 16, STT_FUNC, text_idx as u16);
        symtab.add_local_symbol("helper", 8, 8, STT_FUNC, text_idx as u16);

        let symtab_idx = writer.add_symbol_table(symtab);

        let data = writer.write();
        assert!(data.len() > 200);

        // We should have .symtab and .strtab sections
        // The symtab section should be SHT_SYMTAB
        assert!(symtab_idx > 0);
    }

    // ------------------------------------------------------------------
    // Test: Object with relocations
    // ------------------------------------------------------------------

    #[test]
    fn test_elf64_with_relocations() {
        let mut writer = ElfWriter::new_elf64_rel(ElfMachine::X86_64);

        // Add a .text section
        let text_idx = writer.add_section(
            ".text",
            vec![0u8; 32],
            SHT_PROGBITS,
            SHF_ALLOC | SHF_EXECINSTR,
            16,
        );

        // Add symbol table
        let mut symtab = ElfSymbolTable::new();
        symtab.add_global_symbol("ext_func", 0, 0, STT_FUNC, 0); // undefined
        symtab.add_global_symbol("main", 0, 16, STT_FUNC, text_idx as u16);
        writer.add_symbol_table(symtab);

        // Add relocations
        writer.add_relocation(text_idx, ElfRelocation::rela(0, 1, 1, -4)); // R_X86_64_64
        writer.add_relocation(text_idx, ElfRelocation::rela(8, 1, 2, -4)); // R_X86_64_PC32

        let data = writer.write();
        assert!(data.len() > 200);

        // Should have .rela.text section
        let rela_text_found = data.windows(12).any(|w| {
            // Look for ".rela.text" in string table
            w == b".rela.text\0"
        });
        // Actually, check for the section header entry
        // Just verify output is valid
        assert!(data.len() > 64);
    }

    // ------------------------------------------------------------------
    // Test: Multiple sections and symbols
    // ------------------------------------------------------------------

    #[test]
    fn test_elf64_multiple_sections_and_symbols() {
        let mut writer = ElfWriter::new_elf64_rel(ElfMachine::X86_64);

        let text_idx = writer.add_section(
            ".text",
            vec![0x90u8; 64],
            SHT_PROGBITS,
            SHF_ALLOC | SHF_EXECINSTR,
            16,
        );
        let data_idx = writer.add_section(
            ".data",
            vec![0x42u8; 32],
            SHT_PROGBITS,
            SHF_ALLOC | SHF_WRITE,
            8,
        );
        writer.add_section(".rodata", vec![0x13u8; 16], SHT_PROGBITS, SHF_ALLOC, 4);

        let mut symtab = ElfSymbolTable::new();
        symtab.add_file_symbol("multi.c");
        symtab.add_global_symbol("start", 0, 64, STT_FUNC, text_idx as u16);
        symtab.add_global_symbol("global_data", 0, 32, STT_OBJECT, data_idx as u16);
        symtab.add_local_symbol("local_const", 0, 16, STT_OBJECT, 2);
        writer.add_symbol_table(symtab);

        let data = writer.write();
        assert!(data.len() > 300);

        // Check ELF magic
        assert_eq!(&data[0..4], &ELF_MAGIC);
    }

    // ------------------------------------------------------------------
    // Test: Object with program headers (executable)
    // ------------------------------------------------------------------

    #[test]
    fn test_elf64_exec_with_program_headers() {
        let mut writer = ElfWriter::new_elf64_exec(ElfMachine::X86_64, 0x401000);

        let text_data = vec![0x90u8; 64];
        writer.add_section(
            ".text",
            text_data.clone(),
            SHT_PROGBITS,
            SHF_ALLOC | SHF_EXECINSTR,
            4096,
        );

        // Add a program header for the text segment
        writer.add_program_header(ElfPhdrInfo::load(
            PF_R | PF_X,
            0x1000,
            0x401000,
            64,
            64,
            4096,
        ));

        let data = writer.write();
        assert!(data.len() > 100);

        // Check e_type = ET_EXEC
        assert_eq!(read_u16_le(&data, 16), ET_EXEC);

        // Check entry point
        assert_eq!(read_u64_le(&data, 24), 0x401000);

        // Check that program headers exist
        // e_phnum should be > 0
        let phnum = read_u16_le(&data, 56);
        assert_eq!(phnum, 1);

        // e_phoff should point to right after ELF header
        let phoff = read_u64_le(&data, 32);
        assert_eq!(phoff, 64); // right after 64-byte ELF header
    }

    // ------------------------------------------------------------------
    // Test: ELF32 vs ELF64 output
    // ------------------------------------------------------------------

    #[test]
    fn test_elf32_vs_elf64_header_sizes() {
        let mut w32 = ElfWriter::new_elf32_rel(ElfMachine::X86);
        let data32 = w32.write();

        let mut w64 = ElfWriter::new_elf64_rel(ElfMachine::X86_64);
        let data64 = w64.write();

        // ELF32 header is 52 bytes, ELF64 is 64 bytes
        // Check e_ehsize
        assert_eq!(read_u16_le(&data32, 40), 52); // e_ehsize for 32-bit
        assert_eq!(read_u16_le(&data64, 52), 64); // e_ehsize for 64-bit

        // Both should start with ELF magic
        assert_eq!(&data32[0..4], &ELF_MAGIC);
        assert_eq!(&data64[0..4], &ELF_MAGIC);

        // Different classes
        assert_eq!(data32[4], 1); // ELFCLASS32
        assert_eq!(data64[4], 2); // ELFCLASS64
    }

    // ------------------------------------------------------------------
    // Test: 32-bit object with sections and symbols
    // ------------------------------------------------------------------

    #[test]
    fn test_elf32_with_sections() {
        let mut writer = ElfWriter::new_elf32_rel(ElfMachine::ARM);

        let text_idx = writer.add_section(
            ".text",
            vec![0x00u8; 32],
            SHT_PROGBITS,
            SHF_ALLOC | SHF_EXECINSTR,
            4,
        );

        let mut symtab = ElfSymbolTable::new();
        symtab.add_global_symbol("arm_func", 0, 32, STT_FUNC, text_idx as u16);
        writer.add_symbol_table(symtab);

        let data = writer.write();

        assert_eq!(&data[0..4], &ELF_MAGIC);
        assert_eq!(data[4], 1); // ELFCLASS32
        assert_eq!(read_u16_le(&data, 18), EM_ARM);

        // Should have section headers
        assert!(data.len() > 100);
    }

    // ------------------------------------------------------------------
    // Test: Big-endian output
    // ------------------------------------------------------------------

    #[test]
    fn test_elf64_big_endian_output() {
        let mut writer = ElfWriter::new(
            ElfClass::Elf64,
            ElfEndian::Big,
            ElfOsAbi::SystemV,
            ElfMachine::X86_64,
            ET_REL,
        );

        writer.add_section(
            ".text",
            vec![0x90u8; 16],
            SHT_PROGBITS,
            SHF_ALLOC | SHF_EXECINSTR,
            16,
        );

        let data = writer.write();

        // Check ELF magic
        assert_eq!(&data[0..4], &ELF_MAGIC);

        // Check endianness byte
        assert_eq!(data[5], 2); // ELFDATA2MSB

        // Check e_type in big-endian
        let e_type = u16::from_be_bytes([data[16], data[17]]);
        assert_eq!(e_type, ET_REL);
    }

    #[test]
    fn test_elf32_big_endian_output() {
        let mut writer = ElfWriter::new(
            ElfClass::Elf32,
            ElfEndian::Big,
            ElfOsAbi::SystemV,
            ElfMachine::X86,
            ET_REL,
        );

        let data = writer.write();

        assert_eq!(&data[0..4], &ELF_MAGIC);
        assert_eq!(data[4], 1); // ELFCLASS32
        assert_eq!(data[5], 2); // ELFDATA2MSB
    }

    // ------------------------------------------------------------------
    // Test: OS/ABI settings
    // ------------------------------------------------------------------

    #[test]
    fn test_elf_with_linux_abi() {
        let mut writer = ElfWriter::new(
            ElfClass::Elf64,
            ElfEndian::Little,
            ElfOsAbi::Linux,
            ElfMachine::X86_64,
            ET_REL,
        );
        writer.add_null_section();
        let data = writer.write();

        assert_eq!(data[7], 3); // ELFOSABI_LINUX
    }

    #[test]
    fn test_elf_with_freebsd_abi() {
        let mut writer = ElfWriter::new(
            ElfClass::Elf64,
            ElfEndian::Little,
            ElfOsAbi::FreeBSD,
            ElfMachine::X86_64,
            ET_REL,
        );
        writer.add_null_section();
        let data = writer.write();

        assert_eq!(data[7], 9); // ELFOSABI_FREEBSD
    }

    // ------------------------------------------------------------------
    // Test: Different machine types
    // ------------------------------------------------------------------

    #[test]
    fn test_machine_aarch64() {
        let mut writer = ElfWriter::new_elf64_rel(ElfMachine::AArch64);
        let data = writer.write();

        assert_eq!(read_u16_le(&data, 18), EM_AARCH64);
    }

    #[test]
    fn test_machine_riscv() {
        let mut writer = ElfWriter::new_elf64_rel(ElfMachine::RiscV);
        let data = writer.write();

        assert_eq!(read_u16_le(&data, 18), EM_RISCV);
    }

    #[test]
    fn test_machine_arm32() {
        let mut writer = ElfWriter::new_elf32_rel(ElfMachine::ARM);
        let data = writer.write();

        assert_eq!(read_u16_le(&data, 18), EM_ARM);
    }

    // ------------------------------------------------------------------
    // Test: Section flags
    // ------------------------------------------------------------------

    #[test]
    fn test_section_flags_propagation() {
        let mut writer = ElfWriter::new_elf64_rel(ElfMachine::X86_64);

        writer.add_section(
            ".text",
            vec![0x90u8; 16],
            SHT_PROGBITS,
            SHF_ALLOC | SHF_EXECINSTR,
            16,
        );

        let data = writer.write();

        // The section header table should reflect the flags
        // We'd need to parse the section header to verify, but
        // at minimum the output should be valid
        assert!(data.len() > 64);
    }

    // ------------------------------------------------------------------
    // Test: BSS section (SHT_NOBITS)
    // ------------------------------------------------------------------

    #[test]
    fn test_bss_section_no_file_space() {
        let mut writer = ElfWriter::new_elf64_rel(ElfMachine::X86_64);

        // Add .text first
        writer.add_section(
            ".text",
            vec![0x90u8; 16],
            SHT_PROGBITS,
            SHF_ALLOC | SHF_EXECINSTR,
            16,
        );

        // Add .bss with large size
        writer.add_section(
            ".bss",
            vec![0u8; 1024],
            SHT_NOBITS,
            SHF_ALLOC | SHF_WRITE,
            16,
        );

        let data = writer.write();

        // The file should be small (BSS takes no file space)
        // Total should be roughly: header + .text (16 bytes) + shstrtab + section headers
        assert!(data.len() < 500, "BSS should not occupy file space");
    }

    // ------------------------------------------------------------------
    // Test: Symbol table with null entry
    // ------------------------------------------------------------------

    #[test]
    fn test_symbol_table_null_entry() {
        let mut writer = ElfWriter::new_elf64_rel(ElfMachine::X86_64);

        let text_idx = writer.add_section(
            ".text",
            vec![0x90u8; 16],
            SHT_PROGBITS,
            SHF_ALLOC | SHF_EXECINSTR,
            16,
        );

        let mut symtab = ElfSymbolTable::new();
        symtab.add_global_symbol("my_func", 0, 16, STT_FUNC, text_idx as u16);

        let symtab_idx = writer.add_symbol_table(symtab);
        let data = writer.write();

        // The symbol table should start with a null entry (all zeros)
        // We can check the section data for .symtab
        assert!(symtab_idx > 0);
        assert!(data.len() > 100);
    }

    // ------------------------------------------------------------------
    // Test: Relocation with addend
    // ------------------------------------------------------------------

    #[test]
    fn test_relocations_with_addend() {
        let mut writer = ElfWriter::new_elf64_rel(ElfMachine::X86_64);

        let text_idx = writer.add_section(
            ".text",
            vec![0u8; 32],
            SHT_PROGBITS,
            SHF_ALLOC | SHF_EXECINSTR,
            16,
        );

        let mut symtab = ElfSymbolTable::new();
        symtab.add_global_symbol("ext_sym", 0, 0, STT_FUNC, 0);
        let sym_idx = writer.add_symbol_table(symtab);

        writer.add_relocation(
            text_idx,
            ElfRelocation::rela(4, 1, 1, 42), // offset=4, sym=1, type=1, addend=42
        );
        writer.add_relocation(
            text_idx,
            ElfRelocation::rela(16, 1, 2, -8), // offset=16, sym=1, type=2, addend=-8
        );

        let data = writer.write();
        assert!(data.len() > 150);
    }

    // ------------------------------------------------------------------
    // Test: REL vs RELA relocations
    // ------------------------------------------------------------------

    #[test]
    fn test_rel_vs_rela() {
        // RELA
        {
            let mut writer = ElfWriter::new_elf64_rel(ElfMachine::X86_64);
            let text_idx = writer.add_section(
                ".text",
                vec![0u8; 16],
                SHT_PROGBITS,
                SHF_ALLOC | SHF_EXECINSTR,
                16,
            );
            let mut symtab = ElfSymbolTable::new();
            symtab.add_global_symbol("sym", 0, 0, STT_FUNC, 0);
            writer.add_symbol_table(symtab);
            writer.add_relocation(text_idx, ElfRelocation::rela(0, 1, 1, 0));
            let data = writer.write();
            assert!(data.len() > 100);
        }

        // REL
        {
            let mut writer = ElfWriter::new_elf64_rel(ElfMachine::X86_64);
            let text_idx = writer.add_section(
                ".text",
                vec![0u8; 16],
                SHT_PROGBITS,
                SHF_ALLOC | SHF_EXECINSTR,
                16,
            );
            let mut symtab = ElfSymbolTable::new();
            symtab.add_global_symbol("sym", 0, 0, STT_FUNC, 0);
            writer.add_symbol_table(symtab);
            writer.add_relocation(text_idx, ElfRelocation::rel(0, 1, 1));
            let data = writer.write();
            assert!(data.len() > 100);
        }
    }

    // ------------------------------------------------------------------
    // Test: Notes
    // ------------------------------------------------------------------

    #[test]
    fn test_elf_with_notes() {
        let mut writer = ElfWriter::new_elf64_rel(ElfMachine::X86_64);

        writer.add_note(ElfNote::new("GNU", 3, vec![1, 2, 3, 4])); // NT_GNU_BUILD_ID = 3
        writer.add_note(ElfNote::new("test", 1, vec![0xAA, 0xBB]));

        let data = writer.write();
        assert!(data.len() > 100);

        // Check that note data is present
        let found_gnu = data.windows(4).any(|w| w == b"GNU\0");
        assert!(found_gnu, "Expected to find 'GNU' note name in output");
    }

    // ------------------------------------------------------------------
    // Test: Shared library (ET_DYN)
    // ------------------------------------------------------------------

    #[test]
    fn test_elf64_shared_object() {
        let mut writer = ElfWriter::new_elf64_shared(ElfMachine::X86_64);

        writer.add_section(
            ".text",
            vec![0x90u8; 16],
            SHT_PROGBITS,
            SHF_ALLOC | SHF_EXECINSTR,
            16,
        );

        let data = writer.write();

        assert_eq!(read_u16_le(&data, 16), ET_DYN);
        assert_eq!(&data[0..4], &ELF_MAGIC);
    }

    // ------------------------------------------------------------------
    // Test: Entry point
    // ------------------------------------------------------------------

    #[test]
    fn test_set_entry_point() {
        let mut writer = ElfWriter::new_elf64_exec(ElfMachine::X86_64, 0x400000);
        let data = writer.write();

        assert_eq!(read_u64_le(&data, 24), 0x400000);
    }

    #[test]
    fn test_set_entry_after_construction() {
        let mut writer = ElfWriter::new_elf64_rel(ElfMachine::X86_64);
        writer.file_type = ET_EXEC;
        writer.set_entry(0x800000);

        let data = writer.write();
        assert_eq!(read_u64_le(&data, 24), 0x800000);
        assert_eq!(read_u16_le(&data, 16), ET_EXEC);
    }

    // ------------------------------------------------------------------
    // Test: Section alignment
    // ------------------------------------------------------------------

    #[test]
    fn test_section_alignment() {
        let mut writer = ElfWriter::new_elf64_rel(ElfMachine::X86_64);

        // Add sections with different alignments
        writer.add_section(
            ".text",
            vec![0x90u8; 1],
            SHT_PROGBITS,
            SHF_ALLOC | SHF_EXECINSTR,
            64,
        );
        writer.add_section(
            ".data",
            vec![0x42u8; 1],
            SHT_PROGBITS,
            SHF_ALLOC | SHF_WRITE,
            1,
        );

        let data = writer.write();
        // Output should be valid (aligned properly)
        assert!(data.len() > 64);
    }

    // ------------------------------------------------------------------
    // Test: Flags field
    // ------------------------------------------------------------------

    #[test]
    fn test_flags_field() {
        let mut writer = ElfWriter::new_elf64_rel(ElfMachine::X86_64);
        writer.flags = 0x12345678;
        let data = writer.write();

        let flags = read_u32_le(&data, 48); // e_flags at offset 48 in Elf64Ehdr
        assert_eq!(flags, 0x12345678);
    }

    // ------------------------------------------------------------------
    // Test: shstrtab includes all section names
    // ------------------------------------------------------------------

    #[test]
    fn test_shstrtab_contains_all_names() {
        let mut writer = ElfWriter::new_elf64_rel(ElfMachine::X86_64);

        writer.add_section(
            ".text",
            vec![0x90u8; 8],
            SHT_PROGBITS,
            SHF_ALLOC | SHF_EXECINSTR,
            16,
        );
        writer.add_section(".my_custom_section", vec![0u8; 4], SHT_PROGBITS, 0, 1);

        let data = writer.write();

        // Check that section names appear in the string table
        let found_text = data.windows(6).any(|w| w == b".text\0");
        let found_custom = data
            .windows(20)
            .any(|w| w.len() >= 19 && w[..19] == b".my_custom_section\0"[..19]);

        assert!(found_text, ".text should be in shstrtab");
        assert!(found_custom, ".my_custom_section should be in shstrtab");
        // .shstrtab should contain its own name
        let found_shstrtab = data.windows(10).any(|w| w == b".shstrtab\0");
        assert!(found_shstrtab, ".shstrtab should be in shstrtab");
    }

    // ------------------------------------------------------------------
    // Test: Section link fields
    // ------------------------------------------------------------------

    #[test]
    fn test_section_link_fields() {
        let mut writer = ElfWriter::new_elf64_rel(ElfMachine::X86_64);

        let text_idx = writer.add_section(
            ".text",
            vec![0x90u8; 16],
            SHT_PROGBITS,
            SHF_ALLOC | SHF_EXECINSTR,
            16,
        );

        let mut symtab = ElfSymbolTable::new();
        symtab.add_global_symbol("func", 0, 16, STT_FUNC, text_idx as u16);
        let symtab_idx = writer.add_symbol_table(symtab);

        writer.add_relocation(text_idx, ElfRelocation::rela(0, 1, 1, 0));

        let data = writer.write();

        // The symtab's sh_link should point to strtab
        // The rela section's sh_link should point to symtab
        assert!(symtab_idx > 0);
        assert!(data.len() > 100);
    }

    // ------------------------------------------------------------------
    // Test: Multiple program headers
    // ------------------------------------------------------------------

    #[test]
    fn test_multiple_program_headers() {
        let mut writer = ElfWriter::new_elf64_exec(ElfMachine::X86_64, 0x401000);

        writer.add_program_header(ElfPhdrInfo::load(
            PF_R | PF_X,
            0x1000,
            0x401000,
            0x1000,
            0x1000,
            0x1000,
        ));
        writer.add_program_header(ElfPhdrInfo::load(
            PF_R | PF_W,
            0x2000,
            0x602000,
            0x500,
            0x500,
            0x1000,
        ));

        let data = writer.write();

        let phnum = read_u16_le(&data, 56);
        assert_eq!(phnum, 2);
    }

    // ------------------------------------------------------------------
    // Test: Convenience constructors
    // ------------------------------------------------------------------

    #[test]
    fn test_convenience_constructors() {
        // new_elf64_rel
        {
            let w = ElfWriter::new_elf64_rel(ElfMachine::AArch64);
            assert_eq!(w.class, ElfClass::Elf64);
            assert_eq!(w.file_type, ET_REL);
            assert_eq!(w.machine, ElfMachine::AArch64);
            assert_eq!(w.endian, ElfEndian::Little);
        }

        // new_elf32_rel
        {
            let w = ElfWriter::new_elf32_rel(ElfMachine::ARM);
            assert_eq!(w.class, ElfClass::Elf32);
            assert_eq!(w.file_type, ET_REL);
            assert_eq!(w.machine, ElfMachine::ARM);
        }

        // new_elf64_exec
        {
            let w = ElfWriter::new_elf64_exec(ElfMachine::X86_64, 0x1000);
            assert_eq!(w.class, ElfClass::Elf64);
            assert_eq!(w.file_type, ET_EXEC);
            assert_eq!(w.entry, 0x1000);
        }

        // new_elf64_shared
        {
            let w = ElfWriter::new_elf64_shared(ElfMachine::X86_64);
            assert_eq!(w.class, ElfClass::Elf64);
            assert_eq!(w.file_type, ET_DYN);
        }
    }

    // ------------------------------------------------------------------
    // Test: idempotent add_null_section
    // ------------------------------------------------------------------

    #[test]
    fn test_add_null_section_idempotent() {
        let mut writer = ElfWriter::new_elf64_rel(ElfMachine::X86_64);
        writer.add_null_section();
        writer.add_null_section();
        writer.add_null_section();

        // Should only have one section (index 0)
        assert_eq!(writer.sections.len(), 1);
        assert_eq!(writer.sections[0].section_type, SHT_NULL);
    }

    // ------------------------------------------------------------------
    // Test: Write individual components
    // ------------------------------------------------------------------

    #[test]
    fn test_write_individual_components() {
        let mut writer = ElfWriter::new_elf64_rel(ElfMachine::X86_64);

        writer.add_section(
            ".text",
            vec![0xCCu8; 8],
            SHT_PROGBITS,
            SHF_ALLOC | SHF_EXECINSTR,
            16,
        );

        let mut symtab = ElfSymbolTable::new();
        symtab.add_global_symbol("fn", 0, 8, STT_FUNC, 1);
        writer.add_symbol_table(symtab);

        writer.add_note(ElfNote::new("GNU", 3, vec![0x12, 0x34]));

        // Test individual writers
        let ehdr = writer.write_elf_header();
        assert_eq!(ehdr.len(), 64);
        assert_eq!(&ehdr[0..4], &ELF_MAGIC);

        let shdrs = writer.write_section_headers();
        assert!(!shdrs.is_empty());

        let sec_data = writer.write_section_data();
        assert!(sec_data.contains(&0xCCu8));

        let symtab_data = writer.write_symtab();
        assert!(!symtab_data.is_empty());
        // null entry + 2 symbols (file + fn) = 3 entries * 24 bytes = 72
        // Actually: null + file_symbol(not added in this test) + fn
        // symtab.new() has null entry, then we add "fn" = 2 entries * 24
        assert_eq!(symtab_data.len(), 2 * 24);

        let strtab = writer.write_strtab();
        assert_eq!(strtab[0], 0u8); // Starts with NUL

        let phdrs = writer.write_program_headers();
        assert!(phdrs.is_empty()); // No program headers added

        let notes = writer.write_notes();
        assert!(!notes.is_empty());
    }

    // ------------------------------------------------------------------
    // Test: Roundtrip — write then validate with elf_types parsing
    // ------------------------------------------------------------------

    #[test]
    fn test_roundtrip_write_and_validate_header() {
        let mut writer = ElfWriter::new_elf64_rel(ElfMachine::X86_64);

        let text_data = vec![0x90u8; 32];
        writer.add_section(
            ".text",
            text_data.clone(),
            SHT_PROGBITS,
            SHF_ALLOC | SHF_EXECINSTR,
            16,
        );

        let mut symtab = ElfSymbolTable::new();
        symtab.add_global_symbol("main", 0, 32, STT_FUNC, 1);
        writer.add_symbol_table(symtab);

        let data = writer.write();

        // Validate ELF header fields
        assert_eq!(&data[0..4], &[0x7f, b'E', b'L', b'F']);
        assert_eq!(data[4], 2); // ELFCLASS64
        assert_eq!(data[5], 1); // ELFDATA2LSB
        assert_eq!(data[6], 1); // EV_CURRENT

        let e_type = u16::from_le_bytes([data[16], data[17]]);
        assert_eq!(e_type, ET_REL);

        let e_machine = u16::from_le_bytes([data[18], data[19]]);
        assert_eq!(e_machine, EM_X86_64);

        // Header size
        let e_ehsize = u16::from_le_bytes([data[52], data[53]]);
        assert_eq!(e_ehsize, 64);

        // Section header size
        let e_shentsize = u16::from_le_bytes([data[58], data[59]]);
        assert_eq!(e_shentsize, 64);

        // Should have at least: null, .text, .symtab, .strtab, .shstrtab
        let e_shnum = u16::from_le_bytes([data[60], data[61]]);
        assert!(e_shnum >= 5);

        // e_shstrndx should be valid
        let e_shstrndx = u16::from_le_bytes([data[62], data[63]]);
        assert!(e_shstrndx < e_shnum);
    }

    // ------------------------------------------------------------------
    // Test: Large number of sections
    // ------------------------------------------------------------------

    #[test]
    fn test_many_sections() {
        let mut writer = ElfWriter::new_elf64_rel(ElfMachine::X86_64);

        for i in 0..10 {
            let name = format!(".section_{}", i);
            writer.add_section(
                name,
                vec![i as u8; 8],
                SHT_PROGBITS,
                SHF_ALLOC,
                if i % 2 == 0 { 16 } else { 8 },
            );
        }

        let data = writer.write();
        assert!(data.len() > 400);

        // Should have proper section headers (null + 10 sections + .shstrtab = 12)
        let e_shnum = u16::from_le_bytes([data[60], data[61]]);
        assert_eq!(e_shnum, 12);
    }

    // ------------------------------------------------------------------
    // Test: Write with no sections except null
    // ------------------------------------------------------------------

    #[test]
    fn test_write_with_only_null_section() {
        let mut writer = ElfWriter::new_elf64_rel(ElfMachine::X86_64);
        writer.add_null_section();
        let data = writer.write();

        assert!(data.len() >= 64);
        assert_eq!(&data[0..4], &ELF_MAGIC);
    }

    // ------------------------------------------------------------------
    // Test: Processor-specific flags
    // ------------------------------------------------------------------

    #[test]
    fn test_processor_specific_flags() {
        let mut writer = ElfWriter::new_elf64_rel(ElfMachine::X86_64);
        writer.flags = 0xDEADBEEF;
        let data = writer.write();

        // e_flags is at offset 48 in Elf64Ehdr
        let e_flags = u32::from_le_bytes([data[48], data[49], data[50], data[51]]);
        assert_eq!(e_flags, 0xDEADBEEF);
    }
}