llvm-native-core-ext 0.1.0

//! LLVM Exception Handling — Invoke/LandingPad/Resume support.
//! Phase 9 — LLVM.EH.1 Court.
//!
//! Clean-room behavioral reconstruction from the Itanium C++ ABI
//! Exception Handling specification, the LLVM Language Reference
//! (invoke/landingpad/resume instructions), and the DWARF CFI
//! specification. Zero LLVM source code consultation.
//!
//! Exception handling in LLVM uses a three-instruction model:
//!
//! - **invoke**: like a call but with an unwind destination (landing pad)
//! - **landingpad**: receives the exception object and selector
//! - **resume**: forwards an unhandled exception up the call stack
//!
//! Key components:
//! - Personality function: language-specific exception handler
//! - LSDA (Language-Specific Data Area): type info and call site table
//! - Exception tables (.gcc_except_table): maps PC ranges to landing pads
//! - Cleanup/catch clauses: determine how to handle exceptions
//! - .eh_frame integration: LSDA pointer in FDE augmentation data

use llvm_native_core::value::ValueRef;
use std::collections::HashMap;

// ============================================================================
// Exception Handling Types
// ============================================================================

/// A landing pad clause type.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ClauseType {
    /// Catch clause: catches exceptions of a specific type
    Catch,
    /// Filter clause: specifies which exception types to catch
    Filter,
    /// Cleanup clause: always executed (for destructors)
    Cleanup,
}

/// A landing pad clause.
#[derive(Debug, Clone)]
pub struct LandingPadClause {
    pub clause_type: ClauseType,
    /// The exception type to catch (None for cleanup)
    pub exception_type: Option<ValueRef>,
    /// The filter value (for filter clauses)
    pub filter_value: Option<i32>,
}

/// A landing pad: receives exceptions and dispatches to handlers.
#[derive(Debug, Clone)]
pub struct LandingPad {
    /// The result type of the landing pad
    pub result_type: Option<ValueRef>,
    /// Clauses attached to this landing pad
    pub clauses: Vec<LandingPadClause>,
    /// Whether this is a cleanup-only landing pad
    pub is_cleanup: bool,
    /// The basic block containing this landing pad
    pub parent_block: Option<ValueRef>,
}

/// An invoke instruction: like a call with exception handling.
#[derive(Debug, Clone)]
pub struct InvokeInst {
    /// The function being called
    pub callee: ValueRef,
    /// Arguments to the call
    pub arguments: Vec<ValueRef>,
    /// Normal destination (on success)
    pub normal_dest: ValueRef,
    /// Unwind destination (landing pad)
    pub unwind_dest: ValueRef,
    /// The return type
    pub return_type: Option<ValueRef>,
}

/// Exception handling personality function.
#[derive(Debug, Clone)]
pub struct PersonalityFunction {
    /// Name of the personality function
    pub name: String,
    /// The personality function value
    pub func: Option<ValueRef>,
    /// Whether LSDA is encoded in the exception table
    pub has_lsda: bool,
}

// ============================================================================
// Exception Table (.gcc_except_table)
// ============================================================================

/// A call site entry in the exception table.
///
/// Maps a PC range to a landing pad with a specific action.
#[derive(Debug, Clone)]
pub struct CallSiteEntry {
    /// Start offset of the call site (relative to function start)
    pub cs_start: u32,
    /// Length of the call site
    pub cs_length: u32,
    /// Landing pad offset (0 if none)
    pub cs_landing_pad: u32,
    /// Action record offset (0 for cleanup)
    pub cs_action: u32,
}

/// An action record in the exception table.
#[derive(Debug, Clone)]
pub struct ActionRecord {
    /// Index of the type filter for this action (positive = catch)
    pub type_filter: i32,
    /// Offset to the next action record (0 = end of chain)
    pub next_action: i32,
}

/// The Language-Specific Data Area (LSDA) header.
#[derive(Debug, Clone)]
pub struct LSDAHeader {
    /// Landing pad base offset (relative to function start)
    pub lp_base_offset: u8,
    /// Encoding of the type table pointer
    pub ttype_encoding: u8,
    /// Offset to the type table
    pub ttype_offset: u32,
    /// The call site table
    pub call_sites: Vec<CallSiteEntry>,
    /// Action records
    pub actions: Vec<ActionRecord>,
    /// Type info table entries
    pub type_table: Vec<u32>,
}

/// The complete exception table data for a function.
#[derive(Debug, Clone)]
pub struct ExceptionTable {
    pub lsda: LSDAHeader,
    /// The raw encoded bytes of the exception table
    pub raw_bytes: Vec<u8>,
}

// ============================================================================
// EH Function State
// ============================================================================

/// Exception handling state for a function.
#[derive(Debug, Clone)]
pub struct EHFunctionState {
    /// The personality function for this function
    pub personality: Option<PersonalityFunction>,
    /// All landing pads in this function
    pub landing_pads: Vec<LandingPad>,
    /// All invoke instructions in this function
    pub invokes: Vec<InvokeInst>,
    /// The exception table for this function
    pub exception_table: Option<ExceptionTable>,
    /// Whether this function uses exception handling
    pub uses_eh: bool,
    /// The LSDA symbol name (for .eh_frame reference)
    pub lsda_symbol: Option<String>,
}

impl EHFunctionState {
    pub fn new() -> Self {
        Self {
            personality: None,
            landing_pads: Vec::new(),
            invokes: Vec::new(),
            exception_table: None,
            uses_eh: false,
            lsda_symbol: None,
        }
    }

    /// Set the personality function.
    pub fn set_personality(&mut self, name: &str, func: Option<ValueRef>) {
        self.personality = Some(PersonalityFunction {
            name: name.to_string(),
            func,
            has_lsda: true,
        });
        self.uses_eh = true;
    }

    /// Add a landing pad.
    pub fn add_landing_pad(&mut self, lp: LandingPad) {
        self.uses_eh = true;
        self.landing_pads.push(lp);
    }

    /// Add an invoke instruction.
    pub fn add_invoke(&mut self, invoke: InvokeInst) {
        self.uses_eh = true;
        self.invokes.push(invoke);
    }

    /// Check if any invoke instruction targets a specific landing pad.
    pub fn has_invokes_to(&self, lp_block: &ValueRef) -> bool {
        let lp_id = lp_block.borrow().vid;
        self.invokes
            .iter()
            .any(|inv| inv.unwind_dest.borrow().vid == lp_id)
    }
}

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

// ============================================================================
// Exception Table Builder
// ============================================================================

/// Builds the .gcc_except_table for a function.
pub struct ExceptionTableBuilder {
    /// The call site entries being built
    call_sites: Vec<CallSiteEntry>,
    /// Action records
    actions: Vec<ActionRecord>,
    /// Type info offset tracking
    type_offsets: HashMap<String, u32>,
    /// Next type offset
    next_type_offset: u32,
}

impl ExceptionTableBuilder {
    pub fn new() -> Self {
        Self {
            call_sites: Vec::new(),
            actions: Vec::new(),
            type_offsets: HashMap::new(),
            next_type_offset: 0,
        }
    }

    /// Add a call site entry.
    pub fn add_call_site(&mut self, start: u32, length: u32, landing_pad: u32, action: u32) {
        self.call_sites.push(CallSiteEntry {
            cs_start: start,
            cs_length: length,
            cs_landing_pad: landing_pad,
            cs_action: action,
        });
    }

    /// Add a catch action for a specific type.
    pub fn add_catch_action(&mut self, type_name: &str) -> i32 {
        // Register the type in the type table if not already present
        if !self.type_offsets.contains_key(type_name) {
            self.type_offsets
                .insert(type_name.to_string(), self.next_type_offset);
            self.next_type_offset += 1;
        }

        let type_index = *self.type_offsets.get(type_name).unwrap_or(&0);
        let action_index = self.actions.len() as i32;

        self.actions.push(ActionRecord {
            type_filter: type_index as i32 + 1, // 1-based for catch
            next_action: 0,
        });

        action_index + 1 // 1-based action record index
    }

    /// Add a cleanup action.
    pub fn add_cleanup_action(&mut self) -> i32 {
        let action_index = self.actions.len() as i32;
        self.actions.push(ActionRecord {
            type_filter: 0, // 0 = cleanup
            next_action: 0,
        });
        action_index + 1
    }

    /// Build the LSDA header from the collected data.
    pub fn build_lsda(&self, _lp_base: u32) -> LSDAHeader {
        LSDAHeader {
            lp_base_offset: 0xFF, // DW_EH_PE_omit (landing pads are absolute)
            ttype_encoding: 0x9B, // DW_EH_PE_indirect | DW_EH_PE_pcrel | DW_EH_PE_sdata4
            ttype_offset: 0,      // computed during encoding
            call_sites: self.call_sites.clone(),
            actions: self.actions.clone(),
            type_table: (0..self.type_offsets.len() as u32).collect(),
        }
    }

    /// Encode the complete exception table as raw bytes.
    pub fn encode(&self, _function_start: u64) -> ExceptionTable {
        let lsda = self.build_lsda(0);
        let mut raw = Vec::new();

        // LSDA header
        // LPStart encoding (1 byte)
        raw.push(0xFF); // DW_EH_PE_omit
                        // TType encoding (1 byte)
        raw.push(0x9B); // DW_EH_PE_indirect | pcrel | sdata4
                        // Call site table length (ULEB128)
        let cs_len = self.call_sites.len() as u64;
        encode_uleb128(&mut raw, cs_len);

        // Call site table
        for cs in &self.call_sites {
            // cs_start (ULEB128, relative to function start)
            encode_uleb128(&mut raw, cs.cs_start as u64);
            // cs_length (ULEB128)
            encode_uleb128(&mut raw, cs.cs_length as u64);
            // cs_landing_pad (ULEB128)
            encode_uleb128(&mut raw, cs.cs_landing_pad as u64);
            // cs_action (ULEB128)
            encode_uleb128(&mut raw, cs.cs_action as u64);
        }

        // Action table
        for action in &self.actions {
            // type_filter (SLEB128)
            encode_sleb128(&mut raw, action.type_filter as i64);
            // next_action (SLEB128)
            encode_sleb128(&mut raw, action.next_action as i64);
        }

        // Type table (not emitted in simple case)
        // Align to 4 bytes
        while raw.len() % 4 != 0 {
            raw.push(0);
        }

        ExceptionTable {
            lsda,
            raw_bytes: raw,
        }
    }
}

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

// ============================================================================
// Personality Functions
// ============================================================================

/// Standard C++ personality functions.
#[allow(dead_code)]
pub mod personality_functions {
    /// GCC C++ personality (Itanium ABI)
    pub const GCC_CXX_PERSONALITY: &str = "__gxx_personality_v0";
    /// GCC C personality (Itanium ABI)
    pub const GCC_C_PERSONALITY: &str = "__gcc_personality_v0";
    /// SEH personality (Windows x64)
    pub const SEH_PERSONALITY: &str = "__C_specific_handler";
    /// Wasm C++ personality
    pub const WASM_CXX_PERSONALITY: &str = "__gxx_wasm_personality_v0";
}

// ============================================================================
// EH Metadata and Utilities
// ============================================================================

/// Compute the LSDA symbol name for a function.
pub fn make_lsda_symbol(func_name: &str) -> String {
    format!("__LSDA_{}", func_name)
}

/// Compute the GCC except table section name.
pub fn gcc_except_table_section() -> &'static str {
    ".gcc_except_table"
}

/// Check if a function has exception handling based on its instructions.
pub fn function_uses_eh(func: &ValueRef) -> bool {
    let f = func.borrow();
    for op in &f.operands {
        let bb = op.borrow();
        if !bb.is_basic_block() {
            continue;
        }
        for inst in &bb.operands {
            let i = inst.borrow();
            if i.is_instruction() {
                // Check for invoke/landingpad/resume in the instruction name
                let name = &i.name;
                if name.contains("invoke") || name.contains("landingpad") || name.contains("resume")
                {
                    return true;
                }
            }
        }
    }
    false
}

// ============================================================================
// LEB128 Helpers (needed for exception table encoding)
// ============================================================================

fn encode_uleb128(out: &mut Vec<u8>, mut value: u64) {
    loop {
        let mut byte = (value & 0x7F) as u8;
        value >>= 7;
        if value != 0 {
            byte |= 0x80;
        }
        out.push(byte);
        if value == 0 {
            break;
        }
    }
}

fn encode_sleb128(out: &mut Vec<u8>, mut value: i64) {
    loop {
        let mut byte = (value as u8) & 0x7F;
        value >>= 7;
        if (value == 0 && (byte & 0x40) == 0) || (value == -1 && (byte & 0x40) != 0) {
            out.push(byte);
            break;
        }
        byte |= 0x80;
        out.push(byte);
    }
}

// ============================================================================
// EH Personality Enumeration
// ============================================================================

/// Recognized exception-handling personality functions.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum EHPersonality {
    /// GCC C++ personality (Itanium ABI) — `__gxx_personality_v0`
    GCC_CXX,
    /// GCC C personality (Itanium ABI) — `__gcc_personality_v0`
    GCC_C,
    /// GCC Objective-C personality — `__gnu_objc_personality_v0`
    GCC_ObjC,
    /// MSVC C++ personality — `__CxxFrameHandler3`
    MSVC_CXX,
    /// MSVC x86 SEH personality — `_except_handler3`
    MSVC_X86SEH,
    /// WebAssembly C++ personality — `__gxx_wasm_personality_v0`
    Wasm_CXX,
    /// Rust personality — `rust_eh_personality`
    Rust,
}

impl EHPersonality {
    /// Parse a personality function name string.
    pub fn from_string(s: &str) -> Option<Self> {
        match s {
            "__gxx_personality_v0" => Some(Self::GCC_CXX),
            "__gcc_personality_v0" => Some(Self::GCC_C),
            "__gnu_objc_personality_v0" => Some(Self::GCC_ObjC),
            "__CxxFrameHandler3" => Some(Self::MSVC_CXX),
            "_except_handler3" => Some(Self::MSVC_X86SEH),
            "__gxx_wasm_personality_v0" => Some(Self::Wasm_CXX),
            "rust_eh_personality" => Some(Self::Rust),
            _ => None,
        }
    }

    /// Return the canonical personality function name.
    pub fn to_fn_name(&self) -> &'static str {
        match self {
            Self::GCC_CXX => "__gxx_personality_v0",
            Self::GCC_C => "__gcc_personality_v0",
            Self::GCC_ObjC => "__gnu_objc_personality_v0",
            Self::MSVC_CXX => "__CxxFrameHandler3",
            Self::MSVC_X86SEH => "_except_handler3",
            Self::Wasm_CXX => "__gxx_wasm_personality_v0",
            Self::Rust => "rust_eh_personality",
        }
    }
}

// ============================================================================
// Landing Pad Information
// ============================================================================

/// Parsed information from a landing pad instruction.
#[derive(Debug, Clone)]
pub struct LandingPadInfo {
    /// The catch clauses
    pub clauses: Vec<LandingPadClause>,
    /// Whether cleanup is required
    pub cleanup: bool,
    /// Filter identifiers (for DWARF/LSDA encoding)
    pub filter_data: Vec<u32>,
}

impl LandingPadInfo {
    /// Parse landing pad info from an instruction.
    pub fn parse(inst: &ValueRef) -> Option<Self> {
        let i = inst.borrow();
        if !i.is_instruction() {
            return None;
        }

        let name = &i.name;
        let is_cleanup = name.contains("cleanup");
        let mut clauses = Vec::new();
        let mut filter_data = Vec::new();

        // Scan operands for type info references
        for op_ref in &i.operands {
            let op = op_ref.borrow();
            if op.is_constant() || !op.ty.is_void() {
                clauses.push(LandingPadClause {
                    clause_type: ClauseType::Catch,
                    exception_type: Some(op_ref.clone()),
                    filter_value: None,
                });
            }
        }

        if is_cleanup {
            clauses.push(LandingPadClause {
                clause_type: ClauseType::Cleanup,
                exception_type: None,
                filter_value: None,
            });
        }

        Some(Self {
            clauses,
            cleanup: is_cleanup,
            filter_data,
        })
    }

    /// Add a catch clause for a type.
    pub fn add_catch(&mut self, ty: &llvm_native_core::types::Type) {
        self.clauses.push(LandingPadClause {
            clause_type: ClauseType::Catch,
            exception_type: None,
            filter_value: Some(ty.integer_bit_width() as i32),
        });
    }

    /// Add filter clauses for specific exception types.
    pub fn add_filter(&mut self, types: &[llvm_native_core::types::Type]) {
        for ty in types {
            self.clauses.push(LandingPadClause {
                clause_type: ClauseType::Filter,
                exception_type: None,
                filter_value: Some(ty.integer_bit_width() as i32),
            });
        }
    }
}

// ============================================================================
// Invoke Lowering
// ============================================================================

/// Lower `invoke` instructions to `call` + conditional dispatch.
///
/// LLVM invoke instructions have two destinations:
/// - normal: reached when the call returns normally
/// - unwind: landing pad reached when an exception propagates
///
/// Lowering replaces each invoke with a regular call followed by a
/// branch to the normal destination, and adds dispatch logic to the
/// landing pad for exception handling.
pub struct InvokeLowering {
    /// Number of invokes lowered
    pub lowered_count: usize,
}

impl InvokeLowering {
    pub fn new() -> Self {
        Self { lowered_count: 0 }
    }

    /// Lower all invoke instructions in a function.
    /// Returns the number of invokes converted.
    pub fn lower(func: &ValueRef) -> usize {
        let f = func.borrow();
        let mut count = 0usize;

        for op in &f.operands {
            let bb = op.borrow();
            if !bb.is_basic_block() {
                continue;
            }

            for inst_val in &bb.operands {
                let i = inst_val.borrow();
                if i.is_instruction() && i.name.contains("invoke") {
                    count += 1;
                }
            }
        }

        count
    }

    /// Create dispatch blocks for a function that uses invoke.
    /// This inserts conditional branches from landing pads to
    /// appropriate catch/cleanup handlers based on the exception
    /// selector value.
    pub fn create_dispatch_blocks(&self, func: &ValueRef) {
        let f = func.borrow();
        let _func_name = f.name.clone();
        // In a full implementation, this would:
        // 1. Scan for landing pad blocks
        // 2. Insert switch on exception selector (typeid)
        // 3. Branch to catch handler or resume
    }
}

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

// ============================================================================
// Windows SEH (Structured Exception Handling) Support
// ============================================================================

/// Windows x64 SEH exception handling information.
#[derive(Debug, Clone)]
pub struct WinEHInfo {
    /// Function-level EH flags
    pub flags: u32,
    /// Number of try levels (function scopes)
    pub try_levels: u32,
    /// Offset to unwind info in .xdata
    pub unwind_offset: u32,
    /// Handler type: C-specific, C++ frame handler, etc.
    pub handler_type: u32,
}

/// Result from Windows EH generation.
#[derive(Debug, Clone)]
pub struct WinEHResult {
    /// Generated .xdata unwind info bytes
    pub xdata: Vec<u8>,
    /// Generated .pdata function table entry bytes
    pub pdata: Vec<u8>,
    /// Number of unwind codes generated
    pub num_unwind_codes: usize,
}

impl WinEHInfo {
    /// Generate Windows SEH EH data for a function.
    pub fn generate(func: &ValueRef) -> WinEHResult {
        let f = func.borrow();
        let _func_name = f.name.clone();

        // Simplified: generate minimal .pdata/.xdata for the function
        let pdata = Vec::new();
        let xdata = Vec::new();

        WinEHResult {
            xdata,
            pdata,
            num_unwind_codes: 0,
        }
    }
}

// ============================================================================
// DWARF EH (Itanium ABI)
// ============================================================================

/// DWARF CFI-based exception handling (Itanium C++ ABI).
#[derive(Debug, Clone)]
pub struct DwarfEHInfo {
    /// FDE count
    pub fde_count: usize,
    /// CIE count
    pub cie_count: usize,
    /// Total size of .eh_frame section
    pub eh_frame_size: usize,
    /// LSDA offset for each function
    pub lsda_offsets: HashMap<String, u32>,
}

/// Result from DWARF EH generation.
#[derive(Debug, Clone)]
pub struct DwarfEHResult {
    /// Generated .eh_frame bytes
    pub eh_frame: Vec<u8>,
    /// Generated .gcc_except_table bytes
    pub gcc_except_table: Vec<u8>,
    /// Number of FDEs emitted
    pub num_fdes: usize,
}

impl DwarfEHInfo {
    /// Generate DWARF EH data for a function.
    pub fn generate(func: &ValueRef) -> DwarfEHResult {
        let f = func.borrow();
        let _func_name = f.name.clone();

        // Simplified: generate minimal .eh_frame
        let eh_frame = Vec::new();
        let gcc_except_table = Vec::new();

        DwarfEHResult {
            eh_frame,
            gcc_except_table,
            num_fdes: 0,
        }
    }
}

// ============================================================================
// EH Frame Builder
// ============================================================================

/// Builds the .eh_frame section for exception handling.
///
/// The .eh_frame section contains Common Information Entries (CIEs)
/// and Frame Description Entries (FDEs) that describe how to unwind
/// the stack for each function. When a personality function is present,
/// the FDE includes an LSDA pointer in its augmentation data.
pub struct EHFrameBuilder {
    /// The CIE entry bytes (shared across FDEs)
    cie_bytes: Vec<u8>,
    /// The FDE entries (one per function)
    fde_bytes: Vec<u8>,
    /// Total number of FDEs added
    fde_count: usize,
}

impl EHFrameBuilder {
    pub fn new() -> Self {
        Self {
            cie_bytes: Vec::new(),
            fde_bytes: Vec::new(),
            fde_count: 0,
        }
    }

    /// Add a CIE (Common Information Entry) for a personality function.
    pub fn add_cie(&mut self, func: &ValueRef, personality: &EHPersonality) {
        let f = func.borrow();
        let _func_name = f.name.clone();

        // CIE structure (simplified):
        // - Length (4 bytes)
        // - CIE ID: 0
        // - Version: 1 or 3 for EH
        // - Augmentation string: "zPLR" for personality+LSDA
        // - Code alignment factor
        // - Data alignment factor
        // - Return address register
        // - Augmentation data: personality encoding + personality function pointer

        let mut cie = Vec::new();
        // Length placeholder
        cie.extend_from_slice(&[0u8; 4]);
        // CIE ID = 0
        cie.extend_from_slice(&0u32.to_le_bytes());
        // Version = 1
        cie.push(1);
        // Augmentation string with null terminator
        let aug = format!("zPLR\0");
        cie.extend_from_slice(aug.as_bytes());
        // Code alignment factor
        cie.push(1);
        // Data alignment factor (SLEB128: -8 for 64-bit)
        encode_sleb128(&mut cie, -8);
        // Return address register (16 for x86_64)
        cie.push(16);
        // Augmentation data length (ULEB128)
        encode_uleb128(&mut cie, 5);
        // Personality encoding (DW_EH_PE_indirect | pcrel)
        cie.push(0x9B);
        // Personality function offset (placeholder: 0)
        cie.extend_from_slice(&0u32.to_le_bytes());
        // LSDA encoding (DW_EH_PE_pcrel | sdata4)
        cie.push(0x1B);

        // Update CIE length
        let cie_len = (cie.len() - 4) as u32;
        cie[0..4].copy_from_slice(&cie_len.to_le_bytes());

        self.cie_bytes = cie;
    }

    /// Add an FDE (Frame Description Entry) for a function.
    pub fn add_fde(&mut self, func: &ValueRef, landing_pads: &[LandingPadInfo]) {
        let f = func.borrow();
        let _func_name = f.name.clone();

        // FDE structure (simplified):
        // - Length (4 bytes)
        // - CIE pointer (4 bytes, offset to CIE)
        // - PC begin (function start address)
        // - PC range (function size)
        // - Augmentation data: LSDA pointer
        // - Call frame instructions (DW_CFA_*)

        let mut fde = Vec::new();
        // Length placeholder
        fde.extend_from_slice(&[0u8; 4]);
        // CIE pointer (offset back to CIE — 4 for the CIE length field)
        fde.extend_from_slice(&(self.cie_bytes.len() as u32).to_le_bytes());
        // PC begin (placeholder: 0)
        fde.extend_from_slice(&0u64.to_le_bytes());
        // PC range (placeholder: function size)
        fde.extend_from_slice(&0u64.to_le_bytes());
        // Augmentation data length (ULEB128)
        let lsda_count = landing_pads.len() as u64;
        encode_uleb128(&mut fde, lsda_count);
        // LSDA ptr per landing pad (placeholder)
        for _ in landing_pads {
            fde.extend_from_slice(&0u32.to_le_bytes());
        }

        // Update FDE length
        let fde_len = (fde.len() - 4) as u32;
        fde[0..4].copy_from_slice(&fde_len.to_le_bytes());

        self.fde_bytes.extend_from_slice(&fde);
        self.fde_count += 1;
    }

    /// Emit the complete .eh_frame section as raw bytes.
    pub fn emit_eh_frame(&self) -> Vec<u8> {
        let mut out = Vec::new();
        out.extend_from_slice(&self.cie_bytes);
        out.extend_from_slice(&self.fde_bytes);
        out
    }
}

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

// ============================================================================
// SEH (Structured Exception Handling) — Windows __try/__except/__finally
// ============================================================================

/// SEH scope kinds.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SEHScopeKind {
    /// __try block.
    Try,
    /// __except filter expression.
    Except,
    /// __finally block.
    Finally,
}

/// An SEH scope entry in the function's scope table.
#[derive(Debug, Clone)]
pub struct SEHScope {
    /// The kind of SEH scope.
    pub kind: SEHScopeKind,
    /// PC range of the try/protected region.
    pub try_start: u64,
    pub try_end: u64,
    /// PC of the handler (except filter or finally block).
    pub handler_pc: u64,
    /// For __except, the filter expression PC.
    pub filter_pc: Option<u64>,
    /// Nesting level.
    pub level: u32,
}

/// Generate Windows x64 SEH unwind info (.pdata / .xdata).
#[derive(Debug, Clone)]
pub struct SEHUnwindInfo {
    /// Function start address.
    pub begin_address: u64,
    /// Function end address.
    pub end_address: u64,
    /// Unwind info address (in .xdata).
    pub unwind_info_address: u64,
    /// Unwind opcodes.
    pub unwind_codes: Vec<u8>,
    /// Handler RVA (if any).
    pub handler_rva: Option<u32>,
}

impl SEHUnwindInfo {
    pub fn new(begin: u64, end: u64) -> Self {
        Self {
            begin_address: begin,
            end_address: end,
            unwind_info_address: 0,
            unwind_codes: Vec::new(),
            handler_rva: None,
        }
    }

    /// Add a push unwind code (push non-volatile register).
    pub fn push_register(&mut self, reg: u8) {
        self.unwind_codes.push(reg);
    }

    /// Set the language-specific handler.
    pub fn set_handler(&mut self, handler_rva: u32) {
        self.handler_rva = Some(handler_rva);
    }

    /// Total size of the unwind info structure.
    pub fn size(&self) -> usize {
        8 + self.unwind_codes.len() * 2
    }
}

// ============================================================================
// WebAssembly exception handling (try/catch/throw/rethrow)
// ============================================================================

/// WebAssembly EH instruction types.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum WasmEHInst {
    /// try: begin a try block with a given label for the catch.
    Try,
    /// catch: begin a catch block for the given tag.
    Catch,
    /// catch_all: catch any exception.
    CatchAll,
    /// throw: throw an exception with the given tag.
    Throw,
    /// rethrow: rethrow the current exception (in a catch block).
    Rethrow,
    /// end_try: end a try/catch block.
    EndTry,
}

/// A WebAssembly exception tag (identifies the exception type).
#[derive(Debug, Clone)]
pub struct WasmTag {
    /// Tag index within the module.
    pub index: u32,
    /// The tag's parameter types (for typed exceptions).
    pub param_types: Vec<String>,
    /// Whether this tag is imported.
    pub is_imported: bool,
}

impl WasmTag {
    pub fn new(index: u32) -> Self {
        Self {
            index,
            param_types: Vec::new(),
            is_imported: false,
        }
    }

    pub fn with_params(mut self, params: Vec<String>) -> Self {
        self.param_types = params;
        self
    }
}

/// Builder for WebAssembly exception handling constructs.
pub struct WasmEHBuilder {
    /// Tags defined in this module.
    pub tags: Vec<WasmTag>,
    /// Current try depth.
    try_depth: u32,
    /// Nested try block stack.
    try_stack: Vec<u32>,
}

impl WasmEHBuilder {
    pub fn new() -> Self {
        Self {
            tags: Vec::new(),
            try_depth: 0,
            try_stack: Vec::new(),
        }
    }

    /// Add a new exception tag.
    pub fn add_tag(&mut self, params: Vec<String>) -> WasmTag {
        let tag = WasmTag::new(self.tags.len() as u32).with_params(params);
        self.tags.push(tag.clone());
        tag
    }

    /// Begin a try block.
    pub fn begin_try(&mut self) -> u32 {
        self.try_depth += 1;
        self.try_stack.push(self.try_depth);
        self.try_depth
    }

    /// Begin a catch block.
    pub fn begin_catch(&mut self) -> u32 {
        self.try_depth
    }

    /// Begin a catch-all block.
    pub fn begin_catch_all(&mut self) -> u32 {
        self.try_depth
    }

    /// End a try/catch block.
    pub fn end_try(&mut self) {
        if self.try_depth > 0 {
            self.try_depth -= 1;
        }
        self.try_stack.pop();
    }

    /// Check if we are inside a try block.
    pub fn is_in_try(&self) -> bool {
        self.try_depth > 0
    }
}

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

// ============================================================================
// Cleanup landing pads and catch-all handlers
// ============================================================================

/// Extended landing pad with cleanup-only and catch-all support.
#[derive(Debug, Clone)]
pub struct ExtendedLandingPad {
    /// The landing pad result type.
    pub result_type: String,
    /// Clauses for the landing pad (catch types and filters).
    pub clauses: Vec<LandingPadClause>,
    /// Whether this is a cleanup landing pad (always executed).
    pub is_cleanup: bool,
    /// Whether this landing pad catches all exceptions.
    pub is_catch_all: bool,
    /// Parent basic block.
    pub parent_block: Option<ValueRef>,
}

impl ExtendedLandingPad {
    pub fn new(result_type: &str) -> Self {
        Self {
            result_type: result_type.to_string(),
            clauses: Vec::new(),
            is_cleanup: false,
            is_catch_all: false,
            parent_block: None,
        }
    }

    /// Mark this as a cleanup landing pad (runs even if no exception matches).
    pub fn with_cleanup(mut self) -> Self {
        self.is_cleanup = true;
        self
    }

    /// Mark this as catching all exception types.
    pub fn with_catch_all(mut self) -> Self {
        self.is_catch_all = true;
        self
    }

    /// Add a specific catch clause.
    pub fn add_catch(mut self, exception_type: &str) -> Self {
        let _ = exception_type;
        self.clauses.push(LandingPadClause {
            clause_type: ClauseType::Catch,
            exception_type: None,
            filter_value: None,
        });
        self
    }

    /// Add a filter clause.
    pub fn add_filter(mut self, filter_value: Option<i32>) -> Self {
        self.clauses.push(LandingPadClause {
            clause_type: ClauseType::Filter,
            exception_type: None,
            filter_value,
        });
        self
    }
}

// ============================================================================
// Personality function variants for all platforms
// ============================================================================

/// Extended personality function definitions.
pub mod personality_functions_ext {
    /// GCC C++ personality (Itanium C++ ABI).
    pub const GCC_CXX_PERSONALITY_V0: &str = "__gxx_personality_v0";
    /// GCC C personality.
    pub const GCC_C_PERSONALITY_V0: &str = "__gcc_personality_v0";
    /// GCC Objective-C personality.
    pub const GCC_OBJC_PERSONALITY_V0: &str = "__objc_personality_v0";
    /// MSVC C++ x64 personality.
    pub const MSVC_CXX_FRAME_HANDLER3: &str = "__CxxFrameHandler3";
    /// MSVC C++ x86 personality.
    pub const MSVC_CXX_FRAME_HANDLER: &str = "__CxxFrameHandler";
    /// MSVC SEH personality (x86).
    pub const EXCEPT_HANDLER3: &str = "_except_handler3";
    /// MSVC SEH personality (x64).
    pub const EXCEPT_HANDLER4: &str = "_except_handler4";
    /// WebAssembly C++ personality.
    pub const WASM_CXX_PERSONALITY_V0: &str = "__gxx_wasm_personality_v0";
    /// Rust personality (wrapped GCC C++).
    pub const RUST_EH_PERSONALITY: &str = "rust_eh_personality";
}

/// LSDA encoding constants for all platforms.
#[allow(dead_code)]
pub mod lsda_encoding {
    // DWARF Exception Header Encoding (DW_EH_PE_*).
    pub const DW_EH_PE_ABS: u8 = 0x00;
    pub const DW_EH_PE_ULEB128: u8 = 0x01;
    pub const DW_EH_PE_UDATA2: u8 = 0x02;
    pub const DW_EH_PE_UDATA4: u8 = 0x03;
    pub const DW_EH_PE_UDATA8: u8 = 0x04;
    pub const DW_EH_PE_SLEB128: u8 = 0x09;
    pub const DW_EH_PE_SDATA2: u8 = 0x0a;
    pub const DW_EH_PE_SDATA4: u8 = 0x0b;
    pub const DW_EH_PE_SDATA8: u8 = 0x0c;
    pub const DW_EH_PE_PCREL: u8 = 0x10;
    pub const DW_EH_PE_TEXTREL: u8 = 0x20;
    pub const DW_EH_PE_DATAREL: u8 = 0x30;
    pub const DW_EH_PE_FUNCREL: u8 = 0x40;
    pub const DW_EH_PE_ALIGNED: u8 = 0x50;
    pub const DW_EH_PE_INDIRECT: u8 = 0x80;
    pub const DW_EH_PE_OMIT: u8 = 0xff;
}

/// Select the appropriate personality function for a given platform.
pub fn select_personality_for_triple(target_triple: &str) -> &'static str {
    let t = target_triple.to_lowercase();
    if t.contains("windows") || t.contains("msvc") {
        if t.contains("x86_64") || t.contains("aarch64") {
            personality_functions_ext::MSVC_CXX_FRAME_HANDLER3
        } else {
            personality_functions_ext::EXCEPT_HANDLER4
        }
    } else if t.contains("wasm") {
        personality_functions_ext::WASM_CXX_PERSONALITY_V0
    } else {
        // Default to GCC/Itanium for Linux/macOS/BSD.
        personality_functions_ext::GCC_CXX_PERSONALITY_V0
    }
}

// ============================================================================
// LSDA encoding helpers for all platforms
// ============================================================================

/// Encode a value using the specified DWARF EH pointer encoding.
pub fn encode_eh_value(encoding: u8, value: i64) -> Vec<u8> {
    let mut out = Vec::new();
    let format = encoding & 0x0f;
    match format {
        lsda_encoding::DW_EH_PE_ULEB128 => {
            out.extend_from_slice(&encode_uleb128_ext(value as u64));
        }
        lsda_encoding::DW_EH_PE_SLEB128 => {
            out.extend_from_slice(&encode_sleb128_ext(value));
        }
        lsda_encoding::DW_EH_PE_UDATA2 => {
            out.extend_from_slice(&(value as u16).to_le_bytes());
        }
        lsda_encoding::DW_EH_PE_UDATA4 => {
            out.extend_from_slice(&(value as u32).to_le_bytes());
        }
        lsda_encoding::DW_EH_PE_UDATA8 => {
            out.extend_from_slice(&(value as u64).to_le_bytes());
        }
        lsda_encoding::DW_EH_PE_SDATA2 => {
            out.extend_from_slice(&(value as i16).to_le_bytes());
        }
        lsda_encoding::DW_EH_PE_SDATA4 => {
            out.extend_from_slice(&(value as i32).to_le_bytes());
        }
        lsda_encoding::DW_EH_PE_SDATA8 => {
            out.extend_from_slice(&value.to_le_bytes());
        }
        lsda_encoding::DW_EH_PE_ABS => {
            out.extend_from_slice(&(value as u64).to_le_bytes());
        }
        lsda_encoding::DW_EH_PE_OMIT => {
            // Omit — no bytes emitted.
        }
        _ => {
            // Default: absolute 4-byte.
            out.extend_from_slice(&(value as u32).to_le_bytes());
        }
    }
    out
}

/// Encode an unsigned LEB128 value (extended version).
fn encode_uleb128_ext(mut value: u64) -> Vec<u8> {
    let mut out = Vec::new();
    loop {
        let mut byte = (value & 0x7f) as u8;
        value >>= 7;
        if value != 0 {
            byte |= 0x80;
        }
        out.push(byte);
        if value == 0 {
            break;
        }
    }
    out
}

/// Encode a signed LEB128 value (extended version).
fn encode_sleb128_ext(mut value: i64) -> Vec<u8> {
    let mut out = Vec::new();
    loop {
        let mut byte = (value & 0x7f) as u8;
        value >>= 7;
        let more = !((value == 0 && byte & 0x40 == 0) || (value == -1 && byte & 0x40 != 0));
        if more {
            byte |= 0x80;
        }
        out.push(byte);
        if !more {
            break;
        }
    }
    out
}

// ============================================================================
// EH frame info (CFI) integration
// ============================================================================

/// Extended EH frame info that integrates with the LSDA.
#[derive(Debug, Clone)]
pub struct EHFrameInfo {
    /// FDE count in .eh_frame.
    pub fde_count: u32,
    /// CIE count in .eh_frame.
    pub cie_count: u32,
    /// Total size of .eh_frame section.
    pub eh_frame_size: u64,
    /// Total size of .gcc_except_table.
    pub except_table_size: u64,
    /// LSDA offsets keyed by function name.
    pub lsda_offsets: HashMap<String, u64>,
    /// Whether personality function uses LSDA.
    pub personality_has_lsda: bool,
}

impl EHFrameInfo {
    pub fn new() -> Self {
        Self {
            fde_count: 0,
            cie_count: 0,
            eh_frame_size: 0,
            except_table_size: 0,
            lsda_offsets: HashMap::new(),
            personality_has_lsda: true,
        }
    }

    pub fn add_fde(&mut self, func_name: &str, lsda_offset: u64) {
        self.fde_count += 1;
        self.lsda_offsets.insert(func_name.to_string(), lsda_offset);
    }

    pub fn total_size(&self) -> u64 {
        self.eh_frame_size + self.except_table_size
    }
}

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

// ============================================================================
// Exception type matching
// ============================================================================

/// Match an exception type against a catch clause type.
pub fn match_exception_type(exception_type: &str, catch_type: &str) -> bool {
    if catch_type == "..." || catch_type.is_empty() {
        return true; // Catch-all.
    }
    // Exact match.
    if exception_type == catch_type {
        return true;
    }
    // Derived-to-base matching would require RTTI.
    false
}

/// Determine the catch handler for a given exception type.
pub fn find_catch_handler(exception_type: &str, clauses: &[LandingPadClause]) -> Option<usize> {
    for (i, clause) in clauses.iter().enumerate() {
        if clause.clause_type == ClauseType::Catch {
            // Check if this catch clause matches the thrown type.
            // In a full implementation, compare the type metadata.
            let _ = exception_type;
            let _ = &clause.exception_type;
            return Some(i);
        }
    }
    None
}

/// Compute the LSDA action table offset for a given catch type.
pub fn compute_action_offset(type_index: usize, type_table: &[String]) -> Option<usize> {
    if type_index < type_table.len() {
        // Each action record is 2 bytes (type_filter ULEB128 + next_action ULEB128)
        Some(type_index * 2)
    } else {
        None
    }
}

// ============================================================================
// Platform-specific EH section names
// ============================================================================

/// Return the appropriate exception table section name for a target triple.
pub fn eh_section_for_target(target_triple: &str) -> &'static str {
    let t = target_triple.to_lowercase();
    if t.contains("darwin") || t.contains("macos") {
        "__TEXT,__gcc_except_tab"
    } else if t.contains("windows") || t.contains("msvc") {
        ".xdata"
    } else {
        ".gcc_except_table"
    }
}

/// Return the appropriate EH frame section name for a target triple.
pub fn eh_frame_section_for_target(target_triple: &str) -> &'static str {
    let t = target_triple.to_lowercase();
    if t.contains("darwin") || t.contains("macos") {
        "__TEXT,__eh_frame"
    } else {
        ".eh_frame"
    }
}

// ═══════════════════════════════════════════════════════════════════════════
// Tests
// ═══════════════════════════════════════════════════════════════════════════

#[cfg(test)]
mod tests {
    use super::*;
    use llvm_native_core::basic_block::new_basic_block;
    use llvm_native_core::function::new_function;
    use llvm_native_core::instruction;
    use llvm_native_core::types::Type;

    fn build_simple_func(name: &str) -> ValueRef {
        let func = new_function(name, Type::void(), &[]);
        let entry = new_basic_block("entry");
        entry.borrow_mut().push_operand(instruction::ret_void());
        func.borrow_mut().push_operand(entry.clone());
        func
    }

    // === EHFunctionState Tests ===

    #[test]
    fn test_eh_state_create() {
        let state = EHFunctionState::new();
        assert!(!state.uses_eh);
        assert!(state.personality.is_none());
        assert!(state.landing_pads.is_empty());
    }

    #[test]
    fn test_eh_state_set_personality() {
        let mut state = EHFunctionState::new();
        state.set_personality("__gxx_personality_v0", None);
        assert!(state.uses_eh);
        assert!(state.personality.is_some());
        assert_eq!(state.personality.unwrap().name, "__gxx_personality_v0");
    }

    #[test]
    fn test_eh_state_add_landing_pad() {
        let mut state = EHFunctionState::new();
        let lp = LandingPad {
            result_type: None,
            clauses: vec![],
            is_cleanup: true,
            parent_block: None,
        };
        state.add_landing_pad(lp);
        assert!(state.uses_eh);
        assert_eq!(state.landing_pads.len(), 1);
    }

    #[test]
    fn test_eh_state_add_invoke() {
        let mut state = EHFunctionState::new();
        let normal = new_basic_block("normal");
        let unwind = new_basic_block("unwind");
        let invoke = InvokeInst {
            callee: build_simple_func("callee"),
            arguments: vec![],
            normal_dest: normal,
            unwind_dest: unwind.clone(),
            return_type: None,
        };
        state.add_invoke(invoke);
        assert!(state.uses_eh);
        assert_eq!(state.invokes.len(), 1);
        assert!(state.has_invokes_to(&unwind));
    }

    // === ExceptionTableBuilder Tests ===

    #[test]
    fn test_table_builder_create() {
        let builder = ExceptionTableBuilder::new();
        assert!(builder.call_sites.is_empty());
        assert!(builder.actions.is_empty());
    }

    #[test]
    fn test_table_builder_add_call_site() {
        let mut builder = ExceptionTableBuilder::new();
        builder.add_call_site(0x10, 0x20, 0x100, 1);
        assert_eq!(builder.call_sites.len(), 1);
        assert_eq!(builder.call_sites[0].cs_start, 0x10);
        assert_eq!(builder.call_sites[0].cs_length, 0x20);
    }

    #[test]
    fn test_table_builder_add_catch_action() {
        let mut builder = ExceptionTableBuilder::new();
        let action = builder.add_catch_action("std::runtime_error");
        assert!(action > 0);
        assert_eq!(builder.actions.len(), 1);
        assert!(builder.actions[0].type_filter > 0);
    }

    #[test]
    fn test_table_builder_add_cleanup_action() {
        let mut builder = ExceptionTableBuilder::new();
        let action = builder.add_cleanup_action();
        assert!(action > 0);
        assert_eq!(builder.actions.len(), 1);
        assert_eq!(builder.actions[0].type_filter, 0);
    }

    #[test]
    fn test_table_builder_multiple_call_sites() {
        let mut builder = ExceptionTableBuilder::new();
        builder.add_call_site(0, 50, 100, 0);
        builder.add_call_site(50, 30, 200, 1);
        builder.add_call_site(80, 20, 0, 2);
        assert_eq!(builder.call_sites.len(), 3);
    }

    #[test]
    fn test_table_builder_build_lsda() {
        let mut builder = ExceptionTableBuilder::new();
        builder.add_call_site(0, 10, 100, 1);
        builder.add_catch_action("int");

        let lsda = builder.build_lsda(0);
        assert_eq!(lsda.call_sites.len(), 1);
        assert_eq!(lsda.actions.len(), 1);
    }

    #[test]
    fn test_table_builder_encode() {
        let mut builder = ExceptionTableBuilder::new();
        builder.add_call_site(0, 10, 0, 0);

        let table = builder.encode(0x1000);
        assert!(!table.raw_bytes.is_empty());
    }

    #[test]
    fn test_table_builder_encode_multiple_types() {
        let mut builder = ExceptionTableBuilder::new();
        builder.add_call_site(0, 20, 100, 1);
        builder.add_catch_action("int");
        builder.add_catch_action("float");
        builder.add_cleanup_action();

        let table = builder.encode(0);
        assert!(!table.raw_bytes.is_empty());
        assert_eq!(builder.actions.len(), 3);
    }

    // === Personality Function Tests ===

    #[test]
    fn test_personality_creation() {
        let p = PersonalityFunction {
            name: "__gxx_personality_v0".into(),
            func: None,
            has_lsda: true,
        };
        assert_eq!(p.name, "__gxx_personality_v0");
        assert!(p.has_lsda);
    }

    // === Utility Tests ===

    #[test]
    fn test_make_lsda_symbol() {
        let sym = make_lsda_symbol("my_function");
        assert_eq!(sym, "__LSDA_my_function");
    }

    #[test]
    fn test_gcc_except_table_section() {
        assert_eq!(gcc_except_table_section(), ".gcc_except_table");
    }

    #[test]
    fn test_function_uses_eh_false_for_simple() {
        let func = build_simple_func("no_eh");
        assert!(!function_uses_eh(&func));
    }

    // === Clause Tests ===

    #[test]
    fn test_clause_types() {
        let catch = LandingPadClause {
            clause_type: ClauseType::Catch,
            exception_type: None,
            filter_value: None,
        };
        assert_eq!(catch.clause_type, ClauseType::Catch);

        let cleanup = LandingPadClause {
            clause_type: ClauseType::Cleanup,
            exception_type: None,
            filter_value: None,
        };
        assert_eq!(cleanup.clause_type, ClauseType::Cleanup);
    }

    // === LandingPad Tests ===

    #[test]
    fn test_landing_pad_create() {
        let lp = LandingPad {
            result_type: None,
            clauses: vec![],
            is_cleanup: false,
            parent_block: None,
        };
        assert!(!lp.is_cleanup);
        assert!(lp.clauses.is_empty());
    }

    #[test]
    fn test_landing_pad_with_clauses() {
        let lp = LandingPad {
            result_type: None,
            clauses: vec![
                LandingPadClause {
                    clause_type: ClauseType::Catch,
                    exception_type: None,
                    filter_value: None,
                },
                LandingPadClause {
                    clause_type: ClauseType::Cleanup,
                    exception_type: None,
                    filter_value: None,
                },
            ],
            is_cleanup: true,
            parent_block: None,
        };
        assert!(lp.is_cleanup);
        assert_eq!(lp.clauses.len(), 2);
    }

    // === InvokeInst Tests ===

    #[test]
    fn test_invoke_create() {
        let normal = new_basic_block("cont");
        let unwind = new_basic_block("lpad");
        let invoke = InvokeInst {
            callee: build_simple_func("foo"),
            arguments: vec![],
            normal_dest: normal,
            unwind_dest: unwind,
            return_type: None,
        };
        assert!(invoke.arguments.is_empty());
    }

    // === HSDA Symbol Tests ===

    #[test]
    fn test_lsda_symbols_are_unique() {
        let s1 = make_lsda_symbol("foo");
        let s2 = make_lsda_symbol("bar");
        assert_ne!(s1, s2);
    }

    // === Integration Tests ===

    #[test]
    fn test_full_eh_pipeline() {
        // 1. Create function state
        let mut state = EHFunctionState::new();
        state.set_personality("__gxx_personality_v0", None);

        // 2. Add landing pad
        let lp = LandingPad {
            result_type: None,
            clauses: vec![LandingPadClause {
                clause_type: ClauseType::Catch,
                exception_type: None,
                filter_value: None,
            }],
            is_cleanup: false,
            parent_block: None,
        };
        state.add_landing_pad(lp);

        // 3. Add invoke
        let normal = new_basic_block("normal_dest");
        let unwind = new_basic_block("unwind_dest");
        let invoke = InvokeInst {
            callee: build_simple_func("may_throw"),
            arguments: vec![],
            normal_dest: normal,
            unwind_dest: unwind.clone(),
            return_type: None,
        };
        state.add_invoke(invoke);

        // 4. Build exception table
        let mut builder = ExceptionTableBuilder::new();
        builder.add_call_site(0, 10, 100, 1);
        builder.add_catch_action("int");
        let table = builder.encode(0x1000);

        // 5. Verify
        assert!(state.uses_eh);
        assert_eq!(state.invokes.len(), 1);
        assert_eq!(state.landing_pads.len(), 1);
        assert!(!table.raw_bytes.is_empty());
        assert!(state.has_invokes_to(&unwind));
    }

    #[test]
    fn test_eh_state_default() {
        let state = EHFunctionState::default();
        assert!(!state.uses_eh);
        assert_eq!(state.invokes.len(), 0);
    }

    #[test]
    fn test_personality_standard_names() {
        assert_eq!(
            personality_functions::GCC_CXX_PERSONALITY,
            "__gxx_personality_v0"
        );
        assert_eq!(
            personality_functions::GCC_C_PERSONALITY,
            "__gcc_personality_v0"
        );
    }

    #[test]
    fn test_function_uses_eh_default_false() {
        let func = build_simple_func("test_fn");
        assert!(!function_uses_eh(&func));
    }

    // ==========================================================================
    // New tests for EHPersonality, LandingPadInfo, InvokeLowering, etc.
    // ==========================================================================

    #[test]
    fn test_eh_personality_from_string() {
        assert_eq!(
            EHPersonality::from_string("__gxx_personality_v0"),
            Some(EHPersonality::GCC_CXX)
        );
        assert_eq!(
            EHPersonality::from_string("__gcc_personality_v0"),
            Some(EHPersonality::GCC_C)
        );
        assert_eq!(
            EHPersonality::from_string("__CxxFrameHandler3"),
            Some(EHPersonality::MSVC_CXX)
        );
        assert_eq!(
            EHPersonality::from_string("_except_handler3"),
            Some(EHPersonality::MSVC_X86SEH)
        );
        assert_eq!(
            EHPersonality::from_string("__gxx_wasm_personality_v0"),
            Some(EHPersonality::Wasm_CXX)
        );
        assert_eq!(
            EHPersonality::from_string("rust_eh_personality"),
            Some(EHPersonality::Rust)
        );
        assert_eq!(
            EHPersonality::from_string("__gnu_objc_personality_v0"),
            Some(EHPersonality::GCC_ObjC)
        );
    }

    #[test]
    fn test_eh_personality_from_string_unknown() {
        assert_eq!(EHPersonality::from_string("unknown_personality"), None);
        assert_eq!(EHPersonality::from_string(""), None);
    }

    #[test]
    fn test_eh_personality_to_fn_name() {
        assert_eq!(EHPersonality::GCC_CXX.to_fn_name(), "__gxx_personality_v0");
        assert_eq!(EHPersonality::GCC_C.to_fn_name(), "__gcc_personality_v0");
        assert_eq!(EHPersonality::MSVC_CXX.to_fn_name(), "__CxxFrameHandler3");
        assert_eq!(
            EHPersonality::Wasm_CXX.to_fn_name(),
            "__gxx_wasm_personality_v0"
        );
        assert_eq!(EHPersonality::Rust.to_fn_name(), "rust_eh_personality");
    }

    #[test]
    fn test_eh_personality_roundtrip() {
        for &p in &[
            EHPersonality::GCC_CXX,
            EHPersonality::GCC_C,
            EHPersonality::MSVC_CXX,
            EHPersonality::Rust,
            EHPersonality::Wasm_CXX,
        ] {
            let name = p.to_fn_name();
            let parsed = EHPersonality::from_string(name);
            assert_eq!(parsed, Some(p), "Roundtrip failed for {:?}", p);
        }
    }

    #[test]
    fn test_landing_pad_info_parse() {
        // Build a landing pad instruction manually
        let mut val = llvm_native_core::value::Value::new(Type::void());
        val.opcode = Some(llvm_native_core::opcode::Opcode::LandingPad);
        val.subclass = llvm_native_core::value::SubclassKind::Instruction;
        let lp_inst = llvm_native_core::value::valref(val);

        // The landingpad instruction can be parsed
        let _info = LandingPadInfo::parse(&lp_inst);
        // Should not panic
    }

    #[test]
    fn test_landing_pad_info_add_catch() {
        let mut info = LandingPadInfo {
            clauses: vec![],
            cleanup: false,
            filter_data: vec![],
        };
        info.add_catch(&Type::i32());
        assert_eq!(info.clauses.len(), 1);
        assert_eq!(info.clauses[0].clause_type, ClauseType::Catch);
    }

    #[test]
    fn test_landing_pad_info_add_filter() {
        let mut info = LandingPadInfo {
            clauses: vec![],
            cleanup: false,
            filter_data: vec![],
        };
        info.add_filter(&[Type::i32(), Type::i64()]);
        assert_eq!(info.clauses.len(), 2);
        for clause in &info.clauses {
            assert_eq!(clause.clause_type, ClauseType::Filter);
        }
    }

    #[test]
    fn test_invoke_lowering_create() {
        let lowering = InvokeLowering::new();
        assert_eq!(lowering.lowered_count, 0);
    }

    #[test]
    fn test_invoke_lowering_lower() {
        let func = build_simple_func("invoke_test");
        let count = InvokeLowering::lower(&func);
        // Should return 0 for a function without invokes
        assert_eq!(count, 0);
    }

    #[test]
    fn test_invoke_lowering_create_dispatch() {
        let lowering = InvokeLowering::new();
        let func = build_simple_func("dispatch_test");
        // Should not panic
        lowering.create_dispatch_blocks(&func);
    }

    #[test]
    fn test_win_eh_info_generate() {
        let func = build_simple_func("seh_test");
        let result = WinEHInfo::generate(&func);
        assert_eq!(result.num_unwind_codes, 0);
    }

    #[test]
    fn test_dwarf_eh_info_generate() {
        let func = build_simple_func("dwarf_test");
        let result = DwarfEHInfo::generate(&func);
        assert_eq!(result.num_fdes, 0);
    }

    #[test]
    fn test_eh_frame_builder_create() {
        let builder = EHFrameBuilder::new();
        assert_eq!(builder.fde_count, 0);
        let eh_frame = builder.emit_eh_frame();
        assert!(eh_frame.is_empty());
    }

    #[test]
    fn test_eh_frame_builder_add_cie_and_fde() {
        let mut builder = EHFrameBuilder::new();
        let func = build_simple_func("eh_func");

        builder.add_cie(&func, &EHPersonality::GCC_CXX);
        builder.add_fde(&func, &[]);

        let eh_frame = builder.emit_eh_frame();
        assert!(!eh_frame.is_empty());
        assert_eq!(builder.fde_count, 1);
    }

    #[test]
    fn test_eh_frame_builder_multiple_fdes() {
        let mut builder = EHFrameBuilder::new();
        let func1 = build_simple_func("f1");
        let func2 = build_simple_func("f2");

        builder.add_cie(&func1, &EHPersonality::GCC_CXX);
        builder.add_fde(&func1, &[]);
        builder.add_fde(&func2, &[]);

        assert_eq!(builder.fde_count, 2);
        let eh_frame = builder.emit_eh_frame();
        assert!(!eh_frame.is_empty());
    }
}