miden-debug-engine 0.17.0

Core debugger engine for miden-debug
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

use std::sync::Arc;

use miden_assembly::DefaultSourceManager;
use miden_assembly_syntax::ast::types::Type;
use miden_processor::{ContextId, trace::RowIndex};

use super::ExecutionTrace;
use crate::{Executor, debug::NativePtr, exec::DebugQuery, felt::ToMidenRepr};

fn empty_trace() -> ExecutionTrace {
    ExecutionTrace {
        processor: miden_processor::FastProcessor::new(miden_processor::StackInputs::default()),
        outputs: miden_processor::StackOutputs::default(),
    }
}

fn execute_trace(source: &str) -> ExecutionTrace {
    let source_manager = Arc::new(DefaultSourceManager::default());
    let program = miden_assembly::Assembler::new(source_manager.clone())
        .assemble_program("program", source)
        .map(Arc::from)
        .unwrap();

    Executor::new(vec![]).capture_trace(program, source_manager)
}

#[test]
fn parse_result_reads_multi_felt_outputs_in_stack_order() {
    let outputs = 0x0807_0605_0403_0201_u64.to_felts();
    let trace = ExecutionTrace {
        outputs: miden_processor::StackOutputs::new(&outputs).unwrap(),
        ..empty_trace()
    };

    let result = trace.parse_result::<u64>().unwrap();

    assert_eq!(result, 0x0807_0605_0403_0201_u64);
}

#[test]
fn read_bytes_for_type_preserves_little_endian_bytes() {
    let trace = execute_trace(
        r#"
begin
    push.4660
    push.8
    mem_store

    push.67305985
    push.12
    mem_store

    push.134678021
    push.13
    mem_store
end
"#,
    );
    let ctx = ContextId::root();

    let u16_bytes = trace
        .read_bytes_for_type_in_context(
            NativePtr::new(8, 0),
            &Type::U16,
            ctx,
            RowIndex::from(0_u32),
        )
        .unwrap();
    let u64_bytes = trace
        .read_bytes_for_type_in_context(
            NativePtr::new(12, 0),
            &Type::U64,
            ctx,
            RowIndex::from(0_u32),
        )
        .unwrap();
    let unaligned_u32_bytes = trace
        .read_bytes_for_type_in_context(
            NativePtr::new(12, 1),
            &Type::U32,
            ctx,
            RowIndex::from(0_u32),
        )
        .unwrap();

    assert_eq!(u16_bytes, vec![0x34, 0x12]);
    assert_eq!(u64_bytes, vec![1, 2, 3, 4, 5, 6, 7, 8]);
    assert_eq!(unaligned_u32_bytes, vec![2, 3, 4, 5]);
}

#[test]
fn debug_query_reads_rust_memory_from_byte_address() {
    let trace = execute_trace(
        r#"
begin
    push.67305985
    push.3
    mem_store

    push.134678021
    push.4
    mem_store
end
"#,
    );

    assert_eq!(trace.read_from_rust_memory::<u64>(12), Some(0x0807_0605_0403_0201));
}

#[test]
fn debug_query_reads_uninitialized_rust_memory_as_zero() {
    let trace = execute_trace(
        r#"
begin
    push.67305985
    push.3
    mem_store
end
"#,
    );

    assert_eq!(trace.read_from_rust_memory::<u64>(12), Some(0x0000_0000_0403_0201));
}