refactor: code quality

Author: Boreas618

src/asm/aarch64.rs

@@ -1,5 +1,6 @@
 mod function_generator;
 mod inst;
+mod phi_lowering;
 mod printer;
 mod register_allocator;
 mod types;
@@ -205,34 +206,16 @@ impl<'a> AArch64AsmGenerator<'a> {
         let mut insts: Vec<Inst> = Vec::new();
         insts.extend(Self::handle_arguments(func)?);
 
-        let mut ctx = FunctionGenerator {
-            func_id: &func.identifier,
-            frame: &frame,
-            layouts,
-            insts: &mut insts,
-            next_vreg: &mut next_vreg,
-            cond_map: &mut cond_map,
-        };
-
-        for block in blocks.iter() {
-            ctx.emit_label(&block.label);
-            for stmt in &block.stmts {
-                use ir::stmt::StmtInner::*;
-                match &stmt.inner {
-                    Label(l) => ctx.emit_label(&l.label),
-                    Alloca(_) => { /* Stack slots handled by frame layout */ }
-                    Store(s) => ctx.emit_store(s)?,
-                    Load(s) => ctx.emit_load(s)?,
-                    BiOp(s) => ctx.emit_biop(s)?,
-                    Cmp(s) => ctx.emit_cmp(s)?,
-                    CJump(s) => ctx.emit_cjump(s)?,
-                    Jump(s) => ctx.emit_jump(s),
-                    Gep(s) => ctx.emit_gep(s)?,
-                    Call(s) => ctx.emit_call(s)?,
-                    Return(s) => ctx.emit_return(s)?,
-                    _ => return Err(Error::Internal("unexpected statement in block".into())),
-                }
-            }
+        {
+            let mut ctx = FunctionGenerator {
+                func_id: &func.identifier,
+                frame: &frame,
+                layouts,
+                insts: &mut insts,
+                next_vreg: &mut next_vreg,
+                cond_map: &mut cond_map,
+            };
+            phi_lowering::lower_function_blocks(&mut ctx, blocks)?;
         }
 
         let alloc = register_allocator::allocate(&insts);

src/asm/aarch64/function_generator.rs

@@ -113,7 +113,7 @@ impl<'a> FunctionGenerator<'a> {
         let cond = *self
             .cond_map
             .get(&cond_v)
-            .ok_or_else(|| Error::MissingCond { vreg: cond_v })?;
+            .ok_or(Error::MissingCond { vreg: cond_v })?;
 
         let true_label = self.mangle_block_label(&s.true_label);
         let false_label = self.mangle_block_label(&s.false_label);
@@ -600,6 +600,54 @@ impl<'a> FunctionGenerator<'a> {
         }
     }
 
+    pub fn emit_stmt(&mut self, stmt: &ir::stmt::Stmt) -> Result<(), Error> {
+        use ir::stmt::StmtInner::*;
+        match &stmt.inner {
+            Label(l) => {
+                self.emit_label(&l.label);
+                Ok(())
+            }
+            Alloca(_) => Ok(()),
+            Store(s) => self.emit_store(s),
+            Load(s) => self.emit_load(s),
+            BiOp(s) => self.emit_biop(s),
+            Cmp(s) => self.emit_cmp(s),
+            CJump(s) => self.emit_cjump(s),
+            Jump(s) => {
+                self.emit_jump(s);
+                Ok(())
+            }
+            Gep(s) => self.emit_gep(s),
+            Call(s) => self.emit_call(s),
+            Return(s) => self.emit_return(s),
+            Phi(_) => Err(Error::Internal(
+                "phi nodes should be lowered before assembly emission".into(),
+            )),
+        }
+    }
+
+    pub fn emit_copy(&mut self, dst: &ir::Operand, src: &ir::Operand) -> Result<(), Error> {
+        let dst_vreg = Self::operand_vreg(dst)?;
+        let size = dtype_to_regsize(dst.dtype())?;
+
+        let src_op = match src {
+            ir::Operand::Integer(i) => Operand::Immediate(i.value as i64),
+            ir::Operand::Local(l) => Operand::Register(Register::Virtual(l.index)),
+            ir::Operand::Global(_) => {
+                return Err(Error::UnsupportedOperand {
+                    what: "global variable in phi copy".into(),
+                });
+            }
+        };
+
+        self.insts.push(Inst::Mov {
+            size,
+            dst: Register::Virtual(dst_vreg),
+            src: src_op,
+        });
+        Ok(())
+    }
+
     fn mangle_block_label(&self, label: &ir::BlockLabel) -> String {
         match label {
             ir::BlockLabel::BasicBlock(n) => mangle_bb(self.func_id, *n),