Struct CoreVM 

pub struct CoreVM<'a> {
    pub mem_reads: MemReads<'a>,
    pub program: Arc<Program>,
    pub opts: SP1CoreOpts,
    pub clk_end: u64,
    pub public_value_digest: [u32; 8],
    pub proof_nonce: [u32; 4],
    /* private fields */
}

A RISC-V VM that uses a MinimalTrace to oracle memory access.

Fields

mem_reads: MemReads<'a>

The memory reads cursoir.

program: Arc<Program>

The program that is being executed.

opts: SP1CoreOpts

The options to configure the VM, mostly for syscall / shard handling.

clk_end: u64

The end clk of the trace chunk.

public_value_digest: [u32; 8]

The public value digest.

proof_nonce: [u32; 4]

The nonce associated with the proof.

Implementations

impl<'a> CoreVM<'a>

pub fn new<T: MinimalTrace>( trace: &'a T, program: Arc<Program>, opts: SP1CoreOpts, proof_nonce: [u32; 4], ) -> Self

Create a CoreVM from a MinimalTrace and a Program.

pub fn fetch(&mut self) -> Option<&Instruction>

Fetch the next instruction from the program.

pub fn advance(&mut self) -> CycleResult

Increment the state of the VM by one cycle. Calling this method will update the pc and the clk to the next cycle.

pub fn execute_load( &mut self, instruction: &Instruction, ) -> Result<LoadResult, ExecutionError>

Execute a load instruction.

pub fn execute_store( &mut self, instruction: &Instruction, ) -> Result<StoreResult, ExecutionError>

Execute a store instruction.

pub fn execute_alu(&mut self, instruction: &Instruction) -> AluResult

Execute an ALU instruction.

pub fn execute_jump(&mut self, instruction: &Instruction) -> JumpResult

Execute a jump instruction.

pub fn execute_branch(&mut self, instruction: &Instruction) -> BranchResult

Execute a branch instruction.

pub fn execute_utype(&mut self, instruction: &Instruction) -> UTypeResult

Execute a U-type instruction.

pub fn execute_ecall<RT>( rt: &mut RT, instruction: &Instruction, code: SyscallCode, ) -> Result<EcallResult, ExecutionError>

where RT: SyscallRuntime<'a>,

Execute an ecall instruction.

WARNING:

Its up to the syscall handler to update the shape checker abouut sent/internal ecalls.

pub fn read_code(&self) -> SyscallCode

Peek to get the code from the x5 register.

impl CoreVM<'_>

pub fn register_refresh(&mut self) -> [MemoryReadRecord; 32]

Touch all the registers in the VM, bumping thier clock to self.clk - 1.

impl CoreVM<'_>

pub const fn timestamp(&self, position: MemoryAccessPosition) -> u64

Get the current timestamp for a given memory access position.

pub const fn needs_bump_clk_high(&self) -> bool

Check if the top 24 bits have changed, which imply a state bump event needs to be emitted.

pub const fn needs_state_bump(&self, instruction: &Instruction) -> bool

Check if the state needs to be bumped, which implies a state bump event needs to be emitted.

impl<'a> CoreVM<'a>

pub const fn clk(&self) -> u64

Get the current clock, this clock is incremented by [CLK_INC] each cycle.

pub fn set_clk(&mut self, new_clk: u64)

Set the current clock.

pub fn set_next_clk(&mut self, clk: u64)

Set the next clock.

pub fn global_clk(&self) -> u64

Get the global clock, this clock is incremented by 1 each cycle.

pub const fn pc(&self) -> u64

Get the current program counter.

pub const fn next_pc(&self) -> u64

Get the next program counter that will be set in CoreVM::advance.

pub fn set_next_pc(&mut self, pc: u64)

Set the next program counter.

pub fn exit_code(&self) -> u32

Get the exit code.

pub fn set_exit_code(&mut self, exit_code: u32)

Set the exit code.

pub fn set_pc(&mut self, pc: u64)

Set the program counter.

pub fn set_global_clk(&mut self, global_clk: u64)

Set the global clock.

pub const fn next_clk(&self) -> u64

Get the next clock that will be set in CoreVM::advance.

pub fn registers(&self) -> &[MemoryRecord; 32]

Get the current registers (immutable).

pub fn registers_mut(&mut self) -> &mut [MemoryRecord; 32]

Get the current registers (mutable).

pub fn mem_reads(&mut self) -> &mut MemReads<'a>

Get the memory reads iterator.

pub fn is_retained_syscall(&self, syscall_code: SyscallCode) -> bool

Check if the syscall is retained.

pub const fn is_trace_end(&self) -> bool

Check if the trace has ended.

pub const fn is_done(&self) -> bool

Check if the program has halted.