continued on register allocator rewrite, slow progress as scoping is
proving to be a challenge
This commit is contained in:
@@ -1,7 +1,287 @@
|
||||
use std::{cell::RefCell, collections::HashMap, ops::Deref, rc::Rc};
|
||||
|
||||
use uuid::Uuid;
|
||||
|
||||
use crate::{
|
||||
backend::dsa::{
|
||||
instruction::{InsBlock, Instruction},
|
||||
registers::{Register, RegisterAllocator},
|
||||
variable::Variable,
|
||||
},
|
||||
model::CompilerError,
|
||||
};
|
||||
|
||||
pub struct Allocator {
|
||||
stack_offset: i32,
|
||||
in_use: [(Register, bool); 16],
|
||||
}
|
||||
|
||||
pub struct TempReg(Register);
|
||||
pub struct AssignedReg(Register);
|
||||
pub struct StackSlot(i32);
|
||||
|
||||
impl Deref for TempReg {
|
||||
type Target = Register;
|
||||
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
|
||||
impl Deref for AssignedReg {
|
||||
type Target = Register;
|
||||
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
|
||||
impl Deref for StackSlot {
|
||||
type Target = i32;
|
||||
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
|
||||
impl Allocator {
|
||||
pub fn new() -> Self {
|
||||
let mut in_use = [(Register::Null, false); 16];
|
||||
in_use.copy_from_slice(&Register::get_gp().map(|r| (r, false))[0..16]);
|
||||
|
||||
Self {
|
||||
stack_offset: 0,
|
||||
in_use,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn get_stack_offset(&self) -> i32 {
|
||||
self.stack_offset
|
||||
}
|
||||
|
||||
pub fn destroy_scope(&mut self, scope: &mut Scope) {
|
||||
self.stack_offset = scope.entry_stack_offset;
|
||||
|
||||
for var in scope.variables.drain() {
|
||||
if let Some(assigned) = var.1.register {
|
||||
self.free_assigned(&assigned);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// what we need:
|
||||
|
||||
// - create var in register from temporary register. free temp and use it.
|
||||
//
|
||||
// - create var on stack from struct/array literal. return stack offset to write to.
|
||||
//
|
||||
// - spill var from register to stack. return stack offset to write to.
|
||||
//
|
||||
// - read/write var from stack+offset into register to use while preserving the stack
|
||||
// slot.
|
||||
//
|
||||
// - read / write bytes from the stack+offset in a larger variable into a register.
|
||||
|
||||
pub fn read_var(&mut self, var: &mut Variable) -> Result<InsBlock, CompilerError> {
|
||||
if let Some(slot) = &mut var.stack_slot {
|
||||
if var.register.is_none() {
|
||||
var.register = Some(self.allocate_var()?);
|
||||
}
|
||||
|
||||
if let Some(reg) = &var.register {
|
||||
return Ok(InsBlock::from(Instruction::ldw_reg_offset(
|
||||
**reg,
|
||||
Register::Spr,
|
||||
**slot - self.stack_offset,
|
||||
)));
|
||||
}
|
||||
|
||||
unreachable!()
|
||||
}
|
||||
|
||||
Err(CompilerError::Generic(format!(
|
||||
"Tried to write var {} to stack but var was not assigned a reg and/or stack slot",
|
||||
var.name
|
||||
)))
|
||||
}
|
||||
|
||||
pub fn write_var(&mut self, var: &mut Variable) -> Result<InsBlock, CompilerError> {
|
||||
if let Some(slot) = &var.stack_slot {
|
||||
if let Some(reg) = &var.register {
|
||||
return Ok(InsBlock::from(Instruction::stw_reg_offset(
|
||||
**reg,
|
||||
Register::Spr,
|
||||
**slot - self.stack_offset,
|
||||
)));
|
||||
}
|
||||
}
|
||||
|
||||
Err(CompilerError::Generic(format!(
|
||||
"Tried to write var {} to stack but var was not assigned a reg and/or stack slot",
|
||||
var.name
|
||||
)))
|
||||
}
|
||||
|
||||
pub fn spill_var(&mut self, var: &mut Variable) -> Result<InsBlock, CompilerError> {
|
||||
if let Some(slot) = &var.stack_slot {
|
||||
let block = self.write_var(var)?;
|
||||
if let Some(reg) = &var.register {
|
||||
self.free_assigned(reg);
|
||||
var.register = None;
|
||||
}
|
||||
|
||||
return Ok(block);
|
||||
}
|
||||
|
||||
// var doesn't have a stack slot so we need to create one
|
||||
if let Some(reg) = &var.register {
|
||||
let slot = self.allocate_stack_slot(var.size);
|
||||
let block = InsBlock::from(Instruction::push(**reg));
|
||||
|
||||
self.free_assigned(reg);
|
||||
var.register = None;
|
||||
var.stack_slot = Some(slot);
|
||||
return Ok(block);
|
||||
}
|
||||
|
||||
return Err(CompilerError::Generic(
|
||||
"spill_var called on a variable without a register".to_string(),
|
||||
));
|
||||
}
|
||||
|
||||
pub fn allocate_stack_slot(&mut self, size: usize) -> StackSlot {
|
||||
self.stack_offset -= size as i32;
|
||||
let offset = self.stack_offset;
|
||||
StackSlot(offset)
|
||||
}
|
||||
|
||||
pub fn allocate_var(&mut self) -> Result<AssignedReg, CompilerError> {
|
||||
if let Some(reg) = self.find_free_register() {
|
||||
Ok(AssignedReg(reg))
|
||||
} else {
|
||||
Err(CompilerError::Generic(
|
||||
"No free registers available".to_string(),
|
||||
))
|
||||
}
|
||||
}
|
||||
|
||||
pub fn allocate_temp(&mut self) -> Result<TempReg, CompilerError> {
|
||||
// allocates a temporary register
|
||||
if let Some(reg) = self.find_free_register() {
|
||||
Ok(TempReg(reg))
|
||||
} else {
|
||||
todo!("an efficient stack spilling algorithm. needs scope awareness.");
|
||||
}
|
||||
}
|
||||
|
||||
pub fn free_temp(&mut self, temp: &TempReg) {
|
||||
// frees a temporary register.
|
||||
self.in_use[**temp as usize].1 = false;
|
||||
}
|
||||
|
||||
fn free_assigned(&mut self, reg: &AssignedReg) {
|
||||
// frees a register.
|
||||
self.in_use[**reg as usize].1 = false;
|
||||
}
|
||||
|
||||
// if we have register(s) free, return the first one.
|
||||
fn find_free_register(&mut self) -> Option<Register> {
|
||||
self.in_use.iter_mut().find_map(|(reg, used)| {
|
||||
if !*used {
|
||||
*used = true;
|
||||
Some(*reg)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
pub struct FunctionContext {
|
||||
name: String,
|
||||
|
||||
stack_offset: i32,
|
||||
|
||||
registers: [(Register, bool); 16],
|
||||
allocator: RefCell<Allocator>,
|
||||
}
|
||||
|
||||
impl FunctionContext {
|
||||
pub fn new(name: String) -> Self {
|
||||
Self {
|
||||
name,
|
||||
allocator: RefCell::new(Allocator::new()),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn get_stack_offset(&self) -> i32 {
|
||||
self.allocator.borrow().get_stack_offset()
|
||||
}
|
||||
}
|
||||
|
||||
/// scope object
|
||||
pub struct Scope<'a> {
|
||||
/// outer scope, for a function this will be the global scope.
|
||||
parent: Option<&'a mut Scope<'a>>,
|
||||
|
||||
context: Rc<FunctionContext>,
|
||||
|
||||
/// is the scope a function body or just a loop?
|
||||
/// depending on the type, ending a scope will have different behaviour
|
||||
r#type: ScopeType,
|
||||
|
||||
/// variables
|
||||
variables: HashMap<Uuid, Variable>,
|
||||
|
||||
entry_stack_offset: i32,
|
||||
}
|
||||
|
||||
impl<'a> Scope<'a> {
|
||||
pub fn new(parent: &'a mut Scope<'a>, r#type: ScopeType) -> Scope<'a> {
|
||||
Self {
|
||||
entry_stack_offset: parent.context.get_stack_offset(),
|
||||
context: Rc::clone(&parent.context),
|
||||
parent: Some(parent),
|
||||
r#type,
|
||||
variables: HashMap::new(),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn close(&mut self) -> Result<(), CompilerError> {
|
||||
// closing a scope means we need to drop all variables in scope and free
|
||||
// registers.
|
||||
for (name, var) in self.variables.iter() {
|
||||
todo!()
|
||||
// if let Some(reg) = var.allocated_register {}
|
||||
|
||||
// if let Some(offset) = var.bpr_offset {
|
||||
// self.stack_offset -= offset;
|
||||
// }
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn alloc_temp_reg(&mut self) -> Result<(Register, InsBlock), CompilerError> {
|
||||
todo!()
|
||||
}
|
||||
|
||||
pub fn alloc_var_reg(&mut self) -> Result<(Register, InsBlock), CompilerError> {
|
||||
todo!()
|
||||
}
|
||||
|
||||
pub fn alloc_var_stack(&mut self) -> Result<(Register, InsBlock), CompilerError> {
|
||||
todo!()
|
||||
}
|
||||
|
||||
pub fn free_var_stack(&mut self) -> Result<(Register, InsBlock), CompilerError> {
|
||||
todo!()
|
||||
}
|
||||
|
||||
pub fn free_temp_reg(&mut self) -> Result<(Register, InsBlock), CompilerError> {
|
||||
todo!()
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(PartialEq, Copy, Clone, Debug)]
|
||||
pub enum ScopeType {
|
||||
Function,
|
||||
IfBlock,
|
||||
LoopBlock,
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user