Struct SyscallContext

pub struct SyscallContext<'a, 'b: 'a> {
    pub current_shard: u32,
    pub clk: u32,
    pub next_pc: u32,
    pub exit_code: u32,
    pub rt: &'a mut Executor<'b>,
    pub local_memory_access: HashMap<u32, MemoryLocalEvent>,
}

A runtime for syscalls that is protected so that developers cannot arbitrarily modify the runtime.

Fields

current_shard: u32

The current shard.

clk: u32

The clock cycle.

next_pc: u32

The next program counter.

exit_code: u32

The exit code.

rt: &'a mut Executor<'b>

The runtime.

local_memory_access: HashMap<u32, MemoryLocalEvent>

The local memory access events for the syscall.

Implementations

impl<'a, 'b> SyscallContext<'a, 'b>

pub fn new(runtime: &'a mut Executor<'b>) -> Self

Create a new SyscallContext.

pub fn record_mut(&mut self) -> &mut ExecutionRecord

Get a mutable reference to the execution record.

pub fn add_precompile_event( &mut self, syscall_code: SyscallCode, syscall_event: SyscallEvent, event: PrecompileEvent, )

Add a precompile event to the execution record.

pub fn current_shard(&self) -> u32

Get the current shard.

pub fn mr(&mut self, addr: u32) -> (MemoryReadRecord, u32)

Read a word from memory.

addr must be a pointer to main memory, not a register.

pub fn mr_slice( &mut self, addr: u32, len: usize, ) -> (Vec<MemoryReadRecord>, Vec<u32>)

Read a slice of words from memory.

addr must be a pointer to main memory, not a register.

pub fn mw(&mut self, addr: u32, value: u32) -> MemoryWriteRecord

Write a word to memory.

addr must be a pointer to main memory, not a register.

pub fn mw_slice(&mut self, addr: u32, values: &[u32]) -> Vec<MemoryWriteRecord>

Write a slice of words to memory.

pub fn rr_traced(&mut self, register: Register) -> (MemoryReadRecord, u32)

Read a register and record the memory access.

pub fn rw_traced( &mut self, register: Register, value: u32, ) -> (MemoryWriteRecord, u32)

Write a register and record the memory access.

pub fn postprocess(&mut self) -> Vec<MemoryLocalEvent>

Postprocess the syscall. Specifically will process the syscall’s memory local events.

pub fn register_unsafe(&mut self, register: Register) -> u32

Get the current value of a register, but doesn’t use a memory record. This is generally unconstrained, so you must be careful using it.

pub fn byte_unsafe(&mut self, addr: u32) -> u8

Get the current value of a byte, but doesn’t use a memory record.

pub fn word_unsafe(&mut self, addr: u32) -> u32

Get the current value of a word, but doesn’t use a memory record.

pub fn slice_unsafe(&mut self, addr: u32, len: usize) -> Vec<u32>

Get a slice of words, but doesn’t use a memory record.

pub fn set_next_pc(&mut self, next_pc: u32)

Set the next program counter.

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

Set the exit code.