Struct DebugBackend 

pub struct DebugBackend<B: RiscvTranspiler> { /* private fields */ }

Implementations

impl<B: RiscvTranspiler> DebugBackend<B>

pub const fn new(backend: B) -> Self

Trait Implementations

impl<B: RiscvTranspiler> ComputeInstructions for DebugBackend<B>

fn add(&mut self, rd: RiscRegister, rs1: RiscOperand, rs2: RiscOperand)

Add the values of two registers together, using 64bit arithmetic.

fn sub(&mut self, rd: RiscRegister, rs1: RiscOperand, rs2: RiscOperand)

Subtract the values of two registers from each other, using 64bit arithmetic.

fn xor(&mut self, rd: RiscRegister, rs1: RiscOperand, rs2: RiscOperand)

Bitwise XOR the values of two registers together.

fn or(&mut self, rd: RiscRegister, rs1: RiscOperand, rs2: RiscOperand)

Bitwise OR the values of two registers together.

fn and(&mut self, rd: RiscRegister, rs1: RiscOperand, rs2: RiscOperand)

Bitwise AND the values of two registers together.

fn sll(&mut self, rd: RiscRegister, rs1: RiscOperand, rs2: RiscOperand)

Shift the values of two registers left by the amount specified by the second register.

fn srl(&mut self, rd: RiscRegister, rs1: RiscOperand, rs2: RiscOperand)

Shift the values of two registers right by the amount specified by the second register.

fn sra(&mut self, rd: RiscRegister, rs1: RiscOperand, rs2: RiscOperand)

Shift the values of two registers right by the amount specified by the second register, using arithmetic right shift.

fn slt(&mut self, rd: RiscRegister, rs1: RiscOperand, rs2: RiscOperand)

Set if less than (signed comparison).

fn sltu(&mut self, rd: RiscRegister, rs1: RiscOperand, rs2: RiscOperand)

Set if less than (unsigned comparison).

fn mul(&mut self, rd: RiscRegister, rs1: RiscOperand, rs2: RiscOperand)

Multiply the values of two registers together, using 64bit arithmetic.

fn mulh(&mut self, rd: RiscRegister, rs1: RiscOperand, rs2: RiscOperand)

Multiply the values of two registers together and return the high 64 bits (signed).

fn mulhu(&mut self, rd: RiscRegister, rs1: RiscOperand, rs2: RiscOperand)

Multiply the values of two registers together and return the high 64 bits (unsigned).

fn mulhsu(&mut self, rd: RiscRegister, rs1: RiscOperand, rs2: RiscOperand)

Multiply signed rs1 by unsigned rs2 and return the high 64 bits.

fn div(&mut self, rd: RiscRegister, rs1: RiscOperand, rs2: RiscOperand)

Divide the values of two registers (signed).

fn divu(&mut self, rd: RiscRegister, rs1: RiscOperand, rs2: RiscOperand)

Divide the values of two registers (unsigned).

fn rem(&mut self, rd: RiscRegister, rs1: RiscOperand, rs2: RiscOperand)

Remainder of two registers (signed).

fn remu(&mut self, rd: RiscRegister, rs1: RiscOperand, rs2: RiscOperand)

Remainder of two registers (unsigned).

fn addw(&mut self, rd: RiscRegister, rs1: RiscOperand, rs2: RiscOperand)

Add the values of two registers together, using 64bit arithmetic, but only keeping lower 32 bits.

fn subw(&mut self, rd: RiscRegister, rs1: RiscOperand, rs2: RiscOperand)

Subtract the values of two registers, using 64bit arithmetic, but only keeping lower 32 bits.

fn sllw(&mut self, rd: RiscRegister, rs1: RiscOperand, rs2: RiscOperand)

Shift the values of two registers left by the amount specified by the second register (32-bit).

fn srlw(&mut self, rd: RiscRegister, rs1: RiscOperand, rs2: RiscOperand)

Shift the values of two registers right by the amount specified by the second register (32-bit logical).

fn sraw(&mut self, rd: RiscRegister, rs1: RiscOperand, rs2: RiscOperand)

Shift the values of two registers right by the amount specified by the second register (32-bit arithmetic).

fn mulw(&mut self, rd: RiscRegister, rs1: RiscOperand, rs2: RiscOperand)

Multiply the values of two registers together, using 32bit arithmetic (sign-extended to 64-bit).

fn divw(&mut self, rd: RiscRegister, rs1: RiscOperand, rs2: RiscOperand)

Divide the values of two registers together, using 32bit arithmetic (sign-extended to 64-bit).

fn divuw(&mut self, rd: RiscRegister, rs1: RiscOperand, rs2: RiscOperand)

Divide the values of two registers, unsigned 32bit (sign-extended to 64-bit).

fn remw(&mut self, rd: RiscRegister, rs1: RiscOperand, rs2: RiscOperand)

Remainder the values of two registers together, using 32bit arithmetic (sign-extended to 64-bit).

fn remuw(&mut self, rd: RiscRegister, rs1: RiscOperand, rs2: RiscOperand)

Remainder the values of two registers, unsigned 32bit (sign-extended to 64-bit).

fn auipc(&mut self, rd: RiscRegister, imm: u64)

Advance to the next pc, storing the current (pc + imm) in a register.

fn lui(&mut self, rd: RiscRegister, imm: u64)

Load upper immediate into a register.

impl<B: RiscvTranspiler> ControlFlowInstructions for DebugBackend<B>

fn beq(&mut self, rs1: RiscRegister, rs2: RiscRegister, imm: u64)

Compare the values of two registers, and jump to an address if they are equal.

fn bne(&mut self, rs1: RiscRegister, rs2: RiscRegister, imm: u64)

Compare the values of two registers, and jump to an address if they are not equal.

fn blt(&mut self, rs1: RiscRegister, rs2: RiscRegister, imm: u64)

Compare the values of two registers, and jump to an address if the first is less than the second.

fn bge(&mut self, rs1: RiscRegister, rs2: RiscRegister, imm: u64)

Compare the values of two registers, and jump to an address if the first is greater than or equal to the second.

fn bltu(&mut self, rs1: RiscRegister, rs2: RiscRegister, imm: u64)

Compare the values of two registers, and jump to an address if the first is less than the second, unsigned.

fn bgeu(&mut self, rs1: RiscRegister, rs2: RiscRegister, imm: u64)

Compare the values of two registers, and jump to an address if the first is greater than or equal to the second, unsigned.

fn jal(&mut self, rd: RiscRegister, imm: u64)

Jump to an address.

fn jalr(&mut self, rd: RiscRegister, rs1: RiscRegister, imm: u64)

Jump to an address, and return to the previous address.

impl<B: RiscvTranspiler> MemoryInstructions for DebugBackend<B>

fn lb(&mut self, rd: RiscRegister, rs1: RiscRegister, imm: u64)

Load a byte from memory into a register.

fn lh(&mut self, rd: RiscRegister, rs1: RiscRegister, imm: u64)

Load a half word from memory into a register.

fn lw(&mut self, rd: RiscRegister, rs1: RiscRegister, imm: u64)

Load a word from memory into a register.

fn lbu(&mut self, rd: RiscRegister, rs1: RiscRegister, imm: u64)

Load a byte from memory into a register, zero extended.

fn lhu(&mut self, rd: RiscRegister, rs1: RiscRegister, imm: u64)

Load a half word from memory into a register, zero extended.

fn ld(&mut self, rd: RiscRegister, rs1: RiscRegister, imm: u64)

Load a double word from memory into a register.

fn lwu(&mut self, rd: RiscRegister, rs1: RiscRegister, imm: u64)

Load a word from memory into a register, zero extended.

fn sb(&mut self, rs1: RiscRegister, rs2: RiscRegister, imm: u64)

Store a byte into memory.

fn sh(&mut self, rs1: RiscRegister, rs2: RiscRegister, imm: u64)

Store a half word into memory.

fn sw(&mut self, rs1: RiscRegister, rs2: RiscRegister, imm: u64)

Store a word into memory.

fn sd(&mut self, rs1: RiscRegister, rs2: RiscRegister, imm: u64)

Store a double word into memory.

impl<B: RiscvTranspiler + Debuggable> RiscvTranspiler for DebugBackend<B>

fn new( program_size: usize, memory_size: usize, max_trace_size: u64, pc_start: u64, pc_base: u64, clk_bump: u64, ) -> Result<Self, Error>

Create a new transpiler.

fn register_ecall_handler(&mut self, handler: EcallHandler)

Register a rust function of the form EcallHandler that will be used as the ECALL.

fn start_instr(&mut self)

Populates a jump table entry for the current instruction being transpiled.

fn end_instr(&mut self)

This method should be called for “each pc” in the program. Handle logics when finishing execution of an instruction such as bumping clk and jump to branch destination.

fn inspect_register(&mut self, reg: RiscRegister, handler: DebugFn)

Inspcet a RiscRegister using a function pointer.

fn inspect_immediate(&mut self, imm: u64, handler: DebugFn)

Print an immediate value.

fn call_extern_fn(&mut self, handler: ExternFn)

Call an ExternFn from the outputted assembly.

fn finalize<M: JitMemory>(self) -> Result<JitFunction<M>>

Returns the function pointer to the generated code.

impl<B: RiscvTranspiler> SystemInstructions for DebugBackend<B>

fn ecall(&mut self)

Transfer control to the operating system.

fn unimp(&mut self)

impl<B: RiscvTranspiler> TraceCollector for DebugBackend<B>

fn trace_clk_end(&mut self)

Write the end clk of the trace chunk.

fn trace_clk_start(&mut self)

Write the start clk of the trace chunk.

fn trace_mem_value(&mut self, rs1: RiscRegister, imm: u64)

Write the value located at rs1 + imm into the trace buf.

fn trace_pc_start(&mut self)

Write the start pc of the trace chunk.

fn trace_registers(&mut self)

Write the current state of the registers into the trace buf.