Struct MaterializeOpsVisitor

pub struct MaterializeOpsVisitor<B> { /* private fields */ }

Available on crate feature decode only.

A visitor that materializes whole Ops as it decodes the bytecode stream.

Implementations

impl<B> MaterializeOpsVisitor<B>

pub fn new(bytecode: B) -> Self

Create a new op-materializing visitor for the given bytecode.

Trait Implementations

impl<B: Default> Default for MaterializeOpsVisitor<B>

fn default() -> MaterializeOpsVisitor<B>

Returns the “default value” for a type.

impl<B: BytecodeStream> ExtendedOpVisitor for MaterializeOpsVisitor<B>

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

Raise a trap.

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

Do nothing.

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

Copy the special sp stack pointer register into an x register.

impl<B: BytecodeStream> OpVisitor for MaterializeOpsVisitor<B>

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 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 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 += 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 += 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

type BytecodeStream = B

The type of this visitor’s bytecode stream.

type Return = Op

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.