Enum Instruction 

pub enum Instruction {
    Standard(u32),
    Compressed(u16),
}

RISC-V instruction representation (supports both 32-bit and 16-bit compressed instructions)

Variants

Standard(u32)

32-bit standard instruction

Compressed(u16)

16-bit compressed instruction (C extension)

Implementations

impl Instruction

pub fn new(value: u32) -> Self

Create a new 32-bit instruction

pub fn new_compressed(value: u16) -> Self

Create a new 16-bit compressed instruction

pub fn value(self) -> u32

Get the instruction value as u64 (for compatibility)

pub fn bytes(self) -> Vec<u8>

Get the instruction as bytes with proper length

pub fn size(&self) -> usize

Get the size of this instruction in bytes

pub fn is_compressed(&self) -> bool

Check if this is a compressed instruction

Trait Implementations

impl Clone for Instruction

fn clone(&self) -> Instruction

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Instruction

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

Formats the value using the given formatter.

impl Display for Instruction

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

Formats the value using the given formatter.

impl Instruction for Instruction

fn value(&self) -> u64

Get the instruction as a 32-bit or 64-bit value

fn bytes(&self) -> Vec<u8>

Get the instruction as bytes (little-endian)

fn size(&self) -> usize

Get the size of this instruction in bytes

impl InstructionBuilder<Instruction> for Riscv64InstructionBuilder

unsafe fn function<F>(&self) -> Result<CallableJitFunction<F>, JitError>

Create a JIT-compiled function from the assembled instructions (std-only)

This method converts the assembled instructions into executable machine code that can be called directly as a function. The generic type parameter F specifies the function signature.

Safety

This function is unsafe because:

• It allocates executable memory
• It assumes the assembled code follows the correct ABI
• The caller must ensure the function signature matches the actual code

Examples

use jit_assembler::riscv64::{reg, Riscv64InstructionBuilder};
use jit_assembler::common::InstructionBuilder;
 
let add_func = unsafe {
    Riscv64InstructionBuilder::new()
        .add(reg::A0, reg::A0, reg::A1) // Add first two arguments
        .ret()
        .function::<fn(u64, u64) -> u64>()
}.expect("Failed to create JIT function");
 
// Call the JIT function directly (only works on RISC-V hosts)
let result = add_func.call(10, 20); // Should return 30

type Register = Register

The register type used by this architecture

fn new() -> Self

Create a new instruction builder

fn instructions(&self) -> InstructionCollection<Instruction>

Get the generated instructions

fn push(&mut self, instr: Instruction)

Add an instruction to the builder

fn clear(&mut self)

Clear all instructions

unsafe fn raw_function(&self) -> Result<RawCallableJitFunction, JitError>

Create a raw JIT-compiled function for manual type conversion (std-only)

impl PartialEq for Instruction

fn eq(&self, other: &Instruction) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Instruction

impl Eq for Instruction

impl StructuralPartialEq for Instruction