Struct itsy::bytecode::VM

pub struct VM<T, U> where
    T: VMFunc<T>,
    U: Default,  {
    pub stack: Stack,
    pub heap: Heap,
    // some fields omitted
}

A virtual machine for running Itsy bytecode.

Fields

stack: Stack

heap: Heap

Methods

impl<T, U> VM<T, U> where
    T: VMFunc<T> + VMData<T, U>,
    U: Default, 

Public VM methods.

pub fn new(program: Program<T>) -> Self

Create a new VM instance with the given Program.

pub fn reset(&mut self)

Resets the VM, keeping only code and constants.

pub fn dump_program(&mut self) -> String

Disassembles the bytecode and returns it as a string.

pub fn dump_instruction(&mut self) -> Option<String>

Disassembles the current bytecode instruction and returns it as a string.

pub fn dump_stack(&self) -> String

Returns the current stack as a string.

pub fn dump_frame(&self) -> String

Returns the current stack-frame as a string.

pub fn run(&mut self) -> &mut Self

Executes bytecode until it terminates.

pub fn state(&self) -> VMState

Returns the current VM state.

pub fn context(&mut self) -> &mut U

Returns a reference to the custom context.

pub fn into_context(self) -> U

Destroys the VM and returns its custom context.

impl<T, U> VM<T, U> where
    T: VMFunc<T> + VMData<T, U>,
    U: Default, 

Bytecode instructions. Implemented on VM by the impl_vm! macro.

pub fn debug(&mut self, label: u32)

Does nothing. Used as label when debugging.

pub fn reserve(&mut self, num_items: u8)

Moves the stack pointer by given number of items (32bit words) to make room for local variables.

pub fn constr16(&mut self, const_id: u8)

Load 2 byte from constant pool onto stack.

pub fn constr16_16(&mut self, const_id: u16)

Load 2 byte from constant pool onto stack.

pub fn constr32(&mut self, const_id: u8)

Load 4 byte from constant pool onto stack.

pub fn constr32_16(&mut self, const_id: u16)

Load 4 byte from constant pool onto stack.

pub fn constr64(&mut self, const_id: u8)

Load 8 byte from constant pool onto stack.

pub fn constr64_16(&mut self, const_id: u16)

Load 8 byte from constant pool onto stack.

pub fn consto(&mut self, const_id: u8)

Load object from constant pool onto stack+heap.

pub fn consto_16(&mut self, const_id: u16)

Load object from constant pool onto stack+heap.

pub fn litu(&mut self, value: u8)

Push value onto stack.

pub fn lits(&mut self, value: i8)

Push value onto stack.

pub fn lit0(&mut self)

Push 0 onto stack.

pub fn lit1(&mut self)

Push 1 onto stack.

pub fn lit2(&mut self)

Push 2 onto stack.

pub fn litm1(&mut self)

Push -1 onto stack.

pub fn loadr32(&mut self, offset: i32)

Load stackvalue from offset (relative to the stackframe) and push onto the stack.

pub fn storer32(&mut self, offset: i32)

Pop stackvalue and store it at the given offset (relative to the stackframe).

pub fn loadr64(&mut self, offset: i32)

Load 64 bit stackvalue from offset (relative to the stackframe) and push onto the stack.

pub fn storer64(&mut self, offset: i32)

Pop 64 bit stackvalue and store it at the given offset (relative to the stackframe).

pub fn load_arg1(&mut self)

Load function argument 1 and push it onto the stack. Equivalent to load -4.

pub fn load_arg2(&mut self)

Load function argument 2 and push it onto the stack. Equivalent to load -5.

pub fn load_arg3(&mut self)

Load function argument 3 and push it onto the stack. Equivalent to load -6.

pub fn rustcall(&mut self, func: u16)

Calls the given Rust function.

pub fn call(&mut self, addr: u32, num_args: u8)

Function call. Saves state and sets programm counter to given addr. Expects callee arguments on the stack and number of arguments (in 32 bit words) as num_args.

pub fn ret(&mut self, num_ret: u8)

Function return. Restores state, removes arguments left on stack by caller and leaves call result on the stack.

pub fn and(&mut self)

Pops 2 values from the stack and pushes their logical conjunction.

pub fn or(&mut self)

Pops 2 values from the stack and pushes their logical disjunction.

pub fn not(&mut self)

Pops a values from the stack and pushes its logical negation.

pub fn addi(&mut self)

Pops 2 values from the stack and pushes their sum.

pub fn subi(&mut self)

Pops 2 values from the stack and pushes their difference.

pub fn muli(&mut self)

Pops 2 values from the stack and pushes their product.

pub fn addf(&mut self)

Pops 2 values from the stack and pushes their sum.

pub fn subf(&mut self)

Pops 2 values from the stack and pushes their sum.

pub fn mulf(&mut self)

Pops 2 values from the stack and pushes their product.

pub fn addi64(&mut self)

Pops 2 values from the stack and pushes their sum.

pub fn subi64(&mut self)

Pops 2 values from the stack and pushes their difference.

pub fn muli64(&mut self)

Pops 2 values from the stack and pushes their product.

pub fn addf64(&mut self)

Pops 2 values from the stack and pushes their sum.

pub fn subf64(&mut self)

Pops 2 values from the stack and pushes their sum.

pub fn mulf64(&mut self)

Pops 2 values from the stack and pushes their product.

pub fn jmp(&mut self, addr: u32)

Jumps unconditionally to the given address.

pub fn j0(&mut self, addr: u32)

Pops one values and jumps to given address if it is 0.

pub fn jeqr32(&mut self, addr: u32)

Pops two values and jumps to given address it they equal.

pub fn jeqr64(&mut self, addr: u32)

Pops two values and jumps to given address it they equal.

pub fn jneqr32(&mut self, addr: u32)

Pops two values and jumps to given address it they are not equal.

pub fn jneqr64(&mut self, addr: u32)

Pops two values and jumps to given address it they are not equal.

pub fn jlts32(&mut self, addr: u32)

Pops two values and jumps to given address if the first value is less than the second.

pub fn jltu32(&mut self, addr: u32)

Pops two values and jumps to given address if the first value is less than the second.

pub fn jltf32(&mut self, addr: u32)

Pops two values and jumps to given address if the first value is less than the second.

pub fn jlts64(&mut self, addr: u32)

Pops two values and jumps to given address if the first value is less than the second.

pub fn jltu64(&mut self, addr: u32)

Pops two values and jumps to given address if the first value is less than the second.

pub fn jltf64(&mut self, addr: u32)

Pops two values and jumps to given address if the first value is less than the second.

pub fn jltes32(&mut self, addr: u32)

Pops two values and jumps to given address if the first value is less/equal the second.

pub fn jlteu32(&mut self, addr: u32)

Pops two values and jumps to given address if the first value is less/equal the second.

pub fn jltef32(&mut self, addr: u32)

Pops two values and jumps to given address if the first value is less/equal the second.

pub fn jltes64(&mut self, addr: u32)

Pops two values and jumps to given address if the first value is less/equal the second.

pub fn jlteu64(&mut self, addr: u32)

Pops two values and jumps to given address if the first value is less/equal the second.

pub fn jltef64(&mut self, addr: u32)

Pops two values and jumps to given address if the first value is less/equal the second.

pub fn ceqr32(&mut self)

Pops two values and pushes a 1 if the first value equals the second, otherwise a 0.

pub fn ceqr64(&mut self)

Pops two values and pushes a 1 if the first value equals the second, otherwise a 0.

pub fn cneqr32(&mut self)

Pops two values and pushes a 1 if the first value does not equal the second, otherwise a 0.

pub fn cneqr64(&mut self)

Pops two values and pushes a 1 if the first value does not equal the second, otherwise a 0.

pub fn clts32(&mut self)

Pops two values and pushes a 1 if the first value is lesser than the second, otherwise a 0.

pub fn cltu32(&mut self)

Pops two values and pushes a 1 if the first value is lesser than the second, otherwise a 0.

pub fn cltf32(&mut self)

Pops two values and pushes a 1 if the first value is lesser than the second, otherwise a 0.

pub fn clts64(&mut self)

Pops two values and pushes a 1 if the first value is lesser than the second, otherwise a 0.

pub fn cltu64(&mut self)

Pops two values and pushes a 1 if the first value is lesser than the second, otherwise a 0.

pub fn cltf64(&mut self)

Pops two values and pushes a 1 if the first value is lesser than the second, otherwise a 0.

pub fn cltes32(&mut self)

Pops two values and pushes a 1 if the first value is lesser or equal the second, otherwise a 0.

pub fn clteu32(&mut self)

Pops two values and pushes a 1 if the first value is lesser or equal the second, otherwise a 0.

pub fn cltef32(&mut self)

Pops two values and pushes a 1 if the first value is lesser or equal the second, otherwise a 0.

pub fn cltes64(&mut self)

Pops two values and pushes a 1 if the first value is lesser or equal the second, otherwise a 0.

pub fn clteu64(&mut self)

Pops two values and pushes a 1 if the first value is lesser or equal the second, otherwise a 0.

pub fn cltef64(&mut self)

Pops two values and pushes a 1 if the first value is lesser or equal the second, otherwise a 0.

pub fn inci(&mut self)

Increments the value at the top of the stack.

pub fn deci(&mut self)

Decrements the value at the top of the stack.

pub fn inci64(&mut self)

Increments the value at the top of the stack.

pub fn deci64(&mut self)

Decrements the value at the top of the stack.

pub fn preinci(&mut self, offset: i32)

Increments the stackvalue at given offset (relative to the stackframe) and pushes the result onto the stack.

pub fn predeci(&mut self, offset: i32)

Decrements the stackvalue at given offset (relative to the stackframe) and pushes the result onto the stack.

pub fn preinci64(&mut self, offset: i32)

Increments the stackvalue at given offset (relative to the stackframe) and pushes the result onto the stack.

pub fn predeci64(&mut self, offset: i32)

Decrements the stackvalue at given offset (relative to the stackframe) and pushes the result onto the stack.

pub fn postinci(&mut self, offset: i32)

Increments the stackvalue at given offset (relative to the stackframe) and pushes the previous value onto the stack.

pub fn postdeci(&mut self, offset: i32)

Decrements the stackvalue at given offset (relative to the stackframe) and pushes the previous value onto the stack.

pub fn postinci64(&mut self, offset: i32)

Increments the stackvalue at given offset (relative to the stackframe) and pushes the previous value onto the stack.

pub fn postdeci64(&mut self, offset: i32)

Decrements the stackvalue at given offset (relative to the stackframe) and pushes the previous value onto the stack.

pub fn yld(&mut self)

Yield program execution.

pub fn exit(&mut self)

Terminate program execution.

Trait Implementations

impl<T: Debug, U: Debug> Debug for VM<T, U> where
    T: VMFunc<T>,
    U: Default, 

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

Formats the value using the given formatter.

impl<T, U> Read for VM<T, U> where
    T: VMFunc<T>,
    U: Default, 

fn read(&mut self, buf: &mut [u8]) -> Result<usize>

Pull some bytes from this source into the specified buffer, returning how many bytes were read.

fn read_exact(&mut self, buf: &mut [u8]) -> Result<()>

Read the exact number of bytes required to fill buf.

fn read_vectored(&mut self, bufs: &mut [IoVecMut]) -> Result<usize, Error>

🔬 This is a nightly-only experimental API. (iovec)

Like read, except that it reads into a slice of buffers.

unsafe fn initializer(&self) -> Initializer

🔬 This is a nightly-only experimental API. (read_initializer)

Determines if this Reader can work with buffers of uninitialized memory.

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>

Read all bytes until EOF in this source, placing them into buf.

fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>

Read all bytes until EOF in this source, appending them to buf.

fn by_ref(&mut self) -> &mut Self

Creates a "by reference" adaptor for this instance of Read.

fn bytes(self) -> Bytes<Self>

Transforms this Read instance to an [Iterator] over its bytes.

fn chain<R>(self, next: R) -> Chain<Self, R> where
    R: Read, 

Creates an adaptor which will chain this stream with another.

fn take(self, limit: u64) -> Take<Self>

Creates an adaptor which will read at most limit bytes from it.