feat: Refactor analysis traits to reduce copies (#146)

* Initial too-complicated refactor

* small clippy fixes

* streamlined

* reorg checkpoint

* More refactoring

Author: toolCHAINZ

jingle/examples/location.rs

@@ -2,7 +2,7 @@
 
 use jingle::analysis::Analysis;
 use jingle::analysis::cpa::RunnableConfigurableProgramAnalysis;
-use jingle::analysis::cpa::reducer::CfgReducer;
+use jingle::analysis::cpa::residue::CFG;
 use jingle::analysis::cpa::residue::Residue;
 use jingle::analysis::cpa::state::LocationState;
 use jingle::analysis::location::{BasicLocationAnalysis, CallBehavior};

jingle/examples/stack_offset.rs

@@ -2,12 +2,13 @@
 
 use jingle::analysis::Analysis;
 use jingle::analysis::cpa::lattice::pcode::PcodeAddressLattice;
-use jingle::analysis::cpa::reducer::CfgReducer;
+use jingle::analysis::cpa::residue::CFG;
 use jingle::analysis::cpa::residue::Residue;
 use jingle::analysis::cpa::state::LocationState;
 use jingle::analysis::cpa::{FinalReducer, RunnableConfigurableProgramAnalysis};
 use jingle::analysis::location::{BasicLocationAnalysis, CallBehavior};
 use jingle::analysis::pcode_store::PcodeStore;
+use jingle::analysis::pcode_store::{self, PcodeOpRef};
 use jingle::analysis::valuation::{
     MergeBehavior, SimpleValuation, SimpleValuationAnalysis, SimpleValuationState,
 };
@@ -58,9 +59,8 @@ fn main() {
     let valuation_analysis =
         SimpleValuationAnalysis::new(loaded.arch_info().clone(), MergeBehavior::Or);
 
-    // The tuple implements Analysis via the compound machinery; wrap it with the CfgReducer
-    let mut compound_with_cfg =
-        (location_analysis, valuation_analysis).with_residue(CfgReducer::new());
+    // The tuple implements Analysis via the compound machinery; wrap it with the CfgReducer (factory)
+    let mut compound_with_cfg = (location_analysis, valuation_analysis).with_residue(CFG);
 
     tracing::info!("Starting analysis run at address 0x{:x}", FUNC_NESTED);
 
@@ -133,7 +133,7 @@ fn main() {
 
                 let op_str = cfg
                     .get_op_at(node)
-                    .map(|o: &jingle_sleigh::PcodeOperation| format!("{}", o))
+                    .map(|o: &PcodeOpRef<'_>| format!("{}", o.as_ref()))
                     .unwrap_or_else(|| "no-op".to_string());
 
                 println!("  {} -> {}: {}", origin_str, succ_str, op_str);

jingle/examples/stack_offset_smt.rs

@@ -2,12 +2,13 @@
 
 use jingle::analysis::Analysis;
 use jingle::analysis::cpa::lattice::pcode::PcodeAddressLattice;
-use jingle::analysis::cpa::reducer::CfgReducer;
+use jingle::analysis::cpa::residue::CFG;
 use jingle::analysis::cpa::residue::Residue;
 use jingle::analysis::cpa::state::LocationState;
 use jingle::analysis::cpa::{FinalReducer, RunnableConfigurableProgramAnalysis};
 use jingle::analysis::location::{BasicLocationAnalysis, CallBehavior};
 use jingle::analysis::pcode_store::PcodeStore;
+use jingle::analysis::pcode_store::{self, PcodeOpRef};
 use jingle::analysis::valuation::{MergeBehavior, SmtVal, SmtValuationAnalysis, SmtValuationState};
 use jingle::display::JingleDisplayable;
 use jingle::modeling::machine::cpu::concrete::ConcretePcodeAddress;
@@ -57,8 +58,7 @@ fn main() {
         SmtValuationAnalysis::new(loaded.arch_info().clone(), MergeBehavior::Or);
 
     // The tuple implements Analysis via the compound machinery; wrap it with the CfgReducer
-    let mut compound_with_cfg =
-        (location_analysis, valuation_analysis).with_residue(CfgReducer::new());
+    let mut compound_with_cfg = (location_analysis, valuation_analysis).with_residue(CFG);
 
     tracing::info!("Starting analysis run at address 0x{:x}", FUNC_NESTED);
 
@@ -131,7 +131,7 @@ fn main() {
 
                 let op_str = cfg
                     .get_op_at(node)
-                    .map(|o: &jingle_sleigh::PcodeOperation| format!("{}", o))
+                    .map(|o: &PcodeOpRef<'_>| format!("{}", o.as_ref()))
                     .unwrap_or_else(|| "no-op".to_string());
 
                 println!("  {} -> {}: {}", origin_str, succ_str, op_str);

jingle/examples/unwind.rs

@@ -1,7 +1,7 @@
 #![allow(unused)]
 
 use jingle::analysis::cpa::RunnableConfigurableProgramAnalysis;
-use jingle::analysis::cpa::reducer::CfgReducer;
+use jingle::analysis::cpa::residue::CFG;
 use jingle::analysis::cpa::residue::Residue;
 use jingle::analysis::cpa::state::LocationState;
 use jingle::analysis::location::{CallBehavior, UnwindingAnalysis};
@@ -46,8 +46,8 @@ fn main() {
         UnwindingAnalysis::new(2),
     );
 
-    // Wrap with CfgReducer
-    let mut analysis_with_cfg = location_analysis.with_residue(CfgReducer::new());
+    // Wrap with CfgReducer (pass the factory ZST)
+    let mut analysis_with_cfg = location_analysis.with_residue(CFG);
 
     // Run the unwinding analysis
     let cfg = analysis_with_cfg.run(&loaded, ConcretePcodeAddress::from(FUNC_NESTED));

jingle/src/analysis/cfg/mod.rs

@@ -29,7 +29,7 @@ impl LowerHex for EmptyEdge {
 }
 
 #[derive(Debug)]
-pub struct PcodeCfg<N: CfgState = ConcretePcodeAddress, D = PcodeOperation> {
+pub struct PcodeCfg<N, D> {
     pub(crate) graph: StableDiGraph<N, EmptyEdge>,
     // Key pcode ops by concrete p-code address so lookups by address are efficient.
     // For CFG states `N` that can produce a `ConcretePcodeAddress` via `location()`,

jingle/src/analysis/cfg/model.rs

@@ -1,6 +1,7 @@
 use crate::JingleError;
 // use crate::analysis::compound::CompoundState;
 use crate::analysis::cpa::lattice::flat::FlatLattice;
+use crate::analysis::pcode_store::PcodeOpRef;
 use crate::modeling::machine::MachineState;
 use crate::modeling::machine::cpu::concrete::ConcretePcodeAddress;
 use jingle_sleigh::{PcodeOperation, SleighArchInfo};
@@ -110,6 +111,12 @@ impl<N: CfgStateModel> ModelTransition<N> for PcodeOperation {
     }
 }
 
+impl<'a, N: CfgStateModel> ModelTransition<N> for PcodeOpRef<'a> {
+    fn transition(&self, init: &N) -> Result<N, JingleError> {
+        init.apply(self)
+    }
+}
+
 impl<N: CfgStateModel, T: ModelTransition<N>> ModelTransition<N> for Vec<T> {
     fn transition(&self, init: &N) -> Result<N, JingleError> {
         let mut state = init.clone();

jingle/src/analysis/compound/mod.rs

@@ -20,7 +20,7 @@ where
 {
     type State = CompoundState2<A::State, B::State>;
 
-    type Reducer = CompoundReducer2<A, B>;
+    type Reducer<'op> = CompoundReducer2<'op, A, B>;
 }
 
 impl<A: ConfigurableProgramAnalysis, B: ConfigurableProgramAnalysis, T> IntoState<(A, B)> for T
@@ -52,7 +52,7 @@ where
     type State = CompoundState3<A::State, B::State, C::State>;
 
     // 3-ary reducer
-    type Reducer = CompoundReducer3<A, B, C>;
+    type Reducer<'op> = CompoundReducer3<'op, A, B, C>;
 }
 
 impl<
@@ -96,7 +96,7 @@ where
     type State = CompoundState4<A::State, B::State, C::State, D::State>;
 
     // 4-ary reducer
-    type Reducer = CompoundReducer4<A, B, C, D>;
+    type Reducer<'op> = CompoundReducer4<'op, A, B, C, D>;
 }
 
 impl<

jingle/src/analysis/compound/reducer.rs

@@ -4,23 +4,23 @@ use crate::analysis::{
 };
 
 /// Generic 2-ary compound reducer (keeps the old name for backward compatibility).
-pub struct CompoundReducer<A: ConfigurableProgramAnalysis, B: ConfigurableProgramAnalysis> {
-    a: A::Reducer,
-    b: B::Reducer,
+pub struct CompoundReducer<'op, A: ConfigurableProgramAnalysis, B: ConfigurableProgramAnalysis> {
+    a: A::Reducer<'op>,
+    b: B::Reducer<'op>,
 }
 
-impl<A: ConfigurableProgramAnalysis, B: ConfigurableProgramAnalysis>
-    Residue<CompoundState2<A::State, B::State>> for CompoundReducer<A, B>
+impl<'op, A: ConfigurableProgramAnalysis, B: ConfigurableProgramAnalysis>
+    Residue<'op, CompoundState2<A::State, B::State>> for CompoundReducer<'op, A, B>
 {
     type Output = (
-        <A::Reducer as Residue<A::State>>::Output,
-        <B::Reducer as Residue<B::State>>::Output,
+        <A::Reducer<'op> as Residue<'op, A::State>>::Output,
+        <B::Reducer<'op> as Residue<'op, B::State>>::Output,
     );
 
     fn new() -> Self {
         Self {
-            a: A::Reducer::new(),
-            b: B::Reducer::new(),
+            a: <A::Reducer<'op> as Residue<'op, A::State>>::new(),
+            b: <B::Reducer<'op> as Residue<'op, B::State>>::new(),
         }
     }
 
@@ -34,7 +34,7 @@ impl<A: ConfigurableProgramAnalysis, B: ConfigurableProgramAnalysis>
         curr_state: &CompoundState2<A::State, B::State>,
         dest_state: &CompoundState2<A::State, B::State>,
         merged_state: &CompoundState2<A::State, B::State>,
-        op: &Option<crate::analysis::pcode_store::PcodeOpRef<'_>>,
+        op: &Option<crate::analysis::pcode_store::PcodeOpRef<'op>>,
     ) {
         self.a
             .merged_state(&curr_state.s1, &dest_state.s1, &merged_state.s1, op);
@@ -46,31 +46,31 @@ impl<A: ConfigurableProgramAnalysis, B: ConfigurableProgramAnalysis>
         &mut self,
         state: &CompoundState2<A::State, B::State>,
         dest_state: &CompoundState2<A::State, B::State>,
-        op: &Option<crate::analysis::pcode_store::PcodeOpRef<'_>>,
+        op: &Option<crate::analysis::pcode_store::PcodeOpRef<'op>>,
     ) {
         self.a.new_state(&state.s1, &dest_state.s1, op);
         self.b.new_state(&state.s2, &dest_state.s2, op);
     }
 }
 
 /// Explicitly named 2-ary reducer.
-pub struct CompoundReducer2<A: ConfigurableProgramAnalysis, B: ConfigurableProgramAnalysis> {
-    a: A::Reducer,
-    b: B::Reducer,
+pub struct CompoundReducer2<'op, A: ConfigurableProgramAnalysis, B: ConfigurableProgramAnalysis> {
+    a: A::Reducer<'op>,
+    b: B::Reducer<'op>,
 }
 
-impl<A: ConfigurableProgramAnalysis, B: ConfigurableProgramAnalysis>
-    Residue<CompoundState2<A::State, B::State>> for CompoundReducer2<A, B>
+impl<'op, A: ConfigurableProgramAnalysis, B: ConfigurableProgramAnalysis>
+    Residue<'op, CompoundState2<A::State, B::State>> for CompoundReducer2<'op, A, B>
 {
     type Output = (
-        <A::Reducer as Residue<A::State>>::Output,
-        <B::Reducer as Residue<B::State>>::Output,
+        <A::Reducer<'op> as Residue<'op, A::State>>::Output,
+        <B::Reducer<'op> as Residue<'op, B::State>>::Output,
     );
 
     fn new() -> Self {
         Self {
-            a: A::Reducer::new(),
-            b: B::Reducer::new(),
+            a: <A::Reducer<'op> as Residue<'op, A::State>>::new(),
+            b: <B::Reducer<'op> as Residue<'op, B::State>>::new(),
         }
     }
 
@@ -84,7 +84,7 @@ impl<A: ConfigurableProgramAnalysis, B: ConfigurableProgramAnalysis>
         curr_state: &CompoundState2<A::State, B::State>,
         dest_state: &CompoundState2<A::State, B::State>,
         merged_state: &CompoundState2<A::State, B::State>,
-        op: &Option<crate::analysis::pcode_store::PcodeOpRef<'_>>,
+        op: &Option<crate::analysis::pcode_store::PcodeOpRef<'op>>,
     ) {
         self.a
             .merged_state(&curr_state.s1, &dest_state.s1, &merged_state.s1, op);
@@ -96,7 +96,7 @@ impl<A: ConfigurableProgramAnalysis, B: ConfigurableProgramAnalysis>
         &mut self,
         state: &CompoundState2<A::State, B::State>,
         dest_state: &CompoundState2<A::State, B::State>,
-        op: &Option<crate::analysis::pcode_store::PcodeOpRef<'_>>,
+        op: &Option<crate::analysis::pcode_store::PcodeOpRef<'op>>,
     ) {
         self.a.new_state(&state.s1, &dest_state.s1, op);
         self.b.new_state(&state.s2, &dest_state.s2, op);
@@ -105,29 +105,34 @@ impl<A: ConfigurableProgramAnalysis, B: ConfigurableProgramAnalysis>
 
 /// 3-ary compound reducer.
 pub struct CompoundReducer3<
+    'op,
     A: ConfigurableProgramAnalysis,
     B: ConfigurableProgramAnalysis,
     C: ConfigurableProgramAnalysis,
 > {
-    a: A::Reducer,
-    b: B::Reducer,
-    c: C::Reducer,
+    a: A::Reducer<'op>,
+    b: B::Reducer<'op>,
+    c: C::Reducer<'op>,
 }
 
-impl<A: ConfigurableProgramAnalysis, B: ConfigurableProgramAnalysis, C: ConfigurableProgramAnalysis>
-    Residue<CompoundState3<A::State, B::State, C::State>> for CompoundReducer3<A, B, C>
+impl<
+    'op,
+    A: ConfigurableProgramAnalysis,
+    B: ConfigurableProgramAnalysis,
+    C: ConfigurableProgramAnalysis,
+> Residue<'op, CompoundState3<A::State, B::State, C::State>> for CompoundReducer3<'op, A, B, C>
 {
     type Output = (
-        <A::Reducer as Residue<A::State>>::Output,
-        <B::Reducer as Residue<B::State>>::Output,
-        <C::Reducer as Residue<C::State>>::Output,
+        <A::Reducer<'op> as Residue<'op, A::State>>::Output,
+        <B::Reducer<'op> as Residue<'op, B::State>>::Output,
+        <C::Reducer<'op> as Residue<'op, C::State>>::Output,
     );
 
     fn new() -> Self {
         Self {
-            a: A::Reducer::new(),
-            b: B::Reducer::new(),
-            c: C::Reducer::new(),
+            a: <A::Reducer<'op> as Residue<'op, A::State>>::new(),
+            b: <B::Reducer<'op> as Residue<'op, B::State>>::new(),
+            c: <C::Reducer<'op> as Residue<'op, C::State>>::new(),
         }
     }
 
@@ -141,7 +146,7 @@ impl<A: ConfigurableProgramAnalysis, B: ConfigurableProgramAnalysis, C: Configur
         curr_state: &CompoundState3<A::State, B::State, C::State>,
         dest_state: &CompoundState3<A::State, B::State, C::State>,
         merged_state: &CompoundState3<A::State, B::State, C::State>,
-        op: &Option<crate::analysis::pcode_store::PcodeOpRef<'_>>,
+        op: &Option<crate::analysis::pcode_store::PcodeOpRef<'op>>,
     ) {
         self.a
             .merged_state(&curr_state.s1, &dest_state.s1, &merged_state.s1, op);
@@ -155,7 +160,7 @@ impl<A: ConfigurableProgramAnalysis, B: ConfigurableProgramAnalysis, C: Configur
         &mut self,
         state: &CompoundState3<A::State, B::State, C::State>,
         dest_state: &CompoundState3<A::State, B::State, C::State>,
-        op: &Option<crate::analysis::pcode_store::PcodeOpRef<'_>>,
+        op: &Option<crate::analysis::pcode_store::PcodeOpRef<'op>>,
     ) {
         self.a.new_state(&state.s1, &dest_state.s1, op);
         self.b.new_state(&state.s2, &dest_state.s2, op);
@@ -165,37 +170,40 @@ impl<A: ConfigurableProgramAnalysis, B: ConfigurableProgramAnalysis, C: Configur
 
 /// 4-ary compound reducer.
 pub struct CompoundReducer4<
+    'op,
     A: ConfigurableProgramAnalysis,
     B: ConfigurableProgramAnalysis,
     C: ConfigurableProgramAnalysis,
     D: ConfigurableProgramAnalysis,
 > {
-    a: A::Reducer,
-    b: B::Reducer,
-    c: C::Reducer,
-    d: D::Reducer,
+    a: A::Reducer<'op>,
+    b: B::Reducer<'op>,
+    c: C::Reducer<'op>,
+    d: D::Reducer<'op>,
 }
 
 impl<
+    'op,
     A: ConfigurableProgramAnalysis,
     B: ConfigurableProgramAnalysis,
     C: ConfigurableProgramAnalysis,
     D: ConfigurableProgramAnalysis,
-> Residue<CompoundState4<A::State, B::State, C::State, D::State>> for CompoundReducer4<A, B, C, D>
+> Residue<'op, CompoundState4<A::State, B::State, C::State, D::State>>
+    for CompoundReducer4<'op, A, B, C, D>
 {
     type Output = (
-        <A::Reducer as Residue<A::State>>::Output,
-        <B::Reducer as Residue<B::State>>::Output,
-        <C::Reducer as Residue<C::State>>::Output,
-        <D::Reducer as Residue<D::State>>::Output,
+        <A::Reducer<'op> as Residue<'op, A::State>>::Output,
+        <B::Reducer<'op> as Residue<'op, B::State>>::Output,
+        <C::Reducer<'op> as Residue<'op, C::State>>::Output,
+        <D::Reducer<'op> as Residue<'op, D::State>>::Output,
     );
 
     fn new() -> Self {
         Self {
-            a: A::Reducer::new(),
-            b: B::Reducer::new(),
-            c: C::Reducer::new(),
-            d: D::Reducer::new(),
+            a: <A::Reducer<'op> as Residue<'op, A::State>>::new(),
+            b: <B::Reducer<'op> as Residue<'op, B::State>>::new(),
+            c: <C::Reducer<'op> as Residue<'op, C::State>>::new(),
+            d: <D::Reducer<'op> as Residue<'op, D::State>>::new(),
         }
     }
 
@@ -209,7 +217,7 @@ impl<
         curr_state: &CompoundState4<A::State, B::State, C::State, D::State>,
         dest_state: &CompoundState4<A::State, B::State, C::State, D::State>,
         merged_state: &CompoundState4<A::State, B::State, C::State, D::State>,
-        op: &Option<crate::analysis::pcode_store::PcodeOpRef<'_>>,
+        op: &Option<crate::analysis::pcode_store::PcodeOpRef<'op>>,
     ) {
         self.a
             .merged_state(&curr_state.s1, &dest_state.s1, &merged_state.s1, op);
@@ -225,7 +233,7 @@ impl<
         &mut self,
         state: &CompoundState4<A::State, B::State, C::State, D::State>,
         dest_state: &CompoundState4<A::State, B::State, C::State, D::State>,
-        op: &Option<crate::analysis::pcode_store::PcodeOpRef<'_>>,
+        op: &Option<crate::analysis::pcode_store::PcodeOpRef<'op>>,
     ) {
         self.a.new_state(&state.s1, &dest_state.s1, op);
         self.b.new_state(&state.s2, &dest_state.s2, op);