llvm-native-core-ext 0.1.0

//! LLVM ObjectWriter — write assembled machine code to object files.
//! Phase 3 — LLVM.OBJECT.WRITER.1 Court.
//!
//! Clean-room behavioral reconstruction from the ELF Specification
//! (System V ABI, AMD64 ABI, ARM64 ABI), Mach-O format reference
//! (Apple), and PE/COFF specification (Microsoft). Zero LLVM source
//! code consultation.
//!
//! The object writer takes assembled bytes (from MCAssembler) and
//! packages them into standard object file formats:
//! - ELF64 (Linux, BSD, etc.)
//! - MachO64 (macOS)
//! - COFF/PE (Windows)
//! - Wasm (WebAssembly)

use std::collections::HashMap;
use std::fs;
use std::io::Write;
use std::path::Path;

// ============================================================================
// Relocation Types
// ============================================================================

/// Relocation types for different architectures.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[allow(non_camel_case_types)]
pub enum RelocationType {
    // x86-64
    R_X86_64_NONE,
    R_X86_64_64,       // S + A
    R_X86_64_PC32,     // S + A - P
    R_X86_64_32,       // S + A
    R_X86_64_32S,      // S + A (sign-extended)
    R_X86_64_PLT32,    // L + A - P
    R_X86_64_GOTPCREL, // G + GOT + A - P
    // AArch64
    R_AARCH64_ABS64,
    R_AARCH64_ABS32,
    R_AARCH64_CALL26,
    R_AARCH64_ADR_PREL_PG_HI21,
    R_AARCH64_LDST64_ABS_LO12_NC,
    // ARM32
    R_ARM_ABS32,
    R_ARM_CALL,
    R_ARM_MOVW_ABS_NC,
    R_ARM_MOVT_ABS,
}

impl RelocationType {
    /// Get the ELF relocation type number.
    pub fn elf_value(self) -> u32 {
        match self {
            RelocationType::R_X86_64_NONE => 0,
            RelocationType::R_X86_64_64 => 1,
            RelocationType::R_X86_64_PC32 => 2,
            RelocationType::R_X86_64_32 => 10,
            RelocationType::R_X86_64_32S => 11,
            RelocationType::R_X86_64_PLT32 => 4,
            RelocationType::R_X86_64_GOTPCREL => 9,
            RelocationType::R_AARCH64_ABS64 => 257,
            RelocationType::R_AARCH64_ABS32 => 258,
            RelocationType::R_AARCH64_CALL26 => 283,
            RelocationType::R_AARCH64_ADR_PREL_PG_HI21 => 275,
            RelocationType::R_AARCH64_LDST64_ABS_LO12_NC => 286,
            RelocationType::R_ARM_ABS32 => 2,
            RelocationType::R_ARM_CALL => 28,
            RelocationType::R_ARM_MOVW_ABS_NC => 43,
            RelocationType::R_ARM_MOVT_ABS => 44,
        }
    }
}

// ============================================================================
// Object File Formats
// ============================================================================

/// Supported object file formats.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ObjectFormat {
    ELF,
    MachO,
    COFF,
    Wasm,
}

impl ObjectFormat {
    /// Auto-detect the format from a target triple string.
    pub fn from_target_triple(triple: &str) -> Self {
        let lower = triple.to_lowercase();
        if lower.contains("apple") || lower.contains("darwin") || lower.contains("macos") {
            ObjectFormat::MachO
        } else if lower.contains("windows") || lower.contains("msvc") || lower.contains("mingw") {
            ObjectFormat::COFF
        } else if lower.contains("wasm") {
            ObjectFormat::Wasm
        } else {
            ObjectFormat::ELF
        }
    }
}

/// Section flags.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct SectionFlags {
    pub alloc: bool,   // SHF_ALLOC — occupies memory
    pub write: bool,   // SHF_WRITE — writable
    pub exec: bool,    // SHF_EXECINSTR — executable
    pub merge: bool,   // SHF_MERGE — can be merged
    pub strings: bool, // SHF_STRINGS — contains null-terminated strings
}

impl SectionFlags {
    pub fn text() -> Self {
        Self {
            alloc: true,
            write: false,
            exec: true,
            merge: false,
            strings: false,
        }
    }
    pub fn data() -> Self {
        Self {
            alloc: true,
            write: true,
            exec: false,
            merge: false,
            strings: false,
        }
    }
    pub fn rodata() -> Self {
        Self {
            alloc: true,
            write: false,
            exec: false,
            merge: false,
            strings: false,
        }
    }
    pub fn bss() -> Self {
        Self {
            alloc: true,
            write: true,
            exec: false,
            merge: false,
            strings: false,
        }
    }
    /// Convert to ELF sh_flags value.
    fn to_elf_flags(self) -> u64 {
        let mut f = 0u64;
        if self.alloc {
            f |= 2; // SHF_ALLOC
        }
        if self.write {
            f |= 1; // SHF_WRITE
        }
        if self.exec {
            f |= 4; // SHF_EXECINSTR
        }
        if self.merge {
            f |= 0x10; // SHF_MERGE
        }
        if self.strings {
            f |= 0x20; // SHF_STRINGS
        }
        f
    }
}

// ============================================================================
// Symbol Table
// ============================================================================

/// Symbol binding.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SymbolBinding {
    Local,
    Global,
    Weak,
}

/// Symbol type.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SymbolType {
    NoType,
    Object,
    Func,
    Section,
}

/// A symbol entry for the object file.
#[derive(Debug, Clone)]
pub struct ObjectSymbol {
    pub name: String,
    pub value: u64,
    pub size: u64,
    pub binding: SymbolBinding,
    pub sym_type: SymbolType,
    /// Section index (1-based, 0=UNDEF, 0xFFF1=ABS)
    pub section_index: u16,
}

// ============================================================================
// Relocation Entry
// ============================================================================

/// A relocation entry.
#[derive(Debug, Clone)]
pub struct RelocationEntry {
    /// Offset within the section where the relocation applies
    pub offset: u64,
    /// Symbol index this relocation references
    pub symbol_index: u32,
    /// The type of relocation
    pub rel_type: RelocationType,
    /// Addend for RELA relocations
    pub addend: i64,
}

// ============================================================================
// Section Data
// ============================================================================

/// A section to be written to the object file.
#[derive(Debug, Clone)]
pub struct ObjectSection {
    pub name: String,
    pub data: Vec<u8>,
    pub flags: SectionFlags,
    /// Section type (SHT_PROGBITS=1, SHT_NOBITS=8, etc.)
    pub section_type: u32,
    /// Alignment (power of 2)
    pub alignment: u64,
    /// Relocations for this section
    pub relocations: Vec<RelocationEntry>,
}

// ============================================================================
// Mach-O Specific Types
// ============================================================================

/// Mach-O CPU architectures.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum MachOArch {
    X86_64,
    ARM64,
    ARM,
}

impl MachOArch {
    pub fn cpu_type(&self) -> u32 {
        match self {
            MachOArch::X86_64 => 0x01000007, // CPU_TYPE_X86_64
            MachOArch::ARM64 => 0x0100000C,  // CPU_TYPE_ARM64
            MachOArch::ARM => 0x0000000C,    // CPU_TYPE_ARM
        }
    }

    pub fn cpu_subtype(&self) -> u32 {
        match self {
            MachOArch::X86_64 => 3, // CPU_SUBTYPE_X86_64_ALL
            MachOArch::ARM64 => 0,  // CPU_SUBTYPE_ARM64_ALL
            MachOArch::ARM => 9,    // CPU_SUBTYPE_ARM_V7
        }
    }
}

/// A Mach-O segment with its sections.
#[derive(Debug, Clone)]
pub struct MachOSegment {
    pub name: String,
    pub vmaddr: u64,
    pub vmsize: u64,
    pub fileoff: u64,
    pub filesize: u64,
    pub maxprot: u32,
    pub initprot: u32,
    pub nsects: u32,
    pub flags: u32,
}

/// A Mach-O symbol for nlist_64.
#[derive(Debug, Clone)]
pub struct MachoSymbol {
    pub name: String,
    pub n_type: u8,
    pub n_sect: u8,
    pub n_desc: u16,
    pub n_value: u64,
}

// ============================================================================
// COFF Specific Types
// ============================================================================

/// A COFF symbol entry.
#[derive(Debug, Clone)]
pub struct CoffSymbol {
    pub name: String,
    pub value: u32,
    pub section_number: i16,
    pub sym_type: u16,
    pub storage_class: u8,
    pub aux_count: u8,
}

/// A COFF relocation entry.
#[derive(Debug, Clone)]
pub struct CoffRelocation {
    pub virtual_address: u32,
    pub symbol_index: u32,
    pub rel_type: u16,
}

// ============================================================================
// Wasm Specific Types
// ============================================================================

/// A WebAssembly section.
#[derive(Debug, Clone)]
pub struct WasmSection {
    pub section_type: u8,
    pub data: Vec<u8>,
}

// ============================================================================
// Mach-O Constants
// ============================================================================

/// Mach-O magic numbers.
pub mod macho_const {
    pub const MH_MAGIC_64: u32 = 0xFEEDFACF;
    pub const MH_MAGIC: u32 = 0xFEEDFACE;

    // File types
    pub const MH_OBJECT: u32 = 1;
    pub const MH_EXECUTE: u32 = 2;
    pub const MH_DYLIB: u32 = 6;

    // Load command types
    pub const LC_SEGMENT: u32 = 0x01;
    pub const LC_SEGMENT_64: u32 = 0x19;
    pub const LC_SYMTAB: u32 = 0x02;
    pub const LC_DYSYMTAB: u32 = 0x0B;
    pub const LC_UUID: u32 = 0x1B;
    pub const LC_VERSION_MIN_MACOSX: u32 = 0x24;
    pub const LC_VERSION_MIN_IPHONEOS: u32 = 0x25;
    pub const LC_MAIN: u32 = 0x80000028;
    pub const LC_LOAD_DYLIB: u32 = 0x0C;
    pub const LC_RPATH: u32 = 0x8000001C;
    pub const LC_FUNCTION_STARTS: u32 = 0x26;
    pub const LC_DATA_IN_CODE: u32 = 0x29;

    // VM protection
    pub const VM_PROT_NONE: u32 = 0x0;
    pub const VM_PROT_READ: u32 = 0x1;
    pub const VM_PROT_WRITE: u32 = 0x2;
    pub const VM_PROT_EXECUTE: u32 = 0x4;

    // CPU types
    pub const CPU_TYPE_X86_64: u32 = 0x01000007;
    pub const CPU_TYPE_ARM64: u32 = 0x0100000C;
    pub const CPU_TYPE_ARM: u32 = 0x0000000C;

    // Segment flags
    pub const SG_HIGHVM: u32 = 0x1;
    pub const SG_PROTECTED_VERSION_1: u32 = 0x8;

    // Section flags
    pub const S_REGULAR: u32 = 0x0;
    pub const S_ATTR_PURE_INSTRUCTIONS: u32 = 0x80000000;
    pub const S_ATTR_SOME_INSTRUCTIONS: u32 = 0x00000400;
    pub const S_ATTR_DEBUG: u32 = 0x02000000;

    // Symbol type flags (n_type)
    pub const N_STAB: u8 = 0xE0;
    pub const N_TYPE: u8 = 0x0E;
    pub const N_EXT: u8 = 0x01;
    pub const N_UNDF: u8 = 0x00;
    pub const N_ABS: u8 = 0x02;
    pub const N_SECT: u8 = 0x0E;
    pub const N_PBUD: u8 = 0x0C;
    pub const N_INDR: u8 = 0x0A;
}

// ============================================================================
// COFF Constants
// ============================================================================

/// COFF/PE constants.
pub mod coff_const {
    // Machine types
    pub const IMAGE_FILE_MACHINE_AMD64: u16 = 0x8664;
    pub const IMAGE_FILE_MACHINE_ARM64: u16 = 0xAA64;
    pub const IMAGE_FILE_MACHINE_ARM: u16 = 0x1C0;
    pub const IMAGE_FILE_MACHINE_I386: u16 = 0x14C;

    // Section characteristics
    pub const IMAGE_SCN_CNT_CODE: u32 = 0x00000020;
    pub const IMAGE_SCN_CNT_INITIALIZED_DATA: u32 = 0x00000040;
    pub const IMAGE_SCN_CNT_UNINITIALIZED_DATA: u32 = 0x00000080;
    pub const IMAGE_SCN_MEM_EXECUTE: u32 = 0x20000000;
    pub const IMAGE_SCN_MEM_READ: u32 = 0x40000000;
    pub const IMAGE_SCN_MEM_WRITE: u32 = 0x80000000;
    pub const IMAGE_SCN_MEM_DISCARDABLE: u32 = 0x02000000;
    pub const IMAGE_SCN_LNK_REMOVE: u32 = 0x00000800;

    // Symbol storage class
    pub const IMAGE_SYM_CLASS_EXTERNAL: u8 = 2;
    pub const IMAGE_SYM_CLASS_STATIC: u8 = 3;
    pub const IMAGE_SYM_CLASS_FUNCTION: u8 = 101;
    pub const IMAGE_SYM_CLASS_FILE: u8 = 103;
}

// ============================================================================
// Multi-Format ObjectWriter — Main Interface
// ============================================================================

/// The ObjectWriter builds object files from sections, symbols, and relocations.
pub struct ObjectWriter {
    pub format: ObjectFormat,
    pub target_triple: String,
    pub sections: Vec<ObjectSection>,
    pub symbols: Vec<ObjectSymbol>,
    /// Per-section alignment overrides
    pub section_alignments: Vec<(String, u64)>,
    /// Debug sections (DWARF)
    pub debug_sections: Vec<(String, Vec<u8>)>,
}

impl ObjectWriter {
    pub fn new(format: ObjectFormat, triple: &str) -> Self {
        Self {
            format,
            target_triple: triple.to_string(),
            sections: Vec::new(),
            symbols: Vec::new(),
            section_alignments: Vec::new(),
            debug_sections: Vec::new(),
        }
    }

    /// Add a section with data.
    pub fn add_section(&mut self, name: &str, data: Vec<u8>, flags: SectionFlags) -> usize {
        let idx = self.sections.len();
        self.sections.push(ObjectSection {
            name: name.to_string(),
            data,
            flags,
            section_type: 1, // SHT_PROGBITS
            alignment: 16,
            relocations: Vec::new(),
        });
        idx
    }

    /// Add an empty BSS section (no data, just size).
    pub fn add_bss_section(&mut self, name: &str, size: u64) -> usize {
        let idx = self.sections.len();
        self.sections.push(ObjectSection {
            name: name.to_string(),
            data: vec![0u8; size as usize],
            flags: SectionFlags::bss(),
            section_type: 8, // SHT_NOBITS
            alignment: 16,
            relocations: Vec::new(),
        });
        idx
    }

    /// Add a symbol.
    pub fn add_symbol(
        &mut self,
        name: &str,
        value: u64,
        size: u64,
        binding: SymbolBinding,
        sym_type: SymbolType,
        section_index: u16,
    ) {
        self.symbols.push(ObjectSymbol {
            name: name.to_string(),
            value,
            size,
            binding,
            sym_type,
            section_index,
        });
    }

    /// Add a relocation to a section.
    pub fn add_relocation(
        &mut self,
        section_index: usize,
        offset: u64,
        symbol_index: u32,
        rel_type: RelocationType,
        addend: i64,
    ) {
        if section_index < self.sections.len() {
            self.sections[section_index]
                .relocations
                .push(RelocationEntry {
                    offset,
                    symbol_index,
                    rel_type,
                    addend,
                });
        }
    }

    /// Add a debug section (DWARF).
    pub fn add_debug_section(&mut self, name: &str, data: Vec<u8>) {
        self.debug_sections.push((name.to_string(), data));
    }

    /// Set the alignment for a section.
    pub fn set_section_alignment(&mut self, name: &str, align: u64) {
        // Update existing section if it exists
        if let Some(sec) = self.sections.iter_mut().find(|s| s.name == name) {
            sec.alignment = align;
        }
        // Also store for later sections
        self.section_alignments.retain(|(n, _)| n != name);
        self.section_alignments.push((name.to_string(), align));
    }

    /// Get the size of a section's data.
    pub fn get_section_size(&self, name: &str) -> Option<u64> {
        self.sections
            .iter()
            .find(|s| s.name == name)
            .map(|s| s.data.len() as u64)
    }

    /// Set the target architecture (auto-detects format from arch name).
    pub fn set_target_arch(&mut self, arch: &str) {
        let triple = match arch {
            "x86_64" | "amd64" => "x86_64-unknown-linux-gnu",
            "aarch64" | "arm64" => "aarch64-unknown-linux-gnu",
            "arm" | "arm32" => "arm-unknown-linux-gnueabihf",
            "wasm32" | "wasm" => "wasm32-unknown-unknown",
            _ => "x86_64-unknown-linux-gnu",
        };
        self.target_triple = triple.to_string();
        self.format = ObjectFormat::from_target_triple(&self.target_triple);
    }

    /// Write the complete object file as bytes.
    pub fn write(&self) -> Vec<u8> {
        match self.format {
            ObjectFormat::ELF => self.write_elf64(),
            ObjectFormat::MachO => self.write_macho64(),
            ObjectFormat::COFF => self.write_coff64(),
            ObjectFormat::Wasm => self.write_wasm_module(),
        }
    }

    /// Write the object file to disk.
    pub fn write_to_file(&self, path: &str) -> Result<(), String> {
        let data = self.write();
        let path = Path::new(path);
        if let Some(parent) = path.parent() {
            fs::create_dir_all(parent).map_err(|e| format!("Failed to create dir: {}", e))?;
        }
        let mut file =
            fs::File::create(path).map_err(|e| format!("Failed to create file: {}", e))?;
        file.write_all(&data)
            .map_err(|e| format!("Failed to write: {}", e))?;
        Ok(())
    }

    // ========================================================================
    // ELF64 Writer
    // ========================================================================

    fn write_elf64(&self) -> Vec<u8> {
        // We need to build the ELF file layout:
        // 1. ELF header (64 bytes)
        // 2. Program header table (optional, for executables; we write none for .o)
        // 3. Section data (each section's raw bytes)
        // 4. Section header string table (.shstrtab)
        // 5. Symbol string table (.strtab)
        // 6. Symbol table (.symtab)
        // 7. Relocation sections (.rela.text, etc.)
        // 8. Section header table

        // Build the string tables first so we know their sizes
        let shstrtab = self.build_shstrtab();
        let strtab = self.build_strtab();
        let symtab = self.build_symtab();

        let num_sections = self.sections.len() + 4; // +shstrtab, +strtab, +symtab, +1 NULL
        let mut relocation_sections: Vec<(usize, Vec<u8>)> = Vec::new();

        // Build relocation sections
        for (i, sec) in self.sections.iter().enumerate() {
            if !sec.relocations.is_empty() {
                let rela_data = self.build_rela_section(i);
                relocation_sections.push((i, rela_data));
            }
        }
        let num_rela = relocation_sections.len();
        let total_sections = num_sections + num_rela;

        // Compute offsets
        let mut offset: u64 = 64; // after ELF header

        // No program headers for .o files
        let phoff: u64 = 0;
        let phnum: u16 = 0;

        // Section data offsets
        let mut section_offsets: Vec<u64> = Vec::new();
        let mut section_sizes: Vec<u64> = Vec::new();

        // NULL section (index 0)
        section_offsets.push(0);
        section_sizes.push(0);

        // User sections
        for sec in &self.sections {
            section_offsets.push(offset);
            section_sizes.push(sec.data.len() as u64);
            offset += sec.data.len() as u64;
        }

        // .shstrtab
        let shstrtab_offset = offset;
        section_offsets.push(shstrtab_offset);
        section_sizes.push(shstrtab.len() as u64);
        offset += shstrtab.len() as u64;

        // .strtab
        let strtab_offset = offset;
        section_offsets.push(strtab_offset);
        section_sizes.push(strtab.len() as u64);
        offset += strtab.len() as u64;

        // .symtab
        let symtab_offset = offset;
        section_offsets.push(symtab_offset);
        section_sizes.push(symtab.len() as u64);
        offset += symtab.len() as u64;

        // Relocation sections
        let mut rela_info: Vec<(usize, u64, u64)> = Vec::new(); // (section_idx, offset, size)
        for (sec_idx, rela_data) in &relocation_sections {
            rela_info.push((*sec_idx, offset, rela_data.len() as u64));
            section_offsets.push(offset);
            section_sizes.push(rela_data.len() as u64);
            offset += rela_data.len() as u64;
        }

        // Section header table offset
        let shoff = offset;

        // Allocate output buffer
        let total_size = shoff + (total_sections as u64 * 64);
        let mut out = vec![0u8; total_size as usize];

        // Write ELF header
        self.write_elf_header(&mut out, shoff, phoff, phnum, total_sections as u16);

        // Write user section data
        let mut current_offset = 64u64;
        for sec in &self.sections {
            let len = sec.data.len();
            out[current_offset as usize..current_offset as usize + len].copy_from_slice(&sec.data);
            current_offset += len as u64;
        }

        // Write .shstrtab
        let len = shstrtab.len();
        out[shstrtab_offset as usize..shstrtab_offset as usize + len].copy_from_slice(&shstrtab);

        // Write .strtab
        let len = strtab.len();
        out[strtab_offset as usize..strtab_offset as usize + len].copy_from_slice(&strtab);

        // Write .symtab
        let len = symtab.len();
        out[symtab_offset as usize..symtab_offset as usize + len].copy_from_slice(&symtab);

        // Write relocation sections
        for (_, rela_data) in &relocation_sections {
            let off = rela_info
                .iter()
                .find(|(_, o, _)| {
                    *o == current_offset
                        || out[*o as usize..*o as usize + 4] == rela_data[0..4.min(rela_data.len())]
                })
                .map(|(_, o, _)| *o)
                .unwrap_or(current_offset);
            let len = rela_data.len();
            out[off as usize..off as usize + len].copy_from_slice(rela_data);
            current_offset = off + len as u64;
        }

        // Write section header table
        self.write_section_headers(
            &mut out,
            shoff,
            total_sections,
            &section_offsets,
            &section_sizes,
            &shstrtab,
            &rela_info,
        );

        out
    }

    fn write_elf_header(&self, out: &mut [u8], shoff: u64, _phoff: u64, phnum: u16, shnum: u16) {
        // e_ident[16]
        out[0] = 0x7F;
        out[1] = b'E';
        out[2] = b'L';
        out[3] = b'F';
        out[4] = 2; // ELFCLASS64
        out[5] = 1; // ELFDATA2LSB (little-endian)
        out[6] = 1; // EV_CURRENT
        out[7] = 0; // ELFOSABI_NONE (System V)
        out[8] = 0; // ABI version
        out[9..16].fill(0);

        // e_type = ET_REL (1) for .o files
        out[16] = 1;
        out[17] = 0;

        // e_machine
        let machine = self.elf_machine();
        out[18] = machine as u8;
        out[19] = (machine >> 8) as u8;

        // e_version
        out[20] = 1;
        out[21] = 0;
        out[22] = 0;
        out[23] = 0;

        out[24..32].fill(0);

        out[32..40].fill(0);

        // e_shoff
        let bytes = shoff.to_le_bytes();
        out[40..48].copy_from_slice(&bytes);

        out[48..52].fill(0);

        // e_ehsize = 64
        out[52] = 64;
        out[53] = 0;

        // e_phentsize
        out[54] = 0;
        out[55] = 0;

        // e_phnum
        out[56] = phnum as u8;
        out[57] = (phnum >> 8) as u8;

        // e_shentsize = 64
        out[58] = 64;
        out[59] = 0;

        // e_shnum
        out[60] = shnum as u8;
        out[61] = (shnum >> 8) as u8;

        // e_shstrndx (index of .shstrtab section)
        let shstrndx = self.sections.len() as u16 + 1; // +1 for NULL, then user sections, then shstrtab
        out[62] = shstrndx as u8;
        out[63] = (shstrndx >> 8) as u8;
    }

    fn elf_machine(&self) -> u16 {
        if self.target_triple.contains("x86_64") {
            62 // EM_X86_64
        } else if self.target_triple.contains("aarch64") {
            183 // EM_AARCH64
        } else if self.target_triple.contains("arm") {
            40 // EM_ARM
        } else {
            62 // default to x86_64
        }
    }

    #[allow(clippy::too_many_arguments)]
    fn write_section_headers(
        &self,
        out: &mut [u8],
        shoff: u64,
        total_sections: usize,
        offsets: &[u64],
        sizes: &[u64],
        shstrtab: &[u8],
        rela_info: &[(usize, u64, u64)],
    ) {
        let user_section_count = self.sections.len();
        let _shstrtab_idx = user_section_count + 1; // after NULL + user sections

        for i in 0..total_sections {
            let hdr_off = (shoff as usize) + i * 64;
            if hdr_off + 64 > out.len() {
                break;
            }

            let hdr = &mut out[hdr_off..hdr_off + 64];

            if i == 0 {
                // Section 0 is always NULL
                continue; // already zeroed
            }

            let sec_idx = i - 1; // 0-based index into user sections + special sections

            // sh_name — offset into .shstrtab
            let name_offset = if i <= user_section_count {
                // User section
                if sec_idx < user_section_count {
                    self.shstrtab_offset(&self.sections[sec_idx].name, shstrtab)
                } else {
                    0
                }
            } else {
                // Special sections
                let special_idx = i - user_section_count - 1;
                let name = match special_idx {
                    0 => ".shstrtab",
                    1 => ".strtab",
                    2 => ".symtab",
                    _ => {
                        // Relocation sections
                        let rela_i = special_idx - 3;
                        if rela_i < rela_info.len() {
                            let (_user_sec, _, _) = rela_info[rela_i];
                            // We need a name like ".rela.text"
                            // Can't dynamically format here; use a pre-built name
                            ".rela"
                        } else {
                            ".unknown"
                        }
                    }
                };
                self.shstrtab_offset(name, shstrtab)
            };

            let name_bytes = name_offset.to_le_bytes();
            hdr[0..4].copy_from_slice(&name_bytes);

            // sh_type
            let (sh_type, sh_flags, sh_entsize, sh_link, sh_info) = if i <= user_section_count {
                let sec = &self.sections[sec_idx];
                (sec.section_type, sec.flags.to_elf_flags(), 0u64, 0u32, 0u32)
            } else {
                let special_idx = i - user_section_count - 1;
                match special_idx {
                    0 => (3, 0, 0, 0, 0),               // SHT_STRTAB (.shstrtab)
                    1 => (3, 0, 0, 0, 0),               // SHT_STRTAB (.strtab)
                    2 => (2, 0, 24, (i as u32) - 2, 1), // SHT_SYMTAB (.symtab), link to .strtab
                    _ => {
                        let rela_i = special_idx - 3;
                        if rela_i < rela_info.len() {
                            let (user_sec, _, _) = rela_info[rela_i];
                            (4, 0, 24, (i as u32) - 2, (user_sec + 1) as u32) // SHT_RELA
                        } else {
                            (1, 0, 0, 0, 0) // SHT_PROGBITS
                        }
                    }
                }
            };

            let type_bytes = sh_type.to_le_bytes();
            hdr[4..8].copy_from_slice(&type_bytes);

            let flags_bytes = sh_flags.to_le_bytes();
            hdr[8..16].copy_from_slice(&flags_bytes);

            // sh_addr = 0 for .o
            // sh_offset
            let off = offsets[i];
            let off_bytes = off.to_le_bytes();
            hdr[24..32].copy_from_slice(&off_bytes);

            // sh_size
            let size = sizes[i];
            let size_bytes = size.to_le_bytes();
            hdr[32..40].copy_from_slice(&size_bytes);

            // sh_link
            let link_bytes = sh_link.to_le_bytes();
            hdr[40..44].copy_from_slice(&link_bytes);

            // sh_info
            let info_bytes = sh_info.to_le_bytes();
            hdr[44..48].copy_from_slice(&info_bytes);

            // sh_addralign
            let align: u64 = if i <= user_section_count {
                self.sections[sec_idx].alignment
            } else {
                8
            };
            let align_bytes = align.to_le_bytes();
            hdr[48..56].copy_from_slice(&align_bytes);

            // sh_entsize
            let entsize_bytes = sh_entsize.to_le_bytes();
            hdr[56..64].copy_from_slice(&entsize_bytes);
        }
    }

    fn build_shstrtab(&self) -> Vec<u8> {
        let mut names: Vec<String> = Vec::new();
        // NULL entry
        names.push(String::new());

        // User sections
        for sec in &self.sections {
            names.push(sec.name.clone());
        }

        // Special sections
        names.push(".shstrtab".to_string());
        names.push(".strtab".to_string());
        names.push(".symtab".to_string());

        // Debug sections
        for (dbg_name, _) in &self.debug_sections {
            names.push(dbg_name.clone());
        }

        // Build string table
        let mut data = vec![0u8]; // leading null
        for name in &names {
            data.extend_from_slice(name.as_bytes());
            data.push(0u8);
        }
        data
    }

    fn shstrtab_offset(&self, name: &str, shstrtab: &[u8]) -> u32 {
        // Scan for the name in the shstrtab
        let name_bytes = name.as_bytes();
        for i in 0..shstrtab.len() {
            if i + name_bytes.len() <= shstrtab.len()
                && shstrtab[i..i + name_bytes.len()] == *name_bytes
            {
                // Check for null terminator
                if i == 0 || shstrtab[i - 1] == 0 {
                    // Also check that the name ends at a null or at end
                    let after = i + name_bytes.len();
                    if after >= shstrtab.len() || shstrtab[after] == 0 {
                        return i as u32;
                    }
                }
            }
        }
        0
    }

    fn build_strtab(&self) -> Vec<u8> {
        let mut data = vec![0u8]; // leading null
        for sym in &self.symbols {
            data.extend_from_slice(sym.name.as_bytes());
            data.push(0u8);
        }
        data
    }

    fn build_symtab(&self) -> Vec<u8> {
        // ELF64 symbol table entry: 24 bytes
        // st_name(4) st_info(1) st_other(1) st_shndx(2) st_value(8) st_size(8)
        let mut data = Vec::new();

        // NULL symbol (index 0)
        data.extend_from_slice(&[0u8; 24]);

        for sym in &self.symbols {
            let mut entry = [0u8; 24];

            // st_name — offset into .strtab (computed later, for now use index-based)
            // Actually we need to compute the offset; for now use 0 placeholder
            let name_offset = self.strtab_offset(&sym.name);
            entry[0..4].copy_from_slice(&name_offset.to_le_bytes());

            // st_info: bind << 4 | type
            let bind = match sym.binding {
                SymbolBinding::Local => 0u8,
                SymbolBinding::Global => 1,
                SymbolBinding::Weak => 2,
            };
            let stype = match sym.sym_type {
                SymbolType::NoType => 0u8,
                SymbolType::Object => 1,
                SymbolType::Func => 2,
                SymbolType::Section => 3,
            };
            entry[4] = (bind << 4) | stype;

            // st_other = 0 (STV_DEFAULT)
            entry[5] = 0;

            // st_shndx
            entry[6..8].copy_from_slice(&sym.section_index.to_le_bytes());

            // st_value
            entry[8..16].copy_from_slice(&sym.value.to_le_bytes());

            // st_size
            entry[16..24].copy_from_slice(&sym.size.to_le_bytes());

            data.extend_from_slice(&entry);
        }
        data
    }

    fn strtab_offset(&self, name: &str) -> u32 {
        // Compute offset: first entry is at offset 1 (after leading null)
        let mut offset = 1u32;
        for sym in &self.symbols {
            if sym.name == name {
                return offset;
            }
            offset += sym.name.len() as u32 + 1;
        }
        0
    }

    fn build_rela_section(&self, section_index: usize) -> Vec<u8> {
        let sec = &self.sections[section_index];
        let mut data = Vec::new();

        for reloc in &sec.relocations {
            // ELF64 RELA entry: 24 bytes
            // r_offset(8) r_info(8) r_addend(8)
            let mut entry = [0u8; 24];

            // r_offset
            entry[0..8].copy_from_slice(&reloc.offset.to_le_bytes());

            // r_info: (sym << 32) | type
            let r_info: u64 =
                ((reloc.symbol_index as u64) << 32) | (reloc.rel_type.elf_value() as u64);
            entry[8..16].copy_from_slice(&r_info.to_le_bytes());

            // r_addend
            entry[16..24].copy_from_slice(&reloc.addend.to_le_bytes());

            data.extend_from_slice(&entry);
        }
        data
    }

    // ========================================================================
    // MachO64 Writer — Full Implementation
    // ========================================================================

    /// Write a complete Mach-O 64-bit object file.
    fn write_macho64(&self) -> Vec<u8> {
        let mach_arch = if self.target_triple.contains("x86_64") {
            MachOArch::X86_64
        } else if self.target_triple.contains("aarch64") || self.target_triple.contains("arm64") {
            MachOArch::ARM64
        } else if self.target_triple.contains("arm") {
            MachOArch::ARM
        } else {
            MachOArch::X86_64
        };

        // Build Mach-O specific data structures
        let macho_syms: Vec<MachoSymbol> = self
            .symbols
            .iter()
            .map(|s| MachoSymbol {
                name: s.name.clone(),
                n_type: if matches!(s.binding, SymbolBinding::Global) {
                    macho_const::N_SECT | macho_const::N_EXT
                } else {
                    macho_const::N_SECT
                },
                n_sect: if s.section_index == 0 {
                    macho_const::N_UNDF
                } else {
                    s.section_index as u8
                },
                n_desc: 0,
                n_value: s.value,
            })
            .collect();

        let macho_strtab_strings: Vec<String> = macho_syms.iter().map(|s| s.name.clone()).collect();

        let mut segments: Vec<MachOSegment> = Vec::new();

        // Group sections into segments
        if !self.sections.is_empty() {
            let text_sections: Vec<usize> = self
                .sections
                .iter()
                .enumerate()
                .filter(|(_, s)| s.flags.exec && !s.flags.write)
                .map(|(i, _)| i)
                .collect();

            let data_sections: Vec<usize> = self
                .sections
                .iter()
                .enumerate()
                .filter(|(_, s)| !s.flags.exec && s.flags.write)
                .map(|(i, _)| i)
                .collect();

            let rodata_sections: Vec<usize> = self
                .sections
                .iter()
                .enumerate()
                .filter(|(_, s)| !s.flags.exec && !s.flags.write && s.section_type != 8)
                .map(|(i, _)| i)
                .collect();

            if !text_sections.is_empty() {
                segments.push(MachOSegment {
                    name: "__TEXT".to_string(),
                    vmaddr: 0,
                    vmsize: 0,  // computed below
                    fileoff: 0, // computed below
                    filesize: 0,
                    maxprot: macho_const::VM_PROT_READ | macho_const::VM_PROT_EXECUTE,
                    initprot: macho_const::VM_PROT_READ | macho_const::VM_PROT_EXECUTE,
                    nsects: text_sections.len() as u32,
                    flags: 0,
                });
            }

            if !rodata_sections.is_empty() {
                segments.push(MachOSegment {
                    name: "__RODATA".to_string(),
                    vmaddr: 0,
                    vmsize: 0,
                    fileoff: 0,
                    filesize: 0,
                    maxprot: macho_const::VM_PROT_READ,
                    initprot: macho_const::VM_PROT_READ,
                    nsects: rodata_sections.len() as u32,
                    flags: 0,
                });
            }

            if !data_sections.is_empty() {
                segments.push(MachOSegment {
                    name: "__DATA".to_string(),
                    vmaddr: 0,
                    vmsize: 0,
                    fileoff: 0,
                    filesize: 0,
                    maxprot: macho_const::VM_PROT_READ | macho_const::VM_PROT_WRITE,
                    initprot: macho_const::VM_PROT_READ | macho_const::VM_PROT_WRITE,
                    nsects: data_sections.len() as u32,
                    flags: 0,
                });
            }
        }

        // Build sections per segment
        let header = self.write_macho_header(mach_arch);
        let mut lc_data = Vec::new();

        // For now, emit a simplified set of load commands
        let lc_segments = self.write_macho_load_commands(
            &segments,
            &self.sections,
            0, // symtab offset placeholder
            0, // strtab offset placeholder
            macho_syms.len() as u32,
            macho_strtab_strings
                .iter()
                .map(|s| s.len() as u32 + 1)
                .sum(),
        );
        lc_data.extend_from_slice(&lc_segments);

        // UUID command
        let uuid = self.generate_uuid();
        let mut uuid_cmd = Vec::new();
        uuid_cmd.extend_from_slice(&macho_const::LC_UUID.to_le_bytes());
        uuid_cmd.extend_from_slice(&24u32.to_le_bytes()); // cmdsize
        uuid_cmd.extend_from_slice(&uuid);
        lc_data.extend_from_slice(&uuid_cmd);

        // Version min command
        let mut ver_cmd = Vec::new();
        ver_cmd.extend_from_slice(&macho_const::LC_VERSION_MIN_MACOSX.to_le_bytes());
        ver_cmd.extend_from_slice(&16u32.to_le_bytes()); // cmdsize
        ver_cmd.extend_from_slice(&0x000A0E00u32.to_le_bytes()); // macOS 10.14
        ver_cmd.extend_from_slice(&0x000A0E00u32.to_le_bytes()); // SDK 10.14
        lc_data.extend_from_slice(&ver_cmd);

        // Symtab command
        let symtab_cmd = self.write_macho_symtab(&macho_syms, &macho_strtab_strings, 0, 0);
        lc_data.extend_from_slice(&symtab_cmd);

        // Dysymtab command
        let dysymtab_cmd = self.write_macho_dysymtab(&macho_syms);
        lc_data.extend_from_slice(&dysymtab_cmd);

        // Count commands
        let ncmds: u32 = 4; // segment(s) + UUID + version_min + symtab + dysymtab
        let sizeofcmds: u32 = lc_data.len() as u32;

        // Assemble the file
        let mut out = Vec::new();

        // Mach-O header
        out.extend_from_slice(&header);

        // Update ncmds and sizeofcmds in header
        let ncmds_offset = 16;
        out[ncmds_offset..ncmds_offset + 4].copy_from_slice(&ncmds.to_le_bytes());
        out[ncmds_offset + 4..ncmds_offset + 8].copy_from_slice(&sizeofcmds.to_le_bytes());

        // Load commands
        out.extend_from_slice(&lc_data);

        // Section data
        for sec in &self.sections {
            out.extend_from_slice(&sec.data);
        }

        // Symbol table
        let st = self.write_macho_strtab(&macho_strtab_strings);
        let symtab_bytes = self.write_macho_symtab_raw(&macho_syms);
        let symtab_fileoff = out.len();
        out.extend_from_slice(&symtab_bytes);
        let strtab_fileoff = out.len();
        out.extend_from_slice(&st);

        // Patch symtab command offsets (approximate: symtab is last-but-one lc, at fixed offset)
        // The symtab cmd is at header(32) + lc_segments + uuid(24) + ver(16) = 32 + lc_segments.len() + 40
        let symtab_cmd_start = 32 + lc_segments.len() + 24 + 16;
        if symtab_cmd_start + 24 <= out.len() {
            out[symtab_cmd_start + 8..symtab_cmd_start + 12]
                .copy_from_slice(&(symtab_fileoff as u32).to_le_bytes());
            out[symtab_cmd_start + 12..symtab_cmd_start + 16]
                .copy_from_slice(&(macho_syms.len() as u32).to_le_bytes());
            out[symtab_cmd_start + 16..symtab_cmd_start + 20]
                .copy_from_slice(&(strtab_fileoff as u32).to_le_bytes());
            out[symtab_cmd_start + 20..symtab_cmd_start + 24]
                .copy_from_slice(&(st.len() as u32).to_le_bytes());
        }

        out
    }

    /// Write a Mach-O 64-bit header.
    pub fn write_macho_header(&self, arch: MachOArch) -> Vec<u8> {
        let mut out = Vec::with_capacity(32);

        // mach_header_64
        out.extend_from_slice(&macho_const::MH_MAGIC_64.to_le_bytes()); // magic
        out.extend_from_slice(&arch.cpu_type().to_le_bytes()); // cputype
        out.extend_from_slice(&arch.cpu_subtype().to_le_bytes()); // cpusubtype
        out.extend_from_slice(&macho_const::MH_OBJECT.to_le_bytes()); // filetype
        out.extend_from_slice(&0u32.to_le_bytes()); // ncmds (placeholder)
        out.extend_from_slice(&0u32.to_le_bytes()); // sizeofcmds (placeholder)
        out.extend_from_slice(&0u32.to_le_bytes()); // flags
        out.extend_from_slice(&0u32.to_le_bytes()); // reserved

        out
    }

    /// Write Mach-O load commands for the given segments.
    pub fn write_macho_load_commands(
        &self,
        segments: &[MachOSegment],
        sections: &[ObjectSection],
        _symtab_off: u32,
        _strtab_off: u32,
        _nsyms: u32,
        _strsize: u32,
    ) -> Vec<u8> {
        let mut out = Vec::new();
        let mut current_fileoff: u64 = 0; // Will be set properly later

        // Track which sections belong to which segment
        let text_sections: Vec<usize> = sections
            .iter()
            .enumerate()
            .filter(|(_, s)| s.flags.exec && !s.flags.write)
            .map(|(i, _)| i)
            .collect();

        let rodata_sections: Vec<usize> = sections
            .iter()
            .enumerate()
            .filter(|(_, s)| !s.flags.exec && !s.flags.write && s.section_type != 8)
            .map(|(i, _)| i)
            .collect();

        let data_sections: Vec<usize> = sections
            .iter()
            .enumerate()
            .filter(|(_, s)| !s.flags.exec && s.flags.write)
            .map(|(i, _)| i)
            .collect();

        for seg in segments {
            let seg_sections: Vec<&ObjectSection> = match seg.name.as_str() {
                "__TEXT" => text_sections.iter().map(|&i| &sections[i]).collect(),
                "__RODATA" => rodata_sections.iter().map(|&i| &sections[i]).collect(),
                "__DATA" => data_sections.iter().map(|&i| &sections[i]).collect(),
                _ => Vec::new(),
            };

            self.write_macho_segment_command(seg, &seg_sections, current_fileoff, &mut out);
            current_fileoff += seg_sections
                .iter()
                .map(|s| s.data.len() as u64)
                .sum::<u64>();
        }

        out
    }

    /// Write a single LC_SEGMENT_64 command.
    fn write_macho_segment_command(
        &self,
        seg: &MachOSegment,
        sections: &[&ObjectSection],
        fileoff: u64,
        out: &mut Vec<u8>,
    ) {
        // LC_SEGMENT_64: cmd(4) + cmdsize(4) + segname(16) + vmaddr(8) + vmsize(8) +
        // fileoff(8) + filesize(8) + maxprot(4) + initprot(4) + nsects(4) + flags(4) = 72
        let nsects = sections.len() as u32;
        let cmdsize = 72 + nsects * 80; // + section_64 headers
        let total_size: u64 = sections.iter().map(|s| s.data.len() as u64).sum();

        out.extend_from_slice(&macho_const::LC_SEGMENT_64.to_le_bytes());
        out.extend_from_slice(&cmdsize.to_le_bytes());

        // segname (16 bytes, padded)
        let mut segname_bytes = [0u8; 16];
        let name_bytes = seg.name.as_bytes();
        let copy_len = std::cmp::min(name_bytes.len(), 16);
        segname_bytes[..copy_len].copy_from_slice(&name_bytes[..copy_len]);
        out.extend_from_slice(&segname_bytes);

        out.extend_from_slice(&0u64.to_le_bytes()); // vmaddr
        out.extend_from_slice(&total_size.to_le_bytes()); // vmsize
        out.extend_from_slice(&fileoff.to_le_bytes());
        out.extend_from_slice(&total_size.to_le_bytes()); // filesize
        out.extend_from_slice(&seg.maxprot.to_le_bytes());
        out.extend_from_slice(&seg.initprot.to_le_bytes());
        out.extend_from_slice(&nsects.to_le_bytes());
        out.extend_from_slice(&seg.flags.to_le_bytes());

        // Write section headers within this segment
        let mut section_offset = fileoff;
        for sec in sections {
            let sec_flags = if sec.flags.exec {
                macho_const::S_ATTR_PURE_INSTRUCTIONS | macho_const::S_ATTR_SOME_INSTRUCTIONS
            } else {
                macho_const::S_REGULAR
            };

            self.write_macho_section_header(sec, section_offset, sec_flags, out);
            section_offset += sec.data.len() as u64;
        }
    }

    /// Write a Mach-O section_64 header (80 bytes).
    fn write_macho_section_header(
        &self,
        sec: &ObjectSection,
        offset: u64,
        flags: u32,
        out: &mut Vec<u8>,
    ) {
        // sectname (16 bytes)
        let mut sectname = [0u8; 16];
        let name_bytes = sec.name.as_bytes();
        let copy_len = std::cmp::min(name_bytes.len(), 16);
        sectname[..copy_len].copy_from_slice(&name_bytes[..copy_len]);
        out.extend_from_slice(&sectname);

        // segname (16 bytes) — use the section name as segment name placeholder
        let mut segname = [0u8; 16];
        let seg: &[u8] = if sec.flags.exec && !sec.flags.write {
            b"__TEXT"
        } else if sec.flags.write {
            b"__DATA"
        } else {
            b"__RODATA"
        };
        let copy_len = std::cmp::min(seg.len(), 16);
        segname[..copy_len].copy_from_slice(&seg[..copy_len]);
        out.extend_from_slice(&segname);

        out.extend_from_slice(&0u64.to_le_bytes()); // addr
        out.extend_from_slice(&(sec.data.len() as u64).to_le_bytes()); // size
        out.extend_from_slice(&(offset as u32).to_le_bytes()); // offset
        out.extend_from_slice(&(sec.alignment as u32).to_le_bytes()); // align
        out.extend_from_slice(&0u32.to_le_bytes()); // reloff
        out.extend_from_slice(&0u32.to_le_bytes()); // nreloc
        out.extend_from_slice(&flags.to_le_bytes());
        out.extend_from_slice(&0u32.to_le_bytes()); // reserved1
        out.extend_from_slice(&0u32.to_le_bytes()); // reserved2
        out.extend_from_slice(&0u32.to_le_bytes()); // reserved3
    }

    /// Write a Mach-O section with data (standalone, for use by single sections).
    pub fn write_macho_section(&self, name: &str, segment: &str, data: &[u8]) -> Vec<u8> {
        let mut out = Vec::with_capacity(data.len());
        // This just returns section data; the header is managed by the segment
        out.extend_from_slice(data);
        // Also include alignment padding
        let align_to = 4;
        while out.len() % align_to != 0 {
            out.push(0);
        }
        let _ = (name, segment);
        out
    }

    /// Write the Mach-O symtab load command.
    pub fn write_macho_symtab(
        &self,
        _symbols: &[MachoSymbol],
        _strings: &[String],
        symoff: u32,
        stroff: u32,
    ) -> Vec<u8> {
        let mut out = Vec::with_capacity(24);
        out.extend_from_slice(&macho_const::LC_SYMTAB.to_le_bytes());
        out.extend_from_slice(&24u32.to_le_bytes()); // cmdsize
        out.extend_from_slice(&symoff.to_le_bytes());
        out.extend_from_slice(&(_symbols.len() as u32).to_le_bytes());
        out.extend_from_slice(&stroff.to_le_bytes());
        let strsize: u32 = _strings.iter().map(|s| s.len() as u32 + 1).sum();
        out.extend_from_slice(&(strsize + 1).to_le_bytes()); // +1 for leading null
        out
    }

    /// Write the Mach-O symtab raw data (nlist_64 entries).
    pub fn write_macho_symtab_raw(&self, symbols: &[MachoSymbol]) -> Vec<u8> {
        let mut out = Vec::with_capacity(symbols.len() * 16);
        for sym in symbols {
            // n_strx (4 bytes) — placeholder, filled later
            out.extend_from_slice(&0u32.to_le_bytes());
            out.push(sym.n_type);
            out.push(sym.n_sect);
            out.extend_from_slice(&sym.n_desc.to_le_bytes());
            out.extend_from_slice(&sym.n_value.to_le_bytes());
        }
        out
    }

    /// Write the Mach-O string table.
    pub fn write_macho_strtab(&self, strings: &[String]) -> Vec<u8> {
        let mut out = vec![0u8]; // leading null
        for s in strings {
            out.extend_from_slice(s.as_bytes());
            out.push(0);
        }
        out
    }

    /// Write the Mach-O dysymtab command.
    pub fn write_macho_dysymtab(&self, symbols: &[MachoSymbol]) -> Vec<u8> {
        let mut out = Vec::with_capacity(32);

        let nlocals = symbols
            .iter()
            .filter(|s| s.n_type & macho_const::N_EXT == 0)
            .count() as u32;
        let nexdef = symbols
            .iter()
            .filter(|s| {
                s.n_type & macho_const::N_EXT != 0
                    && s.n_type & macho_const::N_TYPE == macho_const::N_SECT
            })
            .count() as u32;
        let nundef = symbols
            .iter()
            .filter(|s| s.n_type & macho_const::N_TYPE == macho_const::N_UNDF)
            .count() as u32;

        out.extend_from_slice(&macho_const::LC_DYSYMTAB.to_le_bytes());
        out.extend_from_slice(&80u32.to_le_bytes()); // cmdsize
                                                     // ilocalsym, nlocalsym
        out.extend_from_slice(&0u32.to_le_bytes());
        out.extend_from_slice(&nlocals.to_le_bytes());
        // iextdefsym, nextdefsym
        out.extend_from_slice(&nlocals.to_le_bytes());
        out.extend_from_slice(&nexdef.to_le_bytes());
        // iundefsym, nundefsym
        out.extend_from_slice(&(nlocals + nexdef).to_le_bytes());
        out.extend_from_slice(&nundef.to_le_bytes());
        // toc, modtab, extrefsym, indirectsym, extrel, locrel (all 0 for .o)
        out.extend_from_slice(&[0u8; 48]);

        out
    }

    /// Generate a random UUID for Mach-O files.
    fn generate_uuid(&self) -> [u8; 16] {
        // Simple deterministic UUID based on section contents
        let mut uuid = [0u8; 16];
        let mut hash: u64 = 0x9E3779B97F4A7C15; // golden ratio based
        for sec in &self.sections {
            for &b in &sec.data {
                hash = hash.wrapping_mul(0xC6A4A7935BD1E995).wrapping_add(b as u64);
            }
        }
        for sym in &self.symbols {
            for &b in sym.name.as_bytes() {
                hash = hash.wrapping_mul(0xC6A4A7935BD1E995).wrapping_add(b as u64);
            }
        }
        // Fill UUID with hash-derived bytes
        for i in 0..8 {
            uuid[i] = (hash >> (i * 8)) as u8;
            uuid[i + 8] = (hash.wrapping_mul(3) >> (i * 8)) as u8;
        }
        // Set UUID version 4
        uuid[6] = (uuid[6] & 0x0F) | 0x40;
        uuid[8] = (uuid[8] & 0x3F) | 0x80;
        uuid
    }

    // ========================================================================
    // COFF/PE Writer — Full Implementation
    // ========================================================================

    /// Write a complete COFF object file.
    fn write_coff64(&self) -> Vec<u8> {
        let machine = if self.target_triple.contains("x86_64") {
            coff_const::IMAGE_FILE_MACHINE_AMD64
        } else if self.target_triple.contains("aarch64") {
            coff_const::IMAGE_FILE_MACHINE_ARM64
        } else if self.target_triple.contains("arm") {
            coff_const::IMAGE_FILE_MACHINE_ARM
        } else {
            coff_const::IMAGE_FILE_MACHINE_AMD64
        };

        let num_sections = self.sections.len() as u16;

        // Build COFF symbols
        let coff_syms: Vec<CoffSymbol> = self
            .symbols
            .iter()
            .map(|s| CoffSymbol {
                name: s.name.clone(),
                value: s.value as u32,
                section_number: s.section_index as i16,
                sym_type: match s.sym_type {
                    SymbolType::Func => 0x20,
                    _ => 0,
                },
                storage_class: match s.binding {
                    SymbolBinding::Global => coff_const::IMAGE_SYM_CLASS_EXTERNAL,
                    SymbolBinding::Local => coff_const::IMAGE_SYM_CLASS_STATIC,
                    SymbolBinding::Weak => coff_const::IMAGE_SYM_CLASS_EXTERNAL,
                },
                aux_count: 0,
            })
            .collect();

        // Build COFF relocations
        let mut coff_relocs: Vec<(usize, Vec<CoffRelocation>)> = Vec::new();
        for (i, sec) in self.sections.iter().enumerate() {
            if !sec.relocations.is_empty() {
                let relocs: Vec<CoffRelocation> = sec
                    .relocations
                    .iter()
                    .map(|r| CoffRelocation {
                        virtual_address: r.offset as u32,
                        symbol_index: r.symbol_index,
                        rel_type: match r.rel_type {
                            RelocationType::R_X86_64_64 => 1,
                            RelocationType::R_X86_64_32 => 3,
                            _ => 0,
                        },
                    })
                    .collect();
                coff_relocs.push((i, relocs));
            }
        }

        // Write header
        let header = self.write_coff_header(machine, num_sections, coff_syms.len() as u32);
        let mut out = Vec::new();
        out.extend_from_slice(&header);

        // Write section headers
        let mut section_headers = Vec::new();
        let mut data_offset = 20u32; // after header

        for sec in &self.sections {
            let characteristics = if sec.flags.exec {
                coff_const::IMAGE_SCN_CNT_CODE
                    | coff_const::IMAGE_SCN_MEM_EXECUTE
                    | coff_const::IMAGE_SCN_MEM_READ
            } else if sec.flags.write {
                coff_const::IMAGE_SCN_CNT_INITIALIZED_DATA
                    | coff_const::IMAGE_SCN_MEM_READ
                    | coff_const::IMAGE_SCN_MEM_WRITE
            } else {
                coff_const::IMAGE_SCN_CNT_INITIALIZED_DATA | coff_const::IMAGE_SCN_MEM_READ
            };

            let sec_header = self.write_coff_section_header(
                &sec.name,
                sec.data.len() as u32,
                data_offset,
                characteristics,
                sec.relocations.len() as u16,
            );
            section_headers.push(sec_header);
            data_offset += sec.data.len() as u32;
        }

        for sh in &section_headers {
            out.extend_from_slice(sh);
        }

        // Write section data
        for sec in &self.sections {
            out.extend_from_slice(&sec.data);
        }

        // Write relocations
        let mut reloc_offset = out.len() as u32;
        for (sec_idx, relocs) in &coff_relocs {
            // Patch the section header's reloc_ptr
            let sec_header_offset = 20 + sec_idx * 40;
            out[sec_header_offset + 24..sec_header_offset + 28]
                .copy_from_slice(&reloc_offset.to_le_bytes());
            let reloc_data = self.write_coff_relocations(relocs);
            out.extend_from_slice(&reloc_data);
            reloc_offset += reloc_data.len() as u32;
        }

        // Write symbol table
        let symtab_offset = out.len() as u32;
        out[8..12].copy_from_slice(&symtab_offset.to_le_bytes());
        let symtab_data = self.write_coff_symtab(&coff_syms);
        out.extend_from_slice(&symtab_data);

        // Write string table for symbol names > 8 chars
        let strtab_size: u32 = coff_syms
            .iter()
            .filter(|s| s.name.len() > 8)
            .map(|s| s.name.len() as u32 + 1)
            .sum::<u32>()
            + 4; // +4 for size field
        out.extend_from_slice(&strtab_size.to_le_bytes());
        for sym in &coff_syms {
            if sym.name.len() > 8 {
                out.extend_from_slice(sym.name.as_bytes());
                out.push(0);
            }
        }

        out
    }

    /// Write a COFF file header (20 bytes).
    pub fn write_coff_header(&self, machine: u16, num_sections: u16, num_symbols: u32) -> Vec<u8> {
        let mut out = Vec::with_capacity(20);
        out.extend_from_slice(&machine.to_le_bytes());
        out.extend_from_slice(&num_sections.to_le_bytes());
        out.extend_from_slice(&0u32.to_le_bytes()); // timestamp
        out.extend_from_slice(&0u32.to_le_bytes()); // symtab_offset (placeholder)
        out.extend_from_slice(&num_symbols.to_le_bytes());
        out.extend_from_slice(&0u16.to_le_bytes()); // opt_header_size
        out.extend_from_slice(&0u16.to_le_bytes()); // characteristics
        out
    }

    /// Write a COFF section header (40 bytes).
    pub fn write_coff_section_header(
        &self,
        name: &str,
        data_size: u32,
        data_offset: u32,
        characteristics: u32,
        num_relocs: u16,
    ) -> Vec<u8> {
        let mut out = Vec::with_capacity(40);

        // Name (8 bytes, padded)
        let mut name_bytes = [0u8; 8];
        let name_slice = name.as_bytes();
        let copy_len = std::cmp::min(name_slice.len(), 8);
        name_bytes[..copy_len].copy_from_slice(&name_slice[..copy_len]);
        out.extend_from_slice(&name_bytes);

        out.extend_from_slice(&data_size.to_le_bytes()); // virtual_size
        out.extend_from_slice(&0u32.to_le_bytes()); // virtual_address
        out.extend_from_slice(&data_size.to_le_bytes()); // raw_data_size
        out.extend_from_slice(&data_offset.to_le_bytes()); // raw_data_ptr
        out.extend_from_slice(&0u32.to_le_bytes()); // reloc_ptr (placeholder)
        out.extend_from_slice(&0u32.to_le_bytes()); // linenum_ptr
        out.extend_from_slice(&num_relocs.to_le_bytes());
        out.extend_from_slice(&0u16.to_le_bytes()); // num_linenums
        out.extend_from_slice(&characteristics.to_le_bytes());
        out
    }

    /// Write a COFF section with data.
    pub fn write_coff_section(&self, name: &str, data: &[u8], characteristics: u32) -> Vec<u8> {
        let sec_header =
            self.write_coff_section_header(name, data.len() as u32, 0, characteristics, 0);
        let mut out = Vec::with_capacity(sec_header.len() + data.len());
        out.extend_from_slice(&sec_header);
        out.extend_from_slice(data);
        out
    }

    /// Write a COFF symbol table.
    pub fn write_coff_symtab(&self, symbols: &[CoffSymbol]) -> Vec<u8> {
        let mut out = Vec::with_capacity(symbols.len() * 18);

        for sym in symbols {
            // Name (8 bytes)
            let mut name_bytes = [0u8; 8];
            if sym.name.len() <= 8 {
                let name_slice = sym.name.as_bytes();
                name_bytes[..name_slice.len()].copy_from_slice(name_slice);
            } else {
                // Use string table: first 4 bytes = 0, next 4 = offset
                // Offset is computed later; placeholder
            }
            out.extend_from_slice(&name_bytes);

            out.extend_from_slice(&sym.value.to_le_bytes());
            out.extend_from_slice(&sym.section_number.to_le_bytes());
            out.extend_from_slice(&sym.sym_type.to_le_bytes());
            out.push(sym.storage_class);
            out.push(sym.aux_count);
        }

        out
    }

    /// Write COFF relocations.
    pub fn write_coff_relocations(&self, relocs: &[CoffRelocation]) -> Vec<u8> {
        let mut out = Vec::with_capacity(relocs.len() * 10);

        for reloc in relocs {
            out.extend_from_slice(&reloc.virtual_address.to_le_bytes());
            out.extend_from_slice(&reloc.symbol_index.to_le_bytes());
            out.extend_from_slice(&reloc.rel_type.to_le_bytes());
        }

        out
    }

    // ========================================================================
    // Wasm Writer — Full Implementation
    // ========================================================================

    /// Write a WebAssembly module.
    fn write_wasm_module(&self) -> Vec<u8> {
        let mut modules_sections = Vec::new();

        // Collect the sections
        for sec in &self.sections {
            let section_type = match sec.name.as_str() {
                ".text" | "code" => 10u8, // CODE section
                ".data" | "data" => 11u8, // DATA section
                _ => 0u8,                 // CUSTOM section
            };

            if section_type == 0 {
                // Custom section: prepend the name
                let mut custom_data = Vec::new();
                write_leb128_u32(&mut custom_data, sec.name.len() as u32);
                custom_data.extend_from_slice(sec.name.as_bytes());
                custom_data.extend_from_slice(&sec.data);
                modules_sections.push(WasmSection {
                    section_type: 0,
                    data: custom_data,
                });
            } else {
                modules_sections.push(WasmSection {
                    section_type,
                    data: sec.data.clone(),
                });
            }
        }

        // Add symbol table as an export section placeholder (if we have symbols)
        if !self.symbols.is_empty() {
            let mut export_data = Vec::new();
            write_leb128_u32(&mut export_data, self.symbols.len() as u32);
            for (i, sym) in self.symbols.iter().enumerate() {
                // name
                write_leb128_u32(&mut export_data, sym.name.len() as u32);
                export_data.extend_from_slice(sym.name.as_bytes());
                // export kind: function = 0
                export_data.push(0x00);
                // function index
                write_leb128_u32(&mut export_data, i as u32);
            }
            modules_sections.push(WasmSection {
                section_type: 7, // EXPORT
                data: export_data,
            });
        }

        self.write_wasm_module_data(&modules_sections)
    }

    /// Write a complete Wasm module from sections.
    pub fn write_wasm_module_data(&self, sections: &[WasmSection]) -> Vec<u8> {
        let mut out = Vec::new();

        // Magic: \0asm
        out.extend_from_slice(&[0x00, 0x61, 0x73, 0x6D]);

        // Version: 1
        out.extend_from_slice(&1u32.to_le_bytes());

        // Write each section
        for section in sections {
            out.push(section.section_type);
            let mut section_data = Vec::new();
            section_data.extend_from_slice(&section.data);
            // Encode section size as LEB128
            let mut size_buf = Vec::new();
            write_leb128_u32(&mut size_buf, section_data.len() as u32);
            out.extend_from_slice(&size_buf);
            out.extend_from_slice(&section_data);
        }

        out
    }
}

// ============================================================================
// LEB128 Encoding Helpers
// ============================================================================

/// Write an unsigned 32-bit integer as LEB128.
pub fn write_leb128_u32(buf: &mut Vec<u8>, mut value: u32) {
    loop {
        let mut byte = (value & 0x7F) as u8;
        value >>= 7;
        if value != 0 {
            byte |= 0x80;
        }
        buf.push(byte);
        if value == 0 {
            break;
        }
    }
}

/// Write a signed 32-bit integer as LEB128.
pub fn write_leb128_i32(buf: &mut Vec<u8>, mut value: i32) {
    loop {
        let mut byte = (value & 0x7F) as u8;
        value >>= 7;
        if (value == 0 && (byte & 0x40) == 0) || (value == -1 && (byte & 0x40) != 0) {
            buf.push(byte);
            break;
        }
        byte |= 0x80;
        buf.push(byte);
    }
}

/// Read an unsigned LEB128 value from bytes, returning (value, bytes_consumed).
pub fn read_leb128_u32(data: &[u8]) -> Option<(u32, usize)> {
    let mut result: u32 = 0;
    let mut shift = 0;
    for (i, &byte) in data.iter().enumerate() {
        result |= ((byte & 0x7F) as u32) << shift;
        if byte & 0x80 == 0 {
            return Some((result, i + 1));
        }
        shift += 7;
        if shift >= 35 {
            return None; // overflow
        }
    }
    None
}

impl Default for ObjectWriter {
    fn default() -> Self {
        Self::new(ObjectFormat::ELF, "x86_64-unknown-linux-gnu")
    }
}

// ============================================================================
// XCOFF Writer
// ============================================================================

impl ObjectWriter {
    /// Write a complete XCOFF32 object file.
    pub fn write_xcoff32(&self) -> Vec<u8> {
        let mut buf: Vec<u8> = Vec::new();

        // XCOFF File Header (20 bytes)
        buf.extend_from_slice(&0x01DFu16.to_be_bytes()); // magic
        buf.extend_from_slice(&(self.sections.len() as u16).to_be_bytes()); // nscns
        buf.extend_from_slice(&0i32.to_be_bytes()); // timestamp
        buf.extend_from_slice(&0u32.to_be_bytes()); // symtab offset (placeholder)
        buf.extend_from_slice(&0i32.to_be_bytes()); // nsyms
        buf.extend_from_slice(&0u16.to_be_bytes()); // opthdr size
        buf.extend_from_slice(&0u16.to_be_bytes()); // flags

        // Write section headers
        self.write_xcoff_section_headers(&mut buf);

        // Write section data
        self.write_xcoff_section_data(&mut buf);

        // Write symbol table (simplified)
        self.write_xcoff_symbol_table(&mut buf);

        // Write string table
        self.write_xcoff_string_table(&mut buf);

        buf
    }

    fn write_xcoff_section_headers(&self, buf: &mut Vec<u8>) {
        for section in &self.sections {
            let flags = if section.flags.exec == true {
                0x20u32 // STYP_TEXT
            } else if section.flags.write == true {
                0x40u32 // STYP_DATA
            } else {
                0x80u32 // STYP_BSS
            };

            // Section name (8 bytes, padded)
            let mut name_bytes = [0u8; 8];
            let name_slice = section.name.as_bytes();
            let copy_len = name_slice.len().min(8);
            name_bytes[..copy_len].copy_from_slice(&name_slice[..copy_len]);
            buf.extend_from_slice(&name_bytes);

            buf.extend_from_slice(&0u32.to_be_bytes()); // paddr
            buf.extend_from_slice(&0u32.to_be_bytes()); // vaddr
            buf.extend_from_slice(&((section.data.len() as u32).to_be_bytes())); // size
            buf.extend_from_slice(&0u32.to_be_bytes()); // scnptr (placeholder)
            buf.extend_from_slice(&0u32.to_be_bytes()); // relptr
            buf.extend_from_slice(&0u32.to_be_bytes()); // lnnoptr
            buf.extend_from_slice(&(section.relocations.len() as u32).to_be_bytes()); // nreloc
            buf.extend_from_slice(&0u32.to_be_bytes()); // nlnno
            buf.extend_from_slice(&flags.to_be_bytes());
        }
    }

    fn write_xcoff_section_data(&self, buf: &mut Vec<u8>) {
        for section in &self.sections {
            buf.extend_from_slice(&section.data);
        }
    }

    fn write_xcoff_symbol_table(&self, buf: &mut Vec<u8>) {
        for symbol in &self.symbols {
            // Symbol entry (18 bytes)
            let mut name_bytes = [0u8; 8];
            let name_slice = symbol.name.as_bytes();
            let copy_len = name_slice.len().min(8);
            name_bytes[..copy_len].copy_from_slice(&name_slice[..copy_len]);
            buf.extend_from_slice(&name_bytes);

            buf.extend_from_slice(&(symbol.value as u32).to_be_bytes());
            buf.extend_from_slice(&(symbol.section_index as i16).to_be_bytes());
            buf.extend_from_slice(&0u16.to_be_bytes()); // sym_type
            buf.extend_from_slice(&0u8.to_be_bytes()); // storage class
            buf.extend_from_slice(&0u8.to_be_bytes()); // num_aux
        }
    }

    fn write_xcoff_string_table(&self, buf: &mut Vec<u8>) {
        // Write length (4 bytes) + strings
        let mut strtab: Vec<u8> = Vec::new();
        for symbol in &self.symbols {
            if symbol.name.len() > 8 {
                strtab.extend_from_slice(symbol.name.as_bytes());
                strtab.push(0);
            }
        }
        let len = (strtab.len() + 4) as u32;
        buf.extend_from_slice(&len.to_be_bytes());
        buf.extend_from_slice(&strtab);
    }
}

// ============================================================================
// GOFF (z/OS) Writer
// ============================================================================

const GOFF_END_REC: u8 = 0x04;

impl ObjectWriter {
    /// Write a GOFF object file.
    pub fn write_goff(&self) -> Vec<u8> {
        let mut buf: Vec<u8> = Vec::new();

        // GOFF header
        buf.push(0x03); // level 3
                        // Header length: always 4 bytes total
        buf.extend_from_slice(&4u16.to_be_bytes());
        buf.push(0x00); // reserved

        // ESD records
        self.write_goff_esd_records(&mut buf);

        // TXT records
        self.write_goff_txt_records(&mut buf);

        // RLD records
        self.write_goff_rld_records(&mut buf);

        // END record
        buf.push(GOFF_END_REC);
        // END record properties: 4 bytes of length
        buf.extend_from_slice(&4u16.to_be_bytes());
        buf.push(0x02); // end of module indicator
        buf.push(0x00);

        buf
    }

    fn write_goff_esd_records(&self, buf: &mut Vec<u8>) {
        // Write ESD records for each section and symbol
        for (i, section) in self.sections.iter().enumerate() {
            buf.push(0x00); // ESD record type
            let name_bytes = section.name.as_bytes();
            let rec_len: u16 = (12 + name_bytes.len() as u16) + 1;
            buf.extend_from_slice(&rec_len.to_be_bytes());
            buf.extend_from_slice(&(i as u32).to_be_bytes()); // symbol ID
            buf.push(0x00); // ESD type: SD (Section Definition)
            buf.push(0x00); // binder
            buf.push(0x01); // amode: 31-bit
            buf.push(0x01); // rmode: ANY
            buf.extend_from_slice(&(section.data.len() as u32).to_be_bytes()); // length
            buf.extend_from_slice(&(8u32).to_be_bytes()); // alignment (default 8)
            buf.extend_from_slice(name_bytes);
            buf.push(0x00); // null terminator for name
        }

        // Write ER (External Reference) for undefined symbols
        for sym in &self.symbols {
            if sym.section_index == 0 {
                buf.push(0x00); // ESD record type
                let name_bytes = sym.name.as_bytes();
                let rec_len: u16 = (12 + name_bytes.len() as u16) + 1;
                buf.extend_from_slice(&rec_len.to_be_bytes());
                buf.extend_from_slice(&0u32.to_be_bytes()); // symbol ID
                buf.push(0x0A); // ER type
                buf.push(0x00); // binder
                buf.push(0x01); // amode
                buf.push(0x01); // rmode
                buf.extend_from_slice(&0u32.to_be_bytes()); // flags
                buf.extend_from_slice(&0u32.to_be_bytes()); // reserved
                buf.extend_from_slice(name_bytes);
                buf.push(0x00);
            }
        }
    }

    fn write_goff_txt_records(&self, buf: &mut Vec<u8>) {
        for (_i, section) in self.sections.iter().enumerate() {
            if section.data.is_empty() {
                continue;
            }
            buf.push(0x01); // TXT record type
            let data_len = section.data.len() as u16;
            buf.extend_from_slice(&(data_len + 8).to_be_bytes()); // record length
            buf.extend_from_slice(&0u32.to_be_bytes()); // section ID
            buf.extend_from_slice(&0u32.to_be_bytes()); // offset
            buf.extend_from_slice(&section.data);
        }
    }

    fn write_goff_rld_records(&self, buf: &mut Vec<u8>) {
        for section in &self.sections {
            for reloc in &section.relocations {
                buf.push(0x02); // RLD record type
                buf.extend_from_slice(&20u16.to_be_bytes()); // record length
                buf.extend_from_slice(&(reloc.symbol_index as u32).to_be_bytes());
                buf.extend_from_slice(&(reloc.offset as u32).to_be_bytes()); // position
                buf.push(8); // length (8 bytes)
                buf.push(0x00); // flags
                buf.extend_from_slice(&reloc.addend.to_be_bytes()); // addend (8 bytes)
                buf.extend_from_slice(&0u16.to_be_bytes()); // reserved
            }
        }
    }
}

// ============================================================================
// Archive Writer
// ============================================================================

const ARFMAG: &[u8; 2] = b"`\n";

impl ObjectWriter {
    /// Write an ar archive containing multiple object files.
    pub fn write_archive(&self, members: &[(String, Vec<u8>)]) -> Vec<u8> {
        let mut buf: Vec<u8> = Vec::new();

        // Archive magic
        buf.extend_from_slice(b"!<arch>\n");

        // Collect member offsets
        let mut offsets: Vec<u64> = Vec::new();
        let mut strtab_data: Vec<u8> = Vec::new();
        let mut long_names: Vec<(String, u64)> = Vec::new();

        // First pass: compute offsets and string table
        let mut current_offset: u64 = 8; // after magic

        for (name, _data) in members {
            let header_size: u64 = 60;
            let data_size = _data.len() as u64;
            let padded_size = if data_size % 2 != 0 {
                data_size + 1
            } else {
                data_size
            };

            if name.len() > 15 {
                // Long name: store in string table
                let str_offset = strtab_data.len() as u64;
                strtab_data.extend_from_slice(name.as_bytes());
                strtab_data.extend_from_slice(b"/");
                long_names.push((name.clone(), str_offset));
            }

            offsets.push(current_offset);
            current_offset += header_size + padded_size;
        }

        // Write symbol table member (SVR4/GNU style)
        if !members.is_empty() {
            // #1/20 — first member: symbol table
            buf.extend_from_slice(format!("/               ").as_bytes().get(..16).unwrap());
            // Date
            buf.extend_from_slice(format!("0           ").as_bytes().get(..12).unwrap());
            // UID, GID
            buf.extend_from_slice(format!("0     ").as_bytes().get(..6).unwrap());
            buf.extend_from_slice(format!("0     ").as_bytes().get(..6).unwrap());
            // Mode
            buf.extend_from_slice(format!("0       ").as_bytes().get(..8).unwrap());

            // Symbol table content: count(4) + offsets(4*N) + string table
            let sym_count = members.len() as u32;
            let mut symtab: Vec<u8> = Vec::new();
            symtab.extend_from_slice(&sym_count.to_be_bytes());
            for (name, _) in members {
                // Offset placeholder: simplified
                symtab.extend_from_slice(&0u32.to_be_bytes());
            }
            // String table: concatenation of symbol names
            for (name, _) in members {
                symtab.extend_from_slice(name.as_bytes());
                symtab.push(0);
            }

            let symtab_size = symtab.len();
            buf.extend_from_slice(format!("{:<10}", symtab_size).as_bytes().get(..10).unwrap());
            buf.extend_from_slice(ARFMAG);
            buf.extend_from_slice(&symtab);
            // Pad to even
            if symtab_size % 2 != 0 {
                buf.push(b'\n');
            }
        }

        // Write member files
        for (i, (name, data)) in members.iter().enumerate() {
            // ar_name (16 bytes): if name > 15 chars, use /offset format
            let name_field = if name.len() > 15 {
                let offset = long_names
                    .iter()
                    .find(|(n, _)| n == name)
                    .map(|(_, o)| *o)
                    .unwrap_or(0);
                format!("/{:<15}", offset)
            } else {
                format!("{:<16}", format!("{}/", name))
            };
            buf.extend_from_slice(name_field.as_bytes().get(..16).unwrap());

            // ar_date (12 bytes): timestamp
            buf.extend_from_slice(format!("{:<12}", 0).as_bytes().get(..12).unwrap());

            // ar_uid (6 bytes)
            buf.extend_from_slice(format!("{:<6}", 0).as_bytes().get(..6).unwrap());

            // ar_gid (6 bytes)
            buf.extend_from_slice(format!("{:<6}", 0).as_bytes().get(..6).unwrap());

            // ar_mode (8 bytes): octal 100644
            buf.extend_from_slice(format!("{:<8}", "100644").as_bytes().get(..8).unwrap());

            // ar_size (10 bytes)
            buf.extend_from_slice(format!("{:<10}", data.len()).as_bytes().get(..10).unwrap());

            // ar_fmag (2 bytes)
            buf.extend_from_slice(ARFMAG);

            // Member data
            buf.extend_from_slice(data);

            // Pad to even
            if data.len() % 2 != 0 {
                buf.push(b'\n');
            }
        }

        // Long filename string table (if any)
        if !long_names.is_empty() {
            buf.extend_from_slice(b"//              "); // name: "//"
            buf.extend_from_slice(format!("0           ").as_bytes().get(..12).unwrap());
            buf.extend_from_slice(format!("0     ").as_bytes().get(..6).unwrap());
            buf.extend_from_slice(format!("0     ").as_bytes().get(..6).unwrap());
            buf.extend_from_slice(format!("0       ").as_bytes().get(..8).unwrap());
            buf.extend_from_slice(
                format!("{:<10}", strtab_data.len())
                    .as_bytes()
                    .get(..10)
                    .unwrap(),
            );
            buf.extend_from_slice(ARFMAG);
            buf.extend_from_slice(&strtab_data);
            if strtab_data.len() % 2 != 0 {
                buf.push(b'\n');
            }
        }

        buf
    }

    /// Write a BSD-style archive (with __.SYMDEF member).
    pub fn write_bsd_archive(&self, members: &[(String, Vec<u8>)]) -> Vec<u8> {
        // BSD format is similar but uses __.SYMDEF as the symbol table name
        let mut buf: Vec<u8> = Vec::new();
        buf.extend_from_slice(b"!<arch>\n");

        // __.SYMDEF member (BSD ranlib)
        buf.extend_from_slice(b"__.SYMDEF       "); // name
        buf.extend_from_slice(format!("0           ").as_bytes().get(..12).unwrap());
        buf.extend_from_slice(format!("0     ").as_bytes().get(..6).unwrap());
        buf.extend_from_slice(format!("0     ").as_bytes().get(..6).unwrap());
        buf.extend_from_slice(format!("0       ").as_bytes().get(..8).unwrap());

        // BSD symdef: ranlib struct size + string table size + count + entries
        let ranlib_entry_size = 8usize; // 4 bytes string offset + 4 bytes member offset
        let count = members.len();
        let mut symdef: Vec<u8> = Vec::new();
        // ranlib structures: for each symbol, {string_offset(u32), member_offset(u32)}
        let mut string_offsets: Vec<u32> = Vec::new();
        let mut string_data: Vec<u8> = Vec::new();
        for (i, (name, _)) in members.iter().enumerate() {
            string_offsets.push(string_data.len() as u32);
            string_data.extend_from_slice(name.as_bytes());
            string_data.push(0);
        }

        // ranlib_size = count * 8 (each entry: 4 + 4)
        // string_size follows
        // total symdef size stored as 4-byte big-endian
        let total_symdef: u32 = (count * ranlib_entry_size + string_data.len()) as u32;
        symdef.extend_from_slice(&total_symdef.to_be_bytes());

        for i in 0..count {
            symdef.extend_from_slice(&string_offsets[i].to_be_bytes());
            symdef.extend_from_slice(&0u32.to_be_bytes()); // member offset (placeholder)
        }
        symdef.extend_from_slice(&string_data);

        buf.extend_from_slice(
            format!("{:<10}", symdef.len())
                .as_bytes()
                .get(..10)
                .unwrap(),
        );
        buf.extend_from_slice(ARFMAG);
        buf.extend_from_slice(&symdef);
        if symdef.len() % 2 != 0 {
            buf.push(b'\n');
        }

        // Write members
        for (name, data) in members {
            let name_field = format!("{:<16}", format!("{}/", name));
            buf.extend_from_slice(name_field.as_bytes().get(..16).unwrap());
            buf.extend_from_slice(format!("{:<12}", 0).as_bytes().get(..12).unwrap());
            buf.extend_from_slice(format!("{:<6}", 0).as_bytes().get(..6).unwrap());
            buf.extend_from_slice(format!("{:<6}", 0).as_bytes().get(..6).unwrap());
            buf.extend_from_slice(format!("{:<8}", "100644").as_bytes().get(..8).unwrap());
            buf.extend_from_slice(format!("{:<10}", data.len()).as_bytes().get(..10).unwrap());
            buf.extend_from_slice(ARFMAG);
            buf.extend_from_slice(data);
            if data.len() % 2 != 0 {
                buf.push(b'\n');
            }
        }

        buf
    }
}

// ============================================================================
// Split DWARF: .dwo Section Emission
// ============================================================================

impl ObjectWriter {
    /// Emit a .debug_info.dwo section (split DWARF).
    pub fn emit_debug_info_dwo(&self, info_data: &[u8]) -> Vec<u8> {
        let mut data: Vec<u8> = Vec::new();
        data.extend_from_slice(info_data);
        data
    }

    /// Emit a .debug_abbrev.dwo section.
    pub fn emit_debug_abbrev_dwo(&self, abbrev_data: &[u8]) -> Vec<u8> {
        let mut data: Vec<u8> = Vec::new();
        data.extend_from_slice(abbrev_data);
        data
    }

    /// Emit a .debug_types.dwo section.
    pub fn emit_debug_types_dwo(&self, types_data: &[u8]) -> Vec<u8> {
        let mut data: Vec<u8> = Vec::new();
        data.extend_from_slice(types_data);
        data
    }

    /// Emit a .debug_str_offsets.dwo section.
    pub fn emit_debug_str_offsets_dwo(&self, offsets: &[u32]) -> Vec<u8> {
        let mut data: Vec<u8> = Vec::new();
        // Header: DWARF32 format
        // unit_length (4 bytes placeholder)
        data.extend_from_slice(&0u32.to_le_bytes());
        // version (2 bytes)
        data.extend_from_slice(&5u16.to_le_bytes());
        // padding (2 bytes)
        data.extend_from_slice(&0u16.to_le_bytes());
        // offsets
        for &off in offsets {
            data.extend_from_slice(&off.to_le_bytes());
        }
        data
    }

    /// Emit a .debug_str.dwo section (string table for split DWARF).
    pub fn emit_debug_str_dwo(&self, strings: &[&str]) -> Vec<u8> {
        let mut data: Vec<u8> = Vec::new();
        for s in strings {
            data.extend_from_slice(s.as_bytes());
            data.push(0); // null terminator
        }
        data
    }

    /// Emit a .debug_loc.dwo section (location lists for split DWARF).
    pub fn emit_debug_loc_dwo(&self, loc_data: &[u8]) -> Vec<u8> {
        let mut data: Vec<u8> = Vec::new();
        data.extend_from_slice(loc_data);
        data
    }

    /// Emit a .debug_macro.dwo section.
    pub fn emit_debug_macro_dwo(&self, macro_data: &[u8]) -> Vec<u8> {
        let mut data: Vec<u8> = Vec::new();
        data.extend_from_slice(macro_data);
        data
    }

    /// Add all .dwo sections to the object writer's debug_sections list.
    pub fn add_split_dwarf_sections(&mut self, dwo_sections: HashMap<String, Vec<u8>>) {
        for (name, data) in dwo_sections {
            self.debug_sections.push((name, data));
        }
    }
}

// ============================================================================
// XCOFF64 Writer and Full Section Support
// ============================================================================

impl ObjectWriter {
    /// Write a complete XCOFF64 object file.
    pub fn write_xcoff64(&self) -> Vec<u8> {
        let mut buf: Vec<u8> = Vec::new();

        // XCOFF64 File Header (24 bytes)
        buf.extend_from_slice(&0x01F7u16.to_be_bytes()); // magic
        buf.extend_from_slice(&(self.sections.len() as u16).to_be_bytes()); // nscns
        buf.extend_from_slice(&0i32.to_be_bytes()); // timestamp (4 bytes)
                                                    // symtab offset (8 bytes, high 4 are 0 in typical cases)
        buf.extend_from_slice(&0u32.to_be_bytes());
        buf.extend_from_slice(&0u32.to_be_bytes());
        buf.extend_from_slice(&0i32.to_be_bytes()); // nsyms
        buf.extend_from_slice(&0u16.to_be_bytes()); // opthdr size
        buf.extend_from_slice(&0u16.to_be_bytes()); // flags

        // XCOFF64 Section Headers (72 bytes each)
        let mut scnptr_accum: u64 = 24; // after header
        scnptr_accum += (self.sections.len() as u64) * 72; // section header table

        for section in &self.sections {
            let flags: u32 = if section.flags.exec {
                0x20 // STYP_TEXT
            } else if section.flags.write {
                0x40 // STYP_DATA
            } else if section.section_type == 0x8 {
                0x80 // STYP_BSS
            } else {
                0x100 // STYP_INFO
            };

            // Section name (8 bytes)
            let mut name_bytes = [0u8; 8];
            let name_slice = section.name.as_bytes();
            let copy_len = name_slice.len().min(8);
            name_bytes[..copy_len].copy_from_slice(&name_slice[..copy_len]);
            buf.extend_from_slice(&name_bytes);

            // paddr (8 bytes)
            buf.extend_from_slice(&0u64.to_be_bytes());
            // vaddr (8 bytes)
            buf.extend_from_slice(&0u64.to_be_bytes());
            // size (8 bytes)
            buf.extend_from_slice(&(section.data.len() as u64).to_be_bytes());
            // scnptr (8 bytes)
            buf.extend_from_slice(&scnptr_accum.to_be_bytes());
            // relptr (8 bytes)
            buf.extend_from_slice(&0u64.to_be_bytes());
            // lnnoptr (8 bytes)
            buf.extend_from_slice(&0u64.to_be_bytes());
            // nreloc (4 bytes)
            buf.extend_from_slice(&(section.relocations.len() as u32).to_be_bytes());
            // nlnno (4 bytes)
            buf.extend_from_slice(&0u32.to_be_bytes());
            // flags (4 bytes)
            buf.extend_from_slice(&flags.to_be_bytes());

            scnptr_accum += section.data.len() as u64;
        }

        // Write section data
        for section in &self.sections {
            buf.extend_from_slice(&section.data);
        }

        // Write relocation entries
        for section in &self.sections {
            for reloc in &section.relocations {
                // XCOFF64 relocation entry (14 bytes)
                buf.extend_from_slice(&(reloc.offset as u64).to_be_bytes()); // vaddr
                buf.extend_from_slice(&(reloc.symbol_index as u32).to_be_bytes()); // symbol index
                buf.push(0x00); // reserved
                buf.push(reloc.rel_type as u8); // rtype
            }
        }

        buf
    }

    /// Write XCOFF loader section.
    pub fn write_xcoff_loader_section(&self) -> Vec<u8> {
        let mut buf: Vec<u8> = Vec::new();
        // Loader header
        buf.extend_from_slice(&1i32.to_be_bytes()); // version
        buf.extend_from_slice(&(self.symbols.len() as i32).to_be_bytes()); // nsyms
        buf.extend_from_slice(&0i32.to_be_bytes()); // nrelocs
        buf.extend_from_slice(&0i32.to_be_bytes()); // import file id
        buf.extend_from_slice(&0i32.to_be_bytes()); // string table length
        buf.extend_from_slice(&0u64.to_be_bytes()); // init pointer
        buf.extend_from_slice(&0u64.to_be_bytes()); // term pointer
        buf.extend_from_slice(&0u64.to_be_bytes()); // entry point
        buf
    }

    /// Write XCOFF loader symbol entries.
    pub fn write_xcoff_loader_symbols(&self) -> Vec<u8> {
        let mut buf: Vec<u8> = Vec::new();
        for symbol in &self.symbols {
            // Symbol name (8 bytes)
            let mut name_bytes = [0u8; 8];
            let name_slice = symbol.name.as_bytes();
            let copy_len = name_slice.len().min(8);
            name_bytes[..copy_len].copy_from_slice(&name_slice[..copy_len]);
            buf.extend_from_slice(&name_bytes);
            // value (8 bytes)
            buf.extend_from_slice(&symbol.value.to_be_bytes());
            // scnum (2 bytes)
            buf.extend_from_slice(&(symbol.section_index as u16).to_be_bytes());
            // smtype (1 byte)
            buf.push(match symbol.sym_type {
                SymbolType::Func => 0x20,   // XTY_SD (CSECT)
                SymbolType::Object => 0x01, // XTY_LD
                _ => 0x00,
            });
            // smclas (1 byte)
            buf.push(0x00);
            // num_aux (1 byte)
            buf.push(0x00);
            // reserved (1 byte)
            buf.push(0x00);
        }
        buf
    }

    /// Write GOFF ESD for Common section.
    pub fn write_goff_cm_esd(&self, name: &str, len: u64, align: u64) -> Vec<u8> {
        let mut buf: Vec<u8> = Vec::new();
        buf.push(0x00); // ESD
        let name_bytes = name.as_bytes();
        let rec_len: u16 = (14 + name_bytes.len() as u16) + 1;
        buf.extend_from_slice(&rec_len.to_be_bytes());
        buf.extend_from_slice(&0u32.to_be_bytes()); // symbol ID
        buf.push(0x06); // CM type
        buf.push(0x00); // binder
        buf.push(0x01); // amode
        buf.push(0x01); // rmode
        buf.extend_from_slice(&len.to_be_bytes());
        buf.extend_from_slice(&align.to_be_bytes());
        buf.extend_from_slice(name_bytes);
        buf.push(0x00);
        buf
    }

    /// Write GOFF ESD for Label Definition.
    pub fn write_goff_ld_esd(&self, name: &str, section_id: u32, offset: u64) -> Vec<u8> {
        let mut buf: Vec<u8> = Vec::new();
        buf.push(0x00); // ESD
        let name_bytes = name.as_bytes();
        let rec_len: u16 = (14 + name_bytes.len() as u16) + 1;
        buf.extend_from_slice(&rec_len.to_be_bytes());
        buf.extend_from_slice(&0u32.to_be_bytes()); // symbol ID
        buf.push(0x01); // LD type
        buf.push(0x00); // binder
        buf.push(0x01); // amode
        buf.push(0x01); // rmode
        buf.extend_from_slice(&section_id.to_be_bytes()); // owning ESD ID
        buf.extend_from_slice(&offset.to_be_bytes()); // offset within section
        buf.extend_from_slice(name_bytes);
        buf.push(0x00);
        buf
    }

    /// Write GOFF ESD for External Definition.
    pub fn write_goff_ed_esd(&self, name: &str) -> Vec<u8> {
        let mut buf: Vec<u8> = Vec::new();
        buf.push(0x00); // ESD
        let name_bytes = name.as_bytes();
        let rec_len: u16 = (14 + name_bytes.len() as u16) + 1;
        buf.extend_from_slice(&rec_len.to_be_bytes());
        buf.extend_from_slice(&0u32.to_be_bytes()); // symbol ID
        buf.push(0x02); // ED type
        buf.push(0x00); // binder
        buf.push(0x01); // amode
        buf.push(0x01); // rmode
        buf.extend_from_slice(&0u32.to_be_bytes()); // owning ESD ID (0)
        buf.extend_from_slice(&0u32.to_be_bytes()); // flags
        buf.extend_from_slice(name_bytes);
        buf.push(0x00);
        buf
    }

    /// Write GOFF ESD for Part Reference (PR).
    pub fn write_goff_pr_esd(&self, name: &str, section_id: u32, offset: u64) -> Vec<u8> {
        let mut buf: Vec<u8> = Vec::new();
        buf.push(0x00); // ESD
        let name_bytes = name.as_bytes();
        let rec_len: u16 = (14 + name_bytes.len() as u16) + 1;
        buf.extend_from_slice(&rec_len.to_be_bytes());
        buf.extend_from_slice(&0u32.to_be_bytes());
        buf.push(0x04); // PR type
        buf.push(0x00);
        buf.push(0x01);
        buf.push(0x01);
        buf.extend_from_slice(&section_id.to_be_bytes());
        buf.extend_from_slice(&offset.to_be_bytes());
        buf.extend_from_slice(name_bytes);
        buf.push(0x00);
        buf
    }

    /// Write GOFF ESD for Part Code (PC).
    pub fn write_goff_pc_esd(&self, name: &str, section_id: u32, offset: u64) -> Vec<u8> {
        let mut buf: Vec<u8> = Vec::new();
        buf.push(0x00);
        let name_bytes = name.as_bytes();
        let rec_len: u16 = (14 + name_bytes.len() as u16) + 1;
        buf.extend_from_slice(&rec_len.to_be_bytes());
        buf.extend_from_slice(&0u32.to_be_bytes());
        buf.push(0x05); // PC type
        buf.push(0x00);
        buf.push(0x01);
        buf.push(0x01);
        buf.extend_from_slice(&section_id.to_be_bytes());
        buf.extend_from_slice(&offset.to_be_bytes());
        buf.extend_from_slice(name_bytes);
        buf.push(0x00);
        buf
    }

    /// Write GOFF END record with a given reason code.
    pub fn write_goff_end_record(&self, reason_code: u8) -> Vec<u8> {
        let mut buf: Vec<u8> = Vec::new();
        buf.push(GOFF_END_REC);
        buf.extend_from_slice(&8u16.to_be_bytes()); // record length
        buf.push(reason_code); // end-of-module = 2, end-of-file = 0
        buf.push(0x00);
        // Flags
        buf.extend_from_slice(&0u32.to_be_bytes());
        buf
    }

    /// Write a DWARF .debug_line.dwo section header.
    pub fn emit_debug_line_dwo(&self, line_program: &[u8]) -> Vec<u8> {
        let mut data: Vec<u8> = Vec::new();
        // DWARF32 unit header for .debug_line.dwo
        data.push(0x05); // version 5
        data.push(0x08); // address_size (8 for 64-bit)
        data.push(0x00); // segment_selector_size
                         // header_length, minimum_instruction_length, etc follow in real impl
        data.extend_from_slice(line_program);
        data
    }

    /// Write a DWARF .debug_addr section.
    pub fn emit_debug_addr(&self, addresses: &[u64]) -> Vec<u8> {
        let mut data: Vec<u8> = Vec::new();
        // DWARF32 .debug_addr header
        let header_size: u32 = 8; // length + version + address_size + segment_sel_size
        data.extend_from_slice(&header_size.to_le_bytes());
        data.extend_from_slice(&5u16.to_le_bytes()); // version 5
        data.push(8); // address_size
        data.push(0); // segment_selector_size
        for &addr in addresses {
            data.extend_from_slice(&addr.to_le_bytes());
        }
        data
    }

    /// Write a DWARF .debug_rnglists.dwo section.
    pub fn emit_debug_rnglists_dwo(&self, ranges: &[u8]) -> Vec<u8> {
        let mut data: Vec<u8> = Vec::new();
        data.extend_from_slice(&0u32.to_le_bytes()); // length placeholder
        data.extend_from_slice(&5u16.to_le_bytes()); // version
        data.push(8); // address_size
        data.push(0); // segment_selector_size
        data.extend_from_slice(&0u32.to_le_bytes()); // offset_entry_count
        data.extend_from_slice(ranges);
        data
    }
}

// ============================================================================
// COFF Auxiliary Symbol Records & Extended Relocation
// ============================================================================

impl ObjectWriter {
    /// Write COFF auxiliary symbol for section definitions.
    pub fn write_coff_aux_section_def(
        &self,
        sec_num: u16,
        sec_size: u32,
        num_relocs: u16,
        num_linenos: u16,
    ) -> Vec<u8> {
        let mut data: Vec<u8> = Vec::new();
        data.extend_from_slice(&sec_size.to_le_bytes()); // Section Length
        data.extend_from_slice(&num_relocs.to_le_bytes()); // Number of Relocations
        data.extend_from_slice(&num_linenos.to_le_bytes()); // Number of Linenumbers
        data.extend_from_slice(&0u32.to_le_bytes()); // CheckSum
        data.extend_from_slice(&sec_num.to_le_bytes()); // Number (section index)
        data.push(0); // Selection (0 for regular)
        data.extend_from_slice(&[0u8; 3]); // reserved
        data
    }

    /// Write COFF auxiliary symbol for function definitions.
    pub fn write_coff_aux_function_def(
        &self,
        tag_index: u32,
        total_size: u32,
        pointer_to_linenumber: u32,
        pointer_to_next_function: u32,
    ) -> Vec<u8> {
        let mut data: Vec<u8> = Vec::new();
        data.extend_from_slice(&tag_index.to_le_bytes());
        data.extend_from_slice(&total_size.to_le_bytes());
        data.extend_from_slice(&pointer_to_linenumber.to_le_bytes());
        data.extend_from_slice(&pointer_to_next_function.to_le_bytes());
        data.extend_from_slice(&[0u8; 2]); // reserved
        data
    }

    /// Write COFF auxiliary symbol for .bf/.ef records.
    pub fn write_coff_aux_bf_ef(&self, unused1: u32, line_number: u16) -> Vec<u8> {
        let mut data: Vec<u8> = Vec::new();
        data.extend_from_slice(&unused1.to_le_bytes());
        data.extend_from_slice(&line_number.to_le_bytes());
        data.extend_from_slice(&[0u8; 6]); // reserved
        data.extend_from_slice(&0u16.to_le_bytes()); // next .bf
        data.extend_from_slice(&[0u8; 2]); // reserved
        data
    }

    /// Write COFF auxiliary symbol for weak externals.
    pub fn write_coff_aux_weak_external(&self, tag_index: u32, characteristics: u32) -> Vec<u8> {
        let mut data: Vec<u8> = Vec::new();
        data.extend_from_slice(&tag_index.to_le_bytes());
        data.extend_from_slice(&characteristics.to_le_bytes());
        data.extend_from_slice(&[0u8; 10]); // reserved
        data
    }

    /// Write COFF auxiliary symbol for files.
    pub fn write_coff_aux_file(&self, filename: &str) -> Vec<u8> {
        let mut data: Vec<u8> = [0u8; 18].to_vec();
        let bytes = filename.as_bytes();
        let copy_len = bytes.len().min(18);
        data[..copy_len].copy_from_slice(&bytes[..copy_len]);
        data
    }

    /// Write COFF relocation with explicit type and symbol index.
    pub fn write_coff_relocation_with_type(
        &self,
        vaddr: u32,
        sym_idx: u32,
        rel_type: u16,
    ) -> Vec<u8> {
        let mut data: Vec<u8> = Vec::new();
        data.extend_from_slice(&vaddr.to_le_bytes());
        data.extend_from_slice(&sym_idx.to_le_bytes());
        data.extend_from_slice(&rel_type.to_le_bytes());
        data
    }

    /// Generate a COFF import library stub.
    pub fn write_coff_import_stub(&self, dll_name: &str, symbol_name: &str) -> Vec<u8> {
        let mut data: Vec<u8> = Vec::new();
        // Simple import thunk: jmp [__imp_symbol]
        // For x86-64: FF 25 00 00 00 00 (jmp [rip+0])
        data.extend_from_slice(&[0xFFu8, 0x25, 0x00, 0x00, 0x00, 0x00]);
        let _ = (dll_name, symbol_name);
        data
    }

    /// Generate a PE import directory entry.
    pub fn write_pe_import_directory_entry(
        &self,
        import_lookup_table_rva: u32,
        timestamp: u32,
        forwarder_chain: u32,
        name_rva: u32,
        import_address_table_rva: u32,
    ) -> Vec<u8> {
        let mut data: Vec<u8> = Vec::new();
        data.extend_from_slice(&import_lookup_table_rva.to_le_bytes());
        data.extend_from_slice(&timestamp.to_le_bytes());
        data.extend_from_slice(&forwarder_chain.to_le_bytes());
        data.extend_from_slice(&name_rva.to_le_bytes());
        data.extend_from_slice(&import_address_table_rva.to_le_bytes());
        data
    }

    /// Generate a PE export directory table.
    pub fn write_pe_export_directory(
        &self,
        characteristics: u32,
        timestamp: u32,
        major_ver: u16,
        minor_ver: u16,
        name_rva: u32,
        ordinal_base: u32,
        num_functions: u32,
        num_names: u32,
        addr_of_functions: u32,
        addr_of_names: u32,
        addr_of_ordinals: u32,
    ) -> Vec<u8> {
        let mut data: Vec<u8> = Vec::new();
        data.extend_from_slice(&characteristics.to_le_bytes());
        data.extend_from_slice(&timestamp.to_le_bytes());
        data.extend_from_slice(&major_ver.to_le_bytes());
        data.extend_from_slice(&minor_ver.to_le_bytes());
        data.extend_from_slice(&name_rva.to_le_bytes());
        data.extend_from_slice(&ordinal_base.to_le_bytes());
        data.extend_from_slice(&num_functions.to_le_bytes());
        data.extend_from_slice(&num_names.to_le_bytes());
        data.extend_from_slice(&addr_of_functions.to_le_bytes());
        data.extend_from_slice(&addr_of_names.to_le_bytes());
        data.extend_from_slice(&addr_of_ordinals.to_le_bytes());
        data
    }

    /// Generate a Mach-O UUID load command.
    pub fn write_macho_uuid_command(&self, uuid: &[u8; 16]) -> Vec<u8> {
        let mut data: Vec<u8> = Vec::new();
        data.extend_from_slice(&0x1Bu32.to_le_bytes()); // LC_UUID
        data.extend_from_slice(&24u32.to_le_bytes()); // cmdsize
        data.extend_from_slice(uuid);
        data
    }

    /// Generate a Mach-O RPATH load command.
    pub fn write_macho_rpath_command(&self, path: &str) -> Vec<u8> {
        let mut data: Vec<u8> = Vec::new();
        let path_bytes = path.as_bytes();
        let cmdsize = 12 + path_bytes.len() + 1;
        data.extend_from_slice(&0x8000001Cu32.to_le_bytes()); // LC_RPATH
        data.extend_from_slice(&(cmdsize as u32).to_le_bytes());
        data.extend_from_slice(&(12u32.to_le_bytes())); // offset to path
        data.extend_from_slice(path_bytes);
        data.push(0);
        data
    }

    /// Generate a Mach-O build version command.
    pub fn write_macho_build_version_command(
        &self,
        platform: u32,
        minos: u32,
        sdk: u32,
        ntools: u32,
    ) -> Vec<u8> {
        let mut data: Vec<u8> = Vec::new();
        data.extend_from_slice(&0x32u32.to_le_bytes()); // LC_BUILD_VERSION
        let cmdsize = 24 + ntools * 8;
        data.extend_from_slice(&cmdsize.to_le_bytes());
        data.extend_from_slice(&platform.to_le_bytes());
        data.extend_from_slice(&minos.to_le_bytes());
        data.extend_from_slice(&sdk.to_le_bytes());
        data.extend_from_slice(&ntools.to_le_bytes());
        data
    }

    /// Generate a Mach-O linkedit data command.
    pub fn write_macho_linkedit_data_command(
        &self,
        cmd: u32,
        dataoff: u32,
        datasize: u32,
    ) -> Vec<u8> {
        let mut buf: Vec<u8> = Vec::new();
        buf.extend_from_slice(&cmd.to_le_bytes());
        buf.extend_from_slice(&16u32.to_le_bytes()); // cmdsize
        buf.extend_from_slice(&dataoff.to_le_bytes());
        buf.extend_from_slice(&datasize.to_le_bytes());
        buf
    }

    /// Write a Mach-O dyld environment command.
    pub fn write_macho_dyld_environment(&self, env: &str) -> Vec<u8> {
        let mut data: Vec<u8> = Vec::new();
        data.extend_from_slice(&0x80000027u32.to_le_bytes()); // LC_DYLD_ENVIRONMENT
        let env_bytes = env.as_bytes();
        data.extend_from_slice(&((12 + env_bytes.len() + 1) as u32).to_le_bytes());
        data.extend_from_slice(&12u32.to_le_bytes()); // offset
        data.extend_from_slice(env_bytes);
        data.push(0);
        data
    }

    /// Write ELF section with content.
    pub fn write_elf_section_content(
        &self,
        name: &str,
        content: &[u8],
        sh_type: u32,
        sh_flags: u64,
        alignment: u64,
    ) -> Vec<u8> {
        let mut data: Vec<u8> = Vec::new();
        // Section header will reference this data; here we just encode the content.
        // Actual section header and offsets are computed during final layout.
        data.extend_from_slice(content);
        let _ = (name, sh_type, sh_flags, alignment);
        data
    }

    /// Write ELF relocation addend as i64 (for RELA format).
    pub fn write_elf_rela_entry(
        &self,
        r_offset: u64,
        r_type: u32,
        r_sym: u32,
        r_addend: i64,
    ) -> Vec<u8> {
        let mut data: Vec<u8> = Vec::new();
        data.extend_from_slice(&r_offset.to_le_bytes());
        let r_info: u64 = ((r_sym as u64) << 32) | (r_type as u64);
        data.extend_from_slice(&r_info.to_le_bytes());
        data.extend_from_slice(&r_addend.to_le_bytes());
        data
    }

    /// Write ELF relocation without addend (for REL format).
    pub fn write_elf_rel_entry(&self, r_offset: u64, r_type: u32, r_sym: u32) -> Vec<u8> {
        let mut data: Vec<u8> = Vec::new();
        data.extend_from_slice(&r_offset.to_le_bytes());
        let r_info: u64 = ((r_sym as u64) << 32) | (r_type as u64);
        data.extend_from_slice(&r_info.to_le_bytes());
        data
    }
}

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

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

    // === ELF64 Writer Tests ===

    #[test]
    fn test_create_object_writer() {
        let writer = ObjectWriter::new(ObjectFormat::ELF, "x86_64-unknown-linux-gnu");
        assert_eq!(writer.format, ObjectFormat::ELF);
        assert_eq!(writer.sections.len(), 0);
        assert_eq!(writer.symbols.len(), 0);
    }

    #[test]
    fn test_add_section() {
        let mut writer = ObjectWriter::new(ObjectFormat::ELF, "x86_64-unknown-linux-gnu");
        let idx = writer.add_section(".text", vec![0x90, 0xC3], SectionFlags::text());
        assert_eq!(idx, 0);
        assert_eq!(writer.sections.len(), 1);
        assert_eq!(writer.sections[0].name, ".text");
        assert_eq!(writer.sections[0].data, vec![0x90, 0xC3]);
    }

    #[test]
    fn test_add_symbol() {
        let mut writer = ObjectWriter::new(ObjectFormat::ELF, "x86_64-unknown-linux-gnu");
        writer.add_symbol("main", 0, 2, SymbolBinding::Global, SymbolType::Func, 1);
        assert_eq!(writer.symbols.len(), 1);
        assert_eq!(writer.symbols[0].name, "main");
        assert_eq!(writer.symbols[0].binding, SymbolBinding::Global);
        assert_eq!(writer.symbols[0].sym_type, SymbolType::Func);
    }

    #[test]
    fn test_add_relocation() {
        let mut writer = ObjectWriter::new(ObjectFormat::ELF, "x86_64-unknown-linux-gnu");
        writer.add_section(".text", vec![0xE9, 0, 0, 0, 0], SectionFlags::text());
        writer.add_symbol("target", 0, 0, SymbolBinding::Global, SymbolType::Func, 0);
        writer.add_relocation(0, 1, 0, RelocationType::R_X86_64_PC32, -4);
        assert_eq!(writer.sections[0].relocations.len(), 1);
        assert_eq!(
            writer.sections[0].relocations[0].rel_type,
            RelocationType::R_X86_64_PC32
        );
    }

    #[test]
    fn test_write_elf_empty() {
        let writer = ObjectWriter::new(ObjectFormat::ELF, "x86_64-unknown-linux-gnu");
        let data = writer.write();
        // Should produce a valid ELF file (at minimum: ELFMAG + header + section headers)
        assert!(data.len() >= 64);
        // Check ELF magic
        assert_eq!(&data[0..4], &[0x7F, b'E', b'L', b'F']);
        // Check class = ELFCLASS64
        assert_eq!(data[4], 2);
        // Check machine = EM_X86_64 (62)
        assert_eq!(u16::from_le_bytes([data[18], data[19]]), 62);
    }

    #[test]
    fn test_write_elf_with_text_section() {
        let mut writer = ObjectWriter::new(ObjectFormat::ELF, "x86_64-unknown-linux-gnu");
        writer.add_section(".text", vec![0x90, 0xC3], SectionFlags::text());
        let data = writer.write();
        assert!(data.len() >= 128); // header + .text data + section headers
                                    // Verify ELF magic
        assert_eq!(&data[0..4], &[0x7F, b'E', b'L', b'F']);
        // Verify .text data appears somewhere after header
        let text_data = vec![0x90, 0xC3];
        let found = data.windows(2).any(|w| w == text_data.as_slice());
        assert!(found, ".text data should appear in the output");
    }

    #[test]
    fn test_write_elf_multiple_sections() {
        let mut writer = ObjectWriter::new(ObjectFormat::ELF, "x86_64-unknown-linux-gnu");
        writer.add_section(".text", vec![0x90, 0xC3], SectionFlags::text());
        writer.add_section(".data", vec![0xDE, 0xAD], SectionFlags::data());
        writer.add_section(".rodata", vec![0x01, 0x02, 0x03], SectionFlags::rodata());
        let data = writer.write();
        assert!(data.len() >= 256);
        assert_eq!(&data[0..4], &[0x7F, b'E', b'L', b'F']);
    }

    #[test]
    fn test_write_elf_aarch64() {
        let writer = ObjectWriter::new(ObjectFormat::ELF, "aarch64-unknown-linux-gnu");
        let data = writer.write();
        // Check machine = EM_AARCH64 (183)
        assert_eq!(u16::from_le_bytes([data[18], data[19]]), 183);
    }

    #[test]
    fn test_write_elf_arm32() {
        let writer = ObjectWriter::new(ObjectFormat::ELF, "arm-unknown-linux-gnueabihf");
        let data = writer.write();
        // Check machine = EM_ARM (40)
        assert_eq!(u16::from_le_bytes([data[18], data[19]]), 40);
    }

    #[test]
    fn test_section_flags_to_elf() {
        let text_flags = SectionFlags::text();
        let elf_flags = text_flags.to_elf_flags();
        assert_eq!(elf_flags & 2, 2); // SHF_ALLOC
        assert_eq!(elf_flags & 4, 4); // SHF_EXECINSTR
        assert_eq!(elf_flags & 1, 0); // not writable

        let data_flags = SectionFlags::data();
        let elf_flags = data_flags.to_elf_flags();
        assert_eq!(elf_flags & 1, 1); // SHF_WRITE
        assert_eq!(elf_flags & 2, 2); // SHF_ALLOC
        assert_eq!(elf_flags & 4, 0); // not executable
    }

    #[test]
    fn test_shstrtab_contains_section_names() {
        let mut writer = ObjectWriter::new(ObjectFormat::ELF, "x86_64-unknown-linux-gnu");
        writer.add_section(".text", vec![0x90], SectionFlags::text());
        writer.add_section(".data", vec![0x42], SectionFlags::data());
        let shstrtab = writer.build_shstrtab();
        let shstrtab_str = String::from_utf8_lossy(&shstrtab);
        assert!(shstrtab_str.contains(".text"));
        assert!(shstrtab_str.contains(".data"));
        assert!(shstrtab_str.contains(".shstrtab"));
        assert!(shstrtab_str.contains(".strtab"));
        assert!(shstrtab_str.contains(".symtab"));
    }

    #[test]
    fn test_strtab_contains_symbol_names() {
        let mut writer = ObjectWriter::new(ObjectFormat::ELF, "x86_64-unknown-linux-gnu");
        writer.add_symbol("main", 0, 10, SymbolBinding::Global, SymbolType::Func, 1);
        writer.add_symbol("printf", 0, 0, SymbolBinding::Global, SymbolType::Func, 0);
        let strtab = writer.build_strtab();
        let strtab_str = String::from_utf8_lossy(&strtab);
        assert!(strtab_str.contains("main"));
        assert!(strtab_str.contains("printf"));
    }

    #[test]
    fn test_symtab_has_null_entry() {
        let mut writer = ObjectWriter::new(ObjectFormat::ELF, "x86_64-unknown-linux-gnu");
        writer.add_symbol("main", 0, 10, SymbolBinding::Global, SymbolType::Func, 1);
        let symtab = writer.build_symtab();
        // Each ELF64 symtab entry is 24 bytes; first entry should be all zeros
        assert_eq!(symtab.len(), 48); // NULL + 1 symbol
        assert_eq!(&symtab[0..24], &[0u8; 24]);
    }

    #[test]
    fn test_relocation_types_have_correct_values() {
        assert_eq!(RelocationType::R_X86_64_NONE.elf_value(), 0);
        assert_eq!(RelocationType::R_X86_64_64.elf_value(), 1);
        assert_eq!(RelocationType::R_X86_64_PC32.elf_value(), 2);
        assert_eq!(RelocationType::R_X86_64_32.elf_value(), 10);
        assert_eq!(RelocationType::R_AARCH64_ABS64.elf_value(), 257);
        assert_eq!(RelocationType::R_AARCH64_CALL26.elf_value(), 283);
        assert_eq!(RelocationType::R_ARM_ABS32.elf_value(), 2);
        assert_eq!(RelocationType::R_ARM_CALL.elf_value(), 28);
    }

    #[test]
    fn test_rela_section_data() {
        let mut writer = ObjectWriter::new(ObjectFormat::ELF, "x86_64-unknown-linux-gnu");
        writer.add_section(".text", vec![0xE9, 0, 0, 0, 0], SectionFlags::text());
        writer.add_symbol("main", 0, 0, SymbolBinding::Global, SymbolType::Func, 1);
        writer.add_relocation(0, 1, 0, RelocationType::R_X86_64_PC32, -4);
        let rela = writer.build_rela_section(0);
        // Each RELA entry is 24 bytes
        assert_eq!(rela.len(), 24);
        // r_offset = 1
        assert_eq!(u64::from_le_bytes(rela[0..8].try_into().unwrap()), 1);
        // r_info (sym=0 << 32 | type=2) = 2
        let r_info = u64::from_le_bytes(rela[8..16].try_into().unwrap());
        assert_eq!(r_info & 0xFFFF_FFFF, 2); // type = R_X86_64_PC32
        assert_eq!(r_info >> 32, 0); // sym index
                                     // r_addend = -4
        assert_eq!(i64::from_le_bytes(rela[16..24].try_into().unwrap()), -4);
    }

    // === Roundtrip: Write then Parse ===

    #[test]
    fn test_roundtrip_elf_write_parse() {
        let mut writer = ObjectWriter::new(ObjectFormat::ELF, "x86_64-unknown-linux-gnu");
        writer.add_section(".text", vec![0x90, 0xC3], SectionFlags::text());
        writer.add_symbol("main", 0, 2, SymbolBinding::Global, SymbolType::Func, 1);
        let data = writer.write();

        // Parse the written data using our existing ObjectFile parser
        let obj = llvm_native_core::object_file::ObjectFile::parse(&data);
        assert!(
            obj.is_some(),
            "ObjectFile::parse should succeed on our written ELF"
        );
        let obj = obj.unwrap();
        assert_eq!(obj.machine_name(), "x86_64");
        assert!(obj.is_valid());
    }

    #[test]
    fn test_roundtrip_elf_aarch64_write_parse() {
        let writer = ObjectWriter::new(ObjectFormat::ELF, "aarch64-unknown-linux-gnu");
        let data = writer.write();

        let obj = llvm_native_core::object_file::ObjectFile::parse(&data);
        assert!(obj.is_some());
        let obj = obj.unwrap();
        assert_eq!(obj.machine_name(), "aarch64");
    }

    // === MachO Writer Tests ===

    #[test]
    fn test_write_macho_empty() {
        let writer = ObjectWriter::new(ObjectFormat::MachO, "x86_64-apple-darwin");
        let data = writer.write();
        // Mach-O magic: 0xFEEDFACF (LE) = CF FA ED FE
        assert_eq!(&data[0..4], &[0xCF, 0xFA, 0xED, 0xFE]);
    }

    #[test]
    fn test_write_macho_header_x86_64() {
        let writer = ObjectWriter::new(ObjectFormat::MachO, "x86_64-apple-darwin");
        let header = writer.write_macho_header(MachOArch::X86_64);
        assert_eq!(header.len(), 32);
        // Check magic (LE)
        let magic = u32::from_le_bytes([header[0], header[1], header[2], header[3]]);
        assert_eq!(magic, macho_const::MH_MAGIC_64);
        // Check cputype
        let cputype = u32::from_le_bytes([header[4], header[5], header[6], header[7]]);
        assert_eq!(cputype, macho_const::CPU_TYPE_X86_64);
    }

    #[test]
    fn test_write_macho_header_arm64() {
        let writer = ObjectWriter::new(ObjectFormat::MachO, "aarch64-apple-darwin");
        let header = writer.write_macho_header(MachOArch::ARM64);
        let cputype = u32::from_le_bytes([header[4], header[5], header[6], header[7]]);
        assert_eq!(cputype, macho_const::CPU_TYPE_ARM64);
    }

    #[test]
    fn test_write_macho_strtab() {
        let writer = ObjectWriter::new(ObjectFormat::MachO, "x86_64-apple-darwin");
        let strings = vec!["_main".to_string(), "_foo".to_string()];
        let strtab = writer.write_macho_strtab(&strings);
        assert_eq!(strtab[0], 0); // leading null
        let s = String::from_utf8_lossy(&strtab);
        assert!(s.contains("_main"));
        assert!(s.contains("_foo"));
    }

    #[test]
    fn test_write_macho_symtab_raw() {
        let writer = ObjectWriter::new(ObjectFormat::MachO, "x86_64-apple-darwin");
        let syms = vec![
            MachoSymbol {
                name: "_main".to_string(),
                n_type: macho_const::N_SECT | macho_const::N_EXT,
                n_sect: 1,
                n_desc: 0,
                n_value: 0x1000,
            },
            MachoSymbol {
                name: "_helper".to_string(),
                n_type: macho_const::N_SECT,
                n_sect: 1,
                n_desc: 0,
                n_value: 0x1010,
            },
        ];
        let raw = writer.write_macho_symtab_raw(&syms);
        // Each nlist_64 entry is 16 bytes
        assert_eq!(raw.len(), 32);
    }

    #[test]
    fn test_write_macho_dysymtab() {
        let writer = ObjectWriter::new(ObjectFormat::MachO, "x86_64-apple-darwin");
        let syms = vec![
            MachoSymbol {
                name: "local".to_string(),
                n_type: macho_const::N_SECT,
                n_sect: 1,
                n_desc: 0,
                n_value: 0x1000,
            },
            MachoSymbol {
                name: "global".to_string(),
                n_type: macho_const::N_SECT | macho_const::N_EXT,
                n_sect: 1,
                n_desc: 0,
                n_value: 0x1010,
            },
        ];
        let dysymtab = writer.write_macho_dysymtab(&syms);
        assert_eq!(dysymtab.len(), 80);
        // Check LC_DYSYMTAB command
        let cmd = u32::from_le_bytes([dysymtab[0], dysymtab[1], dysymtab[2], dysymtab[3]]);
        assert_eq!(cmd, macho_const::LC_DYSYMTAB);
    }

    #[test]
    fn test_write_macho_with_text_section() {
        let mut writer = ObjectWriter::new(ObjectFormat::MachO, "x86_64-apple-darwin");
        writer.add_section("__text", vec![0x90, 0xC3], SectionFlags::text());
        let data = writer.write();
        // Should produce a valid Mach-O file
        assert!(data.len() >= 32);
        // Check Mach-O magic
        assert_eq!(&data[0..4], &[0xCF, 0xFA, 0xED, 0xFE]);
    }

    #[test]
    fn test_macho_arch_cpu_types() {
        assert_eq!(MachOArch::X86_64.cpu_type(), 0x01000007);
        assert_eq!(MachOArch::ARM64.cpu_type(), 0x0100000C);
        assert_eq!(MachOArch::ARM.cpu_type(), 0x0000000C);
    }

    // === COFF Writer Tests ===

    #[test]
    fn test_write_coff_empty() {
        let writer = ObjectWriter::new(ObjectFormat::COFF, "x86_64-pc-windows-msvc");
        let data = writer.write();
        // COFF machine = 0x8664 for AMD64
        assert_eq!(u16::from_le_bytes([data[0], data[1]]), 0x8664);
    }

    #[test]
    fn test_write_coff_with_sections() {
        let mut writer = ObjectWriter::new(ObjectFormat::COFF, "x86_64-pc-windows-msvc");
        writer.add_section(".text", vec![0x90, 0xC3], SectionFlags::text());
        let data = writer.write();
        // Should have machine type + at least 2 sections
        assert!(data.len() >= 20); // COFF header is 20 bytes
    }

    #[test]
    fn test_write_coff_header_x86_64() {
        let writer = ObjectWriter::new(ObjectFormat::COFF, "x86_64-pc-windows-msvc");
        let header = writer.write_coff_header(coff_const::IMAGE_FILE_MACHINE_AMD64, 3, 0);
        assert_eq!(header.len(), 20);
        let machine = u16::from_le_bytes([header[0], header[1]]);
        assert_eq!(machine, coff_const::IMAGE_FILE_MACHINE_AMD64);
        let nsects = u16::from_le_bytes([header[2], header[3]]);
        assert_eq!(nsects, 3);
    }

    #[test]
    fn test_write_coff_header_arm64() {
        let writer = ObjectWriter::new(ObjectFormat::COFF, "aarch64-pc-windows-msvc");
        let header = writer.write_coff_header(coff_const::IMAGE_FILE_MACHINE_ARM64, 2, 0);
        let machine = u16::from_le_bytes([header[0], header[1]]);
        assert_eq!(machine, coff_const::IMAGE_FILE_MACHINE_ARM64);
    }

    #[test]
    fn test_write_coff_section_header() {
        let writer = ObjectWriter::new(ObjectFormat::COFF, "x86_64-pc-windows-msvc");
        let header = writer.write_coff_section_header(
            ".text",
            128,
            64,
            coff_const::IMAGE_SCN_CNT_CODE
                | coff_const::IMAGE_SCN_MEM_EXECUTE
                | coff_const::IMAGE_SCN_MEM_READ,
            2,
        );
        assert_eq!(header.len(), 40);
        // Check name
        let name = String::from_utf8_lossy(&header[0..8]);
        assert!(name.starts_with(".text"));
        // Check characteristics
        let chars = u32::from_le_bytes([header[36], header[37], header[38], header[39]]);
        assert!(chars & coff_const::IMAGE_SCN_CNT_CODE != 0);
    }

    #[test]
    fn test_write_coff_section() {
        let writer = ObjectWriter::new(ObjectFormat::COFF, "x86_64-pc-windows-msvc");
        let data = writer.write_coff_section(
            ".text",
            &[0x90, 0xC3],
            coff_const::IMAGE_SCN_CNT_CODE
                | coff_const::IMAGE_SCN_MEM_EXECUTE
                | coff_const::IMAGE_SCN_MEM_READ,
        );
        assert!(data.len() >= 42); // header (40) + data (2)
    }

    #[test]
    fn test_write_coff_symtab() {
        let writer = ObjectWriter::new(ObjectFormat::COFF, "x86_64-pc-windows-msvc");
        let syms = vec![
            CoffSymbol {
                name: "_main".to_string(),
                value: 0x1000,
                section_number: 1,
                sym_type: 0x20,
                storage_class: coff_const::IMAGE_SYM_CLASS_EXTERNAL,
                aux_count: 0,
            },
            CoffSymbol {
                name: "helper".to_string(),
                value: 0x1010,
                section_number: 1,
                sym_type: 0,
                storage_class: coff_const::IMAGE_SYM_CLASS_STATIC,
                aux_count: 0,
            },
        ];
        let symtab = writer.write_coff_symtab(&syms);
        assert_eq!(symtab.len(), 36); // 2 * 18 bytes
    }

    #[test]
    fn test_write_coff_relocations() {
        let writer = ObjectWriter::new(ObjectFormat::COFF, "x86_64-pc-windows-msvc");
        let relocs = vec![CoffRelocation {
            virtual_address: 5,
            symbol_index: 1,
            rel_type: 1,
        }];
        let data = writer.write_coff_relocations(&relocs);
        assert_eq!(data.len(), 10); // 10 bytes per COFF relocation
    }

    // === Wasm Writer Tests ===

    #[test]
    fn test_write_wasm_empty() {
        let writer = ObjectWriter::new(ObjectFormat::Wasm, "wasm32-unknown-unknown");
        let data = writer.write();
        // Wasm magic
        assert_eq!(&data[0..4], &[0x00, 0x61, 0x73, 0x6D]);
        // Version 1
        assert_eq!(&data[4..8], &1u32.to_le_bytes());
    }

    #[test]
    fn test_write_wasm_module_data() {
        let writer = ObjectWriter::new(ObjectFormat::Wasm, "wasm32-unknown-unknown");
        let sections = vec![
            WasmSection {
                section_type: 1,                    // TYPE
                data: vec![0x01, 0x60, 0x00, 0x00], // 1 type: func () -> ()
            },
            WasmSection {
                section_type: 3,        // FUNCTION
                data: vec![0x01, 0x00], // 1 function, type index 0
            },
        ];
        let data = writer.write_wasm_module_data(&sections);
        assert_eq!(&data[0..4], &[0x00, 0x61, 0x73, 0x6D]);
        assert!(data.len() > 8);
    }

    #[test]
    fn test_leb128_encoding_u32() {
        let mut buf = Vec::new();
        write_leb128_u32(&mut buf, 0);
        assert_eq!(buf, vec![0x00]);

        buf.clear();
        write_leb128_u32(&mut buf, 1);
        assert_eq!(buf, vec![0x01]);

        buf.clear();
        write_leb128_u32(&mut buf, 127);
        assert_eq!(buf, vec![0x7F]);

        buf.clear();
        write_leb128_u32(&mut buf, 128);
        assert_eq!(buf, vec![0x80, 0x01]);

        buf.clear();
        write_leb128_u32(&mut buf, 624485);
        assert_eq!(buf, vec![0xE5, 0x8E, 0x26]);
    }

    #[test]
    fn test_leb128_decoding_u32() {
        let data = vec![0xE5, 0x8E, 0x26];
        let (val, len) = read_leb128_u32(&data).unwrap();
        assert_eq!(val, 624485);
        assert_eq!(len, 3);

        let (val, len) = read_leb128_u32(&[0x00]).unwrap();
        assert_eq!(val, 0);
        assert_eq!(len, 1);
    }

    // === Enhanced ObjectWriter Tests ===

    #[test]
    fn test_object_format_from_target_triple() {
        assert_eq!(
            ObjectFormat::from_target_triple("x86_64-unknown-linux-gnu"),
            ObjectFormat::ELF
        );
        assert_eq!(
            ObjectFormat::from_target_triple("x86_64-apple-darwin"),
            ObjectFormat::MachO
        );
        assert_eq!(
            ObjectFormat::from_target_triple("x86_64-pc-windows-msvc"),
            ObjectFormat::COFF
        );
        assert_eq!(
            ObjectFormat::from_target_triple("wasm32-unknown-unknown"),
            ObjectFormat::Wasm
        );
    }

    #[test]
    fn test_set_target_arch() {
        let mut writer = ObjectWriter::default();
        writer.set_target_arch("aarch64");
        assert!(writer.target_triple.contains("aarch64"));
        assert_eq!(writer.format, ObjectFormat::ELF);

        writer.set_target_arch("arm64");
        assert!(writer.target_triple.contains("aarch64"));
    }

    #[test]
    fn test_set_target_arch_wasm() {
        let mut writer = ObjectWriter::default();
        writer.set_target_arch("wasm32");
        assert!(writer.target_triple.contains("wasm"));
        assert_eq!(writer.format, ObjectFormat::Wasm);
    }

    #[test]
    fn test_add_debug_section() {
        let mut writer = ObjectWriter::new(ObjectFormat::ELF, "x86_64-unknown-linux-gnu");
        writer.add_debug_section(".debug_info", vec![0x01, 0x02, 0x03]);
        assert_eq!(writer.debug_sections.len(), 1);
        assert_eq!(writer.debug_sections[0].0, ".debug_info");
        assert_eq!(writer.debug_sections[0].1, vec![0x01, 0x02, 0x03]);
    }

    #[test]
    fn test_set_section_alignment() {
        let mut writer = ObjectWriter::new(ObjectFormat::ELF, "x86_64-unknown-linux-gnu");
        writer.add_section(".text", vec![0x90], SectionFlags::text());
        writer.set_section_alignment(".text", 64);
        assert_eq!(writer.sections[0].alignment, 64);
    }

    #[test]
    fn test_get_section_size() {
        let mut writer = ObjectWriter::new(ObjectFormat::ELF, "x86_64-unknown-linux-gnu");
        writer.add_section(".text", vec![0x90, 0xC3, 0xCC], SectionFlags::text());
        let size = writer.get_section_size(".text");
        assert_eq!(size, Some(3));
        let size_none = writer.get_section_size(".nonexistent");
        assert_eq!(size_none, None);
    }

    // === BSS Section Test ===

    #[test]
    fn test_add_bss_section() {
        let mut writer = ObjectWriter::new(ObjectFormat::ELF, "x86_64-unknown-linux-gnu");
        let idx = writer.add_bss_section(".bss", 1024);
        assert_eq!(idx, 0);
        assert_eq!(writer.sections[0].name, ".bss");
        assert_eq!(writer.sections[0].section_type, 8); // SHT_NOBITS
        assert_eq!(writer.sections[0].flags.to_elf_flags() & 1, 1); // SHF_WRITE
        assert_eq!(writer.sections[0].data.len(), 1024);
    }

    // === File writing test (uses temp file) ===

    #[test]
    fn test_write_to_file() {
        let writer = ObjectWriter::new(ObjectFormat::ELF, "x86_64-unknown-linux-gnu");
        let tmp_path = "/tmp/test_object_writer_write_to_file.o";
        let result = writer.write_to_file(tmp_path);
        assert!(result.is_ok());
        // Verify the file exists and has valid ELF magic
        let read_back = std::fs::read(tmp_path);
        assert!(read_back.is_ok());
        let data = read_back.unwrap();
        assert_eq!(&data[0..4], &[0x7F, b'E', b'L', b'F']);
        // Cleanup
        let _ = std::fs::remove_file(tmp_path);
    }
}