cleanup

rust2/src/lib.rs

@@ -26,9 +26,12 @@ pub struct Args {
     pub profile: bool,
     #[clap(long)]
     pub dump: Option<DumpKind>,
+    #[clap(long)]
+    pub mir: bool,
     pub file: PathBuf,
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum DumpKind {
     Ast,
     Hir,
@@ -83,10 +86,12 @@ where
     drop(parsed);
     drop(ast_alloc);
 
-    if let Some(DumpKind::Mir) = config.dump {
+    if config.dump == Some(DumpKind::Mir) || config.mir {
         let mir_alloc = Bump::new();
         let mir = mir::optimized_mir(&mir_alloc, &optimized_hir);
-        //println!("{mir:#?}");
+        if config.dump == Some(DumpKind::Mir) {
+            println!("{mir:#?}");
+        }
     }
 
     let cg_alloc = Bump::new();

rust2/src/mir/opts.rs

@@ -27,14 +27,25 @@ fn pass_get_state_info_inner<'mir>(
 ) {
     for stmt in &mut mir.stmts {
         let state = match &mut stmt.kind {
-            StmtKind::AddSub(offset, _, store) => MemoryState::single(
-                alloc,
-                outer,
-                MemoryStateChange::Change {
-                    offset: *offset,
-                    new_state: CellState::WrittenToUnknown(store.clone()),
-                },
-            ),
+            StmtKind::AddSub(offset, n, store) => {
+                let prev_state = outer.state_for_offset(*offset);
+                let new_state = match prev_state {
+                    CellState::WrittenToKnown(_, prev_n) => {
+                        let n = i16::from(prev_n).wrapping_add(*n);
+                        let n = u8::try_from(n).unwrap();
+                        CellState::WrittenToKnown(store.clone(), n)
+                    }
+                    _ => CellState::WrittenToUnknown(store.clone()),
+                };
+                MemoryState::single(
+                    alloc,
+                    outer,
+                    MemoryStateChange::Change {
+                        offset: *offset,
+                        new_state,
+                    },
+                )
+            }
             StmtKind::MoveAddTo {
                 offset,
                 store_set_null,

rust2/src/mir/state.rs

@@ -1,5 +1,7 @@
+// todo: we're gonna leak `Rc`s here aren't we?
+
 use std::{
-    cell::RefCell,
+    cell::{Cell, RefCell},
     fmt::{Debug, Formatter},
     rc::Rc,
 };
@@ -32,10 +34,36 @@ pub struct MemoryState<'mir>(Rc<RefCell<MemoryStateInner<'mir>>>);
 
 impl<'mir> MemoryState<'mir> {
     pub fn empty(alloc: &'mir Bump) -> Self {
-        Self(Rc::new(RefCell::new(MemoryStateInner {
-            prev: None,
-            deltas: Vec::new_in(alloc),
-        })))
+        Self::new(None, Vec::new_in(alloc))
+    }
+
+    pub fn single(
+        alloc: &'mir Bump,
+        prev: MemoryState<'mir>,
+        delta: MemoryStateChange,
+    ) -> MemoryState<'mir> {
+        let mut deltas = Vec::new_in(alloc);
+        deltas.push(delta);
+        Self::new(Some(prev), deltas)
+    }
+
+    pub fn double(
+        alloc: &'mir Bump,
+        prev: MemoryState<'mir>,
+        delta1: MemoryStateChange,
+        delta2: MemoryStateChange,
+    ) -> MemoryState<'mir> {
+        let mut deltas = Vec::new_in(alloc);
+        deltas.push(delta1);
+        deltas.push(delta2);
+        Self::new(Some(prev), deltas)
+    }
+
+    pub fn new(
+        prev: Option<MemoryState<'mir>>,
+        deltas: BumpVec<'mir, MemoryStateChange>,
+    ) -> MemoryState<'mir> {
+        Self(Rc::new(RefCell::new(MemoryStateInner { prev, deltas })))
     }
 
     pub fn state_for_offset(&self, offset: i32) -> CellState {
@@ -82,42 +110,8 @@ impl<'mir> MemoryStateInner<'mir> {
     }
 }
 
-impl<'mir> MemoryState<'mir> {
-    pub fn single(
-        alloc: &'mir Bump,
-        prev: MemoryState<'mir>,
-        delta: MemoryStateChange,
-    ) -> MemoryState<'mir> {
-        let mut deltas = Vec::new_in(alloc);
-        deltas.push(delta);
-        Self::new(prev, deltas)
-    }
-
-    pub fn double(
-        alloc: &'mir Bump,
-        prev: MemoryState<'mir>,
-        delta1: MemoryStateChange,
-        delta2: MemoryStateChange,
-    ) -> MemoryState<'mir> {
-        let mut deltas = Vec::new_in(alloc);
-        deltas.push(delta1);
-        deltas.push(delta2);
-        Self::new(prev, deltas)
-    }
-
-    pub fn new(
-        prev: MemoryState<'mir>,
-        deltas: BumpVec<'mir, MemoryStateChange>,
-    ) -> MemoryState<'mir> {
-        Self(Rc::new(RefCell::new(MemoryStateInner {
-            prev: Some(prev),
-            deltas,
-        })))
-    }
-}
-
 #[derive(Clone)]
-pub struct Store(Rc<RefCell<StoreInner>>);
+pub struct Store(Rc<Cell<StoreInner>>);
 
 impl Store {
     pub fn unknown() -> Self {
@@ -127,14 +121,11 @@ impl Store {
 
 impl Debug for Store {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        self.0
-            .try_borrow()
-            .map(|s| StoreInner::fmt(&*s, f))
-            .unwrap_or_else(|_| f.debug_struct("Store").finish_non_exhaustive())
+        self.0.get().fmt(f)
     }
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Copy)]
 pub enum StoreInner {
     Unknown,
     Used(usize),
@@ -143,6 +134,6 @@ pub enum StoreInner {
 
 impl From<StoreInner> for Store {
     fn from(inner: StoreInner) -> Self {
-        Self(Rc::new(RefCell::new(inner)))
+        Self(Rc::new(Cell::new(inner)))
     }
 }