Struct RiscVRegAlloc 

pub struct RiscVRegAlloc { /* private fields */ }

RISC-V register allocator with platform-aware register selection.

RISC-V has 32 general-purpose registers (x0-x31):

• x0: zero (hardwired zero)
• x1: ra (return address)
• x2: sp (stack pointer)
• x3: gp (global pointer)
• x4: tp (thread pointer)
• x5-x7, x28-x31: temporaries
• x8: fp/s0 (frame pointer/saved register)
• x9-x15: s1-s7 (saved registers)
• x16-x27: a0-a7 (argument registers), t0-t6 (temporaries)

Implementations

impl RiscVRegAlloc

pub const CALLER_SAVED_REGISTERS: &'static [&'static str]

pub const CALLEE_SAVED_REGISTERS: &'static [&'static str]

pub const RESERVED_REGISTERS: &'static [&'static str]

pub fn new(target_os: TargetOperatingSystem) -> Self

pub fn target(&self) -> RiscVTarget

The ISA this allocator is emitting for. Held here because every helper that needs the word size already receives the allocator.

pub fn register_convention(reg: &str) -> Option<RiscVRegisterConvention>

pub fn caller_saved_mappings( &self, live_vregs: &[VirtualReg], ) -> Vec<(VirtualReg, &'static str)>

pub fn used_callee_saved_registers(&self) -> Vec<&'static str>

pub fn with_target( target_os: TargetOperatingSystem, target: RiscVTarget, ) -> Self

pub fn set_conservative_mode(&mut self)

Set conservative mode (limit to fewer registers)

pub fn get_stack_slot(&self, vreg: &VirtualReg) -> Option<i32>

Get stack slot for a virtual register

pub fn gpr_pool_for_global_allocation() -> Vec<&'static str>

pub fn from_global_plan( target_os: TargetOperatingSystem, target: RiscVTarget, plan: &HashMap<VirtualReg, Allocation<&'static str>>, stack_slots: &HashMap<VirtualReg, i32>, ) -> Self

Trait Implementations

impl Default for RiscVRegAlloc

fn default() -> Self

Returns the “default value” for a type.

impl LocalRegisterAllocator for RiscVRegAlloc

type PhysReg = &'static str

Architecture-specific physical register handle.

fn alloc_scratch(&mut self) -> Option<Self::PhysReg>

Acquire a short-lived scratch register. Returns None when the dedicated pool is exhausted so the caller may spill or choose an alternate path.

fn free_scratch(&mut self, phys: Self::PhysReg)

Release a scratch register obtained through LocalRegisterAllocator::alloc_scratch.

fn get_mapping(&self, vreg: &VirtualReg) -> Option<Self::PhysReg>

Look up the physical register currently assigned to the virtual register, when available.

fn ensure_mapping(&mut self, vreg: VirtualReg) -> Option<Self::PhysReg>

Ensure that the virtual register has a permanent mapping. Implementers can reject unsupported register classes by returning None, signalling that the caller should spill.

fn mapped_for_register(&self, reg: &Register) -> Option<Self::PhysReg>

Resolve the backing physical register for an arbitrary MIR register (virtual or physical).

fn occupy(&mut self, _phys: Self::PhysReg)

Mark a physical register as occupied, removing it from the allocator’s free pool if necessary.

fn release(&mut self, phys: Self::PhysReg)

Release a previously occupied physical register back to the pool.

fn is_occupied(&self, phys: Self::PhysReg) -> bool

Test whether the allocator currently treats the physical register as occupied.