fix: remove saturating behaviour of signed bitshifts in brillig

Author: TomAFrench

compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs

@@ -1701,7 +1701,8 @@ impl<'block, Registers: RegisterAllocator> BrilligBlock<'block, Registers> {
 
         self.brillig_context.codegen_branch(left_is_negative.address, |ctx, is_negative| {
             if is_negative {
-                // If right value is greater than the left bit size, return -1
+                // Assert right value is less than the left bit size.
+                // We only need to assert this here as the brillig shr opcode implies this constraint.
                 let rhs_does_not_overflow = SingleAddrVariable::new(ctx.allocate_register(), 1);
                 let lhs_bit_size =
                     ctx.make_constant_instruction(left.bit_size.into(), right.bit_size);
@@ -1711,35 +1712,30 @@ impl<'block, Registers: RegisterAllocator> BrilligBlock<'block, Registers> {
                     rhs_does_not_overflow,
                     BrilligBinaryOp::LessThan,
                 );
+                ctx.codegen_constrain(rhs_does_not_overflow, None);
 
-                ctx.codegen_branch(rhs_does_not_overflow.address, |ctx, no_overflow| {
-                    if no_overflow {
-                        let one = ctx.make_constant_instruction(1_u128.into(), left.bit_size);
-
-                        // computes 2^right
-                        let two = ctx.make_constant_instruction(2_u128.into(), left.bit_size);
-                        let two_pow = ctx.make_constant_instruction(1_u128.into(), left.bit_size);
-                        let right_u32 = SingleAddrVariable::new(ctx.allocate_register(), 32);
-                        ctx.cast(right_u32, right);
-                        let pow_body = |ctx: &mut BrilligContext<_, _>, _: SingleAddrVariable| {
-                            ctx.binary_instruction(two_pow, two, two_pow, BrilligBinaryOp::Mul);
-                        };
-                        ctx.codegen_for_loop(None, right_u32.address, None, pow_body);
-
-                        // Right shift using division on 1-complement
-                        ctx.binary_instruction(left, one, result, BrilligBinaryOp::Add);
-                        ctx.convert_signed_division(result, two_pow, result);
-                        ctx.binary_instruction(result, one, result, BrilligBinaryOp::Sub);
-
-                        // Clean-up
-                        ctx.deallocate_single_addr(one);
-                        ctx.deallocate_single_addr(two);
-                        ctx.deallocate_single_addr(two_pow);
-                        ctx.deallocate_single_addr(right_u32);
-                    } else {
-                        ctx.const_instruction(result, ((1_u128 << left.bit_size) - 1).into());
-                    }
-                });
+                let one = ctx.make_constant_instruction(1_u128.into(), left.bit_size);
+
+                // computes 2^right
+                let two = ctx.make_constant_instruction(2_u128.into(), left.bit_size);
+                let two_pow = ctx.make_constant_instruction(1_u128.into(), left.bit_size);
+                let right_u32 = SingleAddrVariable::new(ctx.allocate_register(), 32);
+                ctx.cast(right_u32, right);
+                let pow_body = |ctx: &mut BrilligContext<_, _>, _: SingleAddrVariable| {
+                    ctx.binary_instruction(two_pow, two, two_pow, BrilligBinaryOp::Mul);
+                };
+                ctx.codegen_for_loop(None, right_u32.address, None, pow_body);
+
+                // Right shift using division on 1-complement
+                ctx.binary_instruction(left, one, result, BrilligBinaryOp::Add);
+                ctx.convert_signed_division(result, two_pow, result);
+                ctx.binary_instruction(result, one, result, BrilligBinaryOp::Sub);
+
+                // Clean-up
+                ctx.deallocate_single_addr(one);
+                ctx.deallocate_single_addr(two);
+                ctx.deallocate_single_addr(two_pow);
+                ctx.deallocate_single_addr(right_u32);
 
                 ctx.deallocate_single_addr(rhs_does_not_overflow);
             } else {