Fix optimization issues, enabled back `remove_dead_code` on each iteration and enhanced resolve_label

utxo/src/filter_expr/compiler/mod.rs

@@ -136,19 +136,6 @@ impl<'a> Compiler<'a> {
         })
     }
 
-    pub fn remove_dead_code(opcodes: Vec<OpCode>) -> Vec<OpCode> {
-        let mut new_opcodes = opcodes;
-        loop {
-            let (new_opcodes_, has_changed) = optimizations::remove_dead_code(new_opcodes);
-            new_opcodes = new_opcodes_;
-            if !has_changed {
-                break;
-            }
-        }
-
-        new_opcodes
-    }
-
     pub fn optimize(opcodes: Vec<OpCode>) -> (Vec<OpCode>, bool) {
         vec![
             optimizations::assign_unique_register_addresses,
@@ -156,6 +143,7 @@ impl<'a> Compiler<'a> {
             optimizations::remove_unused_values,
             optimizations::calculate_static_values,
             optimizations::remove_useless_jumps,
+            optimizations::remove_dead_code,
             //optimizations::move_load_top,
         ]
         .into_iter()
@@ -167,19 +155,20 @@ impl<'a> Compiler<'a> {
 
     /// 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> {
+    pub fn labels_to_addr(opcodes: &[OpCode]) -> HashMap<Addr, (Addr, Addr)> {
         let mut pos_without_labels = 0;
         opcodes
             .iter()
-            .map(|opcode| match opcode {
-                OpCode::LABEL(label) => (opcode, pos_without_labels),
+            .enumerate()
+            .map(|(actual_pos, opcode)| match opcode {
+                OpCode::LABEL(label) => (opcode, pos_without_labels, actual_pos),
                 _ => {
                     pos_without_labels = pos_without_labels + 1usize;
-                    (opcode, pos_without_labels - 1)
+                    (opcode, pos_without_labels - 1, actual_pos)
                 }
             })
-            .filter_map(|(opcode, pos)| match opcode {
-                OpCode::LABEL(id) => Some((*id, pos.into())),
+            .filter_map(|(opcode, pos_without_label, pos)| match opcode {
+                OpCode::LABEL(id) => Some((*id, (pos_without_label.into(), pos.into()))),
                 _ => None,
             })
             .collect::<HashMap<_, _>>()
@@ -195,20 +184,23 @@ impl<'a> Compiler<'a> {
                 // Rewrite JMP to not use labels but instead addresses
                 Ok(match opcode {
                     OpCode::JMP(label) => OpCode::JMP(
-                        *labels_to_addr
+                        labels_to_addr
                             .get(&label)
+                            .map(|addr| addr.0)
                             .ok_or(Error::UnknownLabel(*label))?,
                     ),
                     OpCode::JEQ(register, label) => OpCode::JEQ(
                         register,
-                        *labels_to_addr
+                        labels_to_addr
                             .get(&label)
+                            .map(|addr| addr.0)
                             .ok_or(Error::UnknownLabel(*label))?,
                     ),
                     OpCode::JNE(register, label) => OpCode::JNE(
                         register,
-                        *labels_to_addr
+                        labels_to_addr
                             .get(&label)
+                            .map(|addr| addr.0)
                             .ok_or(Error::UnknownLabel(*label))?,
                     ),
                     opcode => opcode,

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

@@ -11,7 +11,7 @@ use std::collections::HashSet;
 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| 0usize).collect::<Vec<_>>();
+    let mut executed_opcodes = vec![0; total];
 
     // current opcode position
     let mut current = 0;
@@ -24,7 +24,6 @@ pub fn remove_dead_code(mut opcodes: Vec<OpCode>) -> (Vec<OpCode>, bool) {
     let label_to_addr = Compiler::labels_to_addr(&opcodes);
 
     loop {
-        println!("current = {current}");
         match if let Some(opcode) = opcodes.get(current) {
             executed_opcodes[current] += 1;
             opcode
@@ -47,7 +46,10 @@ pub fn remove_dead_code(mut opcodes: Vec<OpCode>) -> (Vec<OpCode>, bool) {
                 }
             }
             OpCode::JMP(to) => {
-                let to = label_to_addr.get(to).cloned().expect("Invalid label");
+                let to = label_to_addr
+                    .get(to)
+                    .map(|addr| addr.1)
+                    .expect("Invalid label");
                 if !jumped_at.contains(&to) {
                     jumped_at.insert(*to);
                     current = *to;
@@ -56,7 +58,10 @@ pub fn remove_dead_code(mut opcodes: Vec<OpCode>) -> (Vec<OpCode>, bool) {
                 }
             }
             OpCode::JEQ(_, to) | OpCode::JNE(_, to) => {
-                let to = label_to_addr.get(to).cloned().expect("Invalid label");
+                let to = label_to_addr
+                    .get(to)
+                    .map(|addr| addr.1)
+                    .expect("Invalid label");
                 future_jumps.insert(*to);
                 current += 1;
             }

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

@@ -20,7 +20,7 @@ pub fn remove_useless_jumps(mut opcodes: Vec<OpCode>) -> (Vec<OpCode>, bool) {
         })
         .filter_map(|(pos, opcode)| match &opcode {
             OpCode::JEQ(_, addr) | OpCode::JMP(addr) | OpCode::JNE(_, addr) => {
-                if label_to_addr.get(addr).map(|x| *x) == pos.checked_add(1).map(|r| r.into()) {
+                if label_to_addr.get(addr).map(|x| x.0) == pos.checked_add(1).map(|r| r.into()) {
                     None
                 } else {
                     Some(opcode)

utxo/src/filter_expr/filter.rs

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

utxo/src/filter_expr/tests/nested.expr

@@ -1,3 +1,3 @@
 WHERE
     $foo = 3 + 2 * 4 / 2 * 298210 + $bar
-    AND 25 = 5*$five
+    AND 25+1-1 = 5*$five