miden_debug_engine/exec/
query.rs

1use miden_core::{Felt, Word};
2use miden_processor::{ContextId, MemoryError, ProcessorState, trace::RowIndex};
3use smallvec::SmallVec;
4
5use super::trace::MemoryReadError;
6use crate::{FromMidenRepr, NativePtr};
7
8pub trait DebugQuery {
9    fn state(&self) -> ProcessorState<'_>;
10    fn current_context(&self) -> ContextId;
11    fn current_clock(&self) -> RowIndex;
12
13    /// Read the word at the given Miden memory address
14    fn read_memory_word(&self, addr: u32) -> Result<Option<Word>, MemoryError> {
15        self.state().get_mem_word(self.current_context(), addr)
16    }
17
18    /// Read the element at the given Miden memory address
19    #[track_caller]
20    fn read_memory_element(&self, addr: u32) -> Option<Felt> {
21        self.state().get_mem_value(self.current_context(), addr)
22    }
23
24    /// Read a raw byte vector from `addr`, under `ctx`, at cycle `clk`, sufficient to hold a value
25    /// of type `ty`
26    fn read_bytes_for_type(
27        &self,
28        addr: NativePtr,
29        ty: &miden_assembly_syntax::ast::types::Type,
30    ) -> Result<Vec<u8>, MemoryReadError> {
31        let size = ty.size_in_bytes();
32        read_memory_bytes(addr, size, |addr| Ok(self.read_memory_element(addr).unwrap_or_default()))
33    }
34
35    /// Read a value of the given type, given an address in Rust's address space
36    #[track_caller]
37    fn read_from_rust_memory<T>(&self, addr: u32) -> Option<T>
38    where
39        T: core::any::Any + FromMidenRepr,
40    {
41        let ptr = NativePtr::from_ptr(addr);
42        assert_eq!(ptr.offset, 0, "support for unaligned reads is not yet implemented");
43        let size = <T as FromMidenRepr>::size_in_felts();
44        let mut felts = SmallVec::<[_; 4]>::with_capacity(size);
45        for index in 0..(size as u32) {
46            // Untouched memory reads as zero in the VM, so a missing element defaults; address
47            // overflow, on the other hand, is a failed read.
48            felts.push(self.read_memory_element(ptr.addr.checked_add(index)?).unwrap_or_default());
49        }
50        Some(T::from_felts(&felts))
51    }
52}
53
54/// Reads `size` bytes from memory, starting at `ptr`. Handles `ptr`'s offset.
55///
56/// The `read_elem` callback is used to fetch an element from an element address.
57pub(crate) fn read_memory_bytes<E>(
58    ptr: NativePtr,
59    size: usize,
60    mut read_elem: impl FnMut(u32) -> Result<Felt, E>,
61) -> Result<Vec<u8>, E>
62where
63    E: From<MemoryReadError>,
64{
65    if size == 0 {
66        return Ok(Vec::new());
67    }
68
69    let start = usize::from(ptr.offset);
70    let end = start.checked_add(size).ok_or_else(|| E::from(MemoryReadError::OutOfBounds))?;
71    let num_elements = end.div_ceil(4);
72
73    let mut bytes = Vec::with_capacity(num_elements.saturating_mul(4));
74    for index in 0..num_elements {
75        let index = u32::try_from(index).map_err(|_| E::from(MemoryReadError::OutOfBounds))?;
76        let elem_addr = ptr
77            .addr
78            .checked_add(index)
79            .ok_or_else(|| E::from(MemoryReadError::OutOfBounds))?;
80        bytes.extend(felt_to_le_bytes(read_elem(elem_addr)?));
81    }
82
83    Ok(bytes[start..end].to_vec())
84}
85
86pub(crate) fn felt_to_le_bytes(elem: Felt) -> [u8; 4] {
87    ((elem.as_canonical_u64() & u32::MAX as u64) as u32).to_le_bytes()
88}
miden_debug_engine/exec/query.rs

miden_debug_engine/exec/
query.rs
