Struct lucet_runtime_internals::alloc::Alloc

pub struct Alloc {
    pub heap_accessible_size: usize,
    pub heap_inaccessible_size: usize,
    pub slot: Option<Slot>,
    pub region: Arc<dyn RegionInternal>,
}

The structure that manages the allocations backing an Instance.

Allocs are not to be created directly, but rather are created by Regions during instance creation.

Fields

heap_accessible_size: usize

heap_inaccessible_size: usize

slot: Option<Slot>

region: Arc<dyn RegionInternal>

Methods

impl Alloc

pub fn addr_in_guard_page(&self, addr: *const c_void) -> bool

pub fn expand_heap(
    &mut self,
    expand_bytes: u32,
    module: &dyn Module
) -> Result<u32, Error>

pub fn reset_heap(&mut self, module: &dyn Module) -> Result<(), Error>

pub fn heap_len(&self) -> usize

pub fn slot(&self) -> &Slot

pub unsafe fn heap(&self) -> &[u8]

Return the heap as a byte slice.

pub unsafe fn heap_mut(&mut self) -> &mut [u8]

Return the heap as a mutable byte slice.

pub unsafe fn heap_u32(&self) -> &[u32]

Return the heap as a slice of 32-bit words.

pub unsafe fn heap_u32_mut(&self) -> &mut [u32]

Return the heap as a mutable slice of 32-bit words.

pub unsafe fn heap_u64(&self) -> &[u64]

Return the heap as a slice of 64-bit words.

pub unsafe fn heap_u64_mut(&mut self) -> &mut [u64]

Return the heap as a mutable slice of 64-bit words.

pub unsafe fn stack_mut(&mut self) -> &mut [u8]

Return the stack as a mutable byte slice.

Since the stack grows down, alloc.stack_mut()[0] is the top of the stack, and alloc.stack_mut()[alloc.limits.stack_size - 1] is the last byte at the bottom of the stack.

pub unsafe fn stack_u64_mut(&mut self) -> &mut [u64]

Return the stack as a mutable slice of 64-bit words.

Since the stack grows down, alloc.stack_mut()[0] is the top of the stack, and alloc.stack_mut()[alloc.limits.stack_size - 1] is the last word at the bottom of the stack.

pub unsafe fn globals(&self) -> &[GlobalValue]

Return the globals as a slice.

pub unsafe fn globals_mut(&mut self) -> &mut [GlobalValue]

Return the globals as a mutable slice.

pub unsafe fn sigstack_mut(&mut self) -> &mut [u8]

Return the sigstack as a mutable byte slice.

pub fn mem_in_heap<T>(&self, ptr: *const T, len: usize) -> bool

Trait Implementations

impl Drop for Alloc

fn drop(&mut self)

Executes the destructor for this type.