dom

analysis/src/ir.rs

@@ -32,7 +32,7 @@
 //! ```
 
 mod custom;
-mod info;
+pub mod info;
 mod pretty;
 mod validate;
 mod visit;

analysis/src/ir/info.rs

@@ -38,9 +38,7 @@ pub fn last_register_uses(func: &Func<'_>) -> Vec<Option<Location>> {
 
         let mut check_op = |op: Operand, stmt| match op {
             Operand::Reg(reg) => {
-                dbg!(("reg use", reg, stmt));
                 if uses[reg.as_usize()].is_none() {
-                    dbg!("insert!");
                     uses[reg.as_usize()] = Some(Location { bb, stmt })
                 }
             }
@@ -70,6 +68,29 @@ pub fn last_register_uses(func: &Func<'_>) -> Vec<Option<Location>> {
     uses
 }
 
+pub fn dominates_location(f: &Func<'_>, dom: Location, sub: Location) -> bool {
+    // TODO: Can this be made more efficient by caching renumberings of bbs?
+    if dom.bb == sub.bb {
+        return match (dom.stmt, sub.stmt) {
+            (None, Some(_)) => true,
+            (Some(d_i), Some(s_i)) if d_i < s_i => true,
+            _ => false,
+        };
+    }
+
+    let mut seen = FxHashSet::default();
+    let mut worklist = vec![dom.bb];
+
+    while let Some(bb) = worklist.pop() {
+        if !seen.insert(bb) {
+            continue;
+        }
+        worklist.extend(f.bb(bb).term.successors());
+    }
+
+    seen.contains(&sub.bb)
+}
+
 #[cfg(test)]
 mod tests {
     use crate::{

codegen/src/lib.rs

@@ -54,7 +54,7 @@ pub fn generate<'cx>(lcx: &'cx LoweringCx<'cx>, ir: &Ir<'cx>) -> Result<()> {
     let output = std::process::Command::new("cc")
         .arg("main.o")
         .stdout(Stdio::inherit())
-        .stdout(Stdio::inherit())
+        .stderr(Stdio::inherit())
         .output()
         .map_err(|err| analysis::Error::new_without_span(format!("failed to spawn `cc`: {err}")))?;
 

codegen/src/x86_64.rs

@@ -66,7 +66,7 @@
 //! | %r15     | callee-saved register; optionally used as GOT base pointer | Yes |
 
 use analysis::{
-    ir::{BbIdx, Func, Operand, Register, Statement, StatementKind},
+    ir::{self, BbIdx, Func, Location, Operand, Register, Statement, StatementKind},
     LoweringCx,
 };
 use iced_x86::{
@@ -91,22 +91,59 @@ impl<T> IcedErrExt for Result<T, IcedError> {
     }
 }
 
+/// A machine register from our register list described in the module documentation.
+#[derive(Debug, Clone, Copy)]
+struct MachineReg(usize);
+
 #[derive(Debug, Clone, Copy)]
 enum RegValue {
+    /// The SSA register resides on the stack as it has been spilled.
     Stack { offset: u64 },
+    /// The SSA register resides in a machine register
+    MachineReg(MachineReg),
 }
 
 struct AsmCtxt<'cx> {
     lcx: &'cx LoweringCx<'cx>,
     a: CodeAssembler,
     reg_map: FxHashMap<Register, RegValue>,
+    reg_occupancy: Vec<Option<Register>>,
     current_stack_offset: u64,
     bb_idx: BbIdx,
+
+    // caches
+    last_register_uses: Vec<Option<Location>>,
 }
 
 impl<'cx> AsmCtxt<'cx> {
+    fn allocate_result_ssa_reg(
+        &mut self,
+        f: &Func<'_>,
+        reg: Register,
+        location: Location,
+    ) -> RegValue {
+        for (i, opt_reg) in self.reg_occupancy.iter_mut().enumerate() {
+            if let Some(reg) = opt_reg.as_mut() {
+                if let Some(last_use) = self.last_register_uses[reg.as_usize()] {
+                    if ir::info::dominates_location(f, last_use, location) {
+                        // The last use dominates our location - the SSA reg is dead now.
+                        *opt_reg = None;
+                    }
+                }
+            }
+
+            if opt_reg.is_none() {
+                *opt_reg = Some(reg);
+                return RegValue::MachineReg(MachineReg(i));
+            }
+        }
+
+        todo!("spill.")
+    }
+
     fn generate_func(&mut self, func: &Func<'cx>) -> Result<()> {
         // TODO: Prologue
+        self.a.push(x::rbx);
 
         loop {
             let bb = &func.bbs[self.bb_idx.as_usize()];
@@ -149,6 +186,7 @@ impl<'cx> AsmCtxt<'cx> {
                             let value = self.reg_map[&reg];
                             let stack_offset = match value {
                                 RegValue::Stack { offset } => offset,
+                                RegValue::MachineReg(_) => todo!("machine reg"),
                             };
                             //let rhs = match value {
                             //    Operand::Const(c) => {}
@@ -167,24 +205,26 @@ impl<'cx> AsmCtxt<'cx> {
                         ptr,
                         size,
                         align,
-                    } => todo!(),
+                    } => todo!("loads."),
                     StatementKind::BinOp {
                         kind,
                         lhs,
                         rhs,
                         result,
-                    } => todo!(),
+                    } => todo!("binary operations"),
-                    StatementKind::UnaryOperation { rhs, kind, result } => todo!(),
+                    StatementKind::UnaryOperation { rhs, kind, result } => {
+                        todo!("unary operations")
+                    }
                     StatementKind::PtrOffset {
                         result,
                         ptr: reg,
                         amount,
-                    } => todo!(),
+                    } => todo!("pointer offset :D"),
                     StatementKind::Call {
                         result,
                         func,
                         ref args,
-                    } => todo!(),
+                    } => todo!("function calls 💀"),
                 }
             }
 
@@ -205,8 +245,10 @@ pub fn generate_func<'cx>(lcx: &'cx LoweringCx<'cx>, func: &Func<'cx>) -> Result
         lcx,
         a,
         reg_map: FxHashMap::default(),
+        reg_occupancy: vec![None; 8],
         current_stack_offset: 0,
         bb_idx: BbIdx(0),
+        last_register_uses: ir::info::last_register_uses(func),
     };
 
     cx.generate_func(func)?;