feat(mem2reg): Remove trivial stores

compiler/noirc_evaluator/src/ssa.rs

@@ -117,6 +117,11 @@ pub(crate) fn optimize_into_acir(
     .run_pass(Ssa::remove_enable_side_effects, "After EnableSideEffectsIf removal:")
     .run_pass(Ssa::fold_constants_using_constraints, "After Constraint Folding:")
     .run_pass(Ssa::dead_instruction_elimination, "After Dead Instruction Elimination:")
+    // TODO: mem2reg and DIE were put here to delete any stores that can be removes following die removing loads.
+    // Decide whether we want to run mem2reg once more or just have it able to handle this case on its own
+    .run_pass(Ssa::mem2reg, "After Mem2Reg:")
+    // The extra mem2reg requires another DIE as we can have allocates we do not want
+    .run_pass(Ssa::dead_instruction_elimination, "After Dead Instruction Elimination:")
     .run_pass(Ssa::array_set_optimization, "After Array Set Optimizations:")
     .finish();
 

compiler/noirc_evaluator/src/ssa/opt/mem2reg.rs

@@ -56,7 +56,7 @@
 //!
 //! Repeating this algorithm for each block in the function in program order should result in
 //! optimizing out most known loads. However, identifying all aliases correctly has been proven
 //! undecidable in general (Landi, 1992). So this pass will not always optimize out all loads
 //! that could theoretically be optimized out. This pass can be performed at any time in the
 //! SSA optimization pipeline, although it will be more successful the simpler the program's CFG is.
 //! This pass is currently performed several times to enable other passes - most notably being
@@ -111,7 +111,7 @@
     /// Load and Store instructions that should be removed at the end of the pass.
     ///
     /// We avoid removing individual instructions as we go since removing elements
     /// from the middle of Vecs many times will be slower than a single call to `retain`.
     instructions_to_remove: BTreeSet<InstructionId>,
 
     /// Track a value's last load across all blocks.
@@ -253,7 +253,6 @@
 
                 // If the load is known, replace it with the known value and remove the load
                 if let Some(value) = references.get_known_value(address) {
-                    let result = self.inserter.function.dfg.instruction_results(instruction)[0];
                     self.inserter.map_value(result, value);
                     self.instructions_to_remove.insert(instruction);
                 } else {
@@ -274,6 +273,13 @@
                     self.instructions_to_remove.insert(*last_store);
                 }
 
+                if let Some(last_load) = self.last_loads.get(&address) {
+                    let load_result = self.inserter.function.dfg.instruction_results(*last_load)[0];
+                    if load_result == value {
+                        self.instructions_to_remove.insert(instruction);
+                    }
+                }
+
                 references.set_known_value(address, value);
                 references.last_stores.insert(address, instruction);
             }

compiler/noirc_evaluator/src/ssa/opt/mem2reg/block.rs

@@ -164,6 +164,9 @@ impl Block {
                 // known references if this reference is ever stored to.
             }
         }
+        // else {
+        //     self.references.insert(result, ReferenceValue::Known(address));
+        // }
     }
 
     /// Iterate through each known alias of the given address and apply the function `f` to each.