added potential infrastructure for dfg_passes

Author: EthanBerko32

Cargo.lock

@@ -5,3 +5,5 @@ edition.workspace = true
 
 [dependencies]
 calyx-libm-dfg.workspace = true
+cranelift-entity.workspace = true
+malachite.workspace = true

crates/dfg_passes/Cargo.toml

@@ -0,0 +1,81 @@
+use calyx_libm_dfg as dfg;
+use cranelift_entity::PrimaryMap;
+use dfg::*;
+use std::ops::{Index, IndexMut};
+/*
+#[derive(Copy, Clone, PartialEq, PartialOrd, Eq)]
+pub struct BuilderEdgeId(u32);
+entity_impl!(BuilderEdgeId, "be");
+*/
+
+pub struct DfgBuilder {
+    nodes: PrimaryMap<NodeId, Node>,
+    edges: PrimaryMap<EdgeId, Edge>,
+}
+
+impl DfgBuilder {
+    pub fn new() -> Self {
+        Self {
+            nodes: PrimaryMap::new(),
+            edges: PrimaryMap::new(),
+        }
+    }
+
+    pub fn finish(self) -> Dfg {
+        let mut dfg: Dfg = Dfg::with_nodes(self.nodes);
+
+        for edge in self.edges.values() {
+            let n_out = edge.output;
+            let n_in = edge.input;
+            dfg.add_edge(Edge {
+                input: n_in,
+                output: n_out,
+                props: edge.props.clone(),
+                edge_type: edge.edge_type.clone(),
+            });
+        }
+
+        dfg
+    }
+
+    pub fn add_node(&mut self, node: Node) -> NodeId {
+        self.nodes.push(node)
+    }
+
+    pub fn connect_nodes(
+        &mut self,
+        input: NodeId,
+        output: NodeId,
+        props: Vec<String>,
+        edge_type: Type,
+    ) -> EdgeId {
+        self.edges.push(Edge {
+            input,
+            output,
+            props,
+            edge_type,
+        })
+    }
+}
+
+macro_rules! dfg_index_impl {
+    ($field:ident, $idx:ty, $out:ty) => {
+        impl Index<$idx> for DfgBuilder {
+            type Output = $out;
+
+            #[inline]
+            fn index(&self, index: $idx) -> &Self::Output {
+                &self.$field[index]
+            }
+        }
+
+        impl IndexMut<$idx> for DfgBuilder {
+            #[inline]
+            fn index_mut(&mut self, index: $idx) -> &mut Self::Output {
+                &mut self.$field[index]
+            }
+        }
+    };
+}
+
+dfg_index_impl!(nodes, NodeId, Node);

crates/dfg_passes/src/builder.rs

@@ -1,7 +1,7 @@
 use calyx_libm_dfg as dfg;
 use dfg::*;
 
-pub fn pass(dfg: &mut Dfg) -> Result<(), &'static str>{
+pub fn pass(dfg: &mut Dfg) -> Result<(), &'static str> {
     for node in dfg.node_iter() {
         let kind = node.node_type.clone();
         match kind {
@@ -15,5 +15,8 @@ pub fn pass(dfg: &mut Dfg) -> Result<(), &'static str>{
 }
 
 fn parse_operator(op: ArithOp) {
-
+    match op {
+        ArithOp::Sin => {}
+        _ => return,
+    }
 }

crates/dfg_passes/src/dfg_passes.rs

@@ -1 +1,7 @@
+mod builder;
 mod dfg_passes;
+mod ops;
+
+pub use builder::*;
+pub use dfg_passes::*;
+pub use ops::*;

crates/dfg_passes/src/lib.rs

@@ -0,0 +1,2 @@
+pub mod operator;
+pub mod table;

crates/dfg_passes/src/ops/mod.rs

@@ -0,0 +1,6 @@
+use calyx_libm_dfg as dfg;
+use dfg::*;
+
+pub trait OpBuilder {
+    fn build(&self) -> Dfg;
+}

crates/dfg_passes/src/ops/operator.rs

@@ -0,0 +1,16 @@
+use super::operator::OpBuilder;
+use calyx_libm_dfg as dfg;
+use dfg::*;
+use malachite::Rational;
+
+pub struct Lut {
+    pub left: Rational,
+    pub right: Rational,
+    pub size: u32,
+}
+
+impl OpBuilder for Lut {
+    fn build(&self) -> Dfg {
+        Dfg::new()
+    }
+}