- C frontend broken for now
- If statements work properly now (hopefully) - still issues with while loops pushing vars to the stack. need scoping implemented to fix this! - refactored registers.rs and fixed faulty logic. - made register allocation optimisations
This commit is contained in:
@@ -5,11 +5,12 @@ use std::time::SystemTime;
|
||||
use chrono::{DateTime, Local};
|
||||
|
||||
use super::registers::RegisterAllocator;
|
||||
use crate::backend::dsa::registers::Register;
|
||||
use crate::{block, comment, dsa};
|
||||
|
||||
use crate::model::{
|
||||
BinaryOperator, CompilerError, ConstExpr, Declaration, Dependency, Expression,
|
||||
Program, Statement, UnaryOperator, Variable,
|
||||
BinaryOperator, Call, CompilerError, ConstExpr, Declaration, Dependency, Expression,
|
||||
Program, Statement, TypeId, UnaryOperator, Variable,
|
||||
};
|
||||
|
||||
pub struct CodeGenerator {
|
||||
@@ -149,9 +150,14 @@ impl CodeGenerator {
|
||||
self.generate_global(&var.name, init)
|
||||
}
|
||||
Declaration::Function {
|
||||
name, params, body, ..
|
||||
name,
|
||||
params,
|
||||
body,
|
||||
return_type,
|
||||
} => {
|
||||
let func = self.generate_function(&name, ¶ms, &body).join("\n");
|
||||
let func = self
|
||||
.generate_function(&name, ¶ms, &body, return_type)
|
||||
.join("\n");
|
||||
|
||||
self.functions.push(format!("{func}\n"));
|
||||
}
|
||||
@@ -169,12 +175,23 @@ impl CodeGenerator {
|
||||
name: &str,
|
||||
params: &[Variable],
|
||||
body: &[Statement],
|
||||
return_type: TypeId,
|
||||
) -> Vec<String> {
|
||||
let mut code = Vec::new();
|
||||
|
||||
// Reset allocator for new function
|
||||
self.allocator.reset();
|
||||
|
||||
code.push(format!(
|
||||
"// fn {name}({}) -> {}",
|
||||
params
|
||||
.iter()
|
||||
.map(|p| format!("{}: {}", p.name, p.type_id))
|
||||
.collect::<Vec<String>>()
|
||||
.join(", "),
|
||||
return_type
|
||||
));
|
||||
|
||||
// Function prologue
|
||||
code.push(format!("{}:", name));
|
||||
code.push("\tpush bpr".to_string());
|
||||
@@ -192,7 +209,7 @@ impl CodeGenerator {
|
||||
|
||||
// Generate code for function body
|
||||
for stmt in body {
|
||||
let stmt_code = self.generate_statement(stmt).unwrap();
|
||||
let stmt_code = self.generate_statement(stmt, &mut code).unwrap();
|
||||
code.extend(stmt_code);
|
||||
}
|
||||
|
||||
@@ -211,6 +228,7 @@ impl CodeGenerator {
|
||||
fn generate_statement(
|
||||
&mut self,
|
||||
stmt: &Statement,
|
||||
func_body: &mut Vec<String>,
|
||||
) -> Result<Vec<String>, CompilerError> {
|
||||
let mut code = Vec::new();
|
||||
|
||||
@@ -218,7 +236,8 @@ impl CodeGenerator {
|
||||
Statement::Declaration { var, value } => {
|
||||
if let Some(expr) = value {
|
||||
// Evaluate expression
|
||||
let (result_reg, expr_code) = self.generate_expression(expr, true)?;
|
||||
let (result_reg, expr_code) =
|
||||
self.generate_expression(expr, true, func_body)?;
|
||||
code.extend(expr_code);
|
||||
|
||||
// Store result in variable
|
||||
@@ -233,14 +252,17 @@ impl CodeGenerator {
|
||||
}
|
||||
}
|
||||
|
||||
Statement::Break => unimplemented!(),
|
||||
Statement::Continue => unimplemented!(),
|
||||
Statement::Break => unimplemented!("need scope tracking first!"),
|
||||
Statement::Continue => unimplemented!("need scope tracking first!"),
|
||||
Statement::Defer(_func) => unimplemented!("we need scope tracking first!"),
|
||||
|
||||
Statement::PtrWrite { ptr, value } => {
|
||||
let (result_reg, expr_code) = self.generate_expression(value, true)?;
|
||||
let (result_reg, expr_code) =
|
||||
self.generate_expression(value, true, func_body)?;
|
||||
code.extend(expr_code);
|
||||
|
||||
let (ptr_reg, ptr_code) = self.generate_expression(ptr, true)?;
|
||||
let (ptr_reg, ptr_code) =
|
||||
self.generate_expression(ptr, true, func_body)?;
|
||||
code.extend(ptr_code);
|
||||
|
||||
code.push(format!("\tstw {}, {}", result_reg, ptr_reg));
|
||||
@@ -251,7 +273,8 @@ impl CodeGenerator {
|
||||
|
||||
Statement::Assign { varname, value } => {
|
||||
// Evaluate expression
|
||||
let (result_reg, expr_code) = self.generate_expression(value, true)?;
|
||||
let (result_reg, expr_code) =
|
||||
self.generate_expression(value, true, func_body)?;
|
||||
code.extend(expr_code);
|
||||
|
||||
// Check if this is a global variable
|
||||
@@ -270,7 +293,8 @@ impl CodeGenerator {
|
||||
|
||||
Statement::Return(expr) => {
|
||||
if let Some(e) = expr {
|
||||
let (result_reg, expr_code) = self.generate_expression(e, true)?;
|
||||
let (result_reg, expr_code) =
|
||||
self.generate_expression(e, true, func_body)?;
|
||||
code.extend(expr_code);
|
||||
code.push(format!("\tstw {}, bpr, 8", result_reg));
|
||||
code.push(format!("\tjmp _ret"));
|
||||
@@ -284,7 +308,8 @@ impl CodeGenerator {
|
||||
else_stmt,
|
||||
} => {
|
||||
// Generate condition
|
||||
let (cond_reg, cond_code) = self.generate_expression(condition, true)?;
|
||||
let (cond_reg, cond_code) =
|
||||
self.generate_expression(condition, true, func_body)?;
|
||||
code.extend(cond_code);
|
||||
|
||||
// Compare with zero
|
||||
@@ -302,7 +327,7 @@ impl CodeGenerator {
|
||||
// Then block
|
||||
code.push(format!("{}:", then_label));
|
||||
for s in then_stmt {
|
||||
code.extend(self.generate_statement(s)?);
|
||||
code.extend(self.generate_statement(s, func_body)?);
|
||||
}
|
||||
|
||||
if then_stmt.len() == 0 {
|
||||
@@ -314,7 +339,7 @@ impl CodeGenerator {
|
||||
// Else block
|
||||
code.push(format!("{}:", else_label));
|
||||
for s in else_stmt {
|
||||
code.extend(self.generate_statement(s)?);
|
||||
code.extend(self.generate_statement(s, func_body)?);
|
||||
}
|
||||
|
||||
if else_stmt.len() == 0 {
|
||||
@@ -331,7 +356,8 @@ impl CodeGenerator {
|
||||
code.push(format!("{}:", loop_start));
|
||||
|
||||
// Generate condition
|
||||
let (cond_reg, cond_code) = self.generate_expression(condition, true)?;
|
||||
let (cond_reg, cond_code) =
|
||||
self.generate_expression(condition, true, func_body)?;
|
||||
code.extend(cond_code);
|
||||
|
||||
code.push(format!("\tcmp {}, zero", cond_reg));
|
||||
@@ -341,7 +367,7 @@ impl CodeGenerator {
|
||||
|
||||
// Loop body
|
||||
for s in body {
|
||||
code.extend(self.generate_statement(s)?);
|
||||
code.extend(self.generate_statement(s, func_body)?);
|
||||
}
|
||||
|
||||
code.push(format!("\tjmp {}", loop_start));
|
||||
@@ -354,21 +380,22 @@ impl CodeGenerator {
|
||||
code.push(format!("{}:", loop_start));
|
||||
|
||||
for s in body {
|
||||
code.extend(self.generate_statement(s)?);
|
||||
code.extend(self.generate_statement(s, func_body)?);
|
||||
}
|
||||
|
||||
code.push(format!("\tjmp {}", loop_start));
|
||||
}
|
||||
|
||||
Statement::Expression { expr } => {
|
||||
let (result_reg, expr_code) = self.generate_expression(expr, false)?;
|
||||
let (result_reg, expr_code) =
|
||||
self.generate_expression(expr, false, func_body)?;
|
||||
code.extend(expr_code);
|
||||
self.allocator.free_temp(&result_reg);
|
||||
}
|
||||
|
||||
Statement::Block(statements) => {
|
||||
for s in statements {
|
||||
code.extend(self.generate_statement(s)?);
|
||||
code.extend(self.generate_statement(s, func_body)?);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -382,14 +409,10 @@ impl CodeGenerator {
|
||||
&mut self,
|
||||
expr: &Expression,
|
||||
use_result: bool,
|
||||
) -> Result<(String, Vec<String>), CompilerError> {
|
||||
func_body: &mut Vec<String>,
|
||||
) -> Result<(Register, Vec<String>), CompilerError> {
|
||||
let mut code = Vec::new();
|
||||
|
||||
// optimisation to prevent generating dead code!
|
||||
if expr.is_pure() && !use_result {
|
||||
return Ok((String::new(), code));
|
||||
}
|
||||
|
||||
match expr {
|
||||
Expression::StringLiteral(value) => {
|
||||
let (reg, alloc_code) = self.allocator.alloc_temp()?;
|
||||
@@ -397,7 +420,7 @@ impl CodeGenerator {
|
||||
|
||||
// write string into memory
|
||||
let uuid = self.get_unique_label();
|
||||
code.push(format!("\tdb str_{uuid}: \"{value}\""));
|
||||
func_body.insert(0, format!("db str_{uuid}: \"{value}\""));
|
||||
|
||||
// Load pointer to string
|
||||
code.push(format!("\tlwi str_{uuid}, {reg}"));
|
||||
@@ -415,7 +438,7 @@ impl CodeGenerator {
|
||||
Ok((reg, code))
|
||||
}
|
||||
|
||||
Expression::Number(value) => {
|
||||
Expression::Number { value, .. } => {
|
||||
let (reg, alloc_code) = self.allocator.alloc_temp()?;
|
||||
code.extend(alloc_code);
|
||||
|
||||
@@ -446,13 +469,17 @@ impl CodeGenerator {
|
||||
}
|
||||
}
|
||||
|
||||
Expression::Binary { op, left, right } => {
|
||||
Expression::Binary {
|
||||
op, left, right, ..
|
||||
} => {
|
||||
// Evaluate left operand
|
||||
let (left_reg, left_code) = self.generate_expression(left, true)?;
|
||||
let (left_reg, left_code) =
|
||||
self.generate_expression(left, true, func_body)?;
|
||||
code.extend(left_code);
|
||||
|
||||
// Evaluate right operand
|
||||
let (right_reg, right_code) = self.generate_expression(right, true)?;
|
||||
let (right_reg, right_code) =
|
||||
self.generate_expression(right, true, func_body)?;
|
||||
code.extend(right_code);
|
||||
|
||||
// Allocate result register
|
||||
@@ -485,50 +512,50 @@ impl CodeGenerator {
|
||||
// Comparison operators - return 1 (true) or 0 (false)
|
||||
BinaryOperator::Eq => {
|
||||
code.push(format!("\tcmp {}, {}", left_reg, right_reg));
|
||||
code.push(format!("\tlli 0, {}", result_reg));
|
||||
let end_label = format!("_cmp_end_{}", self.get_unique_label());
|
||||
code.push(format!("\tjne {}", end_label)); // If not equal, skip setting to 1
|
||||
code.push(format!("\tlli 1, {}", result_reg));
|
||||
let end_label = format!("_cmp_end_{}", self.get_unique_label());
|
||||
code.push(format!("\tjeq {}", end_label));
|
||||
code.push(format!("\tlli 0, {}", result_reg));
|
||||
code.push(format!("{}:", end_label));
|
||||
}
|
||||
BinaryOperator::Ne => {
|
||||
code.push(format!("\tcmp {}, {}", left_reg, right_reg));
|
||||
code.push(format!("\tlli 0, {}", result_reg));
|
||||
let end_label = format!("_cmp_end_{}", self.get_unique_label());
|
||||
code.push(format!("\tjeq {}", end_label)); // If equal, skip setting to 1
|
||||
code.push(format!("\tlli 1, {}", result_reg));
|
||||
let end_label = format!("_cmp_end_{}", self.get_unique_label());
|
||||
code.push(format!("\tjne {}", end_label));
|
||||
code.push(format!("\tlli 0, {}", result_reg));
|
||||
code.push(format!("{}:", end_label));
|
||||
}
|
||||
BinaryOperator::Lt => {
|
||||
code.push(format!("\tcmp {}, {}", left_reg, right_reg));
|
||||
code.push(format!("\tlli 0, {}", result_reg));
|
||||
let end_label = format!("_cmp_end_{}", self.get_unique_label());
|
||||
code.push(format!("\tjge {}", end_label)); // If greater or equal, skip setting to 1
|
||||
code.push(format!("\tlli 1, {}", result_reg));
|
||||
let end_label = format!("_cmp_end_{}", self.get_unique_label());
|
||||
code.push(format!("\tjlt {}", end_label));
|
||||
code.push(format!("\tlli 0, {}", result_reg));
|
||||
code.push(format!("{}:", end_label));
|
||||
}
|
||||
BinaryOperator::Le => {
|
||||
code.push(format!("\tcmp {}, {}", left_reg, right_reg));
|
||||
code.push(format!("\tlli 0, {}", result_reg));
|
||||
let end_label = format!("_cmp_end_{}", self.get_unique_label());
|
||||
code.push(format!("\tjgt {}", end_label)); // If greater than, skip setting to 1
|
||||
code.push(format!("\tlli 1, {}", result_reg));
|
||||
let end_label = format!("_cmp_end_{}", self.get_unique_label());
|
||||
code.push(format!("\tjle {}", end_label));
|
||||
code.push(format!("\tlli 0, {}", result_reg));
|
||||
code.push(format!("{}:", end_label));
|
||||
}
|
||||
BinaryOperator::Gt => {
|
||||
code.push(format!("\tcmp {}, {}", left_reg, right_reg));
|
||||
code.push(format!("\tlli 0, {}", result_reg));
|
||||
let end_label = format!("_cmp_end_{}", self.get_unique_label());
|
||||
code.push(format!("\tjle {}", end_label)); // If less or equal, skip setting to 1
|
||||
code.push(format!("\tlli 1, {}", result_reg));
|
||||
let end_label = format!("_cmp_end_{}", self.get_unique_label());
|
||||
code.push(format!("\tjgt {}", end_label));
|
||||
code.push(format!("\tlli 0, {}", result_reg));
|
||||
code.push(format!("{}:", end_label));
|
||||
}
|
||||
BinaryOperator::Ge => {
|
||||
code.push(format!("\tcmp {}, {}", left_reg, right_reg));
|
||||
code.push(format!("\tlli 0, {}", result_reg));
|
||||
let end_label = format!("_cmp_end_{}", self.get_unique_label());
|
||||
code.push(format!("\tjlt {}", end_label)); // If less than, skip setting to 1
|
||||
code.push(format!("\tlli 1, {}", result_reg));
|
||||
let end_label = format!("_cmp_end_{}", self.get_unique_label());
|
||||
code.push(format!("\tjge {}", end_label));
|
||||
code.push(format!("\tlli 8, {}", result_reg));
|
||||
code.push(format!("{}:", end_label));
|
||||
}
|
||||
_ => unimplemented!(),
|
||||
@@ -541,11 +568,15 @@ impl CodeGenerator {
|
||||
Ok((result_reg, code))
|
||||
}
|
||||
|
||||
Expression::Call { name, args } => {
|
||||
Expression::Call {
|
||||
func: Call { name, args },
|
||||
..
|
||||
} => {
|
||||
// first evaluate all the args we're going to need
|
||||
let mut arg_regs = Vec::new();
|
||||
for arg in args.iter().rev() {
|
||||
let (arg_reg, arg_code) = self.generate_expression(arg, true)?;
|
||||
let (arg_reg, arg_code) =
|
||||
self.generate_expression(arg, true, func_body)?;
|
||||
code.extend(arg_code);
|
||||
arg_regs.push(arg_reg);
|
||||
}
|
||||
@@ -561,7 +592,7 @@ impl CodeGenerator {
|
||||
let saved_regs = self.allocator.get_caller_saved_registers();
|
||||
for reg in &saved_regs {
|
||||
// spill variables to stack
|
||||
code.extend(self.allocator.spill_register(reg).unwrap());
|
||||
code.extend(self.allocator.free_register(reg).unwrap());
|
||||
}
|
||||
|
||||
// Evaluate and push arguments in reverse order
|
||||
@@ -587,7 +618,7 @@ impl CodeGenerator {
|
||||
return Err(CompilerError::Undefined(name.clone()));
|
||||
}
|
||||
|
||||
let result_reg: String;
|
||||
let result_reg: Register;
|
||||
|
||||
if use_result {
|
||||
let (temp_result_reg, result_alloc) = self.allocator.alloc_temp()?;
|
||||
@@ -603,7 +634,7 @@ impl CodeGenerator {
|
||||
}
|
||||
}
|
||||
} else {
|
||||
result_reg = "zero".to_string();
|
||||
result_reg = Register::Zero;
|
||||
|
||||
// Clean up arguments
|
||||
if args.len() > 0 {
|
||||
@@ -626,9 +657,9 @@ impl CodeGenerator {
|
||||
Ok((result_reg, code))
|
||||
}
|
||||
|
||||
Expression::Unary { op, operand } => {
|
||||
Expression::Unary { op, operand, .. } => {
|
||||
let (operand_reg, operand_code) =
|
||||
self.generate_expression(operand, true)?;
|
||||
self.generate_expression(operand, true, func_body)?;
|
||||
code.extend(operand_code);
|
||||
|
||||
let (result_reg, result_alloc) = self.allocator.alloc_temp()?;
|
||||
@@ -660,7 +691,7 @@ impl CodeGenerator {
|
||||
Ok((result_reg, code))
|
||||
}
|
||||
|
||||
Expression::Empty => Ok(("zero".to_string(), code)),
|
||||
Expression::Empty => Ok((Register::Null, code)),
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
use std::collections::HashMap;
|
||||
use std::{collections::HashMap, fmt};
|
||||
|
||||
use crate::model::CompilerError;
|
||||
|
||||
@@ -6,78 +6,109 @@ use crate::model::CompilerError;
|
||||
/// Manages general-purpose registers (rg0-rgf) and handles stack spilling
|
||||
pub struct RegisterAllocator {
|
||||
/// Available general-purpose registers
|
||||
available_registers: Vec<String>,
|
||||
|
||||
/// Maps variable names to their current location (register or stack offset)
|
||||
variable_locations: HashMap<String, Location>,
|
||||
|
||||
/// Maps registers to the variables they currently hold
|
||||
register_contents: HashMap<String, String>,
|
||||
register_contents: HashMap<Register, String>,
|
||||
|
||||
/// Current stack offset for local variables (relative to bpr)
|
||||
/// Starts at -4 (going downward from base pointer)
|
||||
stack_offset: i32,
|
||||
|
||||
/// Track which registers are currently in use
|
||||
in_use: HashMap<String, bool>,
|
||||
in_use: HashMap<Register, bool>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub enum Location {
|
||||
Register(String),
|
||||
Stack(i32), // offset from bpr
|
||||
pub struct Location {
|
||||
register: Option<Register>,
|
||||
stack: Option<i32>,
|
||||
}
|
||||
|
||||
impl Location {
|
||||
pub fn stack(offset: i32) -> Self {
|
||||
Location {
|
||||
register: None,
|
||||
stack: Some(offset),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn register(register: Register) -> Self {
|
||||
Location {
|
||||
register: Some(register),
|
||||
stack: None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl RegisterAllocator {
|
||||
pub fn new() -> Self {
|
||||
// Initialize with available GP registers (rg0-rgf = 16 registers)
|
||||
let registers = vec![
|
||||
"rg0", "rg1", "rg2", "rg3", "rg4", "rg5", "rg6", "rg7", "rg8", "rg9", "rga",
|
||||
"rgb", "rgc", "rgd", "rge", "rgf",
|
||||
let in_use = vec![
|
||||
Register::Rg0,
|
||||
Register::Rg1,
|
||||
Register::Rg2,
|
||||
Register::Rg3,
|
||||
Register::Rg4,
|
||||
Register::Rg5,
|
||||
Register::Rg6,
|
||||
Register::Rg7,
|
||||
Register::Rg8,
|
||||
Register::Rg9,
|
||||
Register::Rga,
|
||||
Register::Rgb,
|
||||
Register::Rgc,
|
||||
Register::Rgd,
|
||||
Register::Rge,
|
||||
Register::Rgf,
|
||||
]
|
||||
.into_iter()
|
||||
.map(String::from)
|
||||
.iter()
|
||||
.map(|®| (reg, false))
|
||||
.collect();
|
||||
|
||||
RegisterAllocator {
|
||||
available_registers: registers,
|
||||
// available_registers: registers,
|
||||
variable_locations: HashMap::new(),
|
||||
register_contents: HashMap::new(),
|
||||
stack_offset: -4, // Start at -4 (first local below saved bpr)
|
||||
in_use: HashMap::new(),
|
||||
in_use,
|
||||
}
|
||||
}
|
||||
|
||||
/// Allocate a temporary register for expression evaluation
|
||||
/// Returns the register name and optionally assembly code to save it
|
||||
pub fn alloc_temp(&mut self) -> Result<(String, Vec<String>), CompilerError> {
|
||||
let mut code = Vec::new();
|
||||
|
||||
pub fn alloc_temp(&mut self) -> Result<(Register, Vec<String>), CompilerError> {
|
||||
// Try to find an unused register
|
||||
for reg in &self.available_registers {
|
||||
if !self.in_use.get(reg).unwrap_or(&false) {
|
||||
self.in_use.insert(reg.clone(), true);
|
||||
return Ok((reg.clone(), code));
|
||||
}
|
||||
|
||||
println!("finding! {:#?}", self.in_use);
|
||||
|
||||
if let Some(reg) = self.find_free_register() {
|
||||
self.in_use.insert(reg, true);
|
||||
return Ok((reg, Vec::new()));
|
||||
}
|
||||
|
||||
// All registers in use - need to spill one
|
||||
// Choose the first register with a variable we can spill
|
||||
// Find a register to spill
|
||||
let reg_to_spill = self
|
||||
.available_registers
|
||||
.iter()
|
||||
.find(|reg| self.register_contents.contains_key(*reg))
|
||||
.cloned();
|
||||
|
||||
if let Some(reg) = reg_to_spill {
|
||||
// Spill this variable to stack
|
||||
let spill_code = self.spill_register(®)?;
|
||||
code.extend(spill_code);
|
||||
// let reg_to_spill = self
|
||||
// .available_registers
|
||||
// .iter()
|
||||
// .find(|reg| self.register_contents.contains_key(*reg))
|
||||
// .cloned();
|
||||
|
||||
self.in_use.insert(reg.clone(), true);
|
||||
return Ok((reg, code));
|
||||
}
|
||||
// if let Some(reg) = reg_to_spill {
|
||||
// // Spill this variable to stack
|
||||
// let spill_code = self.spill_register(®)?;
|
||||
// code.extend(spill_code);
|
||||
|
||||
// self.in_use.insert(reg.clone(), true);
|
||||
// return Ok((reg, code));
|
||||
// }
|
||||
|
||||
todo!("an efficient stack spilling algorithm. needs scope awareness.");
|
||||
|
||||
Err(CompilerError::Generic(
|
||||
"All registers are used up yet there are no variables to spill to the stack"
|
||||
@@ -88,7 +119,7 @@ impl RegisterAllocator {
|
||||
/// Free a temporary register after use
|
||||
/// NOTE: This will NOT free registers that contain variables!
|
||||
/// Variables persist throughout their scope and must not be freed
|
||||
pub fn free_temp(&mut self, reg: &str) {
|
||||
pub fn free_temp(&mut self, reg: &Register) {
|
||||
// Check if this register contains a variable
|
||||
if self.register_contents.contains_key(reg) {
|
||||
// This register holds a variable - don't free it!
|
||||
@@ -97,7 +128,19 @@ impl RegisterAllocator {
|
||||
}
|
||||
|
||||
// This is a true temporary - safe to free
|
||||
self.in_use.insert(reg.to_string(), false);
|
||||
self.in_use.insert(*reg, false);
|
||||
}
|
||||
|
||||
pub fn free_var(&mut self, var: &str) {
|
||||
// Check if this variable is in a register
|
||||
if let Some(location) = self.variable_locations.get(var).cloned() {
|
||||
if let Some(reg) = location.register {
|
||||
self.register_contents.remove(®);
|
||||
self.in_use.insert(reg, false);
|
||||
}
|
||||
|
||||
self.variable_locations.remove(var);
|
||||
}
|
||||
}
|
||||
|
||||
/// Allocate a register for a named variable
|
||||
@@ -105,41 +148,46 @@ impl RegisterAllocator {
|
||||
pub fn alloc_var(
|
||||
&mut self,
|
||||
var_name: &str,
|
||||
) -> Result<(String, Vec<String>), CompilerError> {
|
||||
if let Some(location) = self.variable_locations.get(var_name).cloned() {
|
||||
match location {
|
||||
Location::Register(reg) => {
|
||||
return Ok((reg.clone(), Vec::new()));
|
||||
}
|
||||
Location::Stack(offset) => {
|
||||
// Variable was pushed, need to calculate actual position
|
||||
let (reg, mut code) = self.alloc_temp()?;
|
||||
) -> Result<(Register, Vec<String>), CompilerError> {
|
||||
if let Some(mut location) = self.variable_locations.get(var_name).cloned() {
|
||||
// if the var is in a register we can use it already.
|
||||
if let Some(reg) = location.register {
|
||||
return Ok((reg, Vec::new()));
|
||||
}
|
||||
|
||||
// Load from bpr + offset (offset is negative)
|
||||
code.push(format!("\tsubi bpr {} {}", -(offset + 4), reg));
|
||||
code.push(format!(
|
||||
"\tldw {}, {} // bpr{}: {}",
|
||||
reg,
|
||||
reg,
|
||||
offset - 4,
|
||||
var_name
|
||||
));
|
||||
// if the variable is on the stack only, we need to get it in a register.
|
||||
if let Some(offset) = location.stack {
|
||||
// Variable was pushed, need to calculate actual position and update its
|
||||
// location.
|
||||
let (reg, mut code) = self.alloc_temp()?;
|
||||
|
||||
// Update location to register
|
||||
self.variable_locations
|
||||
.insert(var_name.to_string(), Location::Register(reg.clone()));
|
||||
self.register_contents
|
||||
.insert(reg.clone(), var_name.to_string());
|
||||
// acknowledge var is now in a reg as well.
|
||||
location.register = Some(reg);
|
||||
|
||||
return Ok((reg, code));
|
||||
}
|
||||
// Load from bpr + offset (offset is negative)
|
||||
code.push(format!("\tsubi bpr {} {}", -(offset + 4), reg));
|
||||
code.push(format!(
|
||||
"\tldw {}, {} // bpr{}: {}",
|
||||
reg,
|
||||
reg,
|
||||
offset - 4,
|
||||
var_name
|
||||
));
|
||||
|
||||
// Update location to register
|
||||
self.variable_locations
|
||||
.insert(var_name.to_string(), location);
|
||||
self.register_contents
|
||||
.insert(reg.clone(), var_name.to_string());
|
||||
|
||||
return Ok((reg, code));
|
||||
}
|
||||
}
|
||||
|
||||
// Variable doesn't have a location yet, allocate a new register
|
||||
let (reg, code) = self.alloc_temp()?;
|
||||
self.variable_locations
|
||||
.insert(var_name.to_string(), Location::Register(reg.clone()));
|
||||
.insert(var_name.to_string(), Location::register(reg));
|
||||
self.register_contents
|
||||
.insert(reg.clone(), var_name.to_string());
|
||||
|
||||
@@ -156,83 +204,89 @@ impl RegisterAllocator {
|
||||
pub fn load_var(
|
||||
&mut self,
|
||||
var_name: &str,
|
||||
) -> Result<(String, Vec<String>), CompilerError> {
|
||||
) -> Result<(Register, Vec<String>), CompilerError> {
|
||||
self.alloc_var(var_name)
|
||||
}
|
||||
|
||||
/// Store a value from a register into a variable
|
||||
/// Updates tracking and returns any necessary assembly code
|
||||
pub fn store_var(&mut self, var_name: &str, source_reg: &str) -> Vec<String> {
|
||||
let mut code = Vec::new();
|
||||
|
||||
pub fn store_var(&mut self, var_name: &str, source_reg: &Register) -> Vec<String> {
|
||||
// Check if variable already has a location
|
||||
if let Some(location) = self.variable_locations.get(var_name) {
|
||||
match location {
|
||||
Location::Register(dest_reg) => {
|
||||
if dest_reg != source_reg {
|
||||
code.push(format!(
|
||||
"\tmov {}, {} // var {}",
|
||||
source_reg, dest_reg, var_name
|
||||
));
|
||||
}
|
||||
}
|
||||
Location::Stack(offset) => {
|
||||
code.push(format!(
|
||||
"\tstw {}, bpr, {} // var {}",
|
||||
source_reg, offset, var_name
|
||||
));
|
||||
// if the variable exists in a register we write to that.
|
||||
if let Some(reg) = location.register {
|
||||
if reg == *source_reg {
|
||||
return vec![format!(
|
||||
"\tmov {}, {} // var {}",
|
||||
source_reg, reg, var_name
|
||||
)];
|
||||
}
|
||||
}
|
||||
} else {
|
||||
// Variable doesn't exist yet, we can just use the same reg.
|
||||
|
||||
// self.variable_locations.insert(
|
||||
// var_name.to_string(),
|
||||
// Location::Register(source_reg.to_string()),
|
||||
// );
|
||||
// self.register_contents
|
||||
// .insert(source_reg.to_string(), var_name.to_string());
|
||||
// self.in_use.insert(source_reg.to_string(), true);
|
||||
|
||||
let source_reg = source_reg.to_string();
|
||||
|
||||
// if we can avoid a move, absolutely do that.
|
||||
if self.available_registers.contains(&source_reg) {
|
||||
self.variable_locations
|
||||
.insert(var_name.to_string(), Location::Register(source_reg.clone()));
|
||||
self.register_contents
|
||||
.insert(source_reg.clone(), var_name.to_string());
|
||||
self.in_use.insert(source_reg, true);
|
||||
} else if let Some(free_reg) = self.find_free_register() {
|
||||
code.push(format!("\tmov {}, {}", source_reg, free_reg));
|
||||
self.variable_locations
|
||||
.insert(var_name.to_string(), Location::Register(free_reg.clone()));
|
||||
self.register_contents
|
||||
.insert(free_reg.clone(), var_name.to_string());
|
||||
self.in_use.insert(free_reg, true);
|
||||
} else {
|
||||
// No free registers - allocate on stack
|
||||
// code.push(format!("\tstw {}, bpr, {}", source_reg, self.stack_offset));
|
||||
// self.variable_locations
|
||||
// .insert(var_name.to_string(), Location::Stack(self.stack_offset));
|
||||
// self.stack_offset -= 4; // Move to next stack slot
|
||||
//
|
||||
todo!(
|
||||
"we should spill other registers and keep this variable on the stack as it's more recent!"
|
||||
);
|
||||
// if the variable exists on the stack but not a register we write here.
|
||||
if let Some(offset) = location.stack {
|
||||
return vec![format!(
|
||||
"\tstw {}, bpr, {} // var {}",
|
||||
source_reg, offset, var_name
|
||||
)];
|
||||
}
|
||||
}
|
||||
|
||||
code
|
||||
// Variable doesn't exist yet, we can just use the same reg.
|
||||
// if we can avoid a move, absolutely do that.
|
||||
|
||||
// if this is true then there's no permanent variable here so it's safe to use.
|
||||
if !self.register_contents.contains_key(source_reg) {
|
||||
self.variable_locations
|
||||
.insert(var_name.to_string(), Location::register(*source_reg));
|
||||
self.register_contents
|
||||
.insert(*source_reg, var_name.to_string());
|
||||
self.in_use.insert(*source_reg, true);
|
||||
|
||||
return Vec::new();
|
||||
}
|
||||
|
||||
// if current register isn't free, (eg is another variable) we assign somewhere
|
||||
// else.
|
||||
if let Some(free_reg) = self.find_free_register() {
|
||||
self.variable_locations
|
||||
.insert(var_name.to_string(), Location::register(free_reg));
|
||||
self.register_contents
|
||||
.insert(free_reg.clone(), var_name.to_string());
|
||||
self.in_use.insert(free_reg, true);
|
||||
|
||||
return vec![format!("\tmov {}, {}", source_reg, free_reg)];
|
||||
}
|
||||
|
||||
// No free registers - allocate on stack
|
||||
// code.push(format!("\tstw {}, bpr, {}", source_reg, self.stack_offset));
|
||||
// self.variable_locations
|
||||
// .insert(var_name.to_string(), Location::Stack(self.stack_offset));
|
||||
// self.stack_offset -= 4; // Move to next stack slot
|
||||
//
|
||||
todo!("an efficient stack spilling algorithm. needs scope awareness.");
|
||||
}
|
||||
|
||||
/// Spill a register to the stack
|
||||
/// Returns assembly code to perform the spill
|
||||
pub fn spill_register(&mut self, reg: &str) -> Result<Vec<String>, CompilerError> {
|
||||
/// spill a register to the stack (WITHOUT FREEING)
|
||||
pub fn spill_register(
|
||||
&mut self,
|
||||
reg: &Register,
|
||||
) -> Result<Vec<String>, CompilerError> {
|
||||
let mut code = Vec::new();
|
||||
|
||||
if let Some(var_name) = self.register_contents.get(reg).cloned() {
|
||||
// PUSH register to stack (spr decrements automatically)
|
||||
// check if the variable is declared.
|
||||
if let Some(var_name) = self.register_contents.get(reg).cloned()
|
||||
&& let Some(location) = self.variable_locations.get_mut(&var_name)
|
||||
{
|
||||
// check if var is on the stack
|
||||
if let Some(offset) = location.stack {
|
||||
// ensure stack value is up to date with register value.
|
||||
code.push(format!("\tstw {}, {}", reg, offset));
|
||||
return Ok(code);
|
||||
}
|
||||
|
||||
// if the variable is not on the stack:
|
||||
// push register to stack (spr decrements automatically)
|
||||
code.push(format!(
|
||||
"\tpush {} // bpr{}: {}",
|
||||
reg, self.stack_offset, var_name
|
||||
@@ -240,37 +294,83 @@ impl RegisterAllocator {
|
||||
|
||||
// Track that we pushed one word
|
||||
self.stack_offset -= 4;
|
||||
|
||||
// Update variable location - it's now at current spr
|
||||
// Note: We track offset from bpr for consistency
|
||||
self.variable_locations
|
||||
.insert(var_name.clone(), Location::Stack(self.stack_offset));
|
||||
|
||||
// Remove from register tracking
|
||||
self.register_contents.remove(reg);
|
||||
location.stack = Some(self.stack_offset);
|
||||
Ok(code)
|
||||
} else {
|
||||
Err(CompilerError::Generic(format!(
|
||||
"Register {} does not contain a variable to spill!",
|
||||
reg
|
||||
)))
|
||||
}
|
||||
}
|
||||
|
||||
Ok(code)
|
||||
/// free a register by spilling it to the stack.
|
||||
/// Returns assembly code to perform the spill
|
||||
pub fn free_register(
|
||||
&mut self,
|
||||
reg: &Register,
|
||||
) -> Result<Vec<String>, CompilerError> {
|
||||
let mut code = Vec::new();
|
||||
|
||||
// check if the variable is declared.
|
||||
if let Some(var_name) = self.register_contents.get(reg).cloned()
|
||||
&& let Some(location) = self.variable_locations.get_mut(&var_name)
|
||||
{
|
||||
// check if var name is on the stack
|
||||
if let Some(offset) = location.stack {
|
||||
// store current register value in stack location
|
||||
code.push(format!("\tstw {}, {}", reg, offset));
|
||||
|
||||
// free the register.
|
||||
location.register = None;
|
||||
self.register_contents.remove(reg);
|
||||
return Ok(code);
|
||||
}
|
||||
|
||||
// if the variable is not on the stack:
|
||||
// push register to stack (spr decrements automatically)
|
||||
code.push(format!(
|
||||
"\tpush {} // bpr{}: {}",
|
||||
reg, self.stack_offset, var_name
|
||||
));
|
||||
|
||||
// Track that we pushed one word
|
||||
self.stack_offset -= 4;
|
||||
// Update variable location - it's now at current spr
|
||||
// Note: We track offset from bpr for consistency
|
||||
location.stack = Some(self.stack_offset);
|
||||
location.register = None;
|
||||
self.register_contents.remove(reg);
|
||||
|
||||
Ok(code)
|
||||
} else {
|
||||
Err(CompilerError::Generic(format!(
|
||||
"Register {} does not contain a variable to spill!",
|
||||
reg
|
||||
)))
|
||||
}
|
||||
}
|
||||
|
||||
/// Find a free register (not currently in use)
|
||||
fn find_free_register(&self) -> Option<String> {
|
||||
for reg in &self.available_registers {
|
||||
if !self.in_use.get(reg).unwrap_or(&false) {
|
||||
return Some(reg.clone());
|
||||
}
|
||||
}
|
||||
None
|
||||
fn find_free_register(&self) -> Option<Register> {
|
||||
self.in_use
|
||||
.iter()
|
||||
.filter(|(_, in_use)| !**in_use)
|
||||
.map(|(reg, _)| *reg)
|
||||
.next()
|
||||
}
|
||||
|
||||
/// Spill all registers to stack (useful before function calls)
|
||||
pub fn _spill_all(&mut self) -> Vec<String> {
|
||||
let mut code = Vec::new();
|
||||
|
||||
let regs_to_spill: Vec<String> = self.register_contents.keys().cloned().collect();
|
||||
let regs_to_spill: Vec<Register> =
|
||||
self.register_contents.keys().cloned().collect();
|
||||
|
||||
for reg in regs_to_spill {
|
||||
if let Ok(spill_code) = self.spill_register(®) {
|
||||
if let Ok(spill_code) = self.free_register(®) {
|
||||
code.extend(spill_code);
|
||||
}
|
||||
}
|
||||
@@ -293,23 +393,43 @@ impl RegisterAllocator {
|
||||
self.variable_locations.clear();
|
||||
self.register_contents.clear();
|
||||
self.stack_offset = -4;
|
||||
self.in_use.clear();
|
||||
self.in_use = vec![
|
||||
Register::Rg0,
|
||||
Register::Rg1,
|
||||
Register::Rg2,
|
||||
Register::Rg3,
|
||||
Register::Rg4,
|
||||
Register::Rg5,
|
||||
Register::Rg6,
|
||||
Register::Rg7,
|
||||
Register::Rg8,
|
||||
Register::Rg9,
|
||||
Register::Rga,
|
||||
Register::Rgb,
|
||||
Register::Rgc,
|
||||
Register::Rgd,
|
||||
Register::Rge,
|
||||
Register::Rgf,
|
||||
]
|
||||
.iter()
|
||||
.map(|®| (reg, false))
|
||||
.collect();
|
||||
}
|
||||
|
||||
/// Mark a variable as dead (no longer needed)
|
||||
/// Frees its register if it's in one
|
||||
pub fn _free_var(&mut self, var_name: &str) {
|
||||
if let Some(Location::Register(reg)) = self.variable_locations.get(var_name) {
|
||||
let reg = reg.clone();
|
||||
self.register_contents.remove(®);
|
||||
self.in_use.insert(reg, false);
|
||||
}
|
||||
self.variable_locations.remove(var_name);
|
||||
}
|
||||
// pub fn _free_var(&mut self, var_name: &str) {
|
||||
// if let Some(Location::Register(reg)) = self.variable_locations.get(var_name) {
|
||||
// let reg = reg.clone();
|
||||
// self.register_contents.remove(®);
|
||||
// self.in_use.insert(reg, false);
|
||||
// }
|
||||
// self.variable_locations.remove(var_name);
|
||||
// }
|
||||
|
||||
/// Get list of registers that contain variables and are in use
|
||||
/// These need to be saved before function calls
|
||||
pub fn get_caller_saved_registers(&self) -> Vec<String> {
|
||||
pub fn get_caller_saved_registers(&self) -> Vec<Register> {
|
||||
self.register_contents
|
||||
.iter()
|
||||
.filter(|(reg, _)| *self.in_use.get(*reg).unwrap_or(&false))
|
||||
@@ -346,3 +466,50 @@ impl RegisterAllocator {
|
||||
code
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
|
||||
pub enum Register {
|
||||
Rg0,
|
||||
Rg1,
|
||||
Rg2,
|
||||
Rg3,
|
||||
Rg4,
|
||||
Rg5,
|
||||
Rg6,
|
||||
Rg7,
|
||||
Rg8,
|
||||
Rg9,
|
||||
Rga,
|
||||
Rgb,
|
||||
Rgc,
|
||||
Rgd,
|
||||
Rge,
|
||||
Rgf,
|
||||
Zero,
|
||||
Null,
|
||||
}
|
||||
|
||||
impl fmt::Display for Register {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
match self {
|
||||
Self::Rg0 => write!(f, "rg0"),
|
||||
Self::Rg1 => write!(f, "rg1"),
|
||||
Self::Rg2 => write!(f, "rg2"),
|
||||
Self::Rg3 => write!(f, "rg3"),
|
||||
Self::Rg4 => write!(f, "rg4"),
|
||||
Self::Rg5 => write!(f, "rg5"),
|
||||
Self::Rg6 => write!(f, "rg6"),
|
||||
Self::Rg7 => write!(f, "rg7"),
|
||||
Self::Rg8 => write!(f, "rg8"),
|
||||
Self::Rg9 => write!(f, "rg9"),
|
||||
Self::Rga => write!(f, "rga"),
|
||||
Self::Rgb => write!(f, "rgb"),
|
||||
Self::Rgc => write!(f, "rgc"),
|
||||
Self::Rgd => write!(f, "rgd"),
|
||||
Self::Rge => write!(f, "rge"),
|
||||
Self::Rgf => write!(f, "rgf"),
|
||||
Self::Zero => write!(f, "zero"),
|
||||
Self::Null => write!(f, "null"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user