sp1-core-executor 6.1.0

RISC-V executor for SP1
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

use crate::{
    events::{PrecompileEvent, Uint256OpsEvent},
    vm::syscall::SyscallRuntime,
    SyscallCode,
};

const U256_NUM_WORDS: usize = 4;

#[allow(clippy::many_single_char_names)]
pub(crate) fn uint256_ops<'a, RT: SyscallRuntime<'a>>(
    rt: &mut RT,
    syscall_code: SyscallCode,
    arg1: u64,
    arg2: u64,
) -> Option<u64> {
    let clk = rt.core().clk();
    let op = syscall_code.uint256_op_map();

    // Read addresses - arg1 and arg2 come from the syscall, others from registers
    let a_ptr = arg1;
    let b_ptr = arg2;
    let c_ptr_memory = rt.rr(12 /* X12 */);
    let d_ptr_memory = rt.rr(13 /* X13 */);
    let e_ptr_memory = rt.rr(14 /* X14 */);
    let c_ptr = c_ptr_memory.value;
    let d_ptr = d_ptr_memory.value;
    let e_ptr = e_ptr_memory.value;

    // Read input values (8 words = 32 bytes each for uint256) and convert to BigUint
    let a_memory_records = rt.mr_slice(a_ptr, U256_NUM_WORDS);
    rt.increment_clk();
    let a: Vec<_> = a_memory_records.iter().map(|record| record.value).collect();
    let b_memory_records = rt.mr_slice(b_ptr, U256_NUM_WORDS);
    rt.increment_clk();
    let b: Vec<_> = b_memory_records.iter().map(|record| record.value).collect();
    let c_memory_records = rt.mr_slice(c_ptr, U256_NUM_WORDS);
    let c: Vec<_> = c_memory_records.iter().map(|record| record.value).collect();

    rt.increment_clk();

    let d_memory_records = rt.mw_slice(d_ptr, U256_NUM_WORDS);
    let d: Vec<_> = d_memory_records.iter().map(|record| record.value).collect();

    rt.increment_clk();

    let e_memory_records = rt.mw_slice(e_ptr, U256_NUM_WORDS);
    let e: Vec<_> = e_memory_records.iter().map(|record| record.value).collect();

    if RT::TRACING {
        let event = PrecompileEvent::Uint256Ops(Uint256OpsEvent {
            clk,
            op,
            a_ptr,
            a: a.try_into().unwrap(),
            b_ptr,
            b: b.try_into().unwrap(),
            c_ptr,
            c: c.try_into().unwrap(),
            d_ptr,
            d: d.try_into().unwrap(),
            e_ptr,
            e: e.try_into().unwrap(),
            c_ptr_memory,
            d_ptr_memory,
            e_ptr_memory,
            a_memory_records,
            b_memory_records,
            c_memory_records,
            d_memory_records,
            e_memory_records,
            local_mem_access: rt.postprocess_precompile(),
            ..Default::default()
        });

        let syscall_event = rt.syscall_event(
            clk,
            syscall_code,
            arg1,
            arg2,
            false,
            rt.core().next_pc(),
            rt.core().exit_code(),
        );
        rt.add_precompile_event(syscall_code, syscall_event, event);
    }

    None
}