Struct SequencedVisitor

pub struct SequencedVisitor<'a, F, V1, V2> { /* private fields */ }

Available on crate feature decode only.

An OpVisitor combinator to sequence one visitor and then another.

Implementations

impl<'a, F, V1, V2> SequencedVisitor<'a, F, V1, V2>

pub fn new(join: F, v1: &'a mut V1, v2: &'a mut V2) -> Self

Create a new sequenced visitor.

The given join function is used to combine the results of each sub-visitor so that it can be returned from this combined visitor.

Trait Implementations

impl<F, T, V1, V2> ExtendedOpVisitor for SequencedVisitor<'_, F, V1, V2>

where F: FnMut(V1::Return, V2::Return) -> T, V1: ExtendedOpVisitor, V2: ExtendedOpVisitor<BytecodeStream = V1::BytecodeStream>,

fn trap(&mut self) -> Self::Return

Raise a trap.

fn nop(&mut self) -> Self::Return

Do nothing.

fn call_indirect_host(&mut self, sig: u8) -> Self::Return

A special opcode to use an indirect function call to reenter the host from the interpreter.

This is used to implement host intrinsics such as memory.grow for example where that needs to reenter the host from the interpreter.

The sig immediate here is the Nth signature in the for_each_host_signature! macro below. The 0th “argument”, in register x0, is the function pointer that’s being called and all further arguments follow after that in registers.

impl<F, T, V1, V2> OpVisitor for SequencedVisitor<'_, F, V1, V2>

where F: FnMut(V1::Return, V2::Return) -> T, V1: OpVisitor, V2: OpVisitor<BytecodeStream = V1::BytecodeStream>,

fn ret(&mut self) -> Self::Return

Transfer control the address in the lr register.

fn call(&mut self, offset: PcRelOffset) -> Self::Return

Transfer control to the PC at the given offset and set the lr register to the PC just after this instruction.

fn call_indirect(&mut self, reg: XReg) -> Self::Return

Transfer control to the PC in reg and set lr to the PC just after this instruction.

fn jump(&mut self, offset: PcRelOffset) -> Self::Return

Unconditionally transfer control to the PC at the given offset.

fn br_if(&mut self, cond: XReg, offset: PcRelOffset) -> Self::Return

Conditionally transfer control to the given PC offset if cond contains a non-zero value.

fn br_if_not(&mut self, cond: XReg, offset: PcRelOffset) -> Self::Return

Conditionally transfer control to the given PC offset if cond contains a zero value.

fn br_if_xeq32(&mut self, a: XReg, b: XReg, offset: PcRelOffset) -> Self::Return

Branch if a == b.

fn br_if_xneq32( &mut self, a: XReg, b: XReg, offset: PcRelOffset, ) -> Self::Return

Branch if a != b.

fn br_if_xslt32( &mut self, a: XReg, b: XReg, offset: PcRelOffset, ) -> Self::Return

Branch if signed a < b.

fn br_if_xslteq32( &mut self, a: XReg, b: XReg, offset: PcRelOffset, ) -> Self::Return

Branch if signed a <= b.

fn br_if_xult32( &mut self, a: XReg, b: XReg, offset: PcRelOffset, ) -> Self::Return

Branch if unsigned a < b.

fn br_if_xulteq32( &mut self, a: XReg, b: XReg, offset: PcRelOffset, ) -> Self::Return

Branch if unsigned a <= b.

fn br_if_xeq64(&mut self, a: XReg, b: XReg, offset: PcRelOffset) -> Self::Return

Branch if a == b.

fn br_if_xneq64( &mut self, a: XReg, b: XReg, offset: PcRelOffset, ) -> Self::Return

Branch if a != b.

fn br_if_xslt64( &mut self, a: XReg, b: XReg, offset: PcRelOffset, ) -> Self::Return

Branch if signed a < b.

fn br_if_xslteq64( &mut self, a: XReg, b: XReg, offset: PcRelOffset, ) -> Self::Return

Branch if signed a <= b.

fn br_if_xult64( &mut self, a: XReg, b: XReg, offset: PcRelOffset, ) -> Self::Return

Branch if unsigned a < b.

fn br_if_xulteq64( &mut self, a: XReg, b: XReg, offset: PcRelOffset, ) -> Self::Return

Branch if unsigned a <= b.

fn br_table32(&mut self, idx: XReg, amt: u32) -> Self::Return

Branch to the label indicated by idx.

After this instruction are amt instances of PcRelOffset and the idx selects which one will be branched to. The value of idx is clamped to amt - 1 (e.g. the last offset is the “default” one.

fn xmov(&mut self, dst: XReg, src: XReg) -> Self::Return

Move between x registers.

fn fmov(&mut self, dst: FReg, src: FReg) -> Self::Return

Move between f registers.

fn vmov(&mut self, dst: VReg, src: VReg) -> Self::Return

Move between v registers.

fn xconst8(&mut self, dst: XReg, imm: i8) -> Self::Return

Set dst = sign_extend(imm8).

fn xconst16(&mut self, dst: XReg, imm: i16) -> Self::Return

Set dst = sign_extend(imm16).

fn xconst32(&mut self, dst: XReg, imm: i32) -> Self::Return

Set dst = sign_extend(imm32).

fn xconst64(&mut self, dst: XReg, imm: i64) -> Self::Return

Set dst = imm64.

fn xadd32(&mut self, operands: BinaryOperands<XReg>) -> Self::Return

32-bit wrapping addition: low32(dst) = low32(src1) + low32(src2).

The upper 32-bits of dst are unmodified.

fn xadd64(&mut self, operands: BinaryOperands<XReg>) -> Self::Return

64-bit wrapping addition: dst = src1 + src2.

fn xeq64(&mut self, operands: BinaryOperands<XReg>) -> Self::Return

64-bit equality.

fn xneq64(&mut self, operands: BinaryOperands<XReg>) -> Self::Return

64-bit inequality.

fn xslt64(&mut self, operands: BinaryOperands<XReg>) -> Self::Return

64-bit signed less-than.

fn xslteq64(&mut self, operands: BinaryOperands<XReg>) -> Self::Return

64-bit signed less-than-equal.

fn xult64(&mut self, operands: BinaryOperands<XReg>) -> Self::Return

64-bit unsigned less-than.

fn xulteq64(&mut self, operands: BinaryOperands<XReg>) -> Self::Return

64-bit unsigned less-than-equal.

fn xeq32(&mut self, operands: BinaryOperands<XReg>) -> Self::Return

32-bit equality.

fn xneq32(&mut self, operands: BinaryOperands<XReg>) -> Self::Return

32-bit inequality.

fn xslt32(&mut self, operands: BinaryOperands<XReg>) -> Self::Return

32-bit signed less-than.

fn xslteq32(&mut self, operands: BinaryOperands<XReg>) -> Self::Return

32-bit signed less-than-equal.

fn xult32(&mut self, operands: BinaryOperands<XReg>) -> Self::Return

32-bit unsigned less-than.

fn xulteq32(&mut self, operands: BinaryOperands<XReg>) -> Self::Return

32-bit unsigned less-than-equal.

fn load32_u(&mut self, dst: XReg, ptr: XReg) -> Self::Return

dst = zero_extend(load32(ptr))

fn load32_s(&mut self, dst: XReg, ptr: XReg) -> Self::Return

dst = sign_extend(load32(ptr))

fn load64(&mut self, dst: XReg, ptr: XReg) -> Self::Return

dst = load64(ptr)

fn load32_u_offset8(&mut self, dst: XReg, ptr: XReg, offset: i8) -> Self::Return

dst = zero_extend(load32(ptr + offset8))

fn load32_s_offset8(&mut self, dst: XReg, ptr: XReg, offset: i8) -> Self::Return

dst = sign_extend(load32(ptr + offset8))

fn load64_offset8(&mut self, dst: XReg, ptr: XReg, offset: i8) -> Self::Return

dst = load64(ptr + offset8)

fn load32_u_offset64( &mut self, dst: XReg, ptr: XReg, offset: i64, ) -> Self::Return

dst = zero_extend(load32(ptr + offset64))

fn load32_s_offset64( &mut self, dst: XReg, ptr: XReg, offset: i64, ) -> Self::Return

dst = sign_extend(load32(ptr + offset64))

fn load64_offset64(&mut self, dst: XReg, ptr: XReg, offset: i64) -> Self::Return

dst = load64(ptr + offset64)

fn store32(&mut self, ptr: XReg, src: XReg) -> Self::Return

*ptr = low32(src)

fn store64(&mut self, ptr: XReg, src: XReg) -> Self::Return

*ptr = src

fn store32_offset8(&mut self, ptr: XReg, offset: i8, src: XReg) -> Self::Return

*(ptr + sign_extend(offset8)) = low32(src)

fn store64_offset8(&mut self, ptr: XReg, offset: i8, src: XReg) -> Self::Return

*(ptr + sign_extend(offset8)) = src

fn store32_offset64( &mut self, ptr: XReg, offset: i64, src: XReg, ) -> Self::Return

*(ptr + sign_extend(offset64)) = low32(src)

fn store64_offset64( &mut self, ptr: XReg, offset: i64, src: XReg, ) -> Self::Return

*(ptr + sign_extend(offset64)) = src

fn push_frame(&mut self) -> Self::Return

push lr; push fp; fp = sp

fn pop_frame(&mut self) -> Self::Return

sp = fp; pop fp; pop lr

fn xpush32(&mut self, src: XReg) -> Self::Return

*sp = low32(src); sp = sp.checked_add(4)

fn xpush32_many(&mut self, srcs: RegSet<XReg>) -> Self::Return

for src in srcs { xpush32 src }

fn xpush64(&mut self, src: XReg) -> Self::Return

*sp = src; sp = sp.checked_add(8)

fn xpush64_many(&mut self, srcs: RegSet<XReg>) -> Self::Return

for src in srcs { xpush64 src }

fn xpop32(&mut self, dst: XReg) -> Self::Return

*dst = *sp; sp -= 4

fn xpop32_many(&mut self, dsts: RegSet<XReg>) -> Self::Return

for dst in dsts.rev() { xpop32 dst }

fn xpop64(&mut self, dst: XReg) -> Self::Return

*dst = *sp; sp -= 8

fn xpop64_many(&mut self, dsts: RegSet<XReg>) -> Self::Return

for dst in dsts.rev() { xpop64 dst }

fn bitcast_int_from_float_32(&mut self, dst: XReg, src: FReg) -> Self::Return

low32(dst) = bitcast low32(src) as i32

fn bitcast_int_from_float_64(&mut self, dst: XReg, src: FReg) -> Self::Return

dst = bitcast src as i64

fn bitcast_float_from_int_32(&mut self, dst: FReg, src: XReg) -> Self::Return

low32(dst) = bitcast low32(src) as f32

fn bitcast_float_from_int_64(&mut self, dst: FReg, src: XReg) -> Self::Return

dst = bitcast src as f64

fn stack_alloc32(&mut self, amt: u32) -> Self::Return

sp = sp.checked_sub(amt)

fn stack_free32(&mut self, amt: u32) -> Self::Return

sp = sp + amt

type BytecodeStream = <V1 as OpVisitor>::BytecodeStream

The type of this visitor’s bytecode stream.

type Return = T

The type of values returned by each visitor method.

fn bytecode(&mut self) -> &mut Self::BytecodeStream

Get this visitor’s underlying bytecode stream.

fn before_visit(&mut self)

A callback invoked before starting to decode an instruction.

fn after_visit(&mut self)

A callback invoked after an instruction has been completely decoded.