chore(ssa): Predicate for store instruction

crates/noirc_evaluator/src/ssa/acir_gen.rs

@@ -69,7 +69,7 @@ impl Acir {
                 load::evaluate(*array_id, *index, acir_mem, var_cache, evaluator, ctx)
             }
             Operation::Store { .. } => {
-                store::evaluate(&ins.operation, memory_map, var_cache, evaluator, ctx)
+                store::evaluate(&ins.operation, acir_mem, var_cache, evaluator, ctx)
             }
             Operation::Nop => None,
             i @ Operation::Jne(..)

crates/noirc_evaluator/src/ssa/acir_gen/operations/condition.rs

@@ -6,7 +6,7 @@ use crate::{
     },
     Evaluator,
 };
-use acvm::FieldElement;
+use acvm::{acir::native_types::Expression, FieldElement};
 
 pub(crate) fn evaluate(
     condition: NodeId,
@@ -19,11 +19,21 @@ pub(crate) fn evaluate(
     let cond = var_cache.get_or_compute_internal_var_unwrap(condition, evaluator, ctx);
     let l_c = var_cache.get_or_compute_internal_var_unwrap(lhs, evaluator, ctx);
     let r_c = var_cache.get_or_compute_internal_var_unwrap(rhs, evaluator, ctx);
-    let sub = constraints::subtract(l_c.expression(), FieldElement::one(), r_c.expression());
-    let result = constraints::add(
-        &constraints::mul_with_witness(evaluator, cond.expression(), &sub),
-        FieldElement::one(),
-        r_c.expression(),
-    );
+    let result =
+        evaluate_expression(cond.expression(), l_c.expression(), r_c.expression(), evaluator);
     Some(result.into())
 }
+
+pub fn evaluate_expression(
+    condition: &Expression,
+    lhs: &Expression,
+    rhs: &Expression,
+    evaluator: &mut Evaluator,
+) -> Expression {
+    let sub = constraints::subtract(lhs, FieldElement::one(), rhs);
+    constraints::add(
+        &constraints::mul_with_witness(evaluator, condition, &sub),
+        FieldElement::one(),
+        rhs,
+    )
+}

crates/noirc_evaluator/src/ssa/acir_gen/operations/store.rs

@@ -1,23 +1,18 @@
-use acvm::FieldElement;
-
 use crate::{
     ssa::{
-        acir_gen::{
-            constraints::{add, mul_with_witness, subtract},
-            internal_var_cache::InternalVarCache,
-            memory_map::MemoryMap,
-            InternalVar,
-        },
+        acir_gen::{acir_mem::AcirMem, internal_var_cache::InternalVarCache, InternalVar},
         context::SsaContext,
         mem::{self},
         node::Operation,
     },
     Evaluator,
 };
 
+use super::condition;
+
 pub(crate) fn evaluate(
     store: &Operation,
-    memory_map: &mut MemoryMap,
+    acir_mem: &mut AcirMem,
     var_cache: &mut InternalVarCache,
     evaluator: &mut Evaluator,
     ctx: &SsaContext,
@@ -30,7 +25,6 @@ pub(crate) fn evaluate(
         match index.to_const() {
             Some(index) => {
                 let idx = mem::Memory::as_u32(index);
-                let absolute_adr = ctx.mem[array_id].absolute_adr(idx);
                 let value_with_predicate = if let Some(predicate) = predicate {
                     if predicate.is_dummy() || ctx.is_one(predicate) {
                         value
@@ -39,22 +33,21 @@ pub(crate) fn evaluate(
                     } else {
                         let pred =
                             var_cache.get_or_compute_internal_var_unwrap(predicate, evaluator, ctx);
-                        let dummy = memory_map
+                        let dummy_load = acir_mem
                             .load_array_element_constant_index(&ctx.mem[array_id], idx)
                             .unwrap();
-                        let x = mul_with_witness(evaluator, pred.expression(), value.expression());
-                        let y = subtract(
-                            dummy.expression(),
-                            FieldElement::one(),
-                            &mul_with_witness(evaluator, pred.expression(), dummy.expression()),
+                        let result = condition::evaluate_expression(
+                            pred.expression(),
+                            value.expression(),
+                            dummy_load.expression(),
+                            evaluator,
                         );
-                        InternalVar::from(add(&x, FieldElement::one(), &y))
+                        result.into()
                     }
                 } else {
                     value
                 };
-
-                memory_map.insert(absolute_adr, value_with_predicate);
+                acir_mem.insert(array_id, idx, value_with_predicate);
                 //we do not generate constraint, so no output.
                 None
             }

crates/noirc_evaluator/src/ssa/anchor.rs

@@ -1,5 +1,6 @@
 use crate::errors::{RuntimeError, RuntimeErrorKind};
 use crate::ssa::{
+    conditional::DecisionTree,
     context::SsaContext,
     mem::ArrayId,
     node::{NodeId, ObjectType, Opcode, Operation},
@@ -252,9 +253,7 @@ impl Anchor {
                     }
                     Operation::Store { index, value, predicate, .. } => {
                         if !ctx.maybe_distinct(*index, b_idx) {
-                            if ctx.is_one(crate::ssa::conditional::DecisionTree::unwrap_predicate(
-                                ctx, predicate,
-                            )) {
+                            if ctx.is_one(DecisionTree::unwrap_predicate(ctx, predicate)) {
                                 return Some(CseAction::ReplaceWith(*value));
                             } else {
                                 return Some(CseAction::Keep);

crates/noirc_evaluator/src/ssa/conditional.rs

@@ -374,11 +374,13 @@ impl DecisionTree {
             merged_ins = self.synchronize(ctx, &left_ins, &right_ins, left);
         }
         let mut modified = false;
+        // write the merged instructions to the block
         super::optimizations::cse_block(ctx, left, &mut merged_ins, &mut modified)?;
         if modified {
             // A second round is necessary when the synchronization optimizes function calls between the two branches.
             // In that case, the first cse updates the result instructions to the same call and then
             // the second cse can (and must) then simplify identical result instructions.
+            // We clear the list because we want to perform the cse on the block instructions
             merged_ins.clear();
             super::optimizations::cse_block(ctx, left, &mut merged_ins, &mut modified)?;
         }
@@ -731,36 +733,25 @@ impl DecisionTree {
     ) -> Option<NodeId> {
         match (condition1, condition2) {
             (None, None) => None,
-            (Some(condition), None) | (None, Some(condition)) => {
-                if condition.is_dummy() {
-                    None
-                } else {
-                    Some(condition)
-                }
+            (Some(cond), other) | (other, Some(cond)) if cond.is_dummy() => {
+                Self::and_conditions(None, other, stack_frame, ctx)
             }
+            (Some(cond), None) | (None, Some(cond)) => Some(cond),
             (Some(cond1), Some(cond2)) => {
-                if cond1.is_dummy() {
-                    Self::and_conditions(None, condition2, stack_frame, ctx)
-                } else if cond2.is_dummy() {
-                    Self::and_conditions(None, condition1, stack_frame, ctx)
-                } else if cond1 == cond2 {
-                    condition1
-                } else {
-                    let op = Operation::Binary(node::Binary {
-                        lhs: cond1,
-                        rhs: cond2,
-                        operator: BinaryOp::Mul,
-                        predicate: None,
-                    });
-                    let cond = ctx.add_instruction(Instruction::new(
-                        op,
-                        ObjectType::Boolean,
-                        Some(stack_frame.block),
-                    ));
-                    optimizations::simplify_id(ctx, cond).unwrap();
-                    stack_frame.push(cond);
-                    Some(cond)
-                }
+                let op = Operation::Binary(node::Binary {
+                    lhs: cond1,
+                    rhs: cond2,
+                    operator: BinaryOp::Mul,
+                    predicate: None,
+                });
+                let cond = ctx.add_instruction(Instruction::new(
+                    op,
+                    ObjectType::Boolean,
+                    Some(stack_frame.block),
+                ));
+                optimizations::simplify_id(ctx, cond).unwrap();
+                stack_frame.push(cond);
+                Some(cond)
             }
         }
     }

crates/noirc_evaluator/src/ssa/context.rs

@@ -937,12 +937,7 @@ impl SsaContext {
         for (i, v) in values.iter().enumerate() {
             let index =
                 self.get_or_create_const(FieldElement::from(i as i128), ObjectType::Unsigned(32));
-            let op_a = Operation::Store {
-                array_id,
-                index,
-                value: self.zero_with_type(e_type),
-                predicate: None,
-            };
+            let op_a = Operation::Store { array_id, index, value: *v, predicate: None };
             self.new_instruction_inline(op_a, e_type, stack_frame);
         }
     }