Struct JitContext 

pub struct JitContext {
    pub pc: u64,
    pub clk: u64,
    pub global_clk: u64,
    pub is_unconstrained: u64,
    pub public_value_digest: [u32; 8],
    /* private fields */
}

Fields

pc: u64

The current program counter

clk: u64

The number of cycles executed.

global_clk: u64

The number of cycles executed.

is_unconstrained: u64

This context is in unconstrainted mode. 1 if unconstrained, 0 otherwise.

public_value_digest: [u32; 8]

The public value digest words emitted by COMMIT syscalls.

Implementations

impl JitContext

pub unsafe fn trace_mem_access(&self, reads: &[MemValue])

Safety

• todo

pub fn enter_unconstrained(&mut self) -> Result<()>

Enter the unconstrained context, this will create a COW memory map of the memory file descriptor.

pub fn exit_unconstrained(&mut self)

Exit the unconstrained context, this will restore the original memory map.

pub unsafe fn trace_hint(&mut self, addr: u64, value: Vec<u8>)

Indicate that the program has read a hint.

This is used to store the hints read by the program.

Safety

• The address must be aligned to 8 bytes.
• The hints pointer must not be mutably aliased.

pub const fn memory(&mut self) -> ContextMemory<'_>

Obtain a mutable view of the emulated memory.

pub const unsafe fn input_buffer(&mut self) -> &mut VecDeque<Vec<u8>>

Safety

• The input buffer must be non null and valid to read from.

pub const unsafe fn public_values_stream(&mut self) -> &mut Vec<u8>

Safety

• The public values stream must be non null and valid to read from.

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

Obtain a view of the registers.

pub const fn rw(&mut self, reg: RiscRegister, val: u64)

pub const fn rr(&self, reg: RiscRegister) -> u64

pub const fn tracing(&self) -> bool

Trait Implementations

impl Debug for JitContext

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl SyscallContext for JitContext

fn bump_memory_clk(&mut self)

Used for precompiles that access memory, that need to bump the clk. This increment is local to the precompile, and does not affect the number of cycles the precompile itself takes up.

fn get_current_clk(&self) -> u64

Get the current clock value.

fn set_clk(&mut self, clk: u64)

Set the clock value.

fn rr(&self, reg: RiscRegister) -> u64

Read a value from a register.

fn rw(&mut self, _reg: RiscRegister, _value: u64)

Write a value to a register.

fn set_next_pc(&mut self, _pc: u64)

Write next pc.

fn mr_without_prot(&mut self, addr: u64) -> u64

Read a value from memory, without checking page permissions.

fn mw_without_prot(&mut self, addr: u64, val: u64)

Write a value to memory, without checking page permissions.

fn mr_slice_without_prot( &mut self, addr: u64, len: usize, ) -> impl IntoIterator<Item = &u64>

Read a slice of values from memory, without checking page permissions.

fn mr_slice_no_trace( &mut self, addr: u64, len: usize, ) -> impl IntoIterator<Item = &u64>

Read a slice of values from memory, without updating the memory clock or tracing the access.

fn mr_slice_unsafe( &mut self, addr: u64, len: usize, ) -> impl IntoIterator<Item = &u64>

Read a slice of values from memory, without updating the memory clock. Note that it still traces the access when tracing is enabled.

fn mw_slice_without_prot(&mut self, addr: u64, vals: &[u64])

Write a slice of values to memory, without checking page permissions.

fn prot_slice_check( &mut self, _addr: u64, _len: usize, _prot_bitmap: u8, ) -> Result<(), Interrupt>

Check page permissions for a slice of memory.

fn page_prot_write(&mut self, _addr: u64, _val: u8)

Write a page protection value.

fn input_buffer(&mut self) -> &mut VecDeque<Vec<u8>>

Get the input buffer.

fn public_values_stream(&mut self) -> &mut Vec<u8>

Get the public values stream.

fn enter_unconstrained(&mut self) -> Result<()>

Enter the unconstrained context.

fn exit_unconstrained(&mut self)

Exit the unconstrained context.

fn trace_hint(&mut self, addr: u64, value: Vec<u8>)

Trace a hint.

fn trace_value(&mut self, value: u64)

Trace a dummy value.

fn mw_hint(&mut self, addr: u64, val: u64)

Write a hint to memory, which is like setting uninitialized memory to a nonzero value. The clk will be set to 0, just like for uninitialized memory.

fn set_exit_code(&mut self, exit_code: u32)

Set the exit code of the program.

fn set_public_value_digest_word(&mut self, word_idx: u64, digest_word: u32)

Record one word of the public value digest emitted by a COMMIT syscall.

fn is_unconstrained(&self) -> bool

Returns if were in unconstrained mode.

fn global_clk(&self) -> u64

Get the global clock (total cycles executed).

fn elf_info(&self) -> ElfInfo

Fetch loaded ELF information.

fn init_addr_iter(&self) -> impl IntoIterator<Item = u64>

Iterate through all initialized addresses.

fn page_prot_iter(&self) -> impl IntoIterator<Item = (&u64, &PageProtValue)>

Iterate through all non-default page permissions.

fn maybe_dump_profiler_data(&self) -> (Vec<(String, u64, u64)>, Vec<u64>)

Dump all profiler data for dump-elf / bootloader use.

fn maybe_insert_profiler_symbols<I: Iterator<Item = (String, u64, u64)>>( &mut self, _iter: I, )

Insert function symbols in profiler mode.

fn maybe_delete_profiler_symbols<I: Iterator<Item = u64>>(&mut self, _iter: I)

Delete function symbols in profiler mode.

fn mr_slice( &mut self, addr: u64, len: usize, ) -> Result<impl IntoIterator<Item = &u64>, Interrupt>

Read a slice of values from memory, checking page permissions.

fn mw_slice(&mut self, addr: u64, vals: &[u64]) -> Result<(), Interrupt>

Write a slice of values to memory, checking page permissions.

fn read_slice_check(&mut self, addr: u64, len: usize) -> Result<(), Interrupt>

Check read permission for a slice of memory.

fn write_slice_check(&mut self, addr: u64, len: usize) -> Result<(), Interrupt>

Check write permission for a slice of memory.

fn read_write_slice_check( &mut self, addr: u64, len: usize, ) -> Result<(), Interrupt>

Check read+write permission for a slice of memory.

fn page_prot_flush(&mut self)

Flush all buffered page protection writes.