Struct Memory 

pub struct Memory {
    pub rodata: Vec<u8>,
    pub stack: Vec<u8>,
    pub heap: Vec<u8>,
    pub input: Vec<u8>,
    pub heap_ptr: usize,
}

Memory layout

Fields

rodata: Vec<u8>

stack: Vec<u8>

heap: Vec<u8>

input: Vec<u8>

heap_ptr: usize

Implementations

impl Memory

pub const RODATA_START: u64 = 0x100000000

pub const STACK_START: u64 = 0x200000000

pub const HEAP_START: u64 = 0x300000000

pub const INPUT_START: u64 = 0x400000000

pub const DEFAULT_HEAP_SIZE: usize = 32768

pub const STACK_FRAME_SIZE: u64 = 4096

pub fn new( input: Vec<u8>, rodata: Vec<u8>, stack_size: usize, heap_size: usize, ) -> Self

pub fn initial_frame_pointer(&self) -> u64

pub fn stack_size(max_call_depth: usize) -> usize

pub fn read_u8(&self, addr: u64) -> SbpfVmResult<u8>

pub fn read_u16(&self, addr: u64) -> SbpfVmResult<u16>

pub fn read_u32(&self, addr: u64) -> SbpfVmResult<u32>

pub fn read_u64(&self, addr: u64) -> SbpfVmResult<u64>

pub fn read_bytes(&self, addr: u64, len: usize) -> SbpfVmResult<&[u8]>

pub fn write_u8(&mut self, addr: u64, value: u8) -> SbpfVmResult<()>

pub fn write_u16(&mut self, addr: u64, value: u16) -> SbpfVmResult<()>

pub fn write_u32(&mut self, addr: u64, value: u32) -> SbpfVmResult<()>

pub fn write_u64(&mut self, addr: u64, value: u64) -> SbpfVmResult<()>

pub fn write_i64(&mut self, addr: u64, value: i64) -> SbpfVmResult<()>

pub fn write_bytes(&mut self, addr: u64, bytes: &[u8]) -> SbpfVmResult<()>

pub fn alloc(&mut self, size: usize) -> SbpfVmResult<u64>

pub fn reset_heap(&mut self)

Trait Implementations

impl Clone for Memory

fn clone(&self) -> Memory

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Memory

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Memory

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Memory

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.