working on kerboscript codegeneration

+ generated dominance list

Author: DigitalCodeCrafter

src/backend/ks.rs

@@ -0,0 +1,78 @@
+use std::collections::HashSet;
+
+use crate::mir::{Block, BlockId, Body, Terminator};
+
+fn preds_succs(blocks: &[Block]) -> (Vec<Vec<BlockId>>, Vec<Vec<BlockId>>) {
+    let mut preds = vec![vec![]; blocks.len()];
+    let mut succs = vec![vec![]; blocks.len()];
+
+    for b in 0..blocks.len() {
+        let term = &blocks[b].terminator;  
+        let id = BlockId(b as u32); 
+        match term {
+            Terminator::Goto(next) => {
+                preds[next.0 as usize].push(id);
+                succs[b].push(*next);
+            }
+            Terminator::Branch(_, tbb, ebb) => {
+                preds[tbb.0 as usize].push(id);
+                preds[ebb.0 as usize].push(id);
+                succs[b].push(*tbb);
+                succs[b].push(*ebb);
+            }
+            Terminator::Return(_) => {},
+            Terminator::Unreachable => {},
+        }
+    }
+
+    (preds, succs)
+}
+
+fn find_doms(blocks: &[Block], preds: &[Vec<BlockId>]) -> Vec<HashSet<BlockId>> {
+    let all: HashSet<BlockId> = (0..blocks.len() as u32).map(BlockId).collect();
+    let mut dom = vec![all.clone(); blocks.len()];
+    dom[0].clear();
+    dom[0].insert(BlockId(0));
+    dom[0].shrink_to_fit();
+
+    let mut changed = true;
+    while changed {
+        changed = false;
+
+        for b in 1..blocks.len() {
+            let mut new = all.clone();
+
+            for &p in &preds[b] {
+                new = new.intersection(&dom[p.0 as usize]).cloned().collect();
+            }
+
+            new.insert(BlockId(b as u32));
+
+            if new != dom[b] {
+                dom[b] = new;
+                changed = true;
+            }
+        }
+    }
+
+    dom
+}
+
+fn dominates(dom: &[HashSet<BlockId>], a: BlockId, b: BlockId) -> bool {
+    dom[b.0 as usize].contains(&a)
+}
+
+fn is_back_edge(dom: &[HashSet<BlockId>], from: BlockId, to: BlockId) -> bool {
+    dominates(dom, to, from)
+}
+
+pub fn print_doms(body: &Body) {
+    let (preds, succs) = preds_succs(&body.blocks);
+    let doms = find_doms(&body.blocks, &preds);
+    for b in 0..body.blocks.len() {
+        println!("{{ {} }} -> block{} -> {{ {} }}", preds[b].iter().map(|id| format!("block{}", id.0)).collect::<Vec<_>>().join(", "), b, succs[b].iter().map(|id| format!("block{}", id.0)).collect::<Vec<_>>().join(", "));
+    }
+    for b in 0..body.blocks.len() {
+        println!("dom(block{}) = {{ {} }}", b, doms[b].iter().map(|id| format!("block{}", id.0)).collect::<Vec<_>>().join(", "));
+    }
+}

src/backend/mod.rs

@@ -1,4 +1,5 @@
 mod kerboscript;
+pub mod ks;
 
 
 use crate::common::diagnostics::DiagnosticSink;

src/main.rs

@@ -25,16 +25,18 @@ fn main() -> Result<(), ()> {
 
     run_passes(&mut prog_ir, &mut passes);
 
-    let out = backend::emit(&prog_ir, &mut diagnostics);
-
-    render_all(&content, &line_starts, &diagnostics.diagnostics);
-
-    let pretty_ir = pretty::format_body(&prog_ir, "main");
-    for line in pretty_ir.lines() {
-        println!("// {}", line);
-    }
-
-    println!("\n\n{}", out);
+    
+    // let out = backend::emit(&prog_ir, &mut diagnostics);
+    
+    // render_all(&content, &line_starts, &diagnostics.diagnostics);
+    
+    /*let pretty_ir = */ println!("{}", pretty::format_body(&prog_ir, "main"));
+    // for line in pretty_ir.lines() {
+    //     println!("// {}", line);
+    // }
+        
+    backend::ks::print_doms(&prog_ir);
+    // println!("\n\n{}", out);
     Ok(()) 
 }
 

src/mir/lowerer.rs

@@ -10,9 +10,9 @@ pub fn lower(typed_ast: t::TypedAst, symbols: &SymbolTable, _diagnostics: &mut i
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct LocalId(pub(super) u32);
+pub struct LocalId(pub u32);
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct BlockId(pub(super) u32);
+pub struct BlockId(pub u32);
 
 impl LocalId {
     pub fn index(&self) -> u32 { self.0 }

src/semantics/typechecker.rs

@@ -264,6 +264,7 @@ impl<D: DiagnosticSink> TypeChecker<'_, '_, D> {
 
             (Number, Number) => Some(Number),
             (Bool, Bool) => Some(Bool),
+            (Unit, Unit) => Some(Unit),
 
             _ => None,
         }

src/syntax/parser.rs

@@ -423,6 +423,7 @@ impl<'a, 'd, D: DiagnosticSink> Parser<'a, 'd, D> {
     fn parse_if_expr(&mut self, tok: Token) -> Expr<'a> {
         let cond = self.parse_expression(0);
 
+        self.skip_newlines();
         let then_branch = match self.peek_token() {
             token @ Token { kind: TokenKind::LBrace, .. } => {
                 self.stream.next();
@@ -437,8 +438,11 @@ impl<'a, 'd, D: DiagnosticSink> Parser<'a, 'd, D> {
             }
         };
 
+        let save = self.stream.get_position();
+        self.skip_newlines();
         let else_branch = if matches!(self.peek_token().kind, TokenKind::Else) {
             self.stream.next();
+            self.skip_newlines();
             match self.peek_token() {
                 token @ Token { kind: TokenKind::LBrace, .. } => {
                     self.stream.next();
@@ -453,10 +457,12 @@ impl<'a, 'd, D: DiagnosticSink> Parser<'a, 'd, D> {
                         Diagnostic::error("expected a block")
                         .with_span(other.span)
                     );
+                    self.stream.set_position(save);
                     Some(Expr { kind: ExprKind::Block { stmts: vec![], tail_expr: None }, span: Span::new(other.span.start, other.span.start) })
                 }
             }
         } else {
+            self.stream.set_position(save);
             None
         };