wip on old! replacing (#323)

* wip on old! replacing

* feat: simplification

* cleanup

* cleanup

* cleanup

Author: andrii-a8c

crates/move-stackless-bytecode/src/lib.rs

@@ -50,6 +50,7 @@ pub mod packed_types_analysis;
 pub mod pipeline_factory;
 pub mod quantifier_iterator_analysis;
 pub mod reaching_def_analysis;
+pub mod replacement_analysis;
 pub mod spec_global_variable_analysis;
 pub mod spec_instrumentation;
 pub mod spec_purity_analysis;

crates/move-stackless-bytecode/src/pipeline_factory.rs

@@ -6,14 +6,11 @@ use crate::{
     borrow_analysis::BorrowAnalysisProcessor,
     clean_and_optimize::CleanAndOptimizeProcessor,
     conditional_merge_insertion::ConditionalMergeInsertionProcessor,
-    // data_invariant_instrumentation::DataInvariantInstrumentationProcessor,
     debug_instrumentation::DebugInstrumenter,
     deterministic_analysis::DeterministicAnalysisProcessor,
     dynamic_field_analysis::DynamicFieldAnalysisProcessor,
     eliminate_imm_refs::EliminateImmRefsProcessor,
     function_target_pipeline::{FunctionTargetPipeline, FunctionTargetProcessor},
-    // global_invariant_analysis::GlobalInvariantAnalysisProcessor,
-    // global_invariant_instrumentation::GlobalInvariantInstrumentationProcessor,
     inconsistency_check::InconsistencyCheckInstrumenter,
     livevar_analysis::LiveVarAnalysisProcessor,
     loop_analysis::LoopAnalysisProcessor,
@@ -27,6 +24,7 @@ use crate::{
     options::ProverOptions,
     quantifier_iterator_analysis::QuantifierIteratorAnalysisProcessor,
     reaching_def_analysis::ReachingDefProcessor,
+    replacement_analysis::ReplacementAnalysisProcessor,
     spec_global_variable_analysis::SpecGlobalVariableAnalysisProcessor,
     spec_instrumentation::SpecInstrumentationProcessor,
     spec_purity_analysis::SpecPurityAnalysis,
@@ -71,6 +69,7 @@ pub fn default_pipeline_with_options(options: &ProverOptions) -> FunctionTargetP
         TypeInvariantAnalysisProcessor::new(),
         SpecWellFormedAnalysisProcessor::new(),
         QuantifierIteratorAnalysisProcessor::new(),
+        ReplacementAnalysisProcessor::new(),
     ]);
 
     if !options.skip_loop_analysis {

crates/move-stackless-bytecode/src/replacement_analysis.rs

@@ -0,0 +1,113 @@
+use std::collections::BTreeMap;
+
+use move_model::model::{FunId, FunctionEnv, QualifiedId};
+
+use crate::{
+    function_data_builder::FunctionDataBuilder,
+    function_target::FunctionData,
+    function_target_pipeline::{FunctionTargetProcessor, FunctionTargetsHolder},
+    stackless_bytecode::{AssignKind, Bytecode, Operation},
+};
+
+pub struct ReplacementAnalysisProcessor();
+
+impl ReplacementAnalysisProcessor {
+    pub fn new() -> Box<Self> {
+        Box::new(Self())
+    }
+
+    fn is_fn(code: &Bytecode, qid: QualifiedId<FunId>) -> Option<(&Vec<usize>, &Vec<usize>)> {
+        match code {
+            Bytecode::Call(_, dest, Operation::Function(mid, fid, _), srcs, _) => {
+                if qid == mid.qualified(*fid) {
+                    return Some((dest, srcs));
+                }
+            }
+            _ => {}
+        }
+
+        None
+    }
+
+    pub fn find_ref_val_patterns(
+        &self,
+        func_env: &FunctionEnv,
+        data: &FunctionData,
+    ) -> BTreeMap<usize, (Vec<usize>, Vec<usize>)> {
+        if data.code.len() < 2 {
+            return BTreeMap::new();
+        }
+
+        let mut matches = BTreeMap::new();
+        for i in 0..data.code.len() - 1 {
+            if let Some((dest_val, srcs_val)) =
+                Self::is_fn(&data.code[i], func_env.module_env.env.prover_val_qid())
+            {
+                if let Some((dest_ref, srcs_ref)) =
+                    Self::is_fn(&data.code[i + 1], func_env.module_env.env.prover_ref_qid())
+                {
+                    if dest_val == srcs_ref {
+                        matches.insert(i, (dest_ref.clone(), srcs_val.clone()));
+                    }
+                }
+            }
+        }
+
+        matches
+    }
+
+    pub fn replace_patterns(
+        &self,
+        patterns: BTreeMap<usize, (Vec<usize>, Vec<usize>)>,
+        func_env: &FunctionEnv,
+        data: FunctionData,
+    ) -> FunctionData {
+        if patterns.is_empty() {
+            return data;
+        }
+
+        let mut new_data = data.clone();
+        new_data.code = vec![]; // NOTE: for some reason it doesnt work properly without copy + erase
+
+        let mut builder = FunctionDataBuilder::new(func_env, new_data);
+        for (offset, bc) in data.code.into_iter().enumerate() {
+            if patterns.contains_key(&offset) {
+                continue;
+            } else if offset > 0 && patterns.contains_key(&(offset - 1)) {
+                // NOTE: we replace call only with an Assign because it automatically dereferences var
+                let (dest, srcs) = patterns.get(&(offset - 1)).unwrap();
+                builder.emit(Bytecode::Assign(
+                    bc.get_attr_id(),
+                    dest[0],
+                    srcs[0],
+                    AssignKind::Copy,
+                ));
+            } else {
+                builder.emit(bc);
+            }
+        }
+
+        builder.data
+    }
+}
+
+impl FunctionTargetProcessor for ReplacementAnalysisProcessor {
+    fn process(
+        &self,
+        targets: &mut FunctionTargetsHolder,
+        func_env: &FunctionEnv,
+        data: FunctionData,
+        _scc_opt: Option<&[FunctionEnv]>,
+    ) -> FunctionData {
+        if func_env.is_native() {
+            return data;
+        }
+
+        let patterns = self.find_ref_val_patterns(func_env, &data);
+        self.replace_patterns(patterns, func_env, data)
+    }
+
+    fn name(&self) -> String {
+        "replacement_analysis".to_string()
+    }
+}