fix(ssa): Consider shl and shr to have side effects (#9580)

Co-authored-by: Tom French <[email protected]>

Author: aakoshh

compiler/noirc_evaluator/src/ssa/ir/instruction.rs

@@ -460,16 +460,21 @@ impl Instruction {
                 BinaryOp::Div | BinaryOp::Mod => {
                     dfg.get_numeric_constant(binary.rhs).is_none_or(|c| c.is_zero())
                 }
+                BinaryOp::Shl | BinaryOp::Shr => {
+                    // Bit-shifts which are known to be by a number of bits less than the bit size of the type have no side effects.
+                    dfg.get_numeric_constant(binary.rhs).is_none_or(|c| {
+                        let typ = dfg.type_of_value(binary.lhs);
+                        c >= typ.bit_size().into()
+                    })
+                }
                 BinaryOp::Add { unchecked: true }
                 | BinaryOp::Sub { unchecked: true }
                 | BinaryOp::Mul { unchecked: true }
                 | BinaryOp::Eq
                 | BinaryOp::Lt
                 | BinaryOp::And
                 | BinaryOp::Or
-                | BinaryOp::Xor
-                | BinaryOp::Shl
-                | BinaryOp::Shr => false,
+                | BinaryOp::Xor => false,
             },
 
             // These don't have side effects

test_programs/execution_success/regression_9544/Nargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "regression_9544"
+type = "bin"
+authors = [""]
+
+[dependencies]

test_programs/execution_success/regression_9544/Prover.toml

@@ -0,0 +1,2 @@
+c = 8483479640938442498
+return = 5

test_programs/execution_success/regression_9544/src/main.nr

@@ -0,0 +1,15 @@
+fn main(c: u64) -> pub u64 {
+    if c == 1 {
+        if c == 2 {
+            c >> c
+        } else {
+            3
+        }
+    } else {
+        if c == 4 {
+            c >> c
+        } else {
+            5
+        }
+    }
+}

tooling/ast_fuzzer/src/compare/interpreted.rs

@@ -223,6 +223,10 @@ impl Comparable for ssa::interpreter::errors::InterpreterError {
             (DivisionByZero { .. }, ConstrainEqFailed { msg, .. }) => {
                 msg.as_ref().is_some_and(|msg| msg == "attempt to divide by zero")
             }
+            (PoppedFromEmptySlice { .. }, ConstrainEqFailed { msg, .. }) => {
+                // The removal of unreachable instructions can replace popping from an empty slice with an always-fail constraint.
+                msg.as_ref().is_some_and(|msg| msg == "Index out of bounds")
+            }
             (e1, e2) => {
                 // The format strings contain SSA instructions,
                 // where the only difference might be the value ID.

tooling/ast_fuzzer/src/program/func.rs

@@ -1724,8 +1724,7 @@ impl<'a> FunctionContext<'a> {
 
     /// Generate a `match` expression, returning a given type.
     ///
-    /// Match needs a variable; if we don't have one to produce the target type from,
-    /// it returns `None`.
+    /// Match needs a variable; if we don't have one to produce the target type from, it returns `None`.
     fn gen_match(
         &mut self,
         u: &mut Unstructured,
@@ -1827,6 +1826,7 @@ impl<'a> FunctionContext<'a> {
                     let item_id = self.next_local_id();
                     let item_name = format!("item_{}", local_name(item_id));
                     self.locals.add(item_id, false, item_name.clone(), item_type.clone());
+                    self.set_dynamic(item_id, src_dyn);
                     arguments.push((item_id, item_name));
                 }
                 // Generate the original expression we wanted with the new arguments in scope.