Add dataflow analysis scaffolding

Cargo.toml

@@ -1,3 +1,3 @@
 [workspace]
 resolver = "2"
-members = ["bril/bril-rs/bril2json", "common", "driver", "optimizations", "bril/brilirs"]
+members = ["bril/bril-rs/bril2json", "common", "driver", "optimizations", "bril/brilirs", "dataflow_analysis"]

common/src/lib.rs

@@ -286,4 +286,63 @@ mod tests {
             println!("{}", cfg.get_dot_representation());
         }
     }
+
+    #[test]
+    fn test_cfg_construction2() {
+        let program_text = indoc::indoc! {r#"
+            # ARGS: 23
+            @main(n: float) {
+                v0: float = id n;
+                c: float = call @probability v0;
+                c: float = id c;
+                v1: float = id c;
+                print v1;
+                v2: int = const 0;
+            }
+            @probability(n: float): float {
+                v0: float = const 1;
+                prob: float = id v0;
+                v2: float = const 1;
+                i: float = id v2;
+                .for.cond.1:
+                v3: float = id i;
+                v4: float = id n;
+                v5: bool = flt v3 v4;
+                br v5 .for.body.1 .for.end.1;
+                .for.body.1:
+                v6: float = const 365;
+                v7: float = id i;
+                v8: float = fsub v6 v7;
+                log: float = id v8;
+                v9: float = id log;
+                v10: float = const 365;
+                v11: float = fdiv v9 v10;
+                logUpdated: float = id v11;
+                v12: float = id prob;
+                v13: float = id logUpdated;
+                v14: float = fmul v12 v13;
+                prob: float = id v14;
+                v15: float = id i;
+                v16: float = const 1;
+                v17: float = fadd v15 v16;
+                i: float = id v17;
+                jmp .for.cond.1;
+                .for.end.1:
+                v18: float = const 1;
+                v19: float = id prob;
+                v20: float = const 100;
+                v21: float = fmul v19 v20;
+                v22: float = const 100;
+                v23: float = fdiv v21 v22;
+                v24: float = fsub v18 v23;
+                ret v24;
+            }
+    "#};
+        let program = parse_bril_text(program_text).unwrap();
+        for function in &program.functions {
+            let basic_blocks = construct_basic_block_stream(&function.instrs);
+            let cfg = construct_cfg(&basic_blocks);
+            println!("{}", cfg.get_dot_representation());
+        }
+    }
 }

dataflow_analysis/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "dataflow_analysis"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+clap = "4.5.20"
+common = { version = "0.1.0", path = "../common" }
+
+[dependencies.bril-rs]
+version = "0.1.0"
+path = "../bril/bril-rs"
+features = ["ssa", "memory", "float", "speculate", "position"]

dataflow_analysis/src/lib.rs

@@ -0,0 +1,27 @@
+use bril_rs::Program;
+use clap::ValueEnum;
+
+#[derive(ValueEnum, Clone, Debug, PartialEq, Copy)]
+pub enum DataflowAnalyses {
+    LiveVariable,
+}
+
+pub fn run_analysis(dataflow_analysis_name: DataflowAnalyses, program: &Program) -> () {
+    for (function_name, args, cfg) in program.functions.iter().map(|function| {
+        let basic_blocks = common::construct_basic_block_stream(&function.instrs);
+        let cfg = common::construct_cfg(&basic_blocks);
+        (&function.name, &function.args, cfg)
+    }) {
+        println!("{}", function_name);
+        println!("{}", cfg.get_dot_representation());
+        todo!()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn it_works() {}
+}

driver/Cargo.toml

@@ -6,4 +6,5 @@ edition = "2021"
 [dependencies]
 clap = { version = "4.5.20", features = ["derive"] }
 common = { version = "0.1.0", path = "../common" }
+dataflow_analysis = { version = "0.1.0", path = "../dataflow_analysis" }
 optimizations = { version = "0.1.0", path = "../optimizations" }

driver/src/main.rs

@@ -1,6 +1,7 @@
 use std::{error::Error, io::Read};
 
 use clap::Parser;
+use dataflow_analysis::DataflowAnalyses;
 use optimizations::{OptimizationPass, PassManager};
 
 #[derive(Parser)]
@@ -11,6 +12,9 @@ struct Args {
 
     #[arg(long, value_enum)]
     optimizations: Vec<OptimizationPass>,
+
+    #[arg(short, long, value_enum, help = "Type of dataflow analysis to run")]
+    dataflow_analysis: Option<DataflowAnalyses>,
 }
 
 fn main() -> Result<(), Box<dyn Error>> {
@@ -39,7 +43,11 @@ fn main() -> Result<(), Box<dyn Error>> {
         pass_manager.register_pass(*optimization);
     }
     program = pass_manager.run(program);
-
-    println!("{}", program);
+    if let Some(dataflow_analysis_name) = args.dataflow_analysis {
+        dataflow_analysis::run_analysis(dataflow_analysis_name, &program);
+    } else {
+        // Simply print the optimized program
+        println!("{}", program);
+    }
     Ok(())
 }