chore(ssa): Add intial control flow graph

crates/noirc_evaluator/src/ssa_refactor/ir/basic_block_visitors.rs

@@ -13,5 +13,8 @@ pub(crate) fn visit_block_succs<F: FnMut(BasicBlockId)>(basic_block: &BasicBlock
             visit(*then_destination);
             visit(*else_destination);
         }
+        TerminatorInstruction::Return { .. } => {
+            // The last block of the control flow - no successors
+        }
     }
 }

crates/noirc_evaluator/src/ssa_refactor/ir/cfg.rs

@@ -1,4 +1,4 @@
-use std::collections::{hash_set, HashMap, HashSet};
+use std::collections::{HashMap, HashSet};
 
 use super::{
     basic_block::{BasicBlock, BasicBlockId},
@@ -34,7 +34,7 @@ impl ControlFlowGraph {
     }
 
     fn compute(&mut self, func: &Function) {
-        for (basic_block_id, basic_block) in func.basic_blocks_iter() {
+        for (basic_block_id, basic_block) in func.dfg.basic_blocks_iter() {
             self.compute_block(basic_block_id, basic_block);
         }
     }
@@ -67,7 +67,7 @@ impl ControlFlowGraph {
     /// from `basic_block_id` while leaving edges to `basic_block_id` intact.
     pub(crate) fn recompute_block(&mut self, func: &Function, basic_block_id: BasicBlockId) {
         self.invalidate_block_successors(basic_block_id);
-        let basic_block = &func[basic_block_id];
+        let basic_block = &func.dfg[basic_block_id];
         self.compute_block(basic_block_id, basic_block);
     }
 
@@ -86,27 +86,149 @@ impl ControlFlowGraph {
         successor_node.predecessors.insert(from);
     }
 
-    /// Get an iterator over the CFG predecessors to `block`.
-    pub(crate) fn pred_iter(&self, basic_block_id: BasicBlockId) -> PredIter {
+    /// Get an iterator over the CFG predecessors to `basic_block_id`.
+    pub(crate) fn pred_iter(
+        &self,
+        basic_block_id: BasicBlockId,
+    ) -> impl ExactSizeIterator<Item = BasicBlockId> + '_ {
         self.data
             .get(&basic_block_id)
             .expect("ICE: Attempted to iterate predecessors of block not found within cfg.")
             .predecessors
             .iter()
+            .copied()
     }
 
-    /// Get an iterator over the CFG successors to `block`.
-    pub(crate) fn succ_iter(&self, basic_block_id: BasicBlockId) -> SuccIter {
+    /// Get an iterator over the CFG successors to `basic_block_id`.
+    pub(crate) fn succ_iter(
+        &self,
+        basic_block_id: BasicBlockId,
+    ) -> impl ExactSizeIterator<Item = BasicBlockId> + '_ {
         self.data
             .get(&basic_block_id)
             .expect("ICE: Attempted to iterate successors of block not found within cfg.")
             .successors
             .iter()
+            .copied()
     }
 }
 
-/// An iterator over block predecessors. The iterator type is `BasicBlockId`.
-pub(crate) type PredIter<'a> = hash_set::Iter<'a, BasicBlockId>;
+#[cfg(test)]
+mod tests {
+    use crate::ssa_refactor::ir::{instruction::TerminatorInstruction, types::Type};
 
-/// An iterator over block successors. The iterator type is `BasicBlockId`.
-pub(crate) type SuccIter<'a> = hash_set::Iter<'a, BasicBlockId>;
+    use super::{super::function::Function, ControlFlowGraph};
+
+    #[test]
+    fn empty() {
+        let mut func = Function::new();
+        let block_id = func.entry_block();
+        func.dfg[block_id].set_terminator(TerminatorInstruction::Return { return_values: vec![] });
+
+        ControlFlowGraph::with_function(&func);
+    }
+
+    #[test]
+    fn jumps() {
+        let mut func = Function::new();
+        let block0_id = func.entry_block();
+        let cond = func.dfg.add_block_parameter(block0_id, Type::unsigned(1));
+        let block1_id = func.dfg.new_block();
+        let block2_id = func.dfg.new_block();
+
+        func.dfg[block0_id].set_terminator(TerminatorInstruction::JmpIf {
+            condition: cond,
+            then_destination: block2_id,
+            else_destination: block1_id,
+            arguments: vec![],
+        });
+        func.dfg[block1_id].set_terminator(TerminatorInstruction::JmpIf {
+            condition: cond,
+            then_destination: block1_id,
+            else_destination: block2_id,
+            arguments: vec![],
+        });
+        func.dfg[block2_id].set_terminator(TerminatorInstruction::Return { return_values: vec![] });
+
+        let mut cfg = ControlFlowGraph::with_function(&func);
+
+        {
+            let block0_predecessors = cfg.pred_iter(block0_id).collect::<Vec<_>>();
+            let block1_predecessors = cfg.pred_iter(block1_id).collect::<Vec<_>>();
+            let block2_predecessors = cfg.pred_iter(block2_id).collect::<Vec<_>>();
+
+            let block0_successors = cfg.succ_iter(block0_id).collect::<Vec<_>>();
+            let block1_successors = cfg.succ_iter(block1_id).collect::<Vec<_>>();
+            let block2_successors = cfg.succ_iter(block2_id).collect::<Vec<_>>();
+
+            assert_eq!(block0_predecessors.len(), 0);
+            assert_eq!(block1_predecessors.len(), 2);
+            assert_eq!(block2_predecessors.len(), 2);
+
+            assert_eq!(block1_predecessors.contains(&block0_id), true);
+            assert_eq!(block1_predecessors.contains(&block1_id), true);
+            assert_eq!(block2_predecessors.contains(&block0_id), true);
+            assert_eq!(block2_predecessors.contains(&block1_id), true);
+
+            assert_eq!(block0_successors.len(), 2);
+            assert_eq!(block1_successors.len(), 2);
+            assert_eq!(block2_successors.len(), 0);
+
+            assert_eq!(block0_successors.contains(&block1_id), true);
+            assert_eq!(block0_successors.contains(&block2_id), true);
+            assert_eq!(block1_successors.contains(&block1_id), true);
+            assert_eq!(block1_successors.contains(&block2_id), true);
+            assert_eq!(block2_successors, []);
+        }
+
+        // Add a new return block replacing the return in block2
+        let ret_block_id = func.dfg.new_block();
+        func.dfg[ret_block_id]
+            .set_terminator(TerminatorInstruction::Return { return_values: vec![] });
+        func.dfg[block2_id].set_terminator(TerminatorInstruction::Jmp {
+            destination: ret_block_id,
+            arguments: vec![],
+        });
+
+        // Change some instructions and recompute block0, block2 and ret_block
+
+        func.dfg[block0_id].set_terminator(TerminatorInstruction::JmpIf {
+            condition: cond,
+            then_destination: block1_id,
+            else_destination: ret_block_id,
+            arguments: vec![],
+        });
+        cfg.recompute_block(&mut func, block0_id);
+        cfg.recompute_block(&mut func, block2_id);
+        cfg.recompute_block(&mut func, ret_block_id);
+
+        {
+            let block0_predecessors = cfg.pred_iter(block0_id).collect::<Vec<_>>();
+            let block1_predecessors = cfg.pred_iter(block1_id).collect::<Vec<_>>();
+            let block2_predecessors = cfg.pred_iter(block2_id).collect::<Vec<_>>();
+
+            let block0_successors = cfg.succ_iter(block0_id).collect::<Vec<_>>();
+            let block1_successors = cfg.succ_iter(block1_id).collect::<Vec<_>>();
+            let block2_successors = cfg.succ_iter(block2_id).collect::<Vec<_>>();
+
+            assert_eq!(block0_predecessors.len(), 0);
+            assert_eq!(block1_predecessors.len(), 2);
+            assert_eq!(block2_predecessors.len(), 1);
+
+            assert_eq!(block1_predecessors.contains(&block0_id), true);
+            assert_eq!(block1_predecessors.contains(&block1_id), true);
+            assert_eq!(block2_predecessors.contains(&block0_id), false);
+            assert_eq!(block2_predecessors.contains(&block1_id), true);
+
+            assert_eq!(block0_successors.len(), 2);
+            assert_eq!(block1_successors.len(), 2);
+            assert_eq!(block2_successors.len(), 1);
+
+            assert_eq!(block0_successors.contains(&block1_id), true);
+            assert_eq!(block0_successors.contains(&ret_block_id), true);
+            assert_eq!(block1_successors.contains(&block1_id), true);
+            assert_eq!(block1_successors.contains(&block2_id), true);
+            assert_eq!(block2_successors.contains(&ret_block_id), true);
+        }
+    }
+}

crates/noirc_evaluator/src/ssa_refactor/ir/dfg.rs

@@ -1,3 +1,5 @@
+use std::ops::{Index, IndexMut};
+
 use super::{
     basic_block::{BasicBlock, BasicBlockId},
     function::Signature,
@@ -86,6 +88,16 @@ impl DataFlowGraph {
         })
     }
 
+    /// Get an iterator over references to each basic block within the dfg, paired with the basic
+    /// block's id.
+    ///
+    /// The pairs are order by id, which is not guaranteed to be meaningful.
+    pub(crate) fn basic_blocks_iter(
+        &self,
+    ) -> impl ExactSizeIterator<Item = (BasicBlockId, &BasicBlock)> {
+        self.blocks.iter()
+    }
+
     pub(crate) fn block_parameters(&self, block: BasicBlockId) -> &[ValueId] {
         self.blocks[block].parameters()
     }
@@ -183,6 +195,21 @@ impl DataFlowGraph {
     }
 }
 
+impl Index<BasicBlockId> for DataFlowGraph {
+    type Output = BasicBlock;
+    /// Get a reference to a function's basic block for the given id.
+    fn index(&self, id: BasicBlockId) -> &BasicBlock {
+        &self.blocks[id]
+    }
+}
+
+impl IndexMut<BasicBlockId> for DataFlowGraph {
+    /// Get a mutable reference to a function's basic block for the given id.
+    fn index_mut(&mut self, id: BasicBlockId) -> &mut BasicBlock {
+        &mut self.blocks[id]
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::DataFlowGraph;

crates/noirc_evaluator/src/ssa_refactor/ir/function.rs

@@ -1,6 +1,4 @@
-use std::ops::Index;
-
-use super::basic_block::{BasicBlock, BasicBlockId};
+use super::basic_block::BasicBlockId;
 use super::dfg::DataFlowGraph;
 use super::instruction::Instruction;
 use super::map::{Id, SecondaryMap};
@@ -40,26 +38,6 @@ impl Function {
     }
 }
 
-impl Function {
-    /// Get an iterator over references to each basic block within the function, paired with the
-    /// basic block's id.
-    ///
-    /// The pairs are order by id, which is not guaranteed to be meaningful.
-    pub(crate) fn basic_blocks_iter(
-        &self,
-    ) -> impl ExactSizeIterator<Item = (BasicBlockId, &BasicBlock)> {
-        self.basic_blocks.iter()
-    }
-}
-
-impl Index<BasicBlockId> for Function {
-    type Output = BasicBlock;
-    /// Get a function's basic block for the given id.
-    fn index(&self, id: BasicBlockId) -> &BasicBlock {
-        &self.basic_blocks[id]
-    }
-}
-
 /// FunctionId is a reference for a function
 pub(crate) type FunctionId = Id<Function>;