Struct JitDebugger 

pub struct JitDebugger { /* private fields */ }

Interactive JIT debugger

The main orchestrator that coordinates all debugging components to provide a comprehensive debugging experience for JIT-compiled code.

Features

• Step-by-step execution: Execute code one instruction/node at a time
• Breakpoint management: Set conditional and unconditional breakpoints
• Watch expressions: Monitor variable and expression values
• State inspection: Examine variables, memory, and call stack
• Performance profiling: Track execution timing and statistics
• Interactive interface: Command-line interface with rich formatting

Examples

Basic Usage

use torsh_jit::debugger::{JitDebugger, DebuggerConfig};
use torsh_jit::ComputationGraph;

let mut debugger = JitDebugger::new(DebuggerConfig::default());
let graph = ComputationGraph::new();
// let result = debugger.debug_graph(graph)?;

Advanced Configuration

use torsh_jit::debugger::{JitDebugger, DebuggerConfig, UiMode};

let config = DebuggerConfig {
    enable_single_step: true,
    enable_breakpoints: true,
    enable_watches: true,
    enable_memory_view: true,
    enable_disassembly: true,
    max_trace_length: 10000,
    ui_mode: UiMode::Interactive,
};

let mut debugger = JitDebugger::new(config);

Implementations

impl JitDebugger

pub fn new(config: DebuggerConfig) -> Self

Create a new JIT debugger

Arguments

• config - Configuration for the debugger

Examples

use torsh_jit::debugger::{JitDebugger, DebuggerConfig};

let debugger = JitDebugger::new(DebuggerConfig::default());

pub fn debug_graph( &mut self, graph: ComputationGraph, ) -> JitResult<DebugSessionResult>

Start a debugging session for a computation graph

This method starts an interactive debugging session that allows step-by-step execution through the computation graph with full debugging capabilities.

Arguments

• graph - The computation graph to debug

Returns

A DebugSessionResult containing the execution trace, final state, command history, and statistics from the debugging session.

Examples

use torsh_jit::debugger::{JitDebugger, DebuggerConfig};
use torsh_jit::ComputationGraph;

let mut debugger = JitDebugger::new(DebuggerConfig::default());
let graph = ComputationGraph::new();
// let result = debugger.debug_graph(graph)?;
// println!("Executed {} steps", result.execution_trace.len());
// println!("Final state: {:?}", result.final_state);

pub fn debug_ir(&mut self, ir_module: IrModule) -> JitResult<DebugSessionResult>

Start a debugging session for an IR module

This method starts an interactive debugging session for IR (Intermediate Representation) code, allowing instruction-level debugging with full state inspection.

Arguments

• ir_module - The IR module to debug

Returns

A DebugSessionResult containing the execution trace, final state, command history, and statistics from the debugging session.

Examples

use torsh_jit::debugger::{JitDebugger, DebuggerConfig};
use torsh_jit::ir::IrModule;

let mut debugger = JitDebugger::new(DebuggerConfig::default());
let ir_module = IrModule::new("main".to_string());
// let result = debugger.debug_ir(ir_module)?;

pub fn set_breakpoint( &mut self, location: BreakpointLocation, ) -> JitResult<BreakpointId>

Set a breakpoint at a specific location

Arguments

• location - The location where the breakpoint should be set

Returns

The ID of the newly created breakpoint

Examples

use torsh_jit::debugger::{JitDebugger, DebuggerConfig, BreakpointLocation};
use torsh_jit::NodeId;

let mut debugger = JitDebugger::new(DebuggerConfig::default());
let location = BreakpointLocation::GraphNode(NodeId::new(5));
let bp_id = debugger.set_breakpoint(location)?;

pub fn remove_breakpoint(&mut self, id: BreakpointId) -> JitResult<()>

Remove a breakpoint

Arguments

• id - The ID of the breakpoint to remove

Examples

use torsh_jit::debugger::{JitDebugger, DebuggerConfig, BreakpointLocation};
use torsh_jit::NodeId;

let mut debugger = JitDebugger::new(DebuggerConfig::default());
let location = BreakpointLocation::GraphNode(NodeId::new(0));
let bp_id = debugger.set_breakpoint(location)?;
debugger.remove_breakpoint(bp_id)?;

pub fn add_watch(&mut self, expression: String) -> JitResult<WatchId>

Add a watch expression

Arguments

• expression - The expression to watch

Returns

The ID of the newly created watch

Examples

use torsh_jit::debugger::{JitDebugger, DebuggerConfig};

let mut debugger = JitDebugger::new(DebuggerConfig::default());
let watch_id = debugger.add_watch("variable_name".to_string())?;

pub fn remove_watch(&mut self, id: WatchId) -> JitResult<()>

Remove a watch expression

Arguments

• id - The ID of the watch to remove

pub fn get_current_state(&self) -> Option<DebugState>

Get current debugging state

Returns

The current debug state if a session is active, None otherwise

pub fn evaluate_expression( &self, expression: &str, ) -> JitResult<EvaluationResult>

Evaluate an expression in the current context

Arguments

• expression - The expression to evaluate

Returns

The evaluation result

pub fn breakpoints(&self) -> &BreakpointManager

Get breakpoint manager

pub fn breakpoints_mut(&mut self) -> &mut BreakpointManager

Get mutable breakpoint manager

pub fn watch_manager(&self) -> &WatchManager

Get watch manager

pub fn watch_manager_mut(&mut self) -> &mut WatchManager

Get mutable watch manager

pub fn interface(&self) -> &DebuggerInterface

Get debugger interface

pub fn interface_mut(&mut self) -> &mut DebuggerInterface

Get mutable debugger interface

pub fn execution_engine(&self) -> &DebugExecutionEngine

Get execution engine

pub fn execution_engine_mut(&mut self) -> &mut DebugExecutionEngine

Get mutable execution engine

pub fn config(&self) -> &DebuggerConfig

Get configuration

pub fn update_config(&mut self, config: DebuggerConfig)

Update configuration

pub fn has_active_session(&self) -> bool

Check if there is an active debug session

pub fn clear_session(&mut self)

Clear the current debug session

pub fn get_session_statistics(&self) -> Option<DebugStatistics>

Get debug statistics from the current session