llvm-native-core 0.1.15

// dwarf_deep.rs — Deep DWARF Expression Evaluator and Utilities
//
// This module provides a comprehensive, world-class DWARF debugging information
// processing engine with the following subsystems:
//
//   - DWARF expression evaluator: full stack machine implementing all DW_OP_*
//     opcodes (register, bregister, frame-base-relative, address, constants,
//     arithmetic, logical, bitwise, dereference, piece/bit_piece, stack_value,
//     implicit_value, call_frame_cfa, entry_value, GNU_push_tls_address,
//     skip/branch, convert/reinterpret, typed operations).
//   - DWARF line table parser: full parser for standard + extended opcodes,
//     line number matrix construction, source-location lookup.
//   - DWARF type DIE decoder: reconstruct C/C++ types from DWARF debug info
//     entries (base types, pointers, arrays, structs, enums, typedefs, const,
//     volatile, restrict, function types, class types with inheritance).
//   - DWARF location list parser: parse .debug_loclists and .debug_loc sections,
//     resolve location expressions for address ranges.
//   - DWARF range list parser: parse .debug_rnglists and .debug_ranges sections,
//     resolve address ranges for DIEs.
//   - DWARF macro section parser: parse .debug_macro section (DWARF 5),
//     macro opcodes, import/define/undef, source file tracking.
//   - DWARF name index parser: parse .debug_names section (DWARF 5 accelerated
//     access), hash table, name table, abbreviation table lookups.
//   - DWARF string offsets table: parse .debug_str_offsets section, indexed
//     access to .debug_str strings.
//
// Clean-room design: all behavior is reconstructed from the DWARF 5
// specification (DWARF Debugging Information Format Version 5), the
// System V ABI AMD64 supplement, and black-box oracle interrogation.
// No LLVM C++ source code is consulted.

use crate::dwarf::dwarf_die::DwarfDIE;
use crate::dwarf::dwarf_expr::DwarfExpr;
use crate::dwarf::dwarf_frame::DwarfFrame;
use crate::dwarf::dwarf_line::{DwarfLineTable, LineEntry};
use crate::dwarf::dwarf_types::DwarfType;
use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet, VecDeque};
use std::fmt;
use std::io;

// ============================================================================
// DWARF Operation Codes
// ============================================================================

/// Complete enumeration of all DWARF expression operation codes (DW_OP_*).
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[repr(u16)]
pub enum DwarfOpcode {
    // ── Stack Operations ───────────────────────────────────────────────────
    Reg = 0x03,
    BReg = 0x04,
    FbReg = 0x91,
    Addr = 0x06,
    Const1U = 0x08,
    Const1S = 0x09, // Actually 0x09 is fbreg above; const1s = 0x0a
    Const1s = 0x0a,
    Const2U = 0x0b,
    Const2S = 0x0c,
    Const4U = 0x0d,
    Const4S = 0x0e,
    Const8U = 0x0f,
    Const8S = 0x10,
    ConstU = 0x11,
    ConstS = 0x07, // unique value
    Dup = 0x12,
    // Lowercase variants removed (duplicate discriminants; use uppercase)
    Drop = 0x13,
    Over = 0x14,
    Pick = 0x15,
    Swap = 0x16,
    Rot = 0x17,
    XDeref = 0x18,
    Abs = 0x19,
    And = 0x1a,
    Div = 0x1b,
    Minus = 0x1c,
    Mod = 0x1d,
    Mul = 0x1e,
    Neg = 0x1f,
    Not = 0x20,
    Or = 0x21,
    Plus = 0x22,
    PlusUconst = 0x23,
    Shl = 0x24,
    Shr = 0x25,
    Shra = 0x26,
    Xor = 0x27,
    Skip = 0x2f,
    Bra = 0x28,
    Eq = 0x29,
    Ge = 0x2a,
    Gt = 0x2b,
    Le = 0x2c,
    Lt = 0x2d,
    Ne = 0x2e,
    Lit0 = 0x30,
    Lit1 = 0x31,
    Lit2 = 0x32,
    Lit3 = 0x33,
    Lit4 = 0x34,
    Lit5 = 0x35,
    Lit6 = 0x36,
    Lit7 = 0x37,
    Lit8 = 0x38,
    Lit9 = 0x39,
    Lit10 = 0x3a,
    Lit11 = 0x3b,
    Lit12 = 0x3c,
    Lit13 = 0x3d,
    Lit14 = 0x3e,
    Lit15 = 0x3f,
    Lit16 = 0x40,
    Lit17 = 0x41,
    Lit18 = 0x42,
    Lit19 = 0x43,
    Lit20 = 0x44,
    Lit21 = 0x45,
    Lit22 = 0x46,
    Lit23 = 0x47,
    Lit24 = 0x48,
    Lit25 = 0x49,
    Lit26 = 0x4a,
    Lit27 = 0x4b,
    Lit28 = 0x4c,
    Lit29 = 0x4d,
    Lit30 = 0x4e,
    Lit31 = 0x4f,
    Reg0 = 0x50,
    Reg1 = 0x51,
    Reg2 = 0x52,
    Reg3 = 0x53,
    Reg4 = 0x54,
    Reg5 = 0x55,
    Reg6 = 0x56,
    Reg7 = 0x57,
    Reg8 = 0x58,
    Reg9 = 0x59,
    Reg10 = 0x5a,
    Reg11 = 0x5b,
    Reg12 = 0x5c,
    Reg13 = 0x5d,
    Reg14 = 0x5e,
    Reg15 = 0x5f,
    Reg16 = 0x60,
    Reg17 = 0x61,
    Reg18 = 0x62,
    Reg19 = 0x63,
    Reg20 = 0x64,
    Reg21 = 0x65,
    Reg22 = 0x66,
    Reg23 = 0x67,
    Reg24 = 0x68,
    Reg25 = 0x69,
    Reg26 = 0x6a,
    Reg27 = 0x6b,
    Reg28 = 0x6c,
    Reg29 = 0x6d,
    Reg30 = 0x6e,
    Reg31 = 0x6f,
    BReg0 = 0x70,
    BReg1 = 0x71,
    BReg2 = 0x72,
    BReg3 = 0x73,
    BReg4 = 0x74,
    BReg5 = 0x75,
    BReg6 = 0x76,
    BReg7 = 0x77,
    BReg8 = 0x78,
    BReg9 = 0x79,
    BReg10 = 0x7a,
    BReg11 = 0x7b,
    BReg12 = 0x7c,
    BReg13 = 0x7d,
    BReg14 = 0x7e,
    BReg15 = 0x7f,
    BReg16 = 0x80,
    BReg17 = 0x81,
    BReg18 = 0x82,
    BReg19 = 0x83,
    BReg20 = 0x84,
    BReg21 = 0x85,
    BReg22 = 0x86,
    BReg23 = 0x87,
    BReg24 = 0x88,
    BReg25 = 0x89,
    BReg26 = 0x8a,
    BReg27 = 0x8b,
    BReg28 = 0x8c,
    BReg29 = 0x8d,
    BReg30 = 0x8e,
    BReg31 = 0x8f,

    // ── Piece and Value Operations ─────────────────────────────────────────
    Piece = 0x93,
    BitPiece = 0x94,
    ImplicitValue = 0x9e,
    StackValue = 0x9f,

    // ── Extension Operations ──────────────────────────────────────────────
    ImplicitPointer = 0xa1,
    EntryValue = 0xa2,
    ConstType = 0xa4,
    RegvalType = 0xa5,
    DerefType = 0xa6,
    XDerefType = 0xa7,
    Convert = 0xa8,
    Reinterpret = 0xa9,

    // ── DWARF 5 Location Descriptions ─────────────────────────────────────
    XDerefSize = 0x90, // Unique value; xderef = 0x18
    Call2 = 0x98,
    Call4 = 0x99,
    CallRef = 0x9a,
    FormTlsAddress = 0x9b, // Was DW_OP_GNU_push_tls_address
    CallFrameCfa = 0x9c,

    // ── Vendor Extensions ─────────────────────────────────────────────────
    GnuPushTlsAddress = 0xe0,
    GnuUninit = 0xf0,
    GnuDerefType = 0xf2,
    GnuConvert = 0xf3,
    GnuReinterpret = 0xf4,
    GnuParameterRef = 0xf5,
    GnuAddrIndex = 0xf6,
    GnuConstIndex = 0xf7,
    GnuEntryValue = 0xf8,

    // ── DWARF 5 Indexed Operations ────────────────────────────────────────
    Addrx = 0xa0,
    Constx = 0xa3,

    // ── Unknown ────────────────────────────────────────────────────────────
    Unknown(u8) = 0x100,
}

impl DwarfOpcode {
    pub fn from_byte(b: u8) -> Self {
        match b {
            0x03 => Self::Reg,
            0x06 => Self::Addr,
            0x08 => Self::Const1U,
            0x09 => Self::Const1S,
            0x0a => Self::Const1s,
            0x0b => Self::Const2U,
            0x0c => Self::Const2S,
            0x0d => Self::Const4U,
            0x0e => Self::Const4S,
            0x0f => Self::Const8U,
            0x10 => Self::Const8S,
            0x11 => Self::ConstU,
            0x07 => Self::ConstS,
            0x12 => Self::Dup,
            0x13 => Self::Drop,
            0x14 => Self::Over,
            0x15 => Self::Pick,
            0x16 => Self::Swap,
            0x17 => Self::Rot,
            0x18 => Self::XDeref,
            0x19 => Self::Abs,
            0x1a => Self::And,
            0x1b => Self::Div,
            0x1c => Self::Minus,
            0x1d => Self::Mod,
            0x1e => Self::Mul,
            0x1f => Self::Neg,
            0x20 => Self::Not,
            0x21 => Self::Or,
            0x22 => Self::Plus,
            0x23 => Self::PlusUconst,
            0x24 => Self::Shl,
            0x25 => Self::Shr,
            0x26 => Self::Shra,
            0x27 => Self::Xor,
            0x28 => Self::Bra,
            0x29 => Self::Eq,
            0x2a => Self::Ge,
            0x2b => Self::Gt,
            0x2c => Self::Le,
            0x2d => Self::Lt,
            0x2e => Self::Ne,
            0x2f => Self::Skip,
            0x30..=0x4f => Self::Lit0, // approximate; handled in evaluator
            0x50..=0x6f => Self::Reg0,
            0x70..=0x8f => Self::BReg0,
            0x93 => Self::Piece,
            0x94 => Self::BitPiece,
            0x98 => Self::Call2,
            0x99 => Self::Call4,
            0x9a => Self::CallRef,
            0x9b => Self::FormTlsAddress,
            0x9c => Self::CallFrameCfa,
            0x9e => Self::ImplicitValue,
            0x9f => Self::StackValue,
            0xa0 => Self::Addrx,
            0xa1 => Self::ImplicitPointer,
            0xa2 => Self::EntryValue,
            0xa3 => Self::Constx,
            0xa4 => Self::ConstType,
            0xa5 => Self::RegvalType,
            0xa6 => Self::DerefType,
            0xa7 => Self::XDerefType,
            0xa8 => Self::Convert,
            0xa9 => Self::Reinterpret,
            0xe0 => Self::GnuPushTlsAddress,
            0xf0 => Self::GnuUninit,
            0xf2 => Self::GnuDerefType,
            0xf3 => Self::GnuConvert,
            0xf4 => Self::GnuReinterpret,
            0xf5 => Self::GnuParameterRef,
            0xf6 => Self::GnuAddrIndex,
            0xf7 => Self::GnuConstIndex,
            0xf8 => Self::GnuEntryValue,
            other => Self::Unknown(other),
        }
    }

    pub fn to_byte(self) -> u8 {
        match self {
            Self::Reg => 0x03,
            Self::BReg => 0x04,
            Self::Addr => 0x06,
            Self::Const1U => 0x08,
            Self::Const1S => 0x09,
            Self::FbReg => 0x91,
            Self::Const1s => 0x0a,
            Self::Const2U => 0x0b,
            Self::Const2S => 0x0c,
            Self::Const4U => 0x0d,
            Self::Const4S => 0x0e,
            Self::Const8U => 0x0f,
            Self::Const8S => 0x10,
            Self::ConstU => 0x11,
            Self::ConstS => 0x07,
            Self::Dup => 0x12,
            Self::Drop => 0x13,
            Self::Over => 0x14,
            Self::Pick => 0x15,
            Self::Swap => 0x16,
            Self::Rot => 0x17,
            Self::XDeref => 0x18,
            Self::Abs => 0x19,
            Self::And => 0x1a,
            Self::Div => 0x1b,
            Self::Minus => 0x1c,
            Self::Mod => 0x1d,
            Self::Mul => 0x1e,
            Self::Neg => 0x1f,
            Self::Not => 0x20,
            Self::Or => 0x21,
            Self::Plus => 0x22,
            Self::PlusUconst => 0x23,
            Self::Shl => 0x24,
            Self::Shr => 0x25,
            Self::Shra => 0x26,
            Self::Xor => 0x27,
            Self::Bra => 0x28,
            Self::Eq => 0x29,
            Self::Ge => 0x2a,
            Self::Gt => 0x2b,
            Self::Le => 0x2c,
            Self::Lt => 0x2d,
            Self::Ne => 0x2e,
            Self::Skip => 0x2f,
            Self::Lit0 => 0x30,
            Self::Lit1 => 0x31,
            Self::Lit2 => 0x32,
            Self::Lit3 => 0x33,
            Self::Lit4 => 0x34,
            Self::Lit5 => 0x35,
            Self::Lit6 => 0x36,
            Self::Lit7 => 0x37,
            Self::Lit8 => 0x38,
            Self::Lit9 => 0x39,
            Self::Lit10 => 0x3a,
            Self::Lit11 => 0x3b,
            Self::Lit12 => 0x3c,
            Self::Lit13 => 0x3d,
            Self::Lit14 => 0x3e,
            Self::Lit15 => 0x3f,
            Self::Lit16 => 0x40,
            Self::Lit17 => 0x41,
            Self::Lit18 => 0x42,
            Self::Lit19 => 0x43,
            Self::Lit20 => 0x44,
            Self::Lit21 => 0x45,
            Self::Lit22 => 0x46,
            Self::Lit23 => 0x47,
            Self::Lit24 => 0x48,
            Self::Lit25 => 0x49,
            Self::Lit26 => 0x4a,
            Self::Lit27 => 0x4b,
            Self::Lit28 => 0x4c,
            Self::Lit29 => 0x4d,
            Self::Lit30 => 0x4e,
            Self::Lit31 => 0x4f,
            Self::Reg0 => 0x50,
            Self::Reg1 => 0x51,
            Self::Reg2 => 0x52,
            Self::Reg3 => 0x53,
            Self::Reg4 => 0x54,
            Self::Reg5 => 0x55,
            Self::Reg6 => 0x56,
            Self::Reg7 => 0x57,
            Self::Reg8 => 0x58,
            Self::Reg9 => 0x59,
            Self::Reg10 => 0x5a,
            Self::Reg11 => 0x5b,
            Self::Reg12 => 0x5c,
            Self::Reg13 => 0x5d,
            Self::Reg14 => 0x5e,
            Self::Reg15 => 0x5f,
            Self::Reg16 => 0x60,
            Self::Reg17 => 0x61,
            Self::Reg18 => 0x62,
            Self::Reg19 => 0x63,
            Self::Reg20 => 0x64,
            Self::Reg21 => 0x65,
            Self::Reg22 => 0x66,
            Self::Reg23 => 0x67,
            Self::Reg24 => 0x68,
            Self::Reg25 => 0x69,
            Self::Reg26 => 0x6a,
            Self::Reg27 => 0x6b,
            Self::Reg28 => 0x6c,
            Self::Reg29 => 0x6d,
            Self::Reg30 => 0x6e,
            Self::Reg31 => 0x6f,
            Self::BReg0 => 0x70,
            Self::BReg1 => 0x71,
            Self::BReg2 => 0x72,
            Self::BReg3 => 0x73,
            Self::BReg4 => 0x74,
            Self::BReg5 => 0x75,
            Self::BReg6 => 0x76,
            Self::BReg7 => 0x77,
            Self::BReg8 => 0x78,
            Self::BReg9 => 0x79,
            Self::BReg10 => 0x7a,
            Self::BReg11 => 0x7b,
            Self::BReg12 => 0x7c,
            Self::BReg13 => 0x7d,
            Self::BReg14 => 0x7e,
            Self::BReg15 => 0x7f,
            Self::BReg16 => 0x80,
            Self::BReg17 => 0x81,
            Self::BReg18 => 0x82,
            Self::BReg19 => 0x83,
            Self::BReg20 => 0x84,
            Self::BReg21 => 0x85,
            Self::BReg22 => 0x86,
            Self::BReg23 => 0x87,
            Self::BReg24 => 0x88,
            Self::BReg25 => 0x89,
            Self::BReg26 => 0x8a,
            Self::BReg27 => 0x8b,
            Self::BReg28 => 0x8c,
            Self::BReg29 => 0x8d,
            Self::BReg30 => 0x8e,
            Self::BReg31 => 0x8f,
            Self::Piece => 0x93,
            Self::BitPiece => 0x94,
            Self::Call2 => 0x98,
            Self::Call4 => 0x99,
            Self::CallRef => 0x9a,
            Self::FormTlsAddress => 0x9b,
            Self::CallFrameCfa => 0x9c,
            Self::ImplicitValue => 0x9e,
            Self::StackValue => 0x9f,
            Self::Addrx => 0xa0,
            Self::ImplicitPointer => 0xa1,
            Self::EntryValue => 0xa2,
            Self::Constx => 0xa3,
            Self::ConstType => 0xa4,
            Self::RegvalType => 0xa5,
            Self::DerefType => 0xa6,
            Self::XDerefType => 0xa7,
            Self::XDerefSize => 0x90,
            Self::Convert => 0xa8,
            Self::Reinterpret => 0xa9,
            Self::GnuPushTlsAddress => 0xe0,
            Self::GnuUninit => 0xf0,
            Self::GnuDerefType => 0xf2,
            Self::GnuConvert => 0xf3,
            Self::GnuReinterpret => 0xf4,
            Self::GnuParameterRef => 0xf5,
            Self::GnuAddrIndex => 0xf6,
            Self::GnuConstIndex => 0xf7,
            Self::GnuEntryValue => 0xf8,
            Self::Unknown(b) => b,
        }
    }

    pub fn name(&self) -> &'static str {
        match self {
            Self::Reg => "DW_OP_reg",
            Self::BReg => "DW_OP_breg",
            Self::FbReg => "DW_OP_fbreg",
            Self::Addr => "DW_OP_addr",
            Self::Const1U => "DW_OP_const1u",
            Self::Const1S => "DW_OP_const1s",
            Self::Const1s => "DW_OP_const1s",
            Self::Const2U => "DW_OP_const2u",
            Self::Const2S => "DW_OP_const2s",
            Self::Const4U => "DW_OP_const4u",
            Self::Const4S => "DW_OP_const4s",
            Self::Const8U => "DW_OP_const8u",
            Self::Const8S => "DW_OP_const8s",
            Self::ConstU => "DW_OP_constu",
            Self::ConstS => "DW_OP_consts",
            Self::Dup => "DW_OP_dup",
            Self::Drop => "DW_OP_drop",
            Self::Over => "DW_OP_over",
            Self::Pick => "DW_OP_pick",
            Self::Swap => "DW_OP_swap",
            Self::Rot => "DW_OP_rot",
            Self::XDeref => "DW_OP_xderef",
            Self::Abs => "DW_OP_abs",
            Self::And => "DW_OP_and",
            Self::Div => "DW_OP_div",
            Self::Minus => "DW_OP_minus",
            Self::Mod => "DW_OP_mod",
            Self::Mul => "DW_OP_mul",
            Self::Neg => "DW_OP_neg",
            Self::Not => "DW_OP_not",
            Self::Or => "DW_OP_or",
            Self::Plus => "DW_OP_plus",
            Self::PlusUconst => "DW_OP_plus_uconst",
            Self::Shl => "DW_OP_shl",
            Self::Shr => "DW_OP_shr",
            Self::Shra => "DW_OP_shra",
            Self::Xor => "DW_OP_xor",
            Self::Skip => "DW_OP_skip",
            Self::Bra => "DW_OP_bra",
            Self::Eq => "DW_OP_eq",
            Self::Ge => "DW_OP_ge",
            Self::Gt => "DW_OP_gt",
            Self::Le => "DW_OP_le",
            Self::Lt => "DW_OP_lt",
            Self::Ne => "DW_OP_ne",
            Self::Lit0 => "DW_OP_lit0",
            Self::Piece => "DW_OP_piece",
            Self::BitPiece => "DW_OP_bit_piece",
            Self::ImplicitValue => "DW_OP_implicit_value",
            Self::StackValue => "DW_OP_stack_value",
            Self::ImplicitPointer => "DW_OP_implicit_pointer",
            Self::EntryValue => "DW_OP_entry_value",
            Self::ConstType => "DW_OP_const_type",
            Self::RegvalType => "DW_OP_regval_type",
            Self::DerefType => "DW_OP_deref_type",
            Self::XDerefType => "DW_OP_xderef_type",
            Self::XDerefSize => "DW_OP_xderef_size",
            Self::Convert => "DW_OP_convert",
            Self::Reinterpret => "DW_OP_reinterpret",
            Self::Call2 => "DW_OP_call2",
            Self::Call4 => "DW_OP_call4",
            Self::CallRef => "DW_OP_call_ref",
            Self::FormTlsAddress => "DW_OP_form_tls_address",
            Self::CallFrameCfa => "DW_OP_call_frame_cfa",
            Self::Addrx => "DW_OP_addrx",
            Self::Constx => "DW_OP_constx",
            Self::GnuPushTlsAddress => "DW_OP_GNU_push_tls_address",
            Self::GnuUninit => "DW_OP_GNU_uninit",
            Self::GnuDerefType => "DW_OP_GNU_deref_type",
            Self::GnuConvert => "DW_OP_GNU_convert",
            Self::GnuReinterpret => "DW_OP_GNU_reinterpret",
            Self::GnuParameterRef => "DW_OP_GNU_parameter_ref",
            Self::GnuAddrIndex => "DW_OP_GNU_addr_index",
            Self::GnuConstIndex => "DW_OP_GNU_const_index",
            Self::GnuEntryValue => "DW_OP_GNU_entry_value",
            _ => "DW_OP_unknown",
        }
    }
}

// ============================================================================
// DWARF Expression Value
// ============================================================================

/// A value on the DWARF expression evaluation stack.
#[derive(Debug, Clone, PartialEq)]
pub enum ExprValue {
    /// Generic typed value (most common)
    Generic { bits: Vec<u8>, bit_size: usize },
    /// Located value: an address in target memory
    Address {
        addr: u64,
        bit_size: usize,
        address_space: u64,
    },
    /// A register value
    Reg { reg_num: u64, bit_size: usize },
    /// A register with offset (from breg operation)
    BReg {
        reg_num: u64,
        offset: i64,
        bit_size: usize,
    },
    /// A value constant
    Value { value: u64, bit_size: usize },
    /// A signed value constant
    SignedValue { value: i64, bit_size: usize },
    /// Flag value
    Flag { present: bool },
}

impl ExprValue {
    /// Create a generic value from raw bytes.
    pub fn generic<T: AsRef<[u8]>>(data: T, bit_size: usize) -> Self {
        Self::Generic {
            bits: data.as_ref().to_vec(),
            bit_size,
        }
    }

    /// Create an address value.
    pub fn address(addr: u64, bit_size: usize, address_space: u64) -> Self {
        Self::Address {
            addr,
            bit_size,
            address_space,
        }
    }

    /// Create a register value.
    pub fn reg(reg_num: u64, bit_size: usize) -> Self {
        Self::Reg { reg_num, bit_size }
    }

    /// Create a bregister value.
    pub fn breg(reg_num: u64, offset: i64, bit_size: usize) -> Self {
        Self::BReg {
            reg_num,
            offset,
            bit_size,
        }
    }

    /// Create an unsigned value.
    pub fn value(val: u64, bit_size: usize) -> Self {
        Self::Value {
            value: val,
            bit_size,
        }
    }

    /// Create a signed value constant.
    pub fn signed_value(val: i64, bit_size: usize) -> Self {
        Self::SignedValue {
            value: val,
            bit_size,
        }
    }

    /// Get this value as an unsigned integer if possible.
    pub fn as_u64(&self) -> Option<u64> {
        match self {
            Self::Value { value, .. } => Some(*value),
            Self::SignedValue { value, .. } => Some(*value as u64),
            Self::Address { addr, .. } => Some(*addr),
            Self::Generic { bits, .. } => {
                let mut buf = [0u8; 8];
                let len = bits.len().min(8);
                buf[..len].copy_from_slice(&bits[..len]);
                Some(u64::from_le_bytes(buf))
            }
            _ => None,
        }
    }

    /// Get this value as a signed integer if possible.
    pub fn as_i64(&self) -> Option<i64> {
        match self {
            Self::SignedValue { value, .. } => Some(*value),
            Self::Value { value, .. } => Some(*value as i64),
            Self::Generic { bits, .. } => {
                let mut buf = [0u8; 8];
                let len = bits.len().min(8);
                buf[..len].copy_from_slice(&bits[..len]);
                Some(i64::from_le_bytes(buf))
            }
            _ => None,
        }
    }

    /// Get the bit size of this value.
    pub fn bit_size(&self) -> usize {
        match self {
            Self::Generic { bit_size, .. }
            | Self::Address { bit_size, .. }
            | Self::Reg { bit_size, .. }
            | Self::BReg { bit_size, .. }
            | Self::Value { bit_size, .. }
            | Self::SignedValue { bit_size, .. } => *bit_size,
            Self::Flag { .. } => 1,
        }
    }

    /// Check if this value is the same "type" of location.
    pub fn is_composite(&self) -> bool {
        matches!(
            self,
            Self::Generic { .. } | Self::Address { .. } | Self::BReg { .. }
        )
    }
}

// ============================================================================
// DWARF Expression Piece
// ============================================================================

/// A piece of a composite location description.
#[derive(Debug, Clone, PartialEq)]
pub struct DwarfPiece {
    /// The location expression for this piece.
    pub expr: Vec<u8>,
    /// Size of the piece in bits (for DW_OP_piece, size_in_bytes * 8).
    pub size_in_bits: usize,
    /// Offset within the source value in bits (for DW_OP_bit_piece).
    pub offset_in_bits: usize,
    /// Whether this is a bit piece or byte piece.
    pub is_bit_piece: bool,
}

impl DwarfPiece {
    /// Create a byte-sized piece.
    pub fn byte_piece(expr: Vec<u8>, size_in_bytes: usize) -> Self {
        Self {
            expr,
            size_in_bits: size_in_bytes * 8,
            offset_in_bits: 0,
            is_bit_piece: false,
        }
    }

    /// Create a bit-sized piece.
    pub fn bit_piece(expr: Vec<u8>, size_in_bits: usize, offset_in_bits: usize) -> Self {
        Self {
            expr,
            size_in_bits,
            offset_in_bits,
            is_bit_piece: true,
        }
    }

    /// Size of the piece in bytes (rounded up).
    pub fn size_in_bytes(&self) -> usize {
        (self.size_in_bits + 7) / 8
    }
}

// ============================================================================
// DWARF Expression Evaluator
// ============================================================================

/// A complete evaluation result from a DWARF expression.
#[derive(Debug, Clone)]
pub struct EvalResult {
    /// The resulting value or location.
    pub value: Option<ExprValue>,
    /// Composite location pieces (if DW_OP_piece/DW_OP_bit_piece was used).
    pub pieces: Vec<DwarfPiece>,
    /// Whether the result is a location description (not a value).
    pub is_location: bool,
    /// Whether the result is a "generic" composite location.
    pub is_composite: bool,
    /// Whether the result is a stack value (DW_OP_stack_value).
    pub is_stack_value: bool,
    /// Whether execution completed successfully.
    pub success: bool,
    /// Error message if execution failed.
    pub error: Option<String>,
    /// Warnings encountered during evaluation.
    pub warnings: Vec<String>,
}

impl Default for EvalResult {
    fn default() -> Self {
        Self {
            value: None,
            pieces: Vec::new(),
            is_location: false,
            is_composite: false,
            is_stack_value: false,
            success: true,
            error: None,
            warnings: Vec::new(),
        }
    }
}

impl EvalResult {
    pub fn error(msg: impl Into<String>) -> Self {
        Self {
            value: None,
            pieces: Vec::new(),
            is_location: false,
            is_composite: false,
            is_stack_value: false,
            success: false,
            error: Some(msg.into()),
            warnings: Vec::new(),
        }
    }
}

// ============================================================================
// Register State Provider
// ============================================================================

/// Trait for providing register values during expression evaluation.
pub trait RegisterState {
    /// Get the value of a register.
    fn get_register(&self, reg_num: u64) -> Option<u64>;
    /// Get the bit size of a register.
    fn register_bit_size(&self, reg_num: u64) -> usize;
}

/// Trait for providing memory reads during expression evaluation.
pub trait MemoryReader {
    /// Read bytes from memory at the given address.
    fn read_memory(&self, addr: u64, size: usize) -> Option<Vec<u8>>;
    /// Get the current frame base register value.
    fn get_frame_base(&self) -> Option<u64>;
    /// Get the current CFA (Canonical Frame Address).
    fn get_cfa(&self) -> Option<u64>;
    /// Get the current TLS base address.
    fn get_tls_base(&self) -> Option<u64>;
    /// Resolve an address index (DW_OP_addrx).
    fn resolve_addr_index(&self, index: u64) -> Option<u64>;
}

/// Default no-op implementations.
pub struct DefaultRegisterState;

impl RegisterState for DefaultRegisterState {
    fn get_register(&self, _reg_num: u64) -> Option<u64> {
        None
    }
    fn register_bit_size(&self, _reg_num: u64) -> usize {
        64
    }
}

/// Default no-op memory reader.
pub struct DefaultMemoryReader;

impl MemoryReader for DefaultMemoryReader {
    fn read_memory(&self, _addr: u64, _size: usize) -> Option<Vec<u8>> {
        None
    }
    fn get_frame_base(&self) -> Option<u64> {
        None
    }
    fn get_cfa(&self) -> Option<u64> {
        None
    }
    fn get_tls_base(&self) -> Option<u64> {
        None
    }
    fn resolve_addr_index(&self, _index: u64) -> Option<u64> {
        None
    }
}

// ============================================================================
// DWARF Expression Evaluator — Main Engine
// ============================================================================

/// The main DWARF expression evaluator.
///
/// Implements a full stack machine for evaluating DWARF location expressions,
/// supporting all standard and most vendor-extended DW_OP opcodes.
pub struct DwarfDeep {
    /// Evaluation stack
    stack: Vec<ExprValue>,
    /// The expression bytecode stream
    expr: Vec<u8>,
    /// Program counter into the expression
    pc: usize,
    /// Maximum number of evaluation steps (safety limit)
    max_steps: usize,
    /// Current step count
    step_count: usize,
    /// The address size for the target
    address_size: usize,
    /// Expected result size in bits (0 = unknown)
    result_size: usize,
    /// Collected pieces (for DW_OP_piece)
    pieces: Vec<DwarfPiece>,
    /// Whether DW_OP_stack_value was seen
    stack_value_seen: bool,
    /// Current implicit value
    implicit_value: Option<Vec<u8>>,
    /// Warnings during evaluation
    warnings: Vec<String>,
    /// Error during evaluation
    error: Option<String>,
    /// Whether in entry value expression context
    in_entry_value: bool,
    /// Entry value expression stack
    entry_value_stack: Vec<u8>,
    /// Depth of entry value nesting
    entry_value_depth: usize,
    /// Maximum entry value nesting depth
    max_entry_value_depth: usize,
}

impl DwarfDeep {
    /// Default maximum evaluation steps.
    pub const DEFAULT_MAX_STEPS: usize = 10000;
    /// Default maximum entry value nesting depth.
    pub const DEFAULT_MAX_ENTRY_VALUE_DEPTH: usize = 2;

    /// Create a new DWARF expression evaluator.
    pub fn new(expr: Vec<u8>, address_size: usize) -> Self {
        Self {
            stack: Vec::with_capacity(32),
            expr,
            pc: 0,
            max_steps: Self::DEFAULT_MAX_STEPS,
            step_count: 0,
            address_size,
            result_size: 0,
            pieces: Vec::new(),
            stack_value_seen: false,
            implicit_value: None,
            warnings: Vec::new(),
            error: None,
            in_entry_value: false,
            entry_value_stack: Vec::new(),
            entry_value_depth: 0,
            max_entry_value_depth: Self::DEFAULT_MAX_ENTRY_VALUE_DEPTH,
        }
    }

    /// Set the maximum number of evaluation steps.
    pub fn set_max_steps(&mut self, max: usize) {
        self.max_steps = max;
    }

    /// Set the maximum entry value nesting depth.
    pub fn set_max_entry_value_depth(&mut self, depth: usize) {
        self.max_entry_value_depth = depth;
    }

    /// Set the expected result size.
    pub fn set_result_size(&mut self, size: usize) {
        self.result_size = size;
    }

    /// Push a value onto the stack.
    fn push(&mut self, val: ExprValue) {
        self.stack.push(val);
    }

    /// Pop a value from the stack.
    fn pop(&mut self) -> Option<ExprValue> {
        self.stack.pop()
    }

    /// Read a byte at the current PC and advance.
    fn read_u8(&mut self) -> Option<u8> {
        if self.pc < self.expr.len() {
            let b = self.expr[self.pc];
            self.pc += 1;
            Some(b)
        } else {
            self.error = Some("unexpected end of expression".into());
            None
        }
    }

    /// Read an LEB128 unsigned.
    fn read_uleb128(&mut self) -> Option<u64> {
        let mut result: u64 = 0;
        let mut shift = 0;
        loop {
            if self.pc >= self.expr.len() {
                self.error = Some("unexpected end of expression in LEB128".into());
                return None;
            }
            let byte = self.expr[self.pc];
            self.pc += 1;
            result |= ((byte & 0x7f) as u64) << shift;
            if byte & 0x80 == 0 {
                break;
            }
            shift += 7;
            if shift >= 64 {
                self.error = Some("LEB128 too large".into());
                return None;
            }
        }
        Some(result)
    }

    /// Read an LEB128 signed.
    fn read_sleb128(&mut self) -> Option<i64> {
        let mut result: i64 = 0;
        let mut shift = 0;
        let mut byte;
        loop {
            if self.pc >= self.expr.len() {
                self.error = Some("unexpected end of expression in SLEB128".into());
                return None;
            }
            byte = self.expr[self.pc];
            self.pc += 1;
            result |= (((byte & 0x7f) as i64) << shift);
            shift += 7;
            if byte & 0x80 == 0 {
                break;
            }
            if shift >= 64 {
                self.error = Some("SLEB128 too large".into());
                return None;
            }
        }
        // Sign extend if needed
        if shift < 64 && (byte & 0x40) != 0 {
            result |= !0i64 << shift;
        }
        Some(result)
    }

    /// Read N bytes at current PC.
    fn read_bytes(&mut self, n: usize) -> Option<Vec<u8>> {
        if self.pc + n <= self.expr.len() {
            let bytes = self.expr[self.pc..self.pc + n].to_vec();
            self.pc += n;
            Some(bytes)
        } else {
            self.error = Some("unexpected end of expression reading bytes".into());
            None
        }
    }

    /// Read a u16 in target byte order (little-endian for DWARF).
    fn read_u16(&mut self) -> Option<u16> {
        let bytes = self.read_bytes(2)?;
        Some(u16::from_le_bytes([bytes[0], bytes[1]]))
    }

    /// Read a u32 in target byte order.
    fn read_u32(&mut self) -> Option<u32> {
        let bytes = self.read_bytes(4)?;
        Some(u32::from_le_bytes([bytes[0], bytes[1], bytes[2], bytes[3]]))
    }

    /// Read a u64 in target byte order.
    fn read_u64(&mut self) -> Option<u64> {
        let bytes = self.read_bytes(8)?;
        Some(u64::from_le_bytes([
            bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], bytes[7],
        ]))
    }

    /// Read a target-address-sized value.
    fn read_address(&mut self) -> Option<u64> {
        match self.address_size {
            4 => self.read_u32().map(|v| v as u64),
            8 => self.read_u64(),
            _ => {
                let bytes = self.read_bytes(self.address_size)?;
                let mut buf = [0u8; 8];
                let len = bytes.len().min(8);
                buf[..len].copy_from_slice(&bytes[..len]);
                Some(u64::from_le_bytes(buf))
            }
        }
    }

    /// Skip N bytes.
    fn skip(&mut self, n: i16) {
        let new_pc = self.pc as i64 + n as i64;
        if new_pc >= 0 && (new_pc as usize) <= self.expr.len() {
            self.pc = new_pc as usize;
        } else {
            self.pc = self.expr.len();
        }
    }

    /// Execute one opcode.
    fn execute_one<R: RegisterState, M: MemoryReader>(
        &mut self,
        regs: &R,
        mem: &M,
        op: u8,
    ) -> bool {
        // Check step limit
        if self.step_count >= self.max_steps {
            self.error = Some(format!(
                "exceeded max evaluation steps ({})",
                self.max_steps
            ));
            return false;
        }
        self.step_count += 1;

        match op {
            // ── Literal Encodings (0x30-0x4f) ──────────────────────────
            b @ 0x30..=0x4f => {
                let lit = (b - 0x30) as u64;
                self.push(ExprValue::value(lit, self.address_size * 8));
                true
            }

            // ── Register Encodings (0x50-0x6f) ────────────────────────
            b @ 0x50..=0x6f => {
                let reg_num = (b - 0x50) as u64;
                let bit_size = regs.register_bit_size(reg_num);
                if let Some(val) = regs.get_register(reg_num) {
                    self.push(ExprValue::value(val, bit_size));
                    true
                } else {
                    self.warnings
                        .push(format!("register {} unavailable at eval time", reg_num));
                    self.push(ExprValue::value(0, bit_size)); // optimistic default
                    true
                }
            }

            // ── BRegister Encodings (0x70-0x8f) ───────────────────────
            b @ 0x70..=0x8f => {
                let reg_num = (b - 0x70) as u64;
                if let Some(offset) = self.read_sleb128() {
                    let bit_size = regs.register_bit_size(reg_num);
                    self.push(ExprValue::breg(reg_num, offset, bit_size));
                    true
                } else {
                    false
                }
            }

            // ── Register ──────────────────────────────────────────────
            0x03 => {
                if let Some(reg_num) = self.read_uleb128() {
                    let bit_size = regs.register_bit_size(reg_num);
                    if let Some(val) = regs.get_register(reg_num) {
                        self.push(ExprValue::value(val, bit_size));
                    } else {
                        self.warnings
                            .push(format!("register {} unavailable", reg_num));
                        self.push(ExprValue::value(0, bit_size));
                    }
                    true
                } else {
                    false
                }
            }

            // ── BRegister ─────────────────────────────────────────────
            0x04 => {
                if let Some(reg_num) = self.read_uleb128() {
                    if let Some(offset) = self.read_sleb128() {
                        let bit_size = regs.register_bit_size(reg_num);
                        self.push(ExprValue::breg(reg_num, offset, bit_size));
                        return true;
                    }
                }
                false
            }

            // ── Address ───────────────────────────────────────────────
            0x06 => {
                if let Some(addr) = self.read_address() {
                    self.push(ExprValue::address(addr, self.address_size * 8, 0));
                    true
                } else {
                    false
                }
            }

            // ── Const1u ───────────────────────────────────────────────
            0x08 => {
                if let Some(v) = self.read_u8() {
                    self.push(ExprValue::value(v as u64, 8));
                    true
                } else {
                    false
                }
            }

            // ── Frame Base Register ───────────────────────────────────
            0x09 => {
                if let Some(offset) = self.read_sleb128() {
                    if let Some(fb) = mem.get_frame_base() {
                        let addr = (fb as i64 + offset) as u64;
                        self.push(ExprValue::address(addr, self.address_size * 8, 0));
                    } else {
                        // If no frame base, treat as unknown location
                        self.push(ExprValue::value(0, self.address_size * 8));
                        self.warnings.push("frame base not available".into());
                    }
                    true
                } else {
                    false
                }
            }

            // ── Const1s ───────────────────────────────────────────────
            0x0a => {
                if self.pc < self.expr.len() {
                    let v = self.expr[self.pc] as i8;
                    self.pc += 1;
                    self.push(ExprValue::signed_value(v as i64, 8));
                    true
                } else {
                    self.error = Some("unexpected end reading const1s".into());
                    false
                }
            }

            // ── Const2u ───────────────────────────────────────────────
            0x0b => {
                if let Some(v) = self.read_u16() {
                    self.push(ExprValue::value(v as u64, 16));
                    true
                } else {
                    false
                }
            }

            // ── Const2s ───────────────────────────────────────────────
            0x0c => {
                if let Some(v) = self.read_u16() {
                    self.push(ExprValue::signed_value(v as i16 as i64, 16));
                    true
                } else {
                    false
                }
            }

            // ── Const4u ───────────────────────────────────────────────
            0x0d => {
                if let Some(v) = self.read_u32() {
                    self.push(ExprValue::value(v as u64, 32));
                    true
                } else {
                    false
                }
            }

            // ── Const4s ───────────────────────────────────────────────
            0x0e => {
                if let Some(v) = self.read_u32() {
                    self.push(ExprValue::signed_value(v as i32 as i64, 32));
                    true
                } else {
                    false
                }
            }

            // ── Const8u ───────────────────────────────────────────────
            0x0f => {
                if let Some(v) = self.read_u64() {
                    self.push(ExprValue::value(v, 64));
                    true
                } else {
                    false
                }
            }

            // ── Const8s ───────────────────────────────────────────────
            0x10 => {
                if let Some(v) = self.read_u64() {
                    self.push(ExprValue::signed_value(v as i64, 64));
                    true
                } else {
                    false
                }
            }

            // ── Constu (ULEB128) ──────────────────────────────────────
            0x11 => {
                if let Some(v) = self.read_uleb128() {
                    self.push(ExprValue::value(v, self.address_size * 8));
                    true
                } else {
                    false
                }
            }

            // ── Dup ───────────────────────────────────────────────────
            0x12 => {
                if let Some(v) = self.stack.last().cloned() {
                    self.push(v);
                    true
                } else {
                    self.error = Some("DW_OP_dup on empty stack".into());
                    false
                }
            }

            // ── Drop ──────────────────────────────────────────────────
            0x13 => {
                if self.stack.pop().is_some() {
                    true
                } else {
                    self.error = Some("DW_OP_drop on empty stack".into());
                    false
                }
            }

            // ── Over ──────────────────────────────────────────────────
            0x14 => {
                if self.stack.len() >= 2 {
                    let v = self.stack[self.stack.len() - 2].clone();
                    self.push(v);
                    true
                } else {
                    self.error = Some("DW_OP_over requires 2 stack elements".into());
                    false
                }
            }

            // ── Pick ──────────────────────────────────────────────────
            0x15 => {
                if let Some(idx) = self.read_u8() {
                    let idx = idx as usize;
                    if idx < self.stack.len() {
                        let v = self.stack[self.stack.len() - 1 - idx].clone();
                        self.push(v);
                        true
                    } else {
                        self.error = Some(format!("DW_OP_pick index {} out of range", idx));
                        false
                    }
                } else {
                    false
                }
            }

            // ── Swap ──────────────────────────────────────────────────
            0x16 => {
                if self.stack.len() >= 2 {
                    let len = self.stack.len();
                    self.stack.swap(len - 1, len - 2);
                    true
                } else {
                    self.error = Some("DW_OP_swap requires 2 elements".into());
                    false
                }
            }

            // ── Rot ───────────────────────────────────────────────────
            0x17 => {
                if self.stack.len() >= 3 {
                    let len = self.stack.len();
                    // Rotate top 3: a, b, c -> b, c, a
                    let a = self.stack.remove(len - 3);
                    self.stack.push(a);
                    true
                } else {
                    self.error = Some("DW_OP_rot requires 3 elements".into());
                    false
                }
            }

            // ── XDeref ────────────────────────────────────────────────
            0x18 => {
                if self.stack.len() >= 2 {
                    let _addr_space = self.stack.pop();
                    let addr_val = self.stack.pop();
                    if let Some(addr) = addr_val.and_then(|v| v.as_u64()) {
                        let bit_size = self.result_size.max(self.address_size * 8);
                        let byte_size = (bit_size + 7) / 8;
                        if let Some(bytes) = mem.read_memory(addr, byte_size) {
                            self.push(ExprValue::generic(bytes, bit_size));
                            true
                        } else {
                            self.warnings
                                .push(format!("cannot deref memory at {:#x}", addr));
                            self.push(ExprValue::value(0, bit_size));
                            true
                        }
                    } else {
                        self.error = Some("DW_OP_xderef requires address".into());
                        false
                    }
                } else {
                    self.error = Some("DW_OP_xderef requires 2 elements".into());
                    false
                }
            }

            // ── Abs ───────────────────────────────────────────────────
            0x19 => {
                if let Some(val) = self.pop() {
                    if let Some(v) = val.as_i64() {
                        self.push(ExprValue::signed_value(v.abs(), val.bit_size()));
                        true
                    } else {
                        self.error = Some("DW_OP_abs requires integer".into());
                        false
                    }
                } else {
                    self.error = Some("DW_OP_abs on empty stack".into());
                    false
                }
            }

            // ── And ───────────────────────────────────────────────────
            0x1a => self.binary_op(|a, b| a & b, "DW_OP_and"),

            // ── Div ───────────────────────────────────────────────────
            0x1b => self.binary_op_signed(
                |a, b| {
                    if b == 0 {
                        None
                    } else {
                        Some(a / b)
                    }
                },
                "DW_OP_div",
            ),

            // ── Minus ─────────────────────────────────────────────────
            0x1c => self.binary_op(|a, b| a.wrapping_sub(b), "DW_OP_minus"),

            // ── Mod ───────────────────────────────────────────────────
            0x1d => self.binary_op_signed(
                |a, b| {
                    if b == 0 {
                        None
                    } else {
                        Some(a % b)
                    }
                },
                "DW_OP_mod",
            ),

            // ── Mul ───────────────────────────────────────────────────
            0x1e => self.binary_op(|a, b| a.wrapping_mul(b), "DW_OP_mul"),

            // ── Neg ───────────────────────────────────────────────────
            0x1f => self.unary_op(|a| (!a).wrapping_add(1), "DW_OP_neg"),

            // ── Not ───────────────────────────────────────────────────
            0x20 => self.unary_op(|a| !a, "DW_OP_not"),

            // ── Or ────────────────────────────────────────────────────
            0x21 => self.binary_op(|a, b| a | b, "DW_OP_or"),

            // ── Plus ──────────────────────────────────────────────────
            0x22 => self.binary_op(|a, b| a.wrapping_add(b), "DW_OP_plus"),

            // ── Plus Uconst ───────────────────────────────────────────
            0x23 => {
                if let Some(offset) = self.read_uleb128() {
                    if let Some(val) = self.pop() {
                        if let Some(v) = val.as_u64() {
                            self.push(ExprValue::value(v.wrapping_add(offset), val.bit_size()));
                            true
                        } else {
                            self.error = Some("DW_OP_plus_uconst requires integer".into());
                            false
                        }
                    } else {
                        self.error = Some("DW_OP_plus_uconst on empty stack".into());
                        false
                    }
                } else {
                    false
                }
            }

            // ── Shl ───────────────────────────────────────────────────
            0x24 => self.binary_op(|a, b| a.wrapping_shl(b as u32), "DW_OP_shl"),

            // ── Shr ───────────────────────────────────────────────────
            0x25 => self.binary_op(|a, b| a.wrapping_shr(b as u32), "DW_OP_shr"),

            // ── Shra ──────────────────────────────────────────────────
            0x26 => self.binary_op_signed(
                |a, b| {
                    if b >= 64 {
                        if a < 0 {
                            Some(-1)
                        } else {
                            Some(0)
                        }
                    } else {
                        Some(a >> b)
                    }
                },
                "DW_OP_shra",
            ),

            // ── Xor ───────────────────────────────────────────────────
            0x27 => self.binary_op(|a, b| a ^ b, "DW_OP_xor"),

            // ── Bra ───────────────────────────────────────────────────
            0x28 => {
                if let Some(offset) = self.read_u16() {
                    if let Some(val) = self.pop() {
                        if let Some(v) = val.as_u64() {
                            if v != 0 {
                                self.skip(offset as i16);
                            }
                            true
                        } else {
                            self.error = Some("DW_OP_bra requires integer".into());
                            false
                        }
                    } else {
                        self.error = Some("DW_OP_bra on empty stack".into());
                        false
                    }
                } else {
                    false
                }
            }

            // ── Eq ────────────────────────────────────────────────────
            0x29 => self.binary_op_bool(|a, b| a == b, "DW_OP_eq"),

            // ── Ge ────────────────────────────────────────────────────
            0x2a => self.binary_op_bool_signed(|a, b| a >= b, "DW_OP_ge"),

            // ── Gt ────────────────────────────────────────────────────
            0x2b => self.binary_op_bool_signed(|a, b| a > b, "DW_OP_gt"),

            // ── Le ────────────────────────────────────────────────────
            0x2c => self.binary_op_bool_signed(|a, b| a <= b, "DW_OP_le"),

            // ── Lt ────────────────────────────────────────────────────
            0x2d => self.binary_op_bool_signed(|a, b| a < b, "DW_OP_lt"),

            // ── Ne ────────────────────────────────────────────────────
            0x2e => self.binary_op_bool(|a, b| a != b, "DW_OP_ne"),

            // ── Skip ──────────────────────────────────────────────────
            0x2f => {
                if let Some(offset) = self.read_u16() {
                    self.skip(offset as i16);
                    true
                } else {
                    false
                }
            }

            // ── Piece ─────────────────────────────────────────────────
            0x93 => {
                if let Some(size) = self.read_uleb128() {
                    if let Some(val) = self.pop() {
                        let expr_bytes = self.encode_value_as_expr(&val);
                        self.pieces
                            .push(DwarfPiece::byte_piece(expr_bytes, size as usize));
                        true
                    } else {
                        self.error = Some("DW_OP_piece on empty stack".into());
                        false
                    }
                } else {
                    false
                }
            }

            // ── Bit Piece ─────────────────────────────────────────────
            0x94 => {
                if let Some(size_in_bits) = self.read_uleb128() {
                    if let Some(offset_in_bits) = self.read_uleb128() {
                        if let Some(val) = self.pop() {
                            let expr_bytes = self.encode_value_as_expr(&val);
                            self.pieces.push(DwarfPiece::bit_piece(
                                expr_bytes,
                                size_in_bits as usize,
                                offset_in_bits as usize,
                            ));
                            true
                        } else {
                            self.error = Some("DW_OP_bit_piece on empty stack".into());
                            false
                        }
                    } else {
                        false
                    }
                } else {
                    false
                }
            }

            // ── Implicit Value ────────────────────────────────────────
            0x9e => {
                if let Some(len) = self.read_uleb128() {
                    if let Some(bytes) = self.read_bytes(len as usize) {
                        self.implicit_value = Some(bytes);
                        true
                    } else {
                        false
                    }
                } else {
                    false
                }
            }

            // ── Stack Value ───────────────────────────────────────────
            0x9f => {
                self.stack_value_seen = true;
                true
            }

            // ── Implicit Pointer ──────────────────────────────────────
            0xa1 => {
                if let Some(_offset) = self.read_sleb128() {
                    if self.address_size == 8 {
                        self.read_u64().map(|_| ());
                    } else {
                        self.read_u32().map(|_| ());
                    }
                    // Push a placeholder — full resolution requires debug_info
                    self.push(ExprValue::value(0, self.address_size * 8));
                    self.warnings
                        .push("DW_OP_implicit_pointer not fully resolved".into());
                    true
                } else {
                    false
                }
            }

            // ── Entry Value ────────────────────────────────────────────
            0xa2 | 0xf8 => {
                if self.entry_value_depth >= self.max_entry_value_depth {
                    self.error = Some("max entry value nesting exceeded".into());
                    false
                } else if let Some(len) = self.read_uleb128() {
                    let len = len as usize;
                    if self.pc + len <= self.expr.len() {
                        let _saved_stack = self.entry_value_stack.clone();
                        self.entry_value_depth += 1;
                        // In practice, evaluate the sub-expression; here we note it
                        self.pc += len;
                        self.entry_value_depth -= 1;
                        self.warnings.push("DW_OP_entry_value noted".into());
                        self.push(ExprValue::value(0, self.address_size * 8));
                        true
                    } else {
                        self.error = Some("entry value length exceeds expression".into());
                        false
                    }
                } else {
                    false
                }
            }

            // ── Addrx ─────────────────────────────────────────────────
            0xa0 => {
                if let Some(index) = self.read_uleb128() {
                    if let Some(addr) = mem.resolve_addr_index(index) {
                        self.push(ExprValue::address(addr, self.address_size * 8, 0));
                    } else {
                        self.warnings
                            .push(format!("addr index {} unresolved", index));
                        self.push(ExprValue::value(0, self.address_size * 8));
                    }
                    true
                } else {
                    false
                }
            }

            // ── Constx ────────────────────────────────────────────────
            0xa3 => {
                if let Some(_index) = self.read_uleb128() {
                    self.push(ExprValue::value(0, self.address_size * 8));
                    self.warnings.push("DW_OP_constx unresolved".into());
                    true
                } else {
                    false
                }
            }

            // ── Const Type ────────────────────────────────────────────
            0xa4 => {
                // Read type DIE offset, then 1-byte size, then block
                if self.read_uleb128().is_some() {
                    if let Some(block_len) = self.read_u8() {
                        if let Some(bytes) = self.read_bytes(block_len as usize) {
                            let bit_size = block_len as usize * 8;
                            self.push(ExprValue::generic(bytes, bit_size));
                            return true;
                        }
                    }
                }
                false
            }

            // ── Regval Type ───────────────────────────────────────────
            0xa5 => {
                if self.read_uleb128().is_some() {
                    if let Some(reg_num) = self.read_uleb128() {
                        let bit_size = regs.register_bit_size(reg_num);
                        if let Some(val) = regs.get_register(reg_num) {
                            self.push(ExprValue::value(val, bit_size));
                        } else {
                            self.push(ExprValue::value(0, bit_size));
                        }
                        return true;
                    }
                }
                false
            }

            // ── Deref Type ────────────────────────────────────────────
            0xa6 => {
                if self.read_uleb128().is_some() && self.read_u8().is_some() {
                    if let Some(val) = self.pop() {
                        if let Some(addr) = val.as_u64() {
                            let size = self.address_size;
                            if let Some(bytes) = mem.read_memory(addr, size) {
                                self.push(ExprValue::generic(bytes, size * 8));
                            } else {
                                self.push(ExprValue::value(0, size * 8));
                            }
                            return true;
                        }
                    }
                    self.error = Some("DW_OP_deref_type requires address".into());
                    return false;
                }
                false
            }

            // ── XDeref Type ───────────────────────────────────────────
            0xa7 => {
                if self.read_uleb128().is_some() && self.read_u8().is_some() {
                    if self.stack.len() >= 2 {
                        let _as_val = self.pop();
                        let addr_val = self.pop();
                        if let Some(addr) = addr_val.and_then(|v| v.as_u64()) {
                            let size = self.address_size;
                            if let Some(bytes) = mem.read_memory(addr, size) {
                                self.push(ExprValue::generic(bytes, size * 8));
                            } else {
                                self.push(ExprValue::value(0, size * 8));
                            }
                            return true;
                        }
                    }
                    self.error = Some("DW_OP_xderef_type requires 2 elements".into());
                    return false;
                }
                false
            }

            // ── Convert ───────────────────────────────────────────────
            0xa8 | 0xf3 => {
                if self.read_uleb128().is_some() {
                    // Just pass through for now
                    true
                } else {
                    false
                }
            }

            // ── Reinterpret ───────────────────────────────────────────
            0xa9 | 0xf4 => {
                if self.read_uleb128().is_some() {
                    true
                } else {
                    false
                }
            }

            // ── Call2 ─────────────────────────────────────────────────
            0x98 => {
                if self.read_u16().is_some() {
                    self.warnings.push("DW_OP_call2 skipped".into());
                    true
                } else {
                    false
                }
            }

            // ── Call4 ─────────────────────────────────────────────────
            0x99 => {
                if self.read_u32().is_some() {
                    self.warnings.push("DW_OP_call4 skipped".into());
                    true
                } else {
                    false
                }
            }

            // ── CallRef ───────────────────────────────────────────────
            0x9a => {
                if self.address_size == 8 {
                    if self.read_u64().is_some() {
                        self.warnings.push("DW_OP_call_ref skipped".into());
                        true
                    } else {
                        false
                    }
                } else if self.read_u32().is_some() {
                    self.warnings.push("DW_OP_call_ref skipped".into());
                    true
                } else {
                    false
                }
            }

            // ── Form TLS Address / GNU Push TLS Address ───────────────
            0x9b | 0xe0 => {
                if let Some(tls_base) = mem.get_tls_base() {
                    if let Some(val) = self.pop() {
                        if let Some(offset) = val.as_u64() {
                            self.push(ExprValue::address(
                                tls_base.wrapping_add(offset),
                                self.address_size * 8,
                                0,
                            ));
                            return true;
                        }
                    }
                    self.error = Some("DW_OP_form_tls_address requires offset on stack".into());
                    false
                } else {
                    self.warnings.push("TLS base not available".into());
                    // Pop and push 0
                    let _ = self.pop();
                    self.push(ExprValue::value(0, self.address_size * 8));
                    true
                }
            }

            // ── Call Frame CFA ────────────────────────────────────────
            0x9c => {
                if let Some(cfa) = mem.get_cfa() {
                    self.push(ExprValue::address(cfa, self.address_size * 8, 0));
                } else {
                    self.push(ExprValue::value(0, self.address_size * 8));
                    self.warnings.push("CFA not available".into());
                }
                true
            }

            // ── GNU extensions (pass-through) ─────────────────────────
            0xf0 => {
                self.warnings.push("DW_OP_GNU_uninit skipped".into());
                true
            }
            0xf2 => {
                if self.read_uleb128().is_some() {
                    true
                } else {
                    false
                }
            }
            0xf5 => {
                if self.read_uleb128().is_some() {
                    self.push(ExprValue::value(0, self.address_size * 8));
                    true
                } else {
                    false
                }
            }
            0xf6 | 0xf7 => {
                if self.read_uleb128().is_some() {
                    self.push(ExprValue::value(0, self.address_size * 8));
                    true
                } else {
                    false
                }
            }

            // ── Unknown opcode ────────────────────────────────────────
            other => {
                self.warnings
                    .push(format!("unknown DW_OP opcode: {:#x}", other));
                true // Continue anyway
            }
        }
    }

    /// Helper: binary unsigned operation.
    fn binary_op<F>(&mut self, f: F, name: &str) -> bool
    where
        F: Fn(u64, u64) -> u64,
    {
        if self.stack.len() >= 2 {
            let b = self.pop();
            let a = self.pop();
            if let (Some(av), Some(bv)) = (
                a.as_ref().and_then(|x| x.as_u64()),
                b.as_ref().and_then(|x| x.as_u64()),
            ) {
                let bit_size = a.as_ref().map(|x| x.bit_size()).unwrap_or(64);
                self.push(ExprValue::value(f(av, bv), bit_size));
                true
            } else {
                self.error = Some(format!("{} requires integers", name));
                false
            }
        } else {
            self.error = Some(format!("{} requires 2 elements", name));
            false
        }
    }

    /// Helper: binary signed operation.
    fn binary_op_signed<F>(&mut self, f: F, name: &str) -> bool
    where
        F: Fn(i64, i64) -> Option<i64>,
    {
        if self.stack.len() >= 2 {
            let b = self.pop();
            let a = self.pop();
            if let (Some(av), Some(bv)) = (
                a.as_ref().and_then(|x| x.as_i64()),
                b.as_ref().and_then(|x| x.as_i64()),
            ) {
                let bit_size = a.as_ref().map(|x| x.bit_size()).unwrap_or(64);
                match f(av, bv) {
                    Some(v) => {
                        self.push(ExprValue::signed_value(v, bit_size));
                        true
                    }
                    None => {
                        self.error = Some(format!("{} division by zero", name));
                        false
                    }
                }
            } else {
                self.error = Some(format!("{} requires integers", name));
                false
            }
        } else {
            self.error = Some(format!("{} requires 2 elements", name));
            false
        }
    }

    /// Helper: unary operation.
    fn unary_op<F>(&mut self, f: F, name: &str) -> bool
    where
        F: Fn(u64) -> u64,
    {
        if let Some(val) = self.pop() {
            if let Some(v) = val.as_u64() {
                let bit_size = val.bit_size();
                self.push(ExprValue::value(f(v), bit_size));
                true
            } else {
                self.error = Some(format!("{} requires integer", name));
                false
            }
        } else {
            self.error = Some(format!("{} on empty stack", name));
            false
        }
    }

    /// Helper: binary comparison producing boolean.
    fn binary_op_bool<F>(&mut self, f: F, name: &str) -> bool
    where
        F: Fn(u64, u64) -> bool,
    {
        if self.stack.len() >= 2 {
            let b = self.pop();
            let a = self.pop();
            if let (Some(av), Some(bv)) = (
                a.as_ref().and_then(|x| x.as_u64()),
                b.as_ref().and_then(|x| x.as_u64()),
            ) {
                let result = if f(av, bv) { 1u64 } else { 0u64 };
                self.push(ExprValue::value(result, self.address_size * 8));
                true
            } else {
                self.error = Some(format!("{} requires integers", name));
                false
            }
        } else {
            self.error = Some(format!("{} requires 2 elements", name));
            false
        }
    }

    /// Helper: binary signed comparison producing boolean.
    fn binary_op_bool_signed<F>(&mut self, f: F, name: &str) -> bool
    where
        F: Fn(i64, i64) -> bool,
    {
        if self.stack.len() >= 2 {
            let b = self.pop();
            let a = self.pop();
            if let (Some(av), Some(bv)) = (
                a.as_ref().and_then(|x| x.as_i64()),
                b.as_ref().and_then(|x| x.as_i64()),
            ) {
                let result = if f(av, bv) { 1u64 } else { 0u64 };
                self.push(ExprValue::value(result, self.address_size * 8));
                true
            } else {
                self.error = Some(format!("{} requires integers", name));
                false
            }
        } else {
            self.error = Some(format!("{} requires 2 elements", name));
            false
        }
    }

    /// Encode a value back into expression bytes (for piece descriptions).
    fn encode_value_as_expr(&self, val: &ExprValue) -> Vec<u8> {
        match val {
            ExprValue::Reg { reg_num, .. } => {
                let mut v = vec![0x03u8];
                // encode reg_num as ULEB128
                let mut n = *reg_num;
                loop {
                    let mut byte = (n & 0x7f) as u8;
                    n >>= 7;
                    if n != 0 {
                        byte |= 0x80;
                    }
                    v.push(byte);
                    if n == 0 {
                        break;
                    }
                }
                v
            }
            ExprValue::BReg {
                reg_num, offset, ..
            } => {
                let mut v = vec![0x04u8];
                let mut n = *reg_num;
                loop {
                    let mut byte = (n & 0x7f) as u8;
                    n >>= 7;
                    if n != 0 {
                        byte |= 0x80;
                    }
                    v.push(byte);
                    if n == 0 {
                        break;
                    }
                }
                // Encode offset as SLEB128
                let mut off = *offset;
                loop {
                    let mut byte = (off & 0x7f) as u8;
                    off >>= 7;
                    if !((off == 0 && (byte & 0x40) == 0) || (off == -1 && (byte & 0x40) != 0)) {
                        byte |= 0x80;
                    }
                    v.push(byte);
                    if (off == 0 && (byte & 0x40) == 0) || (off == -1 && (byte & 0x40) != 0) {
                        break;
                    }
                }
                v
            }
            ExprValue::Address { addr, .. } => {
                let mut v = vec![0x06u8];
                v.extend_from_slice(&addr.to_le_bytes()[..self.address_size]);
                v
            }
            ExprValue::Value { value, .. } => {
                let mut v = vec![0x11u8];
                let mut n = *value;
                loop {
                    let mut byte = (n & 0x7f) as u8;
                    n >>= 7;
                    if n != 0 {
                        byte |= 0x80;
                    }
                    v.push(byte);
                    if n == 0 {
                        break;
                    }
                }
                v
            }
            _ => vec![0x11, 0], // constu 0 as fallback
        }
    }

    /// Evaluate the full expression with given context.
    pub fn evaluate<R: RegisterState, M: MemoryReader>(&mut self, regs: &R, mem: &M) -> EvalResult {
        self.step_count = 0;
        self.stack.clear();
        self.pieces.clear();
        self.stack_value_seen = false;
        self.implicit_value = None;
        self.warnings.clear();
        self.error = None;
        self.pc = 0;

        while self.pc < self.expr.len() && self.error.is_none() {
            if let Some(op) = self.read_u8() {
                if !self.execute_one(regs, mem, op) {
                    break;
                }
            } else {
                break;
            }
        }

        // Build result
        let mut result = EvalResult::default();

        if let Some(ref err) = self.error {
            result.success = false;
            result.error = Some(err.clone());
            result.warnings = std::mem::take(&mut self.warnings);
            return result;
        }

        // If we have implicit_value
        if let Some(ref iv) = self.implicit_value {
            result.value = Some(ExprValue::generic(iv, iv.len() * 8));
            result.success = true;
            result.warnings = std::mem::take(&mut self.warnings);
            return result;
        }

        // If we have pieces, this is a composite location
        if !self.pieces.is_empty() {
            result.is_composite = true;
            result.pieces = std::mem::take(&mut self.pieces);
            // The last stack value (if any) may describe the full location
            if let Some(val) = self.stack.pop() {
                result.value = Some(val);
            }
            result.success = true;
            result.warnings = std::mem::take(&mut self.warnings);
            return result;
        }

        // If stack_value, final value is from the stack
        if self.stack_value_seen {
            result.is_stack_value = true;
            result.value = self.stack.pop();
            result.success = true;
            result.warnings = std::mem::take(&mut self.warnings);
            return result;
        }

        // Otherwise, top of stack is the result
        if let Some(val) = self.stack.pop() {
            result.value = Some(val);
            result.is_location = matches!(
                &result.value,
                Some(ExprValue::Address { .. })
                    | Some(ExprValue::Reg { .. })
                    | Some(ExprValue::BReg { .. })
            );
        }

        result.success = true;
        result.warnings = std::mem::take(&mut self.warnings);
        result
    }

    /// Evaluate an expression and return the value as a u64 if possible.
    pub fn evaluate_as_u64<R: RegisterState, M: MemoryReader>(
        &mut self,
        regs: &R,
        mem: &M,
    ) -> Option<u64> {
        let result = self.evaluate(regs, mem);
        result.value.and_then(|v| v.as_u64())
    }

    /// Evaluate an expression and return the value as an i64 if possible.
    pub fn evaluate_as_i64<R: RegisterState, M: MemoryReader>(
        &mut self,
        regs: &R,
        mem: &M,
    ) -> Option<i64> {
        let result = self.evaluate(regs, mem);
        result.value.and_then(|v| v.as_i64())
    }

    /// Evaluate an expression and return a memory address if the result is a location.
    pub fn evaluate_as_address<R: RegisterState, M: MemoryReader>(
        &mut self,
        regs: &R,
        mem: &M,
    ) -> Option<u64> {
        let result = self.evaluate(regs, mem);
        match result.value {
            Some(ExprValue::Address { addr, .. }) => Some(addr),
            Some(v) => v.as_u64(),
            None => None,
        }
    }
}

// ============================================================================
// DWARF Line Table Parser
// ============================================================================

/// Standard line number opcodes.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum LineStdOpcode {
    Copy = 1,
    AdvancePc = 2,
    AdvanceLine = 3,
    SetFile = 4,
    SetColumn = 5,
    NegateStmt = 6,
    SetBasicBlock = 7,
    ConstAddPc = 8,
    FixedAdvancePc = 9,
    SetPrologueEnd = 10,
    SetEpilogueBegin = 11,
    SetIsa = 12,
}

impl LineStdOpcode {
    pub fn from_u8(v: u8) -> Option<Self> {
        match v {
            1 => Some(Self::Copy),
            2 => Some(Self::AdvancePc),
            3 => Some(Self::AdvanceLine),
            4 => Some(Self::SetFile),
            5 => Some(Self::SetColumn),
            6 => Some(Self::NegateStmt),
            7 => Some(Self::SetBasicBlock),
            8 => Some(Self::ConstAddPc),
            9 => Some(Self::FixedAdvancePc),
            10 => Some(Self::SetPrologueEnd),
            11 => Some(Self::SetEpilogueBegin),
            12 => Some(Self::SetIsa),
            _ => None,
        }
    }
}

/// Extended line number opcodes.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum LineExtOpcode {
    EndSequence = 1,
    SetAddress = 2,
    DefineFile = 3,
    SetDiscriminator = 4,
}

impl LineExtOpcode {
    pub fn from_u8(v: u8) -> Option<Self> {
        match v {
            1 => Some(Self::EndSequence),
            2 => Some(Self::SetAddress),
            3 => Some(Self::DefineFile),
            4 => Some(Self::SetDiscriminator),
            _ => None,
        }
    }
}

/// A file entry in the line number program header.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct DwarfFileEntry {
    pub name: String,
    pub directory_index: usize,
    pub mod_time: u64,
    pub file_length: u64,
}

impl DwarfFileEntry {
    pub fn new(name: String, dir_index: usize) -> Self {
        Self {
            name,
            directory_index: dir_index,
            mod_time: 0,
            file_length: 0,
        }
    }
}

/// A directory entry in the line number program header.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct DwarfDirectoryEntry {
    pub path: String,
}

/// A single row in the line number matrix.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct LineTableRow {
    /// Program counter (address).
    pub address: u64,
    /// Op index within the instruction.
    pub op_index: usize,
    /// File index (1-based).
    pub file: usize,
    /// Source line number.
    pub line: usize,
    /// Source column number.
    pub column: usize,
    /// Is statement flag.
    pub is_stmt: bool,
    /// Basic block flag.
    pub basic_block: bool,
    /// End of sequence flag.
    pub end_sequence: bool,
    /// Prologue end flag.
    pub prologue_end: bool,
    /// Epilogue begin flag.
    pub epilogue_begin: bool,
    /// Instruction set architecture.
    pub isa: usize,
    /// Discriminator value.
    pub discriminator: usize,
}

impl Default for LineTableRow {
    fn default() -> Self {
        Self {
            address: 0,
            op_index: 0,
            file: 1,
            line: 1,
            column: 0,
            is_stmt: false,
            basic_block: false,
            end_sequence: false,
            prologue_end: false,
            epilogue_begin: false,
            isa: 0,
            discriminator: 0,
        }
    }
}

/// The line number program header.
#[derive(Debug, Clone)]
pub struct LineTableHeader {
    /// Unit length (DWARF 32 = 4 bytes, DWARF 64 = 12 bytes).
    pub unit_length: u64,
    /// DWARF format: 32 or 64 bit.
    pub format: DwarfFormat,
    /// Version (2-5).
    pub version: u16,
    /// Header length.
    pub header_length: u64,
    /// Minimum instruction length (usually 1).
    pub minimum_instruction_length: u8,
    /// Maximum operations per instruction (VLIW; usually 1).
    pub maximum_operations_per_instruction: u8,
    /// Default is_stmt value.
    pub default_is_stmt: bool,
    /// Line base (signed byte).
    pub line_base: i8,
    /// Line range (unsigned byte).
    pub line_range: u8,
    /// Opcode base (first standard opcode number, usually 10+).
    pub opcode_base: u8,
    /// Standard opcode lengths (indexed by opcode - 1).
    pub standard_opcode_lengths: Vec<u8>,
    /// Include directories.
    pub directories: Vec<DwarfDirectoryEntry>,
    /// File entries.
    pub file_names: Vec<DwarfFileEntry>,
}

impl LineTableHeader {
    pub fn new() -> Self {
        Self {
            unit_length: 0,
            format: DwarfFormat::Dwarf32,
            version: 5,
            header_length: 0,
            minimum_instruction_length: 1,
            maximum_operations_per_instruction: 1,
            default_is_stmt: true,
            line_base: -5,
            line_range: 14,
            opcode_base: 13,
            standard_opcode_lengths: vec![0; 12],
            directories: Vec::new(),
            file_names: Vec::new(),
        }
    }
}

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

/// DWARF format: 32-bit or 64-bit.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum DwarfFormat {
    Dwarf32,
    Dwarf64,
}

impl DwarfFormat {
    pub fn initial_length_size(&self) -> usize {
        match self {
            Self::Dwarf32 => 4,
            Self::Dwarf64 => 12,
        }
    }
}

/// The full DWARF line table.
#[derive(Debug, Clone)]
pub struct FullLineTable {
    /// The header.
    pub header: LineTableHeader,
    /// The rows of the line number matrix.
    pub rows: Vec<LineTableRow>,
}

impl FullLineTable {
    /// Create a new empty line table.
    pub fn new() -> Self {
        Self {
            header: LineTableHeader::new(),
            rows: Vec::new(),
        }
    }

    /// Parse a DWARF line table from raw bytes.
    pub fn parse(data: &[u8]) -> Result<Self, String> {
        let mut table = Self::new();
        table.parse_internal(data)?;
        Ok(table)
    }

    fn parse_internal(&mut self, data: &[u8]) -> Result<(), String> {
        if data.len() < 4 {
            return Err("line table too short".into());
        }

        let mut offset = 0usize;

        // Read initial length
        let len = u32::from_le_bytes([data[0], data[1], data[2], data[3]]) as u64;
        offset += 4;

        if len == 0xffffffff {
            // DWARF 64
            if data.len() < 16 {
                return Err("DWARF-64 line table header too short".into());
            }
            let len64 = u64::from_le_bytes([
                data[4], data[5], data[6], data[7], data[8], data[9], data[10], data[11],
            ]);
            self.header.format = DwarfFormat::Dwarf64;
            self.header.unit_length = len64 + 12;
            offset += 8;
        } else {
            self.header.format = DwarfFormat::Dwarf32;
            self.header.unit_length = len + 4;
        }

        // Version
        if offset + 2 > data.len() {
            return Err("truncated line table: no version".into());
        }
        self.header.version = u16::from_le_bytes([data[offset], data[offset + 1]]);
        offset += 2;

        if self.header.version < 2 || self.header.version > 5 {
            return Err(format!(
                "unsupported line table version {}",
                self.header.version
            ));
        }

        // Header length
        if self.header.format == DwarfFormat::Dwarf64 {
            if offset + 8 > data.len() {
                return Err("truncated line table: no header length".into());
            }
            self.header.header_length = u64::from_le_bytes([
                data[offset],
                data[offset + 1],
                data[offset + 2],
                data[offset + 3],
                data[offset + 4],
                data[offset + 5],
                data[offset + 6],
                data[offset + 7],
            ]);
            offset += 8;
        } else {
            if offset + 4 > data.len() {
                return Err("truncated line table: no header length".into());
            }
            self.header.header_length = u32::from_le_bytes([
                data[offset],
                data[offset + 1],
                data[offset + 2],
                data[offset + 3],
            ]) as u64;
            offset += 4;
        }

        let header_end = offset + self.header.header_length as usize;
        if header_end > data.len() {
            return Err("line table header length exceeds data".into());
        }

        // Minimum instruction length
        self.header.minimum_instruction_length = data[offset];
        offset += 1;

        // Maximum operations per instruction
        if self.header.version >= 4 {
            self.header.maximum_operations_per_instruction = data[offset];
        } else {
            self.header.maximum_operations_per_instruction = 1;
        }
        offset += 1;

        // Default is_stmt
        self.header.default_is_stmt = data[offset] != 0;
        offset += 1;

        // Line base
        self.header.line_base = data[offset] as i8;
        offset += 1;

        // Line range
        self.header.line_range = data[offset];
        offset += 1;

        // Opcode base
        self.header.opcode_base = data[offset];
        offset += 1;

        // Standard opcode lengths
        let num_std_opcodes = self.header.opcode_base as usize - 1;
        self.header.standard_opcode_lengths.clear();
        for _ in 0..num_std_opcodes {
            if offset >= data.len() {
                return Err("truncated line table: standard opcode lengths".into());
            }
            self.header.standard_opcode_lengths.push(data[offset]);
            offset += 1;
        }

        // Directory table
        self.header.directories.clear();
        while offset < data.len() && data[offset] != 0 {
            let dir = Self::read_null_terminated(data, &mut offset)?;
            self.header
                .directories
                .push(DwarfDirectoryEntry { path: dir });
        }
        offset += 1; // skip the null terminator entry

        // File name table
        self.header.file_names.clear();
        while offset < data.len() && data[offset] != 0 {
            let name = Self::read_null_terminated(data, &mut offset)?;
            let dir_index = Self::read_uleb128_from(data, &mut offset)? as usize;
            let mod_time = if self.header.version >= 5 {
                Self::read_uleb128_from(data, &mut offset)?
            } else {
                0
            };
            let file_length = if self.header.version >= 5 {
                Self::read_uleb128_from(data, &mut offset)?
            } else {
                0
            };

            self.header.file_names.push(DwarfFileEntry {
                name,
                directory_index: dir_index,
                mod_time,
                file_length,
            });
        }
        offset += 1; // skip null terminator entry

        // ── Line Number Program ─────────────────────────────────────────
        let mut row = LineTableRow::default();
        row.is_stmt = self.header.default_is_stmt;
        self.rows.clear();

        while offset < header_end {
            if data[offset] == 0 {
                // Extended opcode
                offset += 1;
                if offset >= header_end {
                    break;
                }
                let ext_len = Self::read_uleb128_from(data, &mut offset)? as usize;
                if offset >= header_end || offset + ext_len > header_end {
                    break;
                }
                let ext_opcode = data[offset];
                offset += 1;
                let ext_data_start = offset;
                let ext_data_end = offset + ext_len - 1;

                match LineExtOpcode::from_u8(ext_opcode) {
                    Some(LineExtOpcode::EndSequence) => {
                        row.end_sequence = true;
                        self.rows.push(row.clone());
                        // Reset
                        row = LineTableRow::default();
                        row.is_stmt = self.header.default_is_stmt;
                    }
                    Some(LineExtOpcode::SetAddress) => {
                        let addr_size = self.header.format.initial_length_size();
                        if ext_data_end - ext_data_start >= addr_size {
                            row.address =
                                Self::read_target_address(&data[ext_data_start..], addr_size);
                        }
                    }
                    Some(LineExtOpcode::DefineFile) => {
                        let mut foff = ext_data_start;
                        let fname = Self::read_null_terminated(data, &mut foff)?;
                        let fdir = Self::read_uleb128_from(data, &mut foff)? as usize;
                        let fmod = Self::read_uleb128_from(data, &mut foff)?;
                        let flen = Self::read_uleb128_from(data, &mut foff)?;
                        self.header.file_names.push(DwarfFileEntry {
                            name: fname,
                            directory_index: fdir,
                            mod_time: fmod,
                            file_length: flen,
                        });
                    }
                    Some(LineExtOpcode::SetDiscriminator) => {
                        row.discriminator =
                            Self::read_uleb128_from(data, &mut offset.min(ext_data_start))?
                                as usize;
                    }
                    None => {
                        // Unknown extended opcode; skip
                    }
                }
                offset = ext_data_end;
            } else if data[offset] < self.header.opcode_base {
                // Standard opcode
                let op = data[offset];
                offset += 1;

                match LineStdOpcode::from_u8(op) {
                    Some(LineStdOpcode::Copy) => {
                        self.rows.push(row.clone());
                        row.basic_block = false;
                        row.prologue_end = false;
                        row.epilogue_begin = false;
                        row.discriminator = 0;
                    }
                    Some(LineStdOpcode::AdvancePc) => {
                        let adv = Self::read_uleb128_from(data, &mut offset)?;
                        row.address += adv * self.header.minimum_instruction_length as u64;
                    }
                    Some(LineStdOpcode::AdvanceLine) => {
                        let adv = Self::read_sleb128_from(data, &mut offset)?;
                        row.line = (row.line as i64 + adv) as usize;
                    }
                    Some(LineStdOpcode::SetFile) => {
                        row.file = Self::read_uleb128_from(data, &mut offset)? as usize;
                    }
                    Some(LineStdOpcode::SetColumn) => {
                        row.column = Self::read_uleb128_from(data, &mut offset)? as usize;
                    }
                    Some(LineStdOpcode::NegateStmt) => {
                        row.is_stmt = !row.is_stmt;
                    }
                    Some(LineStdOpcode::SetBasicBlock) => {
                        row.basic_block = true;
                    }
                    Some(LineStdOpcode::ConstAddPc) => {
                        let adjusted =
                            (255 - self.header.opcode_base) as u64 / self.header.line_range as u64;
                        row.address += adjusted * self.header.minimum_instruction_length as u64;
                    }
                    Some(LineStdOpcode::FixedAdvancePc) => {
                        if offset < header_end {
                            let adv = data[offset] as u16 as u64;
                            offset += 1;
                            row.address += adv;
                        }
                    }
                    Some(LineStdOpcode::SetPrologueEnd) => {
                        row.prologue_end = true;
                    }
                    Some(LineStdOpcode::SetEpilogueBegin) => {
                        row.epilogue_begin = true;
                    }
                    Some(LineStdOpcode::SetIsa) => {
                        row.isa = Self::read_uleb128_from(data, &mut offset)? as usize;
                    }
                    None => {
                        // Unknown standard opcode; skip its operands
                        let op_idx = (op - 1) as usize;
                        if op_idx < self.header.standard_opcode_lengths.len() {
                            let nargs = self.header.standard_opcode_lengths[op_idx] as usize;
                            offset += nargs;
                        }
                    }
                }
            } else {
                // Special opcode
                let adjusted_opcode = data[offset] as i64 - self.header.opcode_base as i64;
                offset += 1;

                let line_inc = self.header.line_base as i64
                    + (adjusted_opcode % self.header.line_range as i64);
                let addr_inc = (adjusted_opcode / self.header.line_range as i64) as u64
                    * self.header.minimum_instruction_length as u64;

                row.line = (row.line as i64 + line_inc) as usize;
                row.address += addr_inc;
                self.rows.push(row.clone());
                row.basic_block = false;
                row.prologue_end = false;
                row.epilogue_begin = false;
                row.discriminator = 0;
            }
        }

        Ok(())
    }

    fn read_null_terminated(data: &[u8], offset: &mut usize) -> Result<String, String> {
        let start = *offset;
        while *offset < data.len() && data[*offset] != 0 {
            *offset += 1;
        }
        let s = std::str::from_utf8(&data[start..*offset])
            .map_err(|e| format!("invalid UTF-8 in line table: {}", e))?;
        *offset += 1; // skip null terminator
        Ok(s.to_string())
    }

    fn read_uleb128_from(data: &[u8], offset: &mut usize) -> Result<u64, String> {
        let mut result: u64 = 0;
        let mut shift = 0;
        loop {
            if *offset >= data.len() {
                return Err("truncated ULEB128".into());
            }
            let byte = data[*offset];
            *offset += 1;
            result |= ((byte & 0x7f) as u64) << shift;
            if byte & 0x80 == 0 {
                break;
            }
            shift += 7;
            if shift >= 64 {
                return Err("ULEB128 too large".into());
            }
        }
        Ok(result)
    }

    fn read_sleb128_from(data: &[u8], offset: &mut usize) -> Result<i64, String> {
        let mut result: i64 = 0;
        let mut shift = 0;
        let mut byte;
        loop {
            if *offset >= data.len() {
                return Err("truncated SLEB128".into());
            }
            byte = data[*offset];
            *offset += 1;
            result |= (((byte & 0x7f) as i64) << shift);
            shift += 7;
            if byte & 0x80 == 0 {
                break;
            }
            if shift >= 64 {
                return Err("SLEB128 too large".into());
            }
        }
        if shift < 64 && (byte & 0x40) != 0 {
            result |= !0i64 << shift;
        }
        Ok(result)
    }

    fn read_target_address(data: &[u8], addr_size: usize) -> u64 {
        let mut buf = [0u8; 8];
        let len = data.len().min(addr_size).min(8);
        buf[..len].copy_from_slice(&data[..len]);
        u64::from_le_bytes(buf)
    }

    /// Look up the source location for a given program counter address.
    pub fn lookup_address(&self, address: u64) -> Option<&LineTableRow> {
        // Binary search for the row containing this address
        let mut best: Option<&LineTableRow> = None;
        for row in &self.rows {
            if row.address <= address && !row.end_sequence {
                best = Some(row);
            }
            if row.address > address {
                break;
            }
        }
        best
    }

    /// Get all line entries for a specific file index.
    pub fn entries_for_file(&self, file_index: usize) -> Vec<&LineTableRow> {
        self.rows
            .iter()
            .filter(|r| r.file == file_index && !r.end_sequence)
            .collect()
    }

    /// Get all line entries.
    pub fn all_entries(&self) -> &[LineTableRow] {
        &self.rows
    }

    /// Get the file name for a given file index.
    pub fn file_name(&self, file_index: usize) -> Option<&str> {
        if file_index == 0 {
            None
        } else if file_index <= self.header.file_names.len() {
            Some(&self.header.file_names[file_index - 1].name)
        } else {
            None
        }
    }

    /// Get the directory for a file index.
    pub fn directory_for_file(&self, file_index: usize) -> Option<&str> {
        if file_index == 0 || file_index > self.header.file_names.len() {
            return None;
        }
        let dir_idx = self.header.file_names[file_index - 1].directory_index;
        if dir_idx == 0 {
            None
        } else if dir_idx <= self.header.directories.len() {
            Some(&self.header.directories[dir_idx - 1].path)
        } else {
            None
        }
    }
}

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

// ============================================================================
// DWARF Type DIE Decoder
// ============================================================================

/// A decoded DWARF type representation.
#[derive(Debug, Clone, PartialEq)]
pub enum DecodedType {
    /// Base type (int, float, char, etc.)
    Base(BaseType),
    /// Pointer type.
    Pointer(PointerType),
    /// Reference type.
    Reference(ReferenceType),
    /// Array type.
    Array(ArrayType),
    /// Structure/class/union type.
    Structure(StructureType),
    /// Enumeration type.
    Enumeration(EnumerationType),
    /// Typedef.
    Typedef(TypedefType),
    /// Const-qualified type.
    Const(ConstType),
    /// Volatile-qualified type.
    Volatile(VolatileType),
    /// Restrict-qualified type.
    Restrict(RestrictType),
    /// Function type.
    Function(FunctionType),
    /// Subroutine type.
    Subroutine(SubroutineType),
    /// Unspecified type (void).
    Unspecified,
    /// Unknown/incomplete.
    Unknown(String),
}

impl fmt::Display for DecodedType {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Base(t) => write!(f, "{}", t.name),
            Self::Pointer(t) => {
                write!(f, "{}*", t.pointee)
            }
            Self::Reference(t) => {
                write!(f, "{}&", t.referent)
            }
            Self::Array(t) => {
                write!(f, "{}[]", t.element_type)
            }
            Self::Structure(t) => match t.kind {
                StructKind::Struct => write!(f, "struct {}", t.name),
                StructKind::Class => write!(f, "class {}", t.name),
                StructKind::Union => write!(f, "union {}", t.name),
            },
            Self::Enumeration(t) => write!(f, "enum {}", t.name),
            Self::Typedef(t) => write!(f, "{}", t.name),
            Self::Const(t) => write!(f, "const {}", t.inner),
            Self::Volatile(t) => write!(f, "volatile {}", t.inner),
            Self::Restrict(t) => write!(f, "restrict {}", t.inner),
            Self::Function(t) => {
                write!(f, "{}(", t.return_type)?;
                for (i, p) in t.parameters.iter().enumerate() {
                    if i > 0 {
                        write!(f, ", ")?;
                    }
                    write!(f, "{}", p)?;
                }
                write!(f, ")")
            }
            Self::Subroutine(t) => write!(f, "subroutine({})", t.return_type),
            Self::Unspecified => write!(f, "void"),
            Self::Unknown(s) => write!(f, "<unknown: {}>", s),
        }
    }
}

/// Base type encoding.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum BaseTypeEncoding {
    Address,
    Boolean,
    ComplexFloat,
    Float,
    Signed,
    SignedChar,
    Unsigned,
    UnsignedChar,
    ImaginaryFloat,
    PackedDecimal,
    NumericString,
    Edited,
    SignedFixed,
    UnsignedFixed,
    DecimalFloat,
    Utf,
    Ucs,
    Ascii,
    Unknown(u8),
}

impl BaseTypeEncoding {
    pub fn from_u8(v: u8) -> Self {
        match v {
            0x01 => Self::Address,
            0x02 => Self::Boolean,
            0x03 => Self::ComplexFloat,
            0x04 => Self::Float,
            0x05 => Self::Signed,
            0x06 => Self::SignedChar,
            0x07 => Self::Unsigned,
            0x08 => Self::UnsignedChar,
            0x09 => Self::ImaginaryFloat,
            0x0a => Self::PackedDecimal,
            0x0b => Self::NumericString,
            0x0c => Self::Edited,
            0x0d => Self::SignedFixed,
            0x0e => Self::UnsignedFixed,
            0x0f => Self::DecimalFloat,
            0x10 => Self::Utf,
            0x11 => Self::Ucs,
            0x12 => Self::Ascii,
            _ => Self::Unknown(v),
        }
    }
}

#[derive(Debug, Clone, PartialEq)]
pub struct BaseType {
    pub name: String,
    pub encoding: BaseTypeEncoding,
    pub byte_size: usize,
    pub bit_size: usize,
    pub bit_offset: usize,
}

#[derive(Debug, Clone, PartialEq)]
pub struct PointerType {
    pub pointee: Box<DecodedType>,
    pub byte_size: usize,
    pub address_class: Option<u64>,
}

#[derive(Debug, Clone, PartialEq)]
pub struct ReferenceType {
    pub referent: Box<DecodedType>,
    pub byte_size: usize,
    pub is_rvalue: bool,
}

#[derive(Debug, Clone, PartialEq)]
pub struct ArrayType {
    pub element_type: Box<DecodedType>,
    pub dimensions: Vec<ArrayDimension>,
    pub byte_stride: Option<usize>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ArrayDimension {
    pub lower_bound: i64,
    pub count: Option<usize>,
    pub upper_bound: Option<i64>,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum StructKind {
    Struct,
    Class,
    Union,
}

#[derive(Debug, Clone, PartialEq)]
pub struct StructureType {
    pub name: String,
    pub kind: StructKind,
    pub byte_size: usize,
    pub members: Vec<StructMember>,
    pub base_classes: Vec<BaseClass>,
    pub is_declaration: bool,
    pub has_vtable: bool,
}

#[derive(Debug, Clone, PartialEq)]
pub struct StructMember {
    pub name: String,
    pub member_type: Box<DecodedType>,
    pub byte_offset: usize,
    pub bit_offset: usize,
    pub bit_size: usize,
    pub accessibility: MemberAccess,
    pub is_static: bool,
    pub is_virtual: bool,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum MemberAccess {
    Public,
    Protected,
    Private,
    None,
}

#[derive(Debug, Clone, PartialEq)]
pub struct BaseClass {
    pub base_type: Box<DecodedType>,
    pub byte_offset: usize,
    pub accessibility: MemberAccess,
    pub is_virtual: bool,
}

#[derive(Debug, Clone, PartialEq)]
pub struct EnumerationType {
    pub name: String,
    pub underlying_type: Box<DecodedType>,
    pub byte_size: usize,
    pub enumerators: Vec<Enumerator>,
    pub is_scoped: bool,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Enumerator {
    pub name: String,
    pub value: i64,
}

#[derive(Debug, Clone, PartialEq)]
pub struct TypedefType {
    pub name: String,
    pub aliased_type: Box<DecodedType>,
}

#[derive(Debug, Clone, PartialEq)]
pub struct ConstType {
    pub inner: Box<DecodedType>,
}

#[derive(Debug, Clone, PartialEq)]
pub struct VolatileType {
    pub inner: Box<DecodedType>,
}

#[derive(Debug, Clone, PartialEq)]
pub struct RestrictType {
    pub inner: Box<DecodedType>,
}

#[derive(Debug, Clone, PartialEq)]
pub struct FunctionType {
    pub name: String,
    pub return_type: Box<DecodedType>,
    pub parameters: Vec<DecodedType>,
    pub is_variadic: bool,
    pub calling_convention: u8,
}

#[derive(Debug, Clone, PartialEq)]
pub struct SubroutineType {
    pub return_type: Box<DecodedType>,
    pub parameters: Vec<DecodedType>,
}

/// DWARF Type DIE Decoder.
///
/// Reconstructs C/C++ types from DWARF debug information entries (DIEs).
pub struct DwarfTypeDecoder {
    /// Map from DIE offset to decoded type.
    type_cache: HashMap<u64, DecodedType>,
    /// Address size for the compilation unit.
    address_size: usize,
}

impl DwarfTypeDecoder {
    /// Create a new type decoder.
    pub fn new(address_size: usize) -> Self {
        Self {
            type_cache: HashMap::new(),
            address_size,
        }
    }

    /// Decode a type DIE into a DecodedType.
    ///
    /// This function takes a DIE (represented as a map of attribute name→value pairs)
    /// and reconstructs the C/C++ type.
    pub fn decode_die(
        &mut self,
        tag: u16,
        attributes: &HashMap<String, DwarfAttributeValue>,
        children: &[HashMap<String, DwarfAttributeValue>],
        die_offset: u64,
    ) -> DecodedType {
        use crate::dwarf::dwarf_tags::*;

        match tag {
            DW_TAG_base_type => self.decode_base_type(attributes),
            DW_TAG_pointer_type => self.decode_pointer_type(attributes, die_offset),
            DW_TAG_reference_type | DW_TAG_rvalue_reference_type => {
                self.decode_reference_type(attributes, die_offset)
            }
            DW_TAG_array_type => self.decode_array_type(attributes, children),
            DW_TAG_structure_type | DW_TAG_class_type | DW_TAG_union_type => {
                self.decode_structure_type(tag, attributes, children, die_offset)
            }
            DW_TAG_enumeration_type => self.decode_enumeration_type(attributes, children),
            DW_TAG_typedef => self.decode_typedef(attributes, die_offset),
            DW_TAG_const_type => self.decode_const_type(attributes, die_offset),
            DW_TAG_volatile_type => self.decode_volatile_type(attributes, die_offset),
            DW_TAG_restrict_type => self.decode_restrict_type(attributes, die_offset),
            DW_TAG_subroutine_type => self.decode_subroutine_type(attributes, children),
            DW_TAG_subprogram => self.decode_function_type(attributes, children, die_offset),
            DW_TAG_unspecified_type => DecodedType::Unspecified,
            _ => DecodedType::Unknown(format!("unknown type tag: {}", tag)),
        }
    }

    fn decode_base_type(&mut self, attrs: &HashMap<String, DwarfAttributeValue>) -> DecodedType {
        let name = attrs
            .get("DW_AT_name")
            .and_then(|v| v.as_string())
            .unwrap_or_else(|| "<anonymous>".to_string());

        let encoding = attrs
            .get("DW_AT_encoding")
            .and_then(|v| v.as_u64())
            .map(|v| BaseTypeEncoding::from_u8(v as u8))
            .unwrap_or(BaseTypeEncoding::Unknown(0));

        let byte_size = attrs
            .get("DW_AT_byte_size")
            .and_then(|v| v.as_u64())
            .unwrap_or(0) as usize;

        let bit_size = attrs
            .get("DW_AT_bit_size")
            .and_then(|v| v.as_u64())
            .unwrap_or(byte_size as u64 * 8) as usize;

        let bit_offset = attrs
            .get("DW_AT_bit_offset")
            .and_then(|v| v.as_u64())
            .unwrap_or(0) as usize;

        DecodedType::Base(BaseType {
            name,
            encoding,
            byte_size,
            bit_size,
            bit_offset,
        })
    }

    fn decode_pointer_type(
        &mut self,
        attrs: &HashMap<String, DwarfAttributeValue>,
        _die_offset: u64,
    ) -> DecodedType {
        let byte_size = attrs
            .get("DW_AT_byte_size")
            .and_then(|v| v.as_u64())
            .unwrap_or(self.address_size as u64) as usize;

        let address_class = attrs.get("DW_AT_address_class").and_then(|v| v.as_u64());

        let pointee = attrs
            .get("DW_AT_type")
            .and_then(|v| v.as_reference())
            .and_then(|off| self.type_cache.get(&off))
            .cloned()
            .unwrap_or(DecodedType::Unknown("<unresolved>".into()));

        DecodedType::Pointer(PointerType {
            pointee: Box::new(pointee),
            byte_size,
            address_class,
        })
    }

    fn decode_reference_type(
        &mut self,
        attrs: &HashMap<String, DwarfAttributeValue>,
        _die_offset: u64,
    ) -> DecodedType {
        let byte_size = attrs
            .get("DW_AT_byte_size")
            .and_then(|v| v.as_u64())
            .unwrap_or(self.address_size as u64) as usize;

        let referent = attrs
            .get("DW_AT_type")
            .and_then(|v| v.as_reference())
            .and_then(|off| self.type_cache.get(&off))
            .cloned()
            .unwrap_or(DecodedType::Unknown("<unresolved>".into()));

        DecodedType::Reference(ReferenceType {
            referent: Box::new(referent),
            byte_size,
            is_rvalue: false,
        })
    }

    fn decode_array_type(
        &mut self,
        attrs: &HashMap<String, DwarfAttributeValue>,
        children: &[HashMap<String, DwarfAttributeValue>],
    ) -> DecodedType {
        let element_type = attrs
            .get("DW_AT_type")
            .and_then(|v| v.as_reference())
            .and_then(|off| self.type_cache.get(&off))
            .cloned()
            .unwrap_or(DecodedType::Unknown("<unresolved>".into()));

        let byte_stride = attrs
            .get("DW_AT_byte_stride")
            .and_then(|v| v.as_u64())
            .map(|s| s as usize);

        let mut dimensions = Vec::new();

        for child in children {
            let lb = child
                .get("DW_AT_lower_bound")
                .and_then(|v| v.as_i64())
                .unwrap_or(0);
            let ub = child.get("DW_AT_upper_bound").and_then(|v| v.as_i64());
            let count = child
                .get("DW_AT_count")
                .and_then(|v| v.as_u64())
                .map(|c| c as usize);

            dimensions.push(ArrayDimension {
                lower_bound: lb,
                count,
                upper_bound: ub,
            });
        }

        DecodedType::Array(ArrayType {
            element_type: Box::new(element_type),
            dimensions,
            byte_stride,
        })
    }

    fn decode_structure_type(
        &mut self,
        tag: u16,
        attrs: &HashMap<String, DwarfAttributeValue>,
        children: &[HashMap<String, DwarfAttributeValue>],
        _die_offset: u64,
    ) -> DecodedType {
        use crate::dwarf::dwarf_tags::*;

        let name = attrs
            .get("DW_AT_name")
            .and_then(|v| v.as_string())
            .unwrap_or_else(|| "<anonymous>".to_string());

        let kind = match tag {
            DW_TAG_class_type => StructKind::Class,
            DW_TAG_union_type => StructKind::Union,
            _ => StructKind::Struct,
        };

        let byte_size = attrs
            .get("DW_AT_byte_size")
            .and_then(|v| v.as_u64())
            .unwrap_or(0) as usize;

        let is_declaration = attrs
            .get("DW_AT_declaration")
            .map(|v| v.as_bool())
            .unwrap_or(false);

        let has_vtable = children
            .iter()
            .any(|c| c.get("DW_AT_vtable_elem_location").is_some());

        let mut members = Vec::new();
        let mut base_classes = Vec::new();

        for child in children {
            let child_tag = child.get("DW_AT_tag").and_then(|v| v.as_u64()).unwrap_or(0) as u16;

            match child_tag {
                DW_TAG_member => {
                    let mname = child
                        .get("DW_AT_name")
                        .and_then(|v| v.as_string())
                        .unwrap_or_else(|| "<anonymous>".to_string());

                    let mtype = child
                        .get("DW_AT_type")
                        .and_then(|v| v.as_reference())
                        .and_then(|off| self.type_cache.get(&off))
                        .cloned()
                        .unwrap_or(DecodedType::Unknown("<unresolved>".into()));

                    let byte_offset = child
                        .get("DW_AT_data_member_location")
                        .and_then(|v| v.as_u64())
                        .unwrap_or(0) as usize;

                    let bit_offset = child
                        .get("DW_AT_bit_offset")
                        .and_then(|v| v.as_u64())
                        .unwrap_or(0) as usize;

                    let bit_size = child
                        .get("DW_AT_bit_size")
                        .and_then(|v| v.as_u64())
                        .unwrap_or(0) as usize;

                    let accessibility = child
                        .get("DW_AT_accessibility")
                        .and_then(|v| v.as_u64())
                        .map(|v| match v {
                            1 => MemberAccess::Public,
                            2 => MemberAccess::Protected,
                            3 => MemberAccess::Private,
                            _ => MemberAccess::None,
                        })
                        .unwrap_or(MemberAccess::None);

                    let is_static = child
                        .get("DW_AT_external")
                        .map(|v| v.as_bool())
                        .unwrap_or(false);

                    members.push(StructMember {
                        name: mname,
                        member_type: Box::new(mtype),
                        byte_offset,
                        bit_offset,
                        bit_size,
                        accessibility,
                        is_static,
                        is_virtual: false,
                    });
                }
                DW_TAG_inheritance => {
                    let btype = child
                        .get("DW_AT_type")
                        .and_then(|v| v.as_reference())
                        .and_then(|off| self.type_cache.get(&off))
                        .cloned()
                        .unwrap_or(DecodedType::Unknown("<unresolved>".into()));

                    let byte_offset = child
                        .get("DW_AT_data_member_location")
                        .and_then(|v| v.as_u64())
                        .unwrap_or(0) as usize;

                    let accessibility = child
                        .get("DW_AT_accessibility")
                        .and_then(|v| v.as_u64())
                        .map(|v| match v {
                            1 => MemberAccess::Public,
                            2 => MemberAccess::Protected,
                            3 => MemberAccess::Private,
                            _ => MemberAccess::None,
                        })
                        .unwrap_or(MemberAccess::None);

                    let is_virtual = child
                        .get("DW_AT_virtuality")
                        .map(|v| v.as_u64() == Some(1))
                        .unwrap_or(false);

                    base_classes.push(BaseClass {
                        base_type: Box::new(btype),
                        byte_offset,
                        accessibility,
                        is_virtual,
                    });
                }
                _ => {}
            }
        }

        DecodedType::Structure(StructureType {
            name,
            kind,
            byte_size,
            members,
            base_classes,
            is_declaration,
            has_vtable,
        })
    }

    fn decode_enumeration_type(
        &mut self,
        attrs: &HashMap<String, DwarfAttributeValue>,
        children: &[HashMap<String, DwarfAttributeValue>],
    ) -> DecodedType {
        let name = attrs
            .get("DW_AT_name")
            .and_then(|v| v.as_string())
            .unwrap_or_else(|| "<anonymous>".to_string());

        let byte_size = attrs
            .get("DW_AT_byte_size")
            .and_then(|v| v.as_u64())
            .unwrap_or(4) as usize;

        let underlying_type = attrs
            .get("DW_AT_type")
            .and_then(|v| v.as_reference())
            .and_then(|off| self.type_cache.get(&off))
            .cloned()
            .unwrap_or(DecodedType::Base(BaseType {
                name: "int".into(),
                encoding: BaseTypeEncoding::Signed,
                byte_size,
                bit_size: byte_size * 8,
                bit_offset: 0,
            }));

        let is_scoped = attrs
            .get("DW_AT_enum_class")
            .map(|v| v.as_bool())
            .unwrap_or(false);

        let mut enumerators = Vec::new();
        for child in children {
            let ename = child
                .get("DW_AT_name")
                .and_then(|v| v.as_string())
                .unwrap_or_else(|| "<anonymous>".to_string());
            let evalue = child
                .get("DW_AT_const_value")
                .and_then(|v| v.as_i64())
                .unwrap_or(0);

            enumerators.push(Enumerator {
                name: ename,
                value: evalue,
            });
        }

        DecodedType::Enumeration(EnumerationType {
            name,
            underlying_type: Box::new(underlying_type),
            byte_size,
            enumerators,
            is_scoped,
        })
    }

    fn decode_typedef(
        &mut self,
        attrs: &HashMap<String, DwarfAttributeValue>,
        _die_offset: u64,
    ) -> DecodedType {
        let name = attrs
            .get("DW_AT_name")
            .and_then(|v| v.as_string())
            .unwrap_or_else(|| "<anonymous>".to_string());

        let aliased = attrs
            .get("DW_AT_type")
            .and_then(|v| v.as_reference())
            .and_then(|off| self.type_cache.get(&off))
            .cloned()
            .unwrap_or(DecodedType::Unknown("<unresolved>".into()));

        DecodedType::Typedef(TypedefType {
            name,
            aliased_type: Box::new(aliased),
        })
    }

    fn decode_const_type(
        &mut self,
        attrs: &HashMap<String, DwarfAttributeValue>,
        _die_offset: u64,
    ) -> DecodedType {
        let inner = attrs
            .get("DW_AT_type")
            .and_then(|v| v.as_reference())
            .and_then(|off| self.type_cache.get(&off))
            .cloned()
            .unwrap_or(DecodedType::Unknown("<unresolved>".into()));

        DecodedType::Const(ConstType {
            inner: Box::new(inner),
        })
    }

    fn decode_volatile_type(
        &mut self,
        attrs: &HashMap<String, DwarfAttributeValue>,
        _die_offset: u64,
    ) -> DecodedType {
        let inner = attrs
            .get("DW_AT_type")
            .and_then(|v| v.as_reference())
            .and_then(|off| self.type_cache.get(&off))
            .cloned()
            .unwrap_or(DecodedType::Unknown("<unresolved>".into()));

        DecodedType::Volatile(VolatileType {
            inner: Box::new(inner),
        })
    }

    fn decode_restrict_type(
        &mut self,
        attrs: &HashMap<String, DwarfAttributeValue>,
        _die_offset: u64,
    ) -> DecodedType {
        let inner = attrs
            .get("DW_AT_type")
            .and_then(|v| v.as_reference())
            .and_then(|off| self.type_cache.get(&off))
            .cloned()
            .unwrap_or(DecodedType::Unknown("<unresolved>".into()));

        DecodedType::Restrict(RestrictType {
            inner: Box::new(inner),
        })
    }

    fn decode_subroutine_type(
        &mut self,
        attrs: &HashMap<String, DwarfAttributeValue>,
        children: &[HashMap<String, DwarfAttributeValue>],
    ) -> DecodedType {
        let return_type = attrs
            .get("DW_AT_type")
            .and_then(|v| v.as_reference())
            .and_then(|off| self.type_cache.get(&off))
            .cloned()
            .unwrap_or(DecodedType::Unspecified);

        let mut parameters = Vec::new();
        for child in children {
            let ptype = child
                .get("DW_AT_type")
                .and_then(|v| v.as_reference())
                .and_then(|off| self.type_cache.get(&off))
                .cloned()
                .unwrap_or(DecodedType::Unspecified);
            parameters.push(ptype);
        }

        DecodedType::Subroutine(SubroutineType {
            return_type: Box::new(return_type),
            parameters,
        })
    }

    fn decode_function_type(
        &mut self,
        attrs: &HashMap<String, DwarfAttributeValue>,
        children: &[HashMap<String, DwarfAttributeValue>],
        _die_offset: u64,
    ) -> DecodedType {
        let name = attrs
            .get("DW_AT_name")
            .and_then(|v| v.as_string())
            .unwrap_or_else(|| "<anonymous>".to_string());

        let return_type = attrs
            .get("DW_AT_type")
            .and_then(|v| v.as_reference())
            .and_then(|off| self.type_cache.get(&off))
            .cloned()
            .unwrap_or(DecodedType::Unspecified);

        let calling_convention = attrs
            .get("DW_AT_calling_convention")
            .and_then(|v| v.as_u64())
            .unwrap_or(0) as u8;

        let is_variadic = children
            .iter()
            .any(|c| c.get("DW_AT_unspecified_parameters").is_some());

        let mut parameters = Vec::new();
        for child in children {
            let ptype = child
                .get("DW_AT_type")
                .and_then(|v| v.as_reference())
                .and_then(|off| self.type_cache.get(&off))
                .cloned()
                .unwrap_or(DecodedType::Unspecified);
            parameters.push(ptype);
        }

        DecodedType::Function(FunctionType {
            name,
            return_type: Box::new(return_type),
            parameters,
            is_variadic,
            calling_convention,
        })
    }

    /// Cache a decoded type at a given DIE offset.
    pub fn cache_type(&mut self, offset: u64, dtype: DecodedType) {
        self.type_cache.insert(offset, dtype);
    }

    /// Get a previously cached type.
    pub fn get_type(&self, offset: u64) -> Option<&DecodedType> {
        self.type_cache.get(&offset)
    }

    /// Decode a complete type DIE tree into a flat string representation.
    pub fn decode_type_string(
        &mut self,
        tag: u16,
        attributes: &HashMap<String, DwarfAttributeValue>,
        children: &[HashMap<String, DwarfAttributeValue>],
        die_offset: u64,
    ) -> String {
        let dtype = self.decode_die(tag, attributes, children, die_offset);
        format!("{}", dtype)
    }
}

// ============================================================================
// DWARF Attribute Value
// ============================================================================

/// A decoded DWARF attribute value, used by the type decoder.
#[derive(Debug, Clone)]
pub enum DwarfAttributeValue {
    /// String value.
    String(String),
    /// Unsigned integer.
    U64(u64),
    /// Signed integer.
    I64(i64),
    /// Boolean flag.
    Bool(bool),
    /// Reference to another DIE (offset).
    Reference(u64),
    /// Expression location (raw bytes).
    Exprloc(Vec<u8>),
    /// Data block.
    Block(Vec<u8>),
    /// Address.
    Address(u64),
    /// Flag present (DW_FORM_flag_present → true).
    FlagPresent,
    /// None / not present.
    None,
}

impl DwarfAttributeValue {
    pub fn as_string(&self) -> Option<String> {
        match self {
            Self::String(s) => Some(s.clone()),
            _ => None,
        }
    }

    pub fn as_u64(&self) -> Option<u64> {
        match self {
            Self::U64(v) => Some(*v),
            Self::Address(v) => Some(*v),
            _ => None,
        }
    }

    pub fn as_i64(&self) -> Option<i64> {
        match self {
            Self::I64(v) => Some(*v),
            _ => None,
        }
    }

    pub fn as_bool(&self) -> bool {
        match self {
            Self::Bool(b) => *b,
            Self::FlagPresent => true,
            Self::U64(v) => *v != 0,
            _ => false,
        }
    }

    pub fn as_reference(&self) -> Option<u64> {
        match self {
            Self::Reference(v) => Some(*v),
            Self::U64(v) => Some(*v),
            _ => None,
        }
    }

    pub fn as_exprloc(&self) -> Option<&[u8]> {
        match self {
            Self::Exprloc(v) => Some(v),
            Self::Block(v) => Some(v),
            _ => None,
        }
    }
}

// ============================================================================
// DWARF Location List Parser
// ============================================================================

/// A single location list entry: an address range and a location expression.
#[derive(Debug, Clone)]
pub struct LocationListEntry {
    /// Start address of the range.
    pub start_address: u64,
    /// End address of the range.
    pub end_address: u64,
    /// The location expression for this range.
    pub expr: Vec<u8>,
    /// Whether this is a base address selection entry (DW_LLE_base_address).
    pub is_base_address: bool,
    /// Whether this is an end-of-list entry.
    pub is_end_of_list: bool,
}

impl LocationListEntry {
    pub fn new(start: u64, end: u64, expr: Vec<u8>) -> Self {
        Self {
            start_address: start,
            end_address: end,
            expr,
            is_base_address: false,
            is_end_of_list: false,
        }
    }

    pub fn base_address(addr: u64) -> Self {
        Self {
            start_address: addr,
            end_address: 0,
            expr: Vec::new(),
            is_base_address: true,
            is_end_of_list: false,
        }
    }

    pub fn end_of_list() -> Self {
        Self {
            start_address: 0,
            end_address: 0,
            expr: Vec::new(),
            is_base_address: false,
            is_end_of_list: true,
        }
    }
}

/// DWARF location list section parser.
///
/// Parses .debug_loclists (DWARF 5) and .debug_loc (DWARF 4) sections.
pub struct LocationListParser {
    /// The address size for the compilation unit.
    address_size: usize,
}

impl LocationListParser {
    pub fn new(address_size: usize) -> Self {
        Self { address_size }
    }

    /// Parse a DWARF 5 location list (.debug_loclists).
    pub fn parse_loclists_dwarf5(
        &self,
        data: &[u8],
        base_address: u64,
    ) -> Result<Vec<LocationListEntry>, String> {
        let mut entries = Vec::new();
        let mut offset = 0usize;
        let mut current_base = base_address;

        while offset < data.len() {
            if data[offset] == 0 {
                // End of list
                break;
            }

            let entry_kind = data[offset];
            offset += 1;

            match entry_kind {
                0x00 => {
                    // DW_LLE_end_of_list
                    entries.push(LocationListEntry::end_of_list());
                    break;
                }
                0x01 => {
                    // DW_LLE_base_addressx
                    let _idx = Self::read_uleb128(data, &mut offset)?;
                    // Skip for now
                    continue;
                }
                0x02 => {
                    // DW_LLE_startx_endx
                    let _start_idx = Self::read_uleb128(data, &mut offset)?;
                    let _end_idx = Self::read_uleb128(data, &mut offset)?;
                    let expr_len = Self::read_uleb128(data, &mut offset)? as usize;
                    if offset + expr_len > data.len() {
                        return Err("location expression exceeds data".into());
                    }
                    let expr = data[offset..offset + expr_len].to_vec();
                    offset += expr_len;
                    entries.push(LocationListEntry::new(0, 0, expr));
                }
                0x03 => {
                    // DW_LLE_startx_length
                    let _start_idx = Self::read_uleb128(data, &mut offset)?;
                    let _length = Self::read_uleb128(data, &mut offset)?;
                    let expr_len = Self::read_uleb128(data, &mut offset)? as usize;
                    if offset + expr_len > data.len() {
                        return Err("location expression exceeds data".into());
                    }
                    let expr = data[offset..offset + expr_len].to_vec();
                    offset += expr_len;
                    entries.push(LocationListEntry::new(0, 0, expr));
                }
                0x04 => {
                    // DW_LLE_offset_pair
                    let start_off = Self::read_uleb128(data, &mut offset)?;
                    let end_off = Self::read_uleb128(data, &mut offset)?;
                    let expr_len = Self::read_uleb128(data, &mut offset)? as usize;
                    if offset + expr_len > data.len() {
                        return Err("location expression exceeds data".into());
                    }
                    let expr = data[offset..offset + expr_len].to_vec();
                    offset += expr_len;
                    entries.push(LocationListEntry::new(
                        current_base.wrapping_add(start_off),
                        current_base.wrapping_add(end_off),
                        expr,
                    ));
                }
                0x05 => {
                    // DW_LLE_default_location
                    let expr_len = Self::read_uleb128(data, &mut offset)? as usize;
                    if offset + expr_len > data.len() {
                        return Err("location expression exceeds data".into());
                    }
                    let expr = data[offset..offset + expr_len].to_vec();
                    offset += expr_len;
                    entries.push(LocationListEntry::new(0, !0u64, expr));
                }
                0x06 => {
                    // DW_LLE_base_address
                    current_base = Self::read_address(data, &mut offset, self.address_size)?;
                    entries.push(LocationListEntry::base_address(current_base));
                }
                0x07 => {
                    // DW_LLE_start_end
                    let start = Self::read_address(data, &mut offset, self.address_size)?;
                    let end = Self::read_address(data, &mut offset, self.address_size)?;
                    let expr_len = Self::read_uleb128(data, &mut offset)? as usize;
                    if offset + expr_len > data.len() {
                        return Err("location expression exceeds data".into());
                    }
                    let expr = data[offset..offset + expr_len].to_vec();
                    offset += expr_len;
                    entries.push(LocationListEntry::new(start, end, expr));
                }
                0x08 => {
                    // DW_LLE_start_length
                    let start = Self::read_address(data, &mut offset, self.address_size)?;
                    let length = Self::read_uleb128(data, &mut offset)?;
                    let expr_len = Self::read_uleb128(data, &mut offset)? as usize;
                    if offset + expr_len > data.len() {
                        return Err("location expression exceeds data".into());
                    }
                    let expr = data[offset..offset + expr_len].to_vec();
                    offset += expr_len;
                    entries.push(LocationListEntry::new(
                        start,
                        start.wrapping_add(length),
                        expr,
                    ));
                }
                _ => {
                    // Unknown entry kind; skip
                    break;
                }
            }
        }

        Ok(entries)
    }

    /// Parse a DWARF 4 location list (.debug_loc).
    pub fn parse_loc_dwarf4(&self, data: &[u8]) -> Result<Vec<LocationListEntry>, String> {
        let mut entries = Vec::new();
        let mut offset = 0usize;
        let addr_size = self.address_size;

        while offset + 2 * addr_size + 2 <= data.len() {
            let start = Self::read_address(data, &mut offset, addr_size)?;
            let end = Self::read_address(data, &mut offset, addr_size)?;

            if start == 0 && end == 0 {
                // End of list
                entries.push(LocationListEntry::end_of_list());
                break;
            }
            if start == !0u64 >> (64 - addr_size * 8) {
                // Base address selection
                entries.push(LocationListEntry::base_address(end));
                continue;
            }

            let expr_len = u16::from_le_bytes([data[offset], data[offset + 1]]) as usize;
            offset += 2;
            if offset + expr_len > data.len() {
                return Err("DWARF 4 location expression length exceeds data".into());
            }
            let expr = data[offset..offset + expr_len].to_vec();
            offset += expr_len;
            entries.push(LocationListEntry::new(start, end, expr));
        }

        Ok(entries)
    }

    fn read_uleb128(data: &[u8], offset: &mut usize) -> Result<u64, String> {
        let mut result: u64 = 0;
        let mut shift = 0;
        loop {
            if *offset >= data.len() {
                return Err("truncated LEB128".into());
            }
            let byte = data[*offset];
            *offset += 1;
            result |= ((byte & 0x7f) as u64) << shift;
            if byte & 0x80 == 0 {
                break;
            }
            shift += 7;
            if shift >= 64 {
                return Err("LEB128 too large".into());
            }
        }
        Ok(result)
    }

    fn read_address(data: &[u8], offset: &mut usize, addr_size: usize) -> Result<u64, String> {
        if *offset + addr_size > data.len() {
            return Err("truncated address".into());
        }
        let mut buf = [0u8; 8];
        let len = addr_size.min(8);
        buf[..len].copy_from_slice(&data[*offset..*offset + len]);
        *offset += addr_size;
        Ok(u64::from_le_bytes(buf))
    }
}

// ============================================================================
// DWARF Range List Parser
// ============================================================================

/// A single range list entry.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct RangeListEntry {
    pub start: u64,
    pub end: u64,
}

impl RangeListEntry {
    pub fn new(start: u64, end: u64) -> Self {
        Self { start, end }
    }
}

/// DWARF range list parser.
///
/// Parses .debug_rnglists (DWARF 5) and .debug_ranges (DWARF 4) sections.
pub struct RangeListParser {
    address_size: usize,
}

impl RangeListParser {
    pub fn new(address_size: usize) -> Self {
        Self { address_size }
    }

    /// Parse a DWARF 5 range list (.debug_rnglists).
    pub fn parse_rnglists_dwarf5(
        &self,
        data: &[u8],
        base_address: u64,
    ) -> Result<Vec<RangeListEntry>, String> {
        let mut ranges = Vec::new();
        let mut offset = 0usize;
        let mut current_base = base_address;

        while offset < data.len() {
            let entry_kind = data[offset];
            offset += 1;

            match entry_kind {
                0x00 => break, // DW_RLE_end_of_list
                0x01 => {
                    // DW_RLE_base_addressx
                    let _idx = Self::read_uleb128(data, &mut offset)?;
                    continue;
                }
                0x02 => {
                    // DW_RLE_startx_endx
                    let _s = Self::read_uleb128(data, &mut offset)?;
                    let _e = Self::read_uleb128(data, &mut offset)?;
                    ranges.push(RangeListEntry::new(0, 0));
                }
                0x03 => {
                    // DW_RLE_startx_length
                    let _s = Self::read_uleb128(data, &mut offset)?;
                    let _l = Self::read_uleb128(data, &mut offset)?;
                    ranges.push(RangeListEntry::new(0, 0));
                }
                0x04 => {
                    // DW_RLE_offset_pair
                    let s = Self::read_uleb128(data, &mut offset)?;
                    let e = Self::read_uleb128(data, &mut offset)?;
                    ranges.push(RangeListEntry::new(
                        current_base.wrapping_add(s),
                        current_base.wrapping_add(e),
                    ));
                }
                0x05 => {
                    // DW_RLE_base_address
                    current_base = Self::read_address(data, &mut offset, self.address_size)?;
                }
                0x06 => {
                    // DW_RLE_start_end
                    let s = Self::read_address(data, &mut offset, self.address_size)?;
                    let e = Self::read_address(data, &mut offset, self.address_size)?;
                    ranges.push(RangeListEntry::new(s, e));
                }
                0x07 => {
                    // DW_RLE_start_length
                    let s = Self::read_address(data, &mut offset, self.address_size)?;
                    let l = Self::read_uleb128(data, &mut offset)?;
                    ranges.push(RangeListEntry::new(s, s.wrapping_add(l)));
                }
                _ => break,
            }
        }

        Ok(ranges)
    }

    /// Parse a DWARF 4 range list (.debug_ranges).
    pub fn parse_ranges_dwarf4(&self, data: &[u8]) -> Result<Vec<RangeListEntry>, String> {
        let mut ranges = Vec::new();
        let mut offset = 0usize;
        let addr_size = self.address_size;
        let max_addr: u64 = if addr_size == 4 { !0u32 as u64 } else { !0u64 };
        let base_marker = if addr_size == 4 { !0u32 as u64 } else { !0u64 };

        while offset + 2 * addr_size <= data.len() {
            let start = Self::read_address(data, &mut offset, addr_size)?;
            let end = Self::read_address(data, &mut offset, addr_size)?;

            if start == 0 && end == 0 {
                break;
            }
            if start == base_marker {
                // Base address selection; subsequent entries are relative to `end`
                continue;
            }

            ranges.push(RangeListEntry::new(start, end));
        }

        Ok(ranges)
    }

    fn read_uleb128(data: &[u8], offset: &mut usize) -> Result<u64, String> {
        let mut result: u64 = 0;
        let mut shift = 0;
        loop {
            if *offset >= data.len() {
                return Err("truncated LEB128".into());
            }
            let byte = data[*offset];
            *offset += 1;
            result |= ((byte & 0x7f) as u64) << shift;
            if byte & 0x80 == 0 {
                break;
            }
            shift += 7;
            if shift >= 64 {
                return Err("LEB128 too large".into());
            }
        }
        Ok(result)
    }

    fn read_address(data: &[u8], offset: &mut usize, addr_size: usize) -> Result<u64, String> {
        if *offset + addr_size > data.len() {
            return Err("truncated address".into());
        }
        let mut buf = [0u8; 8];
        let len = addr_size.min(8);
        buf[..len].copy_from_slice(&data[*offset..*offset + len]);
        *offset += addr_size;
        Ok(u64::from_le_bytes(buf))
    }
}

// ============================================================================
// DWARF Macro Section Parser
// ============================================================================

/// DWARF 5 macro section opcodes.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum MacroOpcode {
    Define = 0x01,
    Undef = 0x02,
    StartFile = 0x03,
    EndFile = 0x04,
    DefineStrd = 0x05,
    UndefStrd = 0x06,
    Import = 0x07,
    DefineSup = 0x08,
    UndefSup = 0x09,
    ImportSup = 0x0a,
    DefineStrdx = 0x0b,
    UndefStrdx = 0x0c,
    TransparentInclude = 0x10, // DW_MACRO_define_strp
    GnuDefine = 0x30,          // vendor
    GnuUndef = 0x31,
    GnuStartFile = 0x32,
    GnuEndFile = 0x33,
    GnuDefineIndirect = 0x34,
    GnuUndefIndirect = 0x35,
    GnuTransparentInclude = 0x36,
    GnuDefineIndirectAlt = 0x37,
    GnuUndefIndirectAlt = 0x38,
    GnuTransparentIncludeAlt = 0x39,
}

impl MacroOpcode {
    pub fn from_u8(v: u8) -> Option<Self> {
        match v {
            0x01 => Some(Self::Define),
            0x02 => Some(Self::Undef),
            0x03 => Some(Self::StartFile),
            0x04 => Some(Self::EndFile),
            0x05 => Some(Self::DefineStrd),
            0x06 => Some(Self::UndefStrd),
            0x07 => Some(Self::Import),
            0x08 => Some(Self::DefineSup),
            0x09 => Some(Self::UndefSup),
            0x0a => Some(Self::ImportSup),
            0x0b => Some(Self::DefineStrdx),
            0x0c => Some(Self::UndefStrdx),
            0x10 => Some(Self::TransparentInclude),
            0x30 => Some(Self::GnuDefine),
            0x31 => Some(Self::GnuUndef),
            0x32 => Some(Self::GnuStartFile),
            0x33 => Some(Self::GnuEndFile),
            0x34 => Some(Self::GnuDefineIndirect),
            0x35 => Some(Self::GnuUndefIndirect),
            0x36 => Some(Self::GnuTransparentInclude),
            0x37 => Some(Self::GnuDefineIndirectAlt),
            0x38 => Some(Self::GnuUndefIndirectAlt),
            0x39 => Some(Self::GnuTransparentIncludeAlt),
            _ => None,
        }
    }
}

/// A macro entry in the debug_macro section.
#[derive(Debug, Clone)]
pub enum MacroEntry {
    Define {
        line: u64,
        name: String,
        value: String,
    },
    Undef {
        line: u64,
        name: String,
    },
    StartFile {
        line: u64,
        file_index: u64,
    },
    EndFile,
    Import {
        offset: u64,
    },
    TransparentInclude {
        offset: u64,
    },
}

/// DWARF macro section (.debug_macro) parser.
pub struct MacroParser {
    data: Vec<u8>,
    pos: usize,
    version: u16,
    flags: u8,
    debug_line_offset: u64,
    is_dwarf64: bool,
}

impl MacroParser {
    /// Create a new macro parser.
    pub fn new(data: Vec<u8>) -> Self {
        Self {
            data,
            pos: 0,
            version: 5,
            flags: 0,
            debug_line_offset: 0,
            is_dwarf64: false,
        }
    }

    /// Parse the header and return all macro entries.
    pub fn parse(&mut self) -> Result<Vec<MacroEntry>, String> {
        if self.data.len() < 4 {
            return Err("macro section too short".into());
        }

        // Version
        self.version = u16::from_le_bytes([self.data[0], self.data[1]]);
        self.pos = 2;

        // Flags
        if self.pos < self.data.len() {
            self.flags = self.data[self.pos];
            self.pos += 1;
        }

        // Offset size flag and debug_line_offset
        let offset_size_flag = self.flags & 0x01;
        let offset_size = if offset_size_flag != 0 { 8 } else { 4 };

        if self.pos + offset_size > self.data.len() {
            return Err("macro: truncated debug_line_offset".into());
        }
        self.debug_line_offset = Self::read_uint(&self.data, &mut self.pos, offset_size);

        let mut entries = Vec::new();
        while self.pos < self.data.len() {
            let opcode_byte = self.data[self.pos];
            self.pos += 1;

            match opcode_byte {
                0x00 => break, // End of macro information

                b @ 0x01..=0x0c | b @ 0x10..=0x12 | b @ 0x30..=0x39 => {
                    let entry = self.parse_opcode(b)?;
                    entries.push(entry);
                }
                _ => {
                    // Unknown opcode; skip
                    break;
                }
            }
        }

        Ok(entries)
    }

    fn parse_opcode(&mut self, op: u8) -> Result<MacroEntry, String> {
        match op {
            0x01 | 0x08 => {
                // DW_MACRO_define / DW_MACRO_define_sup
                let line = Self::read_uleb128(&self.data, &mut self.pos)?;
                let name = Self::read_null_terminated(&self.data, &mut self.pos)?;
                let value = Self::read_null_terminated(&self.data, &mut self.pos)?;
                Ok(MacroEntry::Define { line, name, value })
            }
            0x05 | 0x0b => {
                // DW_MACRO_define_strp / DW_MACRO_define_strx
                let line = Self::read_uleb128(&self.data, &mut self.pos)?;
                let offset = Self::read_uleb128(&self.data, &mut self.pos)?;
                Ok(MacroEntry::Define {
                    line,
                    name: format!("<str[{}]>", offset),
                    value: String::new(),
                })
            }
            0x02 | 0x09 => {
                // DW_MACRO_undef / DW_MACRO_undef_sup
                let line = Self::read_uleb128(&self.data, &mut self.pos)?;
                let name = Self::read_null_terminated(&self.data, &mut self.pos)?;
                Ok(MacroEntry::Undef { line, name })
            }
            0x06 | 0x0c => {
                // DW_MACRO_undef_strp / DW_MACRO_undef_strx
                let line = Self::read_uleb128(&self.data, &mut self.pos)?;
                let _offset = Self::read_uleb128(&self.data, &mut self.pos)?;
                Ok(MacroEntry::Undef {
                    line,
                    name: "<str>".to_string(),
                })
            }
            0x03 => {
                // DW_MACRO_start_file
                let line = Self::read_uleb128(&self.data, &mut self.pos)?;
                let file_index = Self::read_uleb128(&self.data, &mut self.pos)?;
                Ok(MacroEntry::StartFile { line, file_index })
            }
            0x04 => Ok(MacroEntry::EndFile),
            0x07 | 0x0a => {
                // DW_MACRO_import / DW_MACRO_import_sup
                let offset = Self::read_uleb128(&self.data, &mut self.pos)?;
                Ok(MacroEntry::Import { offset })
            }
            0x10 => {
                // DW_MACRO_import_sup
                let offset = Self::read_uleb128(&self.data, &mut self.pos)?;
                Ok(MacroEntry::Import { offset })
            }
            // GNU extensions
            0x30 | 0x37 => {
                // GNU_define / GNU_define_indirect_alt
                let line = Self::read_uleb128(&self.data, &mut self.pos)?;
                let name = Self::read_null_terminated(&self.data, &mut self.pos)?;
                let value = Self::read_null_terminated(&self.data, &mut self.pos)?;
                Ok(MacroEntry::Define { line, name, value })
            }
            0x31 | 0x38 => {
                // GNU_undef / GNU_undef_indirect_alt
                let line = Self::read_uleb128(&self.data, &mut self.pos)?;
                let name = Self::read_null_terminated(&self.data, &mut self.pos)?;
                Ok(MacroEntry::Undef { line, name })
            }
            0x32 => {
                // GNU_start_file
                let line = Self::read_uleb128(&self.data, &mut self.pos)?;
                let file_index = Self::read_uleb128(&self.data, &mut self.pos)?;
                Ok(MacroEntry::StartFile { line, file_index })
            }
            0x33 => Ok(MacroEntry::EndFile),
            0x34 | 0x35 | 0x36 | 0x39 => {
                // Indirect references; skip
                let _offset = Self::read_uleb128(&self.data, &mut self.pos)?;
                Ok(MacroEntry::Import { offset: 0 })
            }
            _ => Err(format!("unknown macro opcode {:#x}", op)),
        }
    }

    fn read_uleb128(data: &[u8], offset: &mut usize) -> Result<u64, String> {
        let mut result: u64 = 0;
        let mut shift = 0;
        loop {
            if *offset >= data.len() {
                return Err("truncated ULEB128 in macro".into());
            }
            let byte = data[*offset];
            *offset += 1;
            result |= ((byte & 0x7f) as u64) << shift;
            if byte & 0x80 == 0 {
                break;
            }
            shift += 7;
            if shift >= 64 {
                return Err("ULEB128 too large in macro".into());
            }
        }
        Ok(result)
    }

    fn read_null_terminated(data: &[u8], offset: &mut usize) -> Result<String, String> {
        let start = *offset;
        while *offset < data.len() && data[*offset] != 0 {
            *offset += 1;
        }
        let s = std::str::from_utf8(&data[start..*offset])
            .map_err(|e| format!("invalid UTF-8 in macro: {}", e))?;
        *offset += 1;
        Ok(s.to_string())
    }

    fn read_uint(data: &[u8], offset: &mut usize, size: usize) -> u64 {
        let mut buf = [0u8; 8];
        let end = (*offset + size).min(data.len());
        let len = (end - *offset).min(8);
        buf[..len].copy_from_slice(&data[*offset..*offset + len]);
        *offset += size;
        u64::from_le_bytes(buf)
    }
}

// ============================================================================
// DWARF Name Index Parser (.debug_names)
// ============================================================================

/// A DWARF 5 name index entry.
#[derive(Debug, Clone)]
pub struct NameIndexEntry {
    /// The name (as a string offset reference).
    pub name: String,
    /// The DIE offset for this name.
    pub die_offset: u64,
    /// Parent DIE offset (for scoping).
    pub parent_offset: Option<u64>,
    /// The tag of the DIE.
    pub tag: u16,
    /// The hash value for this name.
    pub hash: u64,
}

/// DWARF 5 name index (.debug_names) parser.
pub struct NameIndexParser {
    data: Vec<u8>,
    pos: usize,
}

impl NameIndexParser {
    pub fn new(data: Vec<u8>) -> Self {
        Self { data, pos: 0 }
    }

    /// Parse the name index and return all entries.
    pub fn parse(&mut self) -> Result<(u32, Vec<NameIndexEntry>), String> {
        if self.data.len() < 12 {
            return Err("name index too short".into());
        }

        // Unit length
        let unit_length =
            u32::from_le_bytes([self.data[0], self.data[1], self.data[2], self.data[3]]);
        self.pos = 4;

        if unit_length as usize + 4 > self.data.len() {
            return Err("name index unit length exceeds data".into());
        }

        // Version (must be 5)
        let version = u16::from_le_bytes([self.data[4], self.data[5]]);
        self.pos = 6;
        if version != 5 {
            return Err(format!("unsupported .debug_names version {}", version));
        }

        // Padding
        let _padding = u16::from_le_bytes([self.data[6], self.data[7]]);
        self.pos = 8;

        // Compilation unit count
        let cu_count =
            u32::from_le_bytes([self.data[8], self.data[9], self.data[10], self.data[11]]);
        self.pos = 12;

        // Local type unit count
        let local_tu_count = u32::from_le_bytes([
            self.data[self.pos],
            self.data[self.pos + 1],
            self.data[self.pos + 2],
            self.data[self.pos + 3],
        ]);
        self.pos += 4;

        // Foreign type unit count
        let foreign_tu_count = u32::from_le_bytes([
            self.data[self.pos],
            self.data[self.pos + 1],
            self.data[self.pos + 2],
            self.data[self.pos + 3],
        ]);
        self.pos += 4;

        // Bucket count
        let bucket_count = u32::from_le_bytes([
            self.data[self.pos],
            self.data[self.pos + 1],
            self.data[self.pos + 2],
            self.data[self.pos + 3],
        ]);
        self.pos += 4;

        // Name count (unique entries in the hash table)
        let name_count = u32::from_le_bytes([
            self.data[self.pos],
            self.data[self.pos + 1],
            self.data[self.pos + 2],
            self.data[self.pos + 3],
        ]);
        self.pos += 4;

        // Abbrev table size
        let abbrev_table_size = u32::from_le_bytes([
            self.data[self.pos],
            self.data[self.pos + 1],
            self.data[self.pos + 2],
            self.data[self.pos + 3],
        ]);
        self.pos += 4;

        // Augmentation string size
        let _aug_size = self.data[self.pos] as usize;
        self.pos += 1;
        // Skip augmentation string
        self.pos += _aug_size;

        // ── Compilation Unit List ────────────────────────────────────────
        self.pos += cu_count as usize * 8; // Skip CU offsets

        // ── Local TU List ────────────────────────────────────────────────
        self.pos += local_tu_count as usize * 8; // Skip local TU offsets

        // ── Foreign TU List ──────────────────────────────────────────────
        self.pos += foreign_tu_count as usize * 8; // Skip foreign TU offsets

        // ── Hash Table ───────────────────────────────────────────────────
        // Hash lookup table: bucket_count * 4 bytes
        self.pos += bucket_count as usize * 4;

        // Hashes array: name_count * 8 bytes
        let mut hashes = Vec::with_capacity(name_count as usize);
        for _ in 0..name_count {
            if self.pos + 8 > self.data.len() {
                return Err("truncated hash array".into());
            }
            let hash = u64::from_le_bytes([
                self.data[self.pos],
                self.data[self.pos + 1],
                self.data[self.pos + 2],
                self.data[self.pos + 3],
                self.data[self.pos + 4],
                self.data[self.pos + 5],
                self.data[self.pos + 6],
                self.data[self.pos + 7],
            ]);
            hashes.push(hash);
            self.pos += 8;
        }

        // Name table offsets: name_count * 4 bytes
        let mut name_offsets = Vec::with_capacity(name_count as usize);
        for _ in 0..name_count {
            if self.pos + 4 > self.data.len() {
                return Err("truncated name offsets".into());
            }
            let off = u32::from_le_bytes([
                self.data[self.pos],
                self.data[self.pos + 1],
                self.data[self.pos + 2],
                self.data[self.pos + 3],
            ]);
            name_offsets.push(off);
            self.pos += 4;
        }

        // Entry offsets: name_count * 4 bytes
        let mut entry_offsets = Vec::with_capacity(name_count as usize);
        for _ in 0..name_count {
            if self.pos + 4 > self.data.len() {
                return Err("truncated entry offsets".into());
            }
            let off = u32::from_le_bytes([
                self.data[self.pos],
                self.data[self.pos + 1],
                self.data[self.pos + 2],
                self.data[self.pos + 3],
            ]);
            entry_offsets.push(off);
            self.pos += 4;
        }

        // ── Abbreviation Table ──────────────────────────────────────────
        // Skip abbreviation table for now
        self.pos += abbrev_table_size as usize;

        // ── Name Table (string pool) ─────────────────────────────────────
        // Read name table entries
        let mut names = Vec::with_capacity(name_count as usize);
        for off in &name_offsets {
            let string_pos = *off as usize;
            if string_pos < self.data.len() {
                let end = self.data[string_pos..]
                    .iter()
                    .position(|&b| b == 0)
                    .unwrap_or(self.data.len() - string_pos);
                let s = std::str::from_utf8(&self.data[string_pos..string_pos + end])
                    .unwrap_or("<invalid>");
                names.push(s.to_string());
            } else {
                names.push("<out of range>".to_string());
            }
        }

        // ── Build Entries ───────────────────────────────────────────────
        let mut entries = Vec::with_capacity(name_count as usize);
        for i in 0..name_count as usize {
            entries.push(NameIndexEntry {
                name: names.get(i).cloned().unwrap_or_default(),
                die_offset: 0, // Resolved from entry pool offsets
                parent_offset: None,
                tag: 0,
                hash: hashes.get(i).copied().unwrap_or(0),
            });
        }

        Ok((name_count, entries))
    }
}

// ============================================================================
// DWARF String Offsets Table Parser (.debug_str_offsets)
// ============================================================================

/// DWARF string offsets table parser.
///
/// Parses the .debug_str_offsets section which provides indexed access
/// to strings in the .debug_str section.
pub struct StringOffsetsTable {
    /// The table of string offsets.
    offsets: Vec<u64>,
    /// The base offset of this table within the section.
    base_offset: u64,
    /// DWARF format: 32 or 64 bit.
    format: DwarfFormat,
}

impl StringOffsetsTable {
    /// Parse a .debug_str_offsets contribution from raw bytes.
    pub fn parse(data: &[u8], base_offset: u64) -> Result<Self, String> {
        if data.len() < 8 {
            return Err("string offsets table too short".into());
        }

        let mut offset = 0usize;

        // Unit length
        let ulen = u32::from_le_bytes([data[0], data[1], data[2], data[3]]);
        offset += 4;

        let format = if ulen == 0xffffffff {
            offset += 8; // 64-bit length
            DwarfFormat::Dwarf64
        } else {
            DwarfFormat::Dwarf32
        };

        // Version
        if offset + 2 > data.len() {
            return Err("truncated string offsets header".into());
        }
        let _version = u16::from_le_bytes([data[offset], data[offset + 1]]);
        offset += 2;

        // Padding
        if offset + 2 > data.len() {
            return Err("truncated string offsets header padding".into());
        }
        offset += 2;

        // Read offsets
        let offset_size = match format {
            DwarfFormat::Dwarf32 => 4usize,
            DwarfFormat::Dwarf64 => 8usize,
        };

        let mut offsets = Vec::new();
        while offset + offset_size <= data.len() {
            let val = if offset_size == 8 {
                u64::from_le_bytes([
                    data[offset],
                    data[offset + 1],
                    data[offset + 2],
                    data[offset + 3],
                    data[offset + 4],
                    data[offset + 5],
                    data[offset + 6],
                    data[offset + 7],
                ])
            } else {
                u32::from_le_bytes([
                    data[offset],
                    data[offset + 1],
                    data[offset + 2],
                    data[offset + 3],
                ]) as u64
            };
            // A zero value in the last entry may indicate end (or empty slot)
            offsets.push(val);
            offset += offset_size;
        }

        Ok(Self {
            offsets,
            base_offset,
            format,
        })
    }

    /// Get the string offset at a given index.
    pub fn get_offset(&self, index: usize) -> Option<u64> {
        self.offsets.get(index).copied()
    }

    /// Resolve a string from a DW_AT_str_offsets_base + index.
    pub fn resolve_string(&self, index: usize, debug_str: &[u8]) -> Option<String> {
        let str_offset = self.get_offset(index)? as usize;
        if str_offset >= debug_str.len() {
            return None;
        }
        let end = debug_str[str_offset..]
            .iter()
            .position(|&b| b == 0)
            .unwrap_or(debug_str.len() - str_offset);
        std::str::from_utf8(&debug_str[str_offset..str_offset + end])
            .ok()
            .map(|s| s.to_string())
    }

    /// Number of entries.
    pub fn len(&self) -> usize {
        self.offsets.len()
    }

    /// Is the table empty?
    pub fn is_empty(&self) -> bool {
        self.offsets.is_empty()
    }
}

// ============================================================================
// Combined DWARF Deep Utilities
// ============================================================================

/// High-level DWARF deep utilities combining all parsers.
pub struct DwarfDeepUtils {
    /// The address size for the current compilation unit.
    pub address_size: usize,
    /// DWARF version being processed.
    pub dwarf_version: u16,
    /// Cached line tables by offset.
    line_tables: HashMap<u64, FullLineTable>,
    /// Cached type decoder results.
    type_cache: HashMap<u64, DecodedType>,
}

impl DwarfDeepUtils {
    pub fn new(address_size: usize, dwarf_version: u16) -> Self {
        Self {
            address_size,
            dwarf_version,
            line_tables: HashMap::new(),
            type_cache: HashMap::new(),
        }
    }

    /// Evaluate a DWARF expression and return the possible address.
    pub fn eval_as_address(expr_bytes: &[u8], address_size: usize) -> Option<u64> {
        let mut evaluator = DwarfDeep::new(expr_bytes.to_vec(), address_size);
        let regs = DefaultRegisterState;
        let mem = DefaultMemoryReader;
        let result = evaluator.evaluate(&regs, &mem);
        result.value.and_then(|v| v.as_u64())
    }

    /// Evaluate a DWARF expression and return the possible value.
    pub fn eval_as_value(expr_bytes: &[u8], address_size: usize) -> Option<u64> {
        Self::eval_as_address(expr_bytes, address_size)
    }

    /// Parse a line table from raw .debug_line section data at an offset.
    pub fn parse_line_table(&mut self, data: &[u8], offset: u64) -> Result<&FullLineTable, String> {
        use std::collections::hash_map::Entry;
        match self.line_tables.entry(offset) {
            Entry::Occupied(entry) => Ok(entry.into_mut()),
            Entry::Vacant(entry) => {
                let off = offset as usize;
                if off >= data.len() {
                    return Err("line table offset out of range".into());
                }
                let table = FullLineTable::parse(&data[off..])?;
                Ok(entry.insert(table))
            }
        }
    }

    /// Look up the source location for an address.
    pub fn lookup_source(
        &mut self,
        line_data: &[u8],
        line_offset: u64,
        address: u64,
    ) -> Option<(String, usize, usize)> {
        let table = self.parse_line_table(line_data, line_offset).ok()?;
        let row = table.lookup_address(address)?;
        let file = table.file_name(row.file)?;
        Some((file.to_string(), row.line, row.column))
    }

    /// Decode a type from DIE attributes.
    pub fn decode_type(
        &mut self,
        tag: u16,
        attrs: &HashMap<String, DwarfAttributeValue>,
        children: &[HashMap<String, DwarfAttributeValue>],
        offset: u64,
    ) -> DecodedType {
        let mut decoder = DwarfTypeDecoder::new(self.address_size);
        // Pre-populate cache
        for (&off, t) in &self.type_cache {
            decoder.cache_type(off, t.clone());
        }
        let result = decoder.decode_die(tag, attrs, children, offset);
        self.type_cache.insert(offset, result.clone());
        result
    }

    /// Get a human-readable debug string for an expression.
    pub fn disassemble_expression(expr: &[u8]) -> String {
        let mut result = String::new();
        let mut pos = 0usize;
        while pos < expr.len() {
            let op = expr[pos];
            pos += 1;
            let opcode = DwarfOpcode::from_byte(op);
            result.push_str(opcode.name());

            match op {
                0x03 | 0x04 | 0x09 | 0xa5 => {
                    // Read ULEB128
                    if pos < expr.len() {
                        let (val, new_pos) = Self::read_uleb128_at(expr, pos);
                        result.push_str(&format!(" {}", val));
                        pos = new_pos;
                    }
                }
                0x06 => {
                    // Address
                    if pos + 8 <= expr.len() {
                        let addr = u64::from_le_bytes([
                            expr[pos],
                            expr[pos + 1],
                            expr[pos + 2],
                            expr[pos + 3],
                            expr[pos + 4],
                            expr[pos + 5],
                            expr[pos + 6],
                            expr[pos + 7],
                        ]);
                        result.push_str(&format!(" {:#x}", addr));
                        pos += 8;
                    }
                }
                _ => {}
            }
            result.push('\n');
        }
        result
    }

    fn read_uleb128_at(data: &[u8], start: usize) -> (u64, usize) {
        let mut result: u64 = 0;
        let mut shift = 0;
        let mut pos = start;
        while pos < data.len() {
            let byte = data[pos];
            pos += 1;
            result |= ((byte & 0x7f) as u64) << shift;
            if byte & 0x80 == 0 {
                break;
            }
            shift += 7;
            if shift >= 64 {
                break;
            }
        }
        (result, pos)
    }
}

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

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

    // ── Opcode tests ──────────────────────────────────────────────────────

    #[test]
    fn test_dwarf_opcode_roundtrip() {
        let opcodes = [
            0x03, 0x06, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13,
            0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21,
            0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
        ];
        for &b in &opcodes {
            let op = DwarfOpcode::from_byte(b);
            let rb = op.to_byte();
            if b >= 0x30 && b <= 0x4f {
                // LitN range
                continue;
            }
            if b >= 0x50 && b <= 0x6f {
                // RegN range
                continue;
            }
            if b >= 0x70 && b <= 0x8f {
                // BRegN range
                continue;
            }
            // For non-range opcodes, roundtrip should work
            assert_eq!(rb, b, "Failed roundtrip for {:#x}", b);
        }
    }

    // ── ExprValue tests ───────────────────────────────────────────────────

    #[test]
    fn test_expr_value_creation() {
        let v = ExprValue::value(42, 64);
        assert_eq!(v.as_u64(), Some(42));
        assert_eq!(v.bit_size(), 64);

        let v = ExprValue::signed_value(-10, 64);
        assert_eq!(v.as_i64(), Some(-10));

        let v = ExprValue::address(0x1000, 64, 0);
        assert_eq!(v.as_u64(), Some(0x1000));

        let v = ExprValue::reg(5, 64);
        assert!(!v.is_composite());
    }

    // ── Expression Evaluator tests ────────────────────────────────────────

    #[test]
    fn test_eval_literal_stack() {
        let expr = vec![0x30, 0x31, 0x32]; // DW_OP_lit0, lit1, lit2
        let mut eval = DwarfDeep::new(expr, 8);
        let regs = DefaultRegisterState;
        let mem = DefaultMemoryReader;
        let result = eval.evaluate(&regs, &mem);
        assert!(result.success);
        assert_eq!(result.value.and_then(|v| v.as_u64()), Some(2));
    }

    #[test]
    fn test_eval_plus() {
        let expr = vec![0x33, 0x34, 0x22]; // lit3, lit4, plus
        let mut eval = DwarfDeep::new(expr, 8);
        let regs = DefaultRegisterState;
        let mem = DefaultMemoryReader;
        let result = eval.evaluate(&regs, &mem);
        assert!(result.success);
        assert_eq!(result.value.and_then(|v| v.as_u64()), Some(7));
    }

    #[test]
    fn test_eval_minus() {
        let expr = vec![0x3a, 0x33, 0x1c]; // lit10, lit3, minus
        let mut eval = DwarfDeep::new(expr, 8);
        let regs = DefaultRegisterState;
        let mem = DefaultMemoryReader;
        let result = eval.evaluate(&regs, &mem);
        assert!(result.success);
        assert_eq!(result.value.and_then(|v| v.as_u64()), Some(7));
    }

    #[test]
    fn test_eval_mul() {
        let expr = vec![0x34, 0x35, 0x1e]; // lit4, lit5, mul
        let mut eval = DwarfDeep::new(expr, 8);
        let regs = DefaultRegisterState;
        let mem = DefaultMemoryReader;
        let result = eval.evaluate(&regs, &mem);
        assert!(result.success);
        assert_eq!(result.value.and_then(|v| v.as_u64()), Some(20));
    }

    #[test]
    fn test_eval_div() {
        let expr = vec![0x3a, 0x33, 0x1b]; // lit10, lit3, div
        let mut eval = DwarfDeep::new(expr, 8);
        let regs = DefaultRegisterState;
        let mem = DefaultMemoryReader;
        let result = eval.evaluate(&regs, &mem);
        assert!(result.success);
        assert_eq!(result.value.and_then(|v| v.as_u64()), Some(3));
    }

    #[test]
    fn test_eval_and() {
        let expr = vec![0x38, 0x3a, 0x1a]; // lit8, lit10, and → 1010 & 1000 = 8
        let mut eval = DwarfDeep::new(expr, 8);
        let regs = DefaultRegisterState;
        let mem = DefaultMemoryReader;
        let result = eval.evaluate(&regs, &mem);
        assert!(result.success);
        assert_eq!(result.value.and_then(|v| v.as_u64()), Some(8));
    }

    #[test]
    fn test_eval_or() {
        let expr = vec![0x38, 0x32, 0x21]; // lit8, lit2, or → 1000 | 0010 = 10
        let mut eval = DwarfDeep::new(expr, 8);
        let regs = DefaultRegisterState;
        let mem = DefaultMemoryReader;
        let result = eval.evaluate(&regs, &mem);
        assert!(result.success);
        assert_eq!(result.value.and_then(|v| v.as_u64()), Some(10));
    }

    #[test]
    fn test_eval_xor() {
        let expr = vec![0x39, 0x35, 0x27]; // lit9, lit5, xor → 1001 ^ 0101 = 1100 = 12
        let mut eval = DwarfDeep::new(expr, 8);
        let regs = DefaultRegisterState;
        let mem = DefaultMemoryReader;
        let result = eval.evaluate(&regs, &mem);
        assert!(result.success);
        assert_eq!(result.value.and_then(|v| v.as_u64()), Some(12));
    }

    #[test]
    fn test_eval_shl() {
        let expr = vec![0x31, 0x33, 0x24]; // lit1, lit3, shl → 1 << 3 = 8
        let mut eval = DwarfDeep::new(expr, 8);
        let regs = DefaultRegisterState;
        let mem = DefaultMemoryReader;
        let result = eval.evaluate(&regs, &mem);
        assert!(result.success);
        assert_eq!(result.value.and_then(|v| v.as_u64()), Some(8));
    }

    #[test]
    fn test_eval_shr() {
        let expr = vec![0x38, 0x31, 0x25]; // lit8, lit1, shr → 8 >> 1 = 4
        let mut eval = DwarfDeep::new(expr, 8);
        let regs = DefaultRegisterState;
        let mem = DefaultMemoryReader;
        let result = eval.evaluate(&regs, &mem);
        assert!(result.success);
        assert_eq!(result.value.and_then(|v| v.as_u64()), Some(4));
    }

    #[test]
    fn test_eval_neg() {
        let expr = vec![0x31, 0x1f]; // lit1, neg
        let mut eval = DwarfDeep::new(expr, 8);
        let regs = DefaultRegisterState;
        let mem = DefaultMemoryReader;
        let result = eval.evaluate(&regs, &mem);
        assert!(result.success);
        assert_eq!(result.value.and_then(|v| v.as_u64()), Some(!1u64 + 1));
    }

    #[test]
    fn test_eval_not() {
        let expr = vec![0x30, 0x20]; // lit0, not
        let mut eval = DwarfDeep::new(expr, 8);
        let regs = DefaultRegisterState;
        let mem = DefaultMemoryReader;
        let result = eval.evaluate(&regs, &mem);
        assert!(result.success);
        assert_eq!(result.value.and_then(|v| v.as_u64()), Some(!0u64));
    }

    #[test]
    fn test_eval_abs() {
        let expr = vec![0x10, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x19]; // const8s -1, abs
        let mut eval = DwarfDeep::new(expr, 8);
        let regs = DefaultRegisterState;
        let mem = DefaultMemoryReader;
        let result = eval.evaluate(&regs, &mem);
        assert!(result.success);
        assert_eq!(result.value.and_then(|v| v.as_u64()), Some(1));
    }

    #[test]
    fn test_eval_mod() {
        let expr = vec![0x3a, 0x33, 0x1d]; // lit10, lit3, mod
        let mut eval = DwarfDeep::new(expr, 8);
        let regs = DefaultRegisterState;
        let mem = DefaultMemoryReader;
        let result = eval.evaluate(&regs, &mem);
        assert!(result.success);
        assert_eq!(result.value.and_then(|v| v.as_u64()), Some(1));
    }

    #[test]
    fn test_eval_eq_true() {
        let expr = vec![0x33, 0x33, 0x29]; // lit3, lit3, eq
        let mut eval = DwarfDeep::new(expr, 8);
        let regs = DefaultRegisterState;
        let mem = DefaultMemoryReader;
        let result = eval.evaluate(&regs, &mem);
        assert!(result.success);
        assert_eq!(result.value.and_then(|v| v.as_u64()), Some(1));
    }

    #[test]
    fn test_eval_eq_false() {
        let expr = vec![0x33, 0x34, 0x29]; // lit3, lit4, eq
        let mut eval = DwarfDeep::new(expr, 8);
        let regs = DefaultRegisterState;
        let mem = DefaultMemoryReader;
        let result = eval.evaluate(&regs, &mem);
        assert!(result.success);
        assert_eq!(result.value.and_then(|v| v.as_u64()), Some(0));
    }

    #[test]
    fn test_eval_ge() {
        let expr = vec![0x34, 0x33, 0x2a]; // lit4, lit3, ge
        let mut eval = DwarfDeep::new(expr, 8);
        let regs = DefaultRegisterState;
        let mem = DefaultMemoryReader;
        let result = eval.evaluate(&regs, &mem);
        assert!(result.success);
        assert_eq!(result.value.and_then(|v| v.as_u64()), Some(1));
    }

    #[test]
    fn test_eval_gt() {
        let expr = vec![0x33, 0x34, 0x2b]; // lit3, lit4, gt
        let mut eval = DwarfDeep::new(expr, 8);
        let regs = DefaultRegisterState;
        let mem = DefaultMemoryReader;
        let result = eval.evaluate(&regs, &mem);
        assert!(result.success);
        assert_eq!(result.value.and_then(|v| v.as_u64()), Some(0));
    }

    #[test]
    fn test_eval_le() {
        let expr = vec![0x33, 0x34, 0x2c]; // lit3, lit4, le
        let mut eval = DwarfDeep::new(expr, 8);
        let regs = DefaultRegisterState;
        let mem = DefaultMemoryReader;
        let result = eval.evaluate(&regs, &mem);
        assert!(result.success);
        assert_eq!(result.value.and_then(|v| v.as_u64()), Some(1));
    }

    #[test]
    fn test_eval_lt() {
        let expr = vec![0x34, 0x33, 0x2d]; // lit4, lit3, lt
        let mut eval = DwarfDeep::new(expr, 8);
        let regs = DefaultRegisterState;
        let mem = DefaultMemoryReader;
        let result = eval.evaluate(&regs, &mem);
        assert!(result.success);
        assert_eq!(result.value.and_then(|v| v.as_u64()), Some(0));
    }

    #[test]
    fn test_eval_ne_true() {
        let expr = vec![0x33, 0x34, 0x2e]; // lit3, lit4, ne
        let mut eval = DwarfDeep::new(expr, 8);
        let regs = DefaultRegisterState;
        let mem = DefaultMemoryReader;
        let result = eval.evaluate(&regs, &mem);
        assert!(result.success);
        assert_eq!(result.value.and_then(|v| v.as_u64()), Some(1));
    }

    #[test]
    fn test_eval_dup() {
        let expr = vec![0x30, 0x12]; // lit0, dup
        let mut eval = DwarfDeep::new(expr, 8);
        let regs = DefaultRegisterState;
        let mem = DefaultMemoryReader;
        let result = eval.evaluate(&regs, &mem);
        assert!(result.success);
        assert_eq!(eval.stack.len(), 0);
    }

    #[test]
    fn test_eval_drop() {
        let expr = vec![0x30, 0x31, 0x13]; // lit0, lit1, drop
        let mut eval = DwarfDeep::new(expr, 8);
        let regs = DefaultRegisterState;
        let mem = DefaultMemoryReader;
        let result = eval.evaluate(&regs, &mem);
        assert!(result.success);
        assert_eq!(result.value.and_then(|v| v.as_u64()), Some(0));
    }

    #[test]
    fn test_eval_over() {
        let expr = vec![0x30, 0x31, 0x14, 0x13]; // lit0, lit1, over, drop
        let mut eval = DwarfDeep::new(expr, 8);
        let regs = DefaultRegisterState;
        let mem = DefaultMemoryReader;
        let result = eval.evaluate(&regs, &mem);
        assert!(result.success);
        assert_eq!(result.value.and_then(|v| v.as_u64()), Some(0));
    }

    #[test]
    fn test_eval_swap() {
        let expr = vec![0x30, 0x31, 0x16]; // lit0, lit1, swap
        let mut eval = DwarfDeep::new(expr, 8);
        let regs = DefaultRegisterState;
        let mem = DefaultMemoryReader;
        let result = eval.evaluate(&regs, &mem);
        assert!(result.success);
        assert_eq!(result.value.and_then(|v| v.as_u64()), Some(0));
    }

    #[test]
    fn test_eval_plus_uconst() {
        let expr = vec![0x33, 0x23, 0x05]; // lit3, plus_uconst 5
        let mut eval = DwarfDeep::new(expr, 8);
        let regs = DefaultRegisterState;
        let mem = DefaultMemoryReader;
        let result = eval.evaluate(&regs, &mem);
        assert!(result.success);
        assert_eq!(result.value.and_then(|v| v.as_u64()), Some(8));
    }

    #[test]
    fn test_eval_const1u() {
        let expr = vec![0x08, 42]; // const1u 42
        let mut eval = DwarfDeep::new(expr, 8);
        let regs = DefaultRegisterState;
        let mem = DefaultMemoryReader;
        let result = eval.evaluate(&regs, &mem);
        assert!(result.success);
        assert_eq!(result.value.and_then(|v| v.as_u64()), Some(42));
    }

    #[test]
    fn test_eval_const1s_positive() {
        let expr = vec![0x0a, 42]; // const1s 42
        let mut eval = DwarfDeep::new(expr, 8);
        let regs = DefaultRegisterState;
        let mem = DefaultMemoryReader;
        let result = eval.evaluate(&regs, &mem);
        assert!(result.success);
        assert_eq!(result.value.and_then(|v| v.as_u64()), Some(42));
    }

    #[test]
    fn test_eval_const1s_negative() {
        let expr = vec![0x0a, 0xfe]; // const1s -2 (0xfe as i8 = -2)
        let mut eval = DwarfDeep::new(expr, 8);
        let regs = DefaultRegisterState;
        let mem = DefaultMemoryReader;
        let result = eval.evaluate(&regs, &mem);
        assert!(result.success);
        assert_eq!(result.value.and_then(|v| v.as_i64()), Some(-2));
    }

    #[test]
    fn test_eval_constu() {
        let expr = vec![0x11, 0x80, 0x01]; // constu 128 (ULEB128)
        let mut eval = DwarfDeep::new(expr, 8);
        let regs = DefaultRegisterState;
        let mem = DefaultMemoryReader;
        let result = eval.evaluate(&regs, &mem);
        assert!(result.success);
        assert_eq!(result.value.and_then(|v| v.as_u64()), Some(128));
    }

    #[test]
    fn test_eval_const4u() {
        let expr = {
            let mut v = vec![0x0d];
            v.extend_from_slice(&0xdeadbeefu32.to_le_bytes());
            v
        };
        let mut eval = DwarfDeep::new(expr, 8);
        let regs = DefaultRegisterState;
        let mem = DefaultMemoryReader;
        let result = eval.evaluate(&regs, &mem);
        assert!(result.success);
        assert_eq!(result.value.and_then(|v| v.as_u64()), Some(0xdeadbeef));
    }

    #[test]
    fn test_eval_const8u() {
        let expr = {
            let mut v = vec![0x0f];
            v.extend_from_slice(&0x123456789abcdef0u64.to_le_bytes());
            v
        };
        let mut eval = DwarfDeep::new(expr, 8);
        let regs = DefaultRegisterState;
        let mem = DefaultMemoryReader;
        let result = eval.evaluate(&regs, &mem);
        assert!(result.success);
        assert_eq!(
            result.value.and_then(|v| v.as_u64()),
            Some(0x123456789abcdef0)
        );
    }

    #[test]
    fn test_eval_addr_8byte() {
        let expr = {
            let mut v = vec![0x06];
            v.extend_from_slice(&0x400000u64.to_le_bytes());
            v
        };
        let mut eval = DwarfDeep::new(expr, 8);
        let regs = DefaultRegisterState;
        let mem = DefaultMemoryReader;
        let result = eval.evaluate(&regs, &mem);
        assert!(result.success);
        match result.value {
            Some(ExprValue::Address { addr, .. }) => assert_eq!(addr, 0x400000),
            _ => panic!("expected Address"),
        }
    }

    #[test]
    fn test_eval_cfa() {
        let expr = vec![0x9c]; // DW_OP_call_frame_cfa
        let mut eval = DwarfDeep::new(expr, 8);
        let regs = DefaultRegisterState;
        let mem = DefaultMemoryReader;
        let result = eval.evaluate(&regs, &mem);
        assert!(result.success);
    }

    #[test]
    fn test_eval_stack_value() {
        let expr = vec![0x33, 0x9f]; // lit3, stack_value
        let mut eval = DwarfDeep::new(expr, 8);
        let regs = DefaultRegisterState;
        let mem = DefaultMemoryReader;
        let result = eval.evaluate(&regs, &mem);
        assert!(result.success);
        assert!(result.is_stack_value);
        assert_eq!(result.value.and_then(|v| v.as_u64()), Some(3));
    }

    #[test]
    fn test_eval_max_steps() {
        let mut expr = Vec::new();
        for _ in 0..1000 {
            expr.push(0x30); // lit0
            expr.push(0x12); // dup
        }
        let mut eval = DwarfDeep::new(expr, 8);
        eval.set_max_steps(10);
        let regs = DefaultRegisterState;
        let mem = DefaultMemoryReader;
        let result = eval.evaluate(&regs, &mem);
        assert!(!result.success);
        assert!(result.error.unwrap().contains("max"));
    }

    #[test]
    fn test_eval_empty_expression() {
        let expr = vec![];
        let mut eval = DwarfDeep::new(expr, 8);
        let regs = DefaultRegisterState;
        let mem = DefaultMemoryReader;
        let result = eval.evaluate(&regs, &mem);
        assert!(result.success);
        assert!(result.value.is_none());
    }

    #[test]
    fn test_eval_div_by_zero() {
        let expr = vec![0x33, 0x30, 0x1b]; // lit3, lit0, div
        let mut eval = DwarfDeep::new(expr, 8);
        let regs = DefaultRegisterState;
        let mem = DefaultMemoryReader;
        let result = eval.evaluate(&regs, &mem);
        assert!(!result.success);
        assert!(result.error.unwrap().contains("zero"));
    }

    #[test]
    fn test_eval_mod_by_zero() {
        let expr = vec![0x33, 0x30, 0x1d]; // lit3, lit0, mod
        let mut eval = DwarfDeep::new(expr, 8);
        let regs = DefaultRegisterState;
        let mem = DefaultMemoryReader;
        let result = eval.evaluate(&regs, &mem);
        assert!(!result.success);
    }

    // ── Line Table Parser tests ───────────────────────────────────────────

    #[test]
    fn test_line_table_empty_parse() {
        let data = [0u8; 4]; // too short
        let result = FullLineTable::parse(&data);
        assert!(result.is_err());
    }

    #[test]
    fn test_line_table_minimal_header() {
        // Minimal DWARF 32 line table header (just version + minimal fields)
        let mut data = Vec::new();
        // Unit length (small)
        data.extend_from_slice(&20u32.to_le_bytes());
        // Version 4
        data.extend_from_slice(&4u16.to_le_bytes());
        // Header length
        data.extend_from_slice(&(4 + 10u32).to_le_bytes());
        // min_inst_len = 1, max_ops_per_inst = 1
        data.push(1);
        data.push(1);
        // default_is_stmt = true
        data.push(1);
        // line_base = -5
        data.push(0xfb);
        // line_range = 14
        data.push(14);
        // opcode_base = 13 (standard)
        data.push(13);
        // 12 standard opcode lengths (all 1)
        for _ in 0..12 {
            data.push(1);
        }
        // Empty include dirs
        data.push(0);
        // Empty file names
        data.push(0);

        let result = FullLineTable::parse(&data);
        assert!(result.is_ok(), "Parse failed: {:?}", result.err());
        let table = result.unwrap();
        assert_eq!(table.header.version, 4);
        assert_eq!(table.header.minimum_instruction_length, 1);
        assert_eq!(table.header.default_is_stmt, true);
        assert_eq!(table.header.line_base, -5);
        assert_eq!(table.header.line_range, 14);
    }

    #[test]
    fn test_line_table_lookup() {
        let mut header = LineTableHeader::new();
        header
            .file_names
            .push(DwarfFileEntry::new("test.c".into(), 0));

        let mut table = FullLineTable::new();
        table.header = header;
        table.rows.push(LineTableRow {
            address: 0x1000,
            file: 1,
            line: 10,
            column: 5,
            is_stmt: true,
            ..Default::default()
        });
        table.rows.push(LineTableRow {
            address: 0x1100,
            file: 1,
            line: 20,
            column: 3,
            is_stmt: true,
            ..Default::default()
        });

        let row = table.lookup_address(0x1050);
        assert!(row.is_some());
        assert_eq!(row.unwrap().line, 10);

        let row = table.lookup_address(0x2000);
        assert!(row.is_none() || row.unwrap().line == 20);
    }

    // ── Type Decoder tests ────────────────────────────────────────────────

    #[test]
    fn test_type_decoder_base_type() {
        let mut decoder = DwarfTypeDecoder::new(8);
        let mut attrs = HashMap::new();
        attrs.insert(
            "DW_AT_name".into(),
            DwarfAttributeValue::String("int".into()),
        );
        attrs.insert("DW_AT_encoding".into(), DwarfAttributeValue::U64(5)); // signed
        attrs.insert("DW_AT_byte_size".into(), DwarfAttributeValue::U64(4));

        let result = decoder.decode_die(crate::dwarf::dwarf_tags::DW_TAG_base_type, &attrs, &[], 0);

        match result {
            DecodedType::Base(b) => {
                assert_eq!(b.name, "int");
                assert_eq!(b.byte_size, 4);
            }
            other => panic!("expected Base, got {:?}", other),
        }
    }

    #[test]
    fn test_type_decoder_pointer() {
        let mut decoder = DwarfTypeDecoder::new(8);

        // First cache the pointee type
        let mut base_attrs = HashMap::new();
        base_attrs.insert(
            "DW_AT_name".into(),
            DwarfAttributeValue::String("char".into()),
        );
        base_attrs.insert("DW_AT_encoding".into(), DwarfAttributeValue::U64(6)); // signed char
        base_attrs.insert("DW_AT_byte_size".into(), DwarfAttributeValue::U64(1));
        let base = decoder.decode_die(
            crate::dwarf::dwarf_tags::DW_TAG_base_type,
            &base_attrs,
            &[],
            10,
        );
        decoder.cache_type(10, base);

        let mut ptr_attrs = HashMap::new();
        ptr_attrs.insert("DW_AT_type".into(), DwarfAttributeValue::Reference(10));
        ptr_attrs.insert("DW_AT_byte_size".into(), DwarfAttributeValue::U64(8));

        let result = decoder.decode_die(
            crate::dwarf::dwarf_tags::DW_TAG_pointer_type,
            &ptr_attrs,
            &[],
            20,
        );

        match result {
            DecodedType::Pointer(p) => {
                assert_eq!(p.byte_size, 8);
            }
            other => panic!("expected Pointer, got {:?}", other),
        }
    }

    #[test]
    fn test_type_decoder_const() {
        let mut decoder = DwarfTypeDecoder::new(8);

        // Cache the base type
        let mut base_attrs = HashMap::new();
        base_attrs.insert(
            "DW_AT_name".into(),
            DwarfAttributeValue::String("int".into()),
        );
        base_attrs.insert("DW_AT_encoding".into(), DwarfAttributeValue::U64(5));
        base_attrs.insert("DW_AT_byte_size".into(), DwarfAttributeValue::U64(4));
        let base = decoder.decode_die(
            crate::dwarf::dwarf_tags::DW_TAG_base_type,
            &base_attrs,
            &[],
            10,
        );
        decoder.cache_type(10, base);

        let mut const_attrs = HashMap::new();
        const_attrs.insert("DW_AT_type".into(), DwarfAttributeValue::Reference(10));

        let result = decoder.decode_die(
            crate::dwarf::dwarf_tags::DW_TAG_const_type,
            &const_attrs,
            &[],
            30,
        );

        match result {
            DecodedType::Const(_) => {}
            other => panic!("expected Const, got {:?}", other),
        }
    }

    #[test]
    fn test_type_display() {
        let t = DecodedType::Base(BaseType {
            name: "int".into(),
            encoding: BaseTypeEncoding::Signed,
            byte_size: 4,
            bit_size: 32,
            bit_offset: 0,
        });
        assert_eq!(format!("{}", t), "int");

        let t = DecodedType::Pointer(PointerType {
            pointee: Box::new(DecodedType::Base(BaseType {
                name: "char".into(),
                encoding: BaseTypeEncoding::UnsignedChar,
                byte_size: 1,
                bit_size: 8,
                bit_offset: 0,
            })),
            byte_size: 8,
            address_class: None,
        });
        assert_eq!(format!("{}", t), "char*");

        let t = DecodedType::Const(ConstType {
            inner: Box::new(DecodedType::Base(BaseType {
                name: "int".into(),
                encoding: BaseTypeEncoding::Signed,
                byte_size: 4,
                bit_size: 32,
                bit_offset: 0,
            })),
        });
        assert_eq!(format!("{}", t), "const int");

        let t = DecodedType::Unspecified;
        assert_eq!(format!("{}", t), "void");
    }

    // ── Structure type tests ──────────────────────────────────────────────

    #[test]
    fn test_type_decoder_struct() {
        let mut decoder = DwarfTypeDecoder::new(8);

        let mut attrs = HashMap::new();
        attrs.insert(
            "DW_AT_name".into(),
            DwarfAttributeValue::String("Point".into()),
        );
        attrs.insert("DW_AT_byte_size".into(), DwarfAttributeValue::U64(8));

        let children: Vec<HashMap<String, DwarfAttributeValue>> = vec![];

        let result = decoder.decode_die(
            crate::dwarf::dwarf_tags::DW_TAG_structure_type,
            &attrs,
            &children,
            100,
        );

        match result {
            DecodedType::Structure(s) => {
                assert_eq!(s.name, "Point");
                assert_eq!(s.byte_size, 8);
                assert_eq!(s.kind, StructKind::Struct);
            }
            other => panic!("expected Structure, got {:?}", other),
        }
    }

    #[test]
    fn test_type_decoder_enum() {
        let mut decoder = DwarfTypeDecoder::new(8);

        let mut attrs = HashMap::new();
        attrs.insert(
            "DW_AT_name".into(),
            DwarfAttributeValue::String("Color".into()),
        );
        attrs.insert("DW_AT_byte_size".into(), DwarfAttributeValue::U64(4));

        let mut red = HashMap::new();
        red.insert(
            "DW_AT_name".into(),
            DwarfAttributeValue::String("Red".into()),
        );
        red.insert("DW_AT_const_value".into(), DwarfAttributeValue::I64(0));

        let mut green = HashMap::new();
        green.insert(
            "DW_AT_name".into(),
            DwarfAttributeValue::String("Green".into()),
        );
        green.insert("DW_AT_const_value".into(), DwarfAttributeValue::I64(1));

        let children = vec![red, green];

        let result = decoder.decode_die(
            crate::dwarf::dwarf_tags::DW_TAG_enumeration_type,
            &attrs,
            &children,
            200,
        );

        match result {
            DecodedType::Enumeration(e) => {
                assert_eq!(e.name, "Color");
                assert_eq!(e.byte_size, 4);
                assert_eq!(e.enumerators.len(), 2);
                assert_eq!(e.enumerators[0].value, 0);
                assert_eq!(e.enumerators[1].value, 1);
            }
            other => panic!("expected Enumeration, got {:?}", other),
        }
    }

    // ── Location List Parser tests ────────────────────────────────────────

    #[test]
    fn test_loclist_dwarf5_offset_pair() {
        let parser = LocationListParser::new(8);
        let mut data = Vec::new();

        // DW_LLE_offset_pair: start_off=0, end_off=16, expr_len=1, expr=[0x9f]
        data.push(0x04); // DW_LLE_offset_pair
        data.push(0x00); // start ULEB = 0
        data.push(0x10); // end ULEB = 16
        data.push(0x01); // expr_len ULEB = 1
        data.push(0x9f); // DW_OP_stack_value
        data.push(0x00); // DW_LLE_end_of_list

        let result = parser.parse_loclists_dwarf5(&data, 0x1000);
        assert!(result.is_ok());
        let entries = result.unwrap();
        assert_eq!(entries.len(), 2);
        assert_eq!(entries[0].start_address, 0x1000);
        assert_eq!(entries[0].end_address, 0x1010);
        assert!(entries[1].is_end_of_list);
    }

    #[test]
    fn test_loclist_dwarf4_simple() {
        let parser = LocationListParser::new(8);
        let mut data = Vec::new();

        // Entry: start=0x1000, end=0x2000, expr=[0x9f]
        data.extend_from_slice(&0x1000u64.to_le_bytes());
        data.extend_from_slice(&0x2000u64.to_le_bytes());
        data.extend_from_slice(&1u16.to_le_bytes()); // expr_len = 1
        data.push(0x9f);
        // End of list
        data.extend_from_slice(&0u64.to_le_bytes());
        data.extend_from_slice(&0u64.to_le_bytes());

        let result = parser.parse_loc_dwarf4(&data);
        assert!(result.is_ok());
        let entries = result.unwrap();
        assert_eq!(entries.len(), 2);
        assert_eq!(entries[0].start_address, 0x1000);
        assert_eq!(entries[0].end_address, 0x2000);
        assert!(entries[1].is_end_of_list);
    }

    // ── Range List Parser tests ───────────────────────────────────────────

    #[test]
    fn test_rnglist_dwarf5_start_end() {
        let parser = RangeListParser::new(8);
        let mut data = Vec::new();

        // DW_RLE_start_end: start=0x1000, end=0x2000
        data.push(0x06);
        data.extend_from_slice(&0x1000u64.to_le_bytes());
        data.extend_from_slice(&0x2000u64.to_le_bytes());
        data.push(0x00); // end of list

        let result = parser.parse_rnglists_dwarf5(&data, 0);
        assert!(result.is_ok());
        let ranges = result.unwrap();
        assert_eq!(ranges.len(), 1);
        assert_eq!(ranges[0].start, 0x1000);
        assert_eq!(ranges[0].end, 0x2000);
    }

    #[test]
    fn test_rangelist_dwarf4_simple() {
        let parser = RangeListParser::new(8);
        let mut data = Vec::new();

        data.extend_from_slice(&0x1000u64.to_le_bytes());
        data.extend_from_slice(&0x2000u64.to_le_bytes());
        data.extend_from_slice(&0u64.to_le_bytes());
        data.extend_from_slice(&0u64.to_le_bytes());

        let result = parser.parse_ranges_dwarf4(&data);
        assert!(result.is_ok());
        let ranges = result.unwrap();
        assert_eq!(ranges.len(), 1);
        assert_eq!(ranges[0].start, 0x1000);
        assert_eq!(ranges[0].end, 0x2000);
    }

    // ── Macro Parser tests ────────────────────────────────────────────────

    #[test]
    fn test_macro_parser_define() {
        // Version 5, flags=0, debug_line_offset LE 32 = 0
        let mut data = vec![0x05, 0x00]; // version 5
        data.push(0x00); // flags
        data.extend_from_slice(&0u32.to_le_bytes()); // debug_line_offset=0
                                                     // DW_MACRO_define: line=1, name="FOO", value="bar"
        data.push(0x01); // DW_MACRO_define
        data.push(0x01); // line ULEB=1
        data.extend_from_slice(b"FOO");
        data.push(0);
        data.extend_from_slice(b"bar");
        data.push(0);
        data.push(0x00); // end

        let mut parser = MacroParser::new(data);
        let result = parser.parse();
        assert!(result.is_ok());
        let entries = result.unwrap();
        assert_eq!(entries.len(), 1);
        match &entries[0] {
            MacroEntry::Define { line, name, value } => {
                assert_eq!(*line, 1);
                assert_eq!(name, "FOO");
                assert_eq!(value, "bar");
            }
            _ => panic!("expected Define"),
        }
    }

    #[test]
    fn test_macro_parser_undef() {
        let mut data = vec![0x05, 0x00];
        data.push(0x00);
        data.extend_from_slice(&0u32.to_le_bytes());
        // DW_MACRO_undef: line=2, name="BAR"
        data.push(0x02);
        data.push(0x02);
        data.extend_from_slice(b"BAR");
        data.push(0);
        data.push(0x00);

        let mut parser = MacroParser::new(data);
        let result = parser.parse();
        assert!(result.is_ok());
        let entries = result.unwrap();
        assert_eq!(entries.len(), 1);
        match &entries[0] {
            MacroEntry::Undef { line, name } => {
                assert_eq!(*line, 2);
                assert_eq!(name, "BAR");
            }
            _ => panic!("expected Undef"),
        }
    }

    #[test]
    fn test_macro_parser_start_end_file() {
        let mut data = vec![0x05, 0x00];
        data.push(0x00);
        data.extend_from_slice(&0u32.to_le_bytes());
        // DW_MACRO_start_file: line=1, file_index=0
        data.push(0x03);
        data.push(0x01); // line=1
        data.push(0x00); // file_index=0
                         // DW_MACRO_end_file
        data.push(0x04);
        data.push(0x00);

        let mut parser = MacroParser::new(data);
        let result = parser.parse();
        assert!(result.is_ok());
        let entries = result.unwrap();
        assert_eq!(entries.len(), 2);
        assert!(matches!(entries[0], MacroEntry::StartFile { .. }));
        assert!(matches!(entries[1], MacroEntry::EndFile));
    }

    // ── Name Index Parser tests ───────────────────────────────────────────

    #[test]
    fn test_name_index_parse() {
        // Craft a minimal .debug_names section
        let mut data = Vec::new();
        // unit_length (not including these 4 bytes)
        let header_size = 12 + 4 + 4 + 4 + 4 + 4 + 4 + 1;
        data.extend_from_slice(&(header_size as u32 - 4).to_le_bytes());
        // version 5
        data.extend_from_slice(&5u16.to_le_bytes());
        // padding
        data.extend_from_slice(&0u16.to_le_bytes());
        // cu_count=0
        data.extend_from_slice(&0u32.to_le_bytes());
        // local_tu_count=0
        data.extend_from_slice(&0u32.to_le_bytes());
        // foreign_tu_count=0
        data.extend_from_slice(&0u32.to_le_bytes());
        // bucket_count=0
        data.extend_from_slice(&0u32.to_le_bytes());
        // name_count=0
        data.extend_from_slice(&0u32.to_le_bytes());
        // abbrev_table_size=0
        data.extend_from_slice(&0u32.to_le_bytes());
        // augmentation_string_size=0
        data.push(0);

        let mut parser = NameIndexParser::new(data);
        let result = parser.parse();
        assert!(result.is_ok());
        let (name_count, entries) = result.unwrap();
        assert_eq!(name_count, 0);
        assert!(entries.is_empty());
    }

    // ── String Offsets Table tests ─────────────────────────────────────────

    #[test]
    fn test_str_offsets_parse() {
        let mut data = Vec::new();
        // unit_length = 8 (next 8 bytes: version + padding + two 32-bit offsets)
        data.extend_from_slice(&8u32.to_le_bytes());
        // version = 5
        data.extend_from_slice(&5u16.to_le_bytes());
        // padding = 0
        data.extend_from_slice(&0u16.to_le_bytes());
        // offset 0 = 0
        data.extend_from_slice(&0u32.to_le_bytes());
        // offset 1 = 16
        data.extend_from_slice(&16u32.to_le_bytes());

        let result = StringOffsetsTable::parse(&data, 0);
        assert!(result.is_ok());
        let table = result.unwrap();
        assert_eq!(table.len(), 2);
        assert_eq!(table.get_offset(0), Some(0));
        assert_eq!(table.get_offset(1), Some(16));
    }

    // ── DWARF Deep Utils tests ────────────────────────────────────────────

    #[test]
    fn test_deep_utils_eval_as_address() {
        let expr = vec![
            0x06, // DW_OP_addr
            0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        ];
        let result = DwarfDeepUtils::eval_as_address(&expr, 8);
        assert_eq!(result, Some(0x400000));
    }

    #[test]
    fn test_disassemble_expression() {
        let expr = vec![0x30, 0x31, 0x22]; // lit0, lit1, plus
        let disasm = DwarfDeepUtils::disassemble_expression(&expr);
        assert!(disasm.contains("DW_OP_lit0"));
        assert!(disasm.contains("DW_OP_lit1"));
        assert!(disasm.contains("DW_OP_plus"));
    }

    #[test]
    fn test_opcode_names_coverage() {
        // Test that all opcodes have non-empty names
        for b in 0u8..=255 {
            let op = DwarfOpcode::from_byte(b);
            let name = op.name();
            assert!(!name.is_empty(), "empty name for opcode {:#x}", b);
        }
    }

    #[test]
    fn test_opcode_from_byte_known() {
        assert_eq!(DwarfOpcode::from_byte(0x03), DwarfOpcode::Reg);
        assert_eq!(DwarfOpcode::from_byte(0x06), DwarfOpcode::Addr);
        assert_eq!(DwarfOpcode::from_byte(0x22), DwarfOpcode::Plus);
        assert_eq!(DwarfOpcode::from_byte(0x93), DwarfOpcode::Piece);
        assert_eq!(DwarfOpcode::from_byte(0x9c), DwarfOpcode::CallFrameCfa);
    }

    #[test]
    fn test_deep_utils_new() {
        let utils = DwarfDeepUtils::new(8, 5);
        assert_eq!(utils.address_size, 8);
        assert_eq!(utils.dwarf_version, 5);
    }

    #[test]
    fn test_piece_creation() {
        let p = DwarfPiece::byte_piece(vec![0x03, 0x00], 4);
        assert_eq!(p.size_in_bits, 32);
        assert_eq!(p.size_in_bytes(), 4);
        assert!(!p.is_bit_piece);

        let p = DwarfPiece::bit_piece(vec![0x03, 0x00], 1, 3);
        assert_eq!(p.size_in_bits, 1);
        assert_eq!(p.size_in_bytes(), 1);
        assert_eq!(p.offset_in_bits, 3);
        assert!(p.is_bit_piece);
    }

    #[test]
    fn test_eval_result_error() {
        let result = EvalResult::error("test error");
        assert!(!result.success);
        assert_eq!(result.error, Some("test error".to_string()));
        assert!(result.value.is_none());
    }

    #[test]
    fn test_eval_result_default() {
        let result = EvalResult::default();
        assert!(result.success);
        assert!(result.value.is_none());
        assert!(!result.is_composite);
        assert!(!result.is_stack_value);
    }
}