Struct Instruction 

pub struct Instruction(pub u32);

AArch64 instruction representation (32-bit fixed-width instructions)

Tuple Fields

0: u32

Implementations

impl Instruction

pub fn new(value: u32) -> Self

Create a new 32-bit instruction

pub fn value(self) -> u32

Get the instruction value as u32

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

Get the instruction as bytes (little-endian)

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 Copy for Instruction

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 Eq for Instruction

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 Aarch64InstructionBuilder

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::aarch64::{reg, Aarch64InstructionBuilder};
use jit_assembler::common::InstructionBuilder;
 
let add_func = unsafe {
    Aarch64InstructionBuilder::new()
        .add(reg::X0, reg::X0, reg::X1) // Add first two arguments
        .ret()
        .function::<fn(u64, u64) -> u64>()
}.expect("Failed to create JIT function");
 
// Call the JIT function directly (only works on AArch64 hosts)
// let result = add_func.call(10, 20); // Returns 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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Instruction