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
33        if addr.is_element_aligned() {
34            read_memory_bytes(addr, size, |addr| {
35                Ok(self.read_memory_element(addr).unwrap_or_default())
36            })
37        } else {
38            Err(MemoryReadError::UnalignedRead)
39        }
40    }
41
42    /// Read a value of the given type, given an address in Rust's address space
43    #[track_caller]
44    fn read_from_rust_memory<T>(&self, addr: u32) -> Option<T>
45    where
46        T: core::any::Any + FromMidenRepr,
47    {
48        let ptr = NativePtr::from_ptr(addr);
49        assert_eq!(ptr.offset, 0, "support for unaligned reads is not yet implemented");
50        let size = <T as FromMidenRepr>::size_in_felts();
51        let mut felts = SmallVec::<[_; 4]>::with_capacity(size);
52        for index in 0..(size as u32) {
53            // Untouched memory reads as zero in the VM, so a missing element defaults; address
54            // overflow, on the other hand, is a failed read.
55            felts.push(self.read_memory_element(ptr.addr.checked_add(index)?).unwrap_or_default());
56        }
57        Some(T::from_felts(&felts))
58    }
59}
60
61/// Reads `size` bytes from memory, starting at `ptr`. Handles `ptr`'s offset.
62///
63/// The `read_elem` callback is used to fetch an element from an element address.
64pub(crate) fn read_memory_bytes<E>(
65    ptr: NativePtr,
66    size: usize,
67    mut read_elem: impl FnMut(u32) -> Result<Felt, E>,
68) -> Result<Vec<u8>, E>
69where
70    E: From<MemoryReadError>,
71{
72    if size == 0 {
73        return Ok(Vec::new());
74    }
75
76    let start = usize::from(ptr.offset);
77    let end = start.checked_add(size).ok_or_else(|| E::from(MemoryReadError::OutOfBounds))?;
78    let num_elements = end.div_ceil(4);
79
80    let mut bytes = Vec::with_capacity(num_elements.saturating_mul(4));
81    for index in 0..num_elements {
82        let index = u32::try_from(index).map_err(|_| E::from(MemoryReadError::OutOfBounds))?;
83        let elem_addr = ptr
84            .addr
85            .checked_add(index)
86            .ok_or_else(|| E::from(MemoryReadError::OutOfBounds))?;
87        bytes.extend(felt_to_le_bytes(read_elem(elem_addr)?));
88    }
89
90    Ok(bytes[start..end].to_vec())
91}
92
93pub(crate) fn felt_to_le_bytes(elem: Felt) -> [u8; 4] {
94    ((elem.as_canonical_u64() & u32::MAX as u64) as u32).to_le_bytes()
95}
miden_debug_engine/exec/query.rs

miden_debug_engine/exec/
query.rs
