Add optimization to remove dead code

utxo/src/filter_expr/compiler/mod.rs

@@ -136,6 +136,13 @@ impl<'a> Compiler<'a> {
         })
     }
 
+    pub fn remove_dead_code(opcodes: Vec<OpCode>) -> Vec<OpCode> {
+        let (new_opcodes, _) = optimizations::remove_dead_code(opcodes);
+        new_opcodes
+    }
+
+    /// Returns a list of Addresses that are labeled in the opcodes list. This function is required
+    /// to resolve any jump in the compiler
     pub fn labels_to_addr(opcodes: &[OpCode]) -> HashMap<Addr, Addr> {
         let mut pos_without_labels = 0;
         opcodes

utxo/src/filter_expr/compiler/optimizations/calculate_static_values.rs

@@ -8,7 +8,6 @@ pub fn calculate_static_values(mut opcodes: Vec<OpCode>) -> (Vec<OpCode>, bool)
     let mut register = HashMap::new();
     let mut has_changed = false;
 
-    println!("Calculating static values");
     opcodes.iter_mut().for_each(|opcode| {
         match &opcode {
             OpCode::LOAD(dst, value) => {

utxo/src/filter_expr/compiler/optimizations/mod.rs

@@ -1,11 +1,13 @@
 mod assign_unique_register_address;
 mod calculate_static_values;
 mod move_load_top;
+mod remove_dead_code;
 mod remove_redundant_load_and_mov;
 mod remove_unused_values;
 mod remove_useless_jumps;
 
 pub use self::{
     assign_unique_register_address::*, calculate_static_values::*, move_load_top::*,
-    remove_redundant_load_and_mov::*, remove_unused_values::*, remove_useless_jumps::*,
+    remove_dead_code::*, remove_redundant_load_and_mov::*, remove_unused_values::*,
+    remove_useless_jumps::*,
 };

utxo/src/filter_expr/compiler/optimizations/remove_dead_code.rs

@@ -0,0 +1,96 @@
+use crate::filter_expr::{compiler::Compiler, opcode::OpCode};
+use std::collections::HashSet;
+
+/// Remove OpCodes that are not executed.
+///
+/// This function simulates the Jumps the code may have and attempts to execute all possible
+/// branches, regardless of the actual values, keeping track of executed opcodes.
+///
+/// Non executed opcodes are then removed from the list of opcodes.
+#[inline]
+pub fn remove_dead_code(mut opcodes: Vec<OpCode>) -> (Vec<OpCode>, bool) {
+    let total = opcodes.len();
+    // list of opcodes that have been executed
+    let mut executed_opcodes = opcodes
+        .iter()
+        .map(|opcode| {
+            if matches!(
+                opcode,
+                OpCode::LABEL(_) | OpCode::LOAD(_, _) | OpCode::LOAD_EXTERNAL(_, _)
+            ) {
+                1
+            } else {
+                0usize
+            }
+        })
+        .collect::<Vec<_>>();
+
+    // current opcode position
+    let mut current = 0;
+
+    let mut future_jumps = HashSet::new();
+    // to avoid infinite loop, since the jumps are unconditional, we need to keep track the jumps
+    let mut jumped_at = HashSet::new();
+
+    // convert labels to address for the current list of opcodes
+    let label_to_addr = Compiler::labels_to_addr(&opcodes);
+
+    loop {
+        match if let Some(opcode) = opcodes.get(current) {
+            executed_opcodes[current] += 1;
+            opcode
+        } else {
+            break;
+        } {
+            OpCode::HLT(_) => {
+                let mut has_jumped = false;
+                for jump_to in future_jumps.iter() {
+                    if !jumped_at.contains(jump_to) {
+                        jumped_at.insert(*jump_to);
+                        has_jumped = true;
+                        current = *jump_to;
+                        break;
+                    }
+                }
+
+                if !has_jumped {
+                    break;
+                }
+            }
+            OpCode::JMP(to) => {
+                let to = label_to_addr.get(to).cloned().expect("Invalid label");
+                if !jumped_at.contains(&to) {
+                    jumped_at.insert(*to);
+                    current = *to;
+                } else {
+                    current += 1;
+                }
+            }
+            OpCode::JEQ(_, to) | OpCode::JNE(_, to) => {
+                let to = label_to_addr.get(to).cloned().expect("Invalid label");
+                future_jumps.insert(*to);
+                current += 1;
+            }
+            _ => {
+                current += 1;
+            }
+        }
+    }
+
+    let total_opcodes = opcodes.len();
+    let new_opcodes = opcodes
+        .into_iter()
+        .enumerate()
+        .filter_map(|(idx, opcode)| {
+            if executed_opcodes[idx] == 0 {
+                None
+            } else {
+                Some(opcode)
+            }
+        })
+        .collect::<Vec<_>>();
+
+    let new_opcodes_total = new_opcodes.len();
+
+    (new_opcodes, total_opcodes != new_opcodes_total)
+}

utxo/src/filter_expr/compiler/optimizations/remove_unused_values.rs

@@ -1,6 +1,5 @@
-use std::collections::HashMap;
-
 use crate::filter_expr::opcode::OpCode;
+use std::collections::HashMap;
 
 /// Remove loaded values that are not read by any opcode. This is useful for reducing the size
 /// of the opcodes to be executed

utxo/src/filter_expr/filter.rs

@@ -69,7 +69,7 @@ impl<'a> Filter<'a> {
             }
         }
 
-        self.opcodes = new_opcodes;
+        self.opcodes = Compiler::remove_dead_code(new_opcodes);
         self.initial_register.clear();
         self.opcodes_to_execute = Compiler::resolve_label_to_addr(
             self.opcodes