feat: unchecked math operations in SSA

compiler/noirc_evaluator/src/acir/mod.rs

@@ -1949,9 +1949,9 @@ impl<'a> Context<'a> {
         let bit_count = binary_type.bit_size::<FieldElement>();
         let num_type = binary_type.to_numeric_type();
         let result = match binary.operator {
-            BinaryOp::Add => self.acir_context.add_var(lhs, rhs),
-            BinaryOp::Sub => self.acir_context.sub_var(lhs, rhs),
-            BinaryOp::Mul => self.acir_context.mul_var(lhs, rhs),
+            BinaryOp::Add { .. } => self.acir_context.add_var(lhs, rhs),
+            BinaryOp::Sub { .. } => self.acir_context.sub_var(lhs, rhs),
+            BinaryOp::Mul { .. } => self.acir_context.mul_var(lhs, rhs),
             BinaryOp::Div => self.acir_context.div_var(
                 lhs,
                 rhs,
@@ -2070,7 +2070,7 @@ impl<'a> Context<'a> {
             Value::Instruction { instruction, .. } => {
                 if matches!(
                     &dfg[*instruction],
-                    Instruction::Binary(Binary { operator: BinaryOp::Sub, .. })
+                    Instruction::Binary(Binary { operator: BinaryOp::Sub { .. }, .. })
                 ) {
                     // Subtractions must first have the integer modulus added before truncation can be
                     // applied. This is done in order to prevent underflow.
@@ -3159,7 +3159,11 @@ mod test {
         let func_with_nested_call_v1 = builder.add_parameter(Type::field());
 
         let two = builder.field_constant(2u128);
-        let v0_plus_two = builder.insert_binary(func_with_nested_call_v0, BinaryOp::Add, two);
+        let v0_plus_two = builder.insert_binary(
+            func_with_nested_call_v0,
+            BinaryOp::Add { unchecked: false },
+            two,
+        );
 
         let foo_id = Id::test_new(2);
         let foo_call = builder.import_function(foo_id);

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

@@ -1318,9 +1318,9 @@ impl<'block> BrilligBlock<'block> {
                     BrilligBinaryOp::Modulo
                 }
             }
-            BinaryOp::Add => BrilligBinaryOp::Add,
-            BinaryOp::Sub => BrilligBinaryOp::Sub,
-            BinaryOp::Mul => BrilligBinaryOp::Mul,
+            BinaryOp::Add { .. } => BrilligBinaryOp::Add,
+            BinaryOp::Sub { .. } => BrilligBinaryOp::Sub,
+            BinaryOp::Mul { .. } => BrilligBinaryOp::Mul,
             BinaryOp::Eq => BrilligBinaryOp::Equals,
             BinaryOp::Lt => {
                 if is_signed {

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

@@ -382,14 +382,14 @@ mod test {
         builder.switch_to_block(b2);
 
         let twenty_seven = builder.field_constant(27u128);
-        let v7 = builder.insert_binary(v0, BinaryOp::Add, twenty_seven);
+        let v7 = builder.insert_binary(v0, BinaryOp::Add { unchecked: false }, twenty_seven);
         builder.insert_store(v3, v7);
 
         builder.terminate_with_jmp(b3, vec![]);
 
         builder.switch_to_block(b1);
 
-        let v6 = builder.insert_binary(v1, BinaryOp::Add, twenty_seven);
+        let v6 = builder.insert_binary(v1, BinaryOp::Add { unchecked: false }, twenty_seven);
         builder.insert_store(v3, v6);
 
         builder.terminate_with_jmp(b3, vec![]);
@@ -501,7 +501,7 @@ mod test {
 
         builder.switch_to_block(b2);
 
-        let v6 = builder.insert_binary(v4, BinaryOp::Mul, v4);
+        let v6 = builder.insert_binary(v4, BinaryOp::Mul { unchecked: false }, v4);
 
         builder.terminate_with_jmp(b4, vec![v0]);
 
@@ -526,7 +526,7 @@ mod test {
 
         let v12 = builder.insert_load(v3, Type::field());
 
-        let v13 = builder.insert_binary(v12, BinaryOp::Add, v6);
+        let v13 = builder.insert_binary(v12, BinaryOp::Add { unchecked: false }, v6);
 
         builder.insert_store(v3, v13);
 
@@ -535,13 +535,13 @@ mod test {
         builder.switch_to_block(b8);
 
         let one = builder.field_constant(1u128);
-        let v15 = builder.insert_binary(v7, BinaryOp::Add, one);
+        let v15 = builder.insert_binary(v7, BinaryOp::Add { unchecked: false }, one);
 
         builder.terminate_with_jmp(b4, vec![v15]);
 
         builder.switch_to_block(b6);
 
-        let v16 = builder.insert_binary(v4, BinaryOp::Add, one);
+        let v16 = builder.insert_binary(v4, BinaryOp::Add { unchecked: false }, one);
 
         builder.terminate_with_jmp(b1, vec![v16]);
 

compiler/noirc_evaluator/src/ssa/function_builder/mod.rs

@@ -251,14 +251,6 @@ impl FunctionBuilder {
         operator: BinaryOp,
         rhs: ValueId,
     ) -> ValueId {
-        let lhs_type = self.type_of_value(lhs);
-        let rhs_type = self.type_of_value(rhs);
-        if operator != BinaryOp::Shl && operator != BinaryOp::Shr {
-            assert_eq!(
-                lhs_type, rhs_type,
-                "ICE - Binary instruction operands must have the same type"
-            );
-        }
         let instruction = Instruction::Binary(Binary { lhs, rhs, operator });
         self.insert_instruction(instruction, None).first()
     }

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

@@ -7,7 +7,8 @@
     call_stack::{CallStack, CallStackHelper, CallStackId},
     function::{FunctionId, RuntimeType},
     instruction::{
-        Instruction, InstructionId, InstructionResultType, Intrinsic, TerminatorInstruction,
+        Binary, BinaryOp, Instruction, InstructionId, InstructionResultType, Intrinsic,
+        TerminatorInstruction,
     },
     map::DenseMap,
     types::{NumericType, Type},
@@ -174,6 +175,44 @@
         instruction_data: Instruction,
         ctrl_typevars: Option<Vec<Type>>,
     ) -> InstructionId {
+        let instruction_data = if let Instruction::Binary(binary) = instruction_data {
+            let lhs = binary.lhs;
+            let rhs = binary.rhs;
+            let operator = binary.operator;
+            let lhs_type = self.type_of_value(lhs);
+            let rhs_type = self.type_of_value(rhs);
+            if operator != BinaryOp::Shl && operator != BinaryOp::Shr {
+                assert_eq!(
+                    lhs_type, rhs_type,
+                    "ICE - Binary instruction operands must have the same type"
+                );
+            }
+
+            let operator = if lhs_type.is_field() {
+                // Unchecked operations between fields or bools don't make sense, so we convert those to non-unchecked
+                // to reduce noise and confusion in the generated SSA.
+                match operator {
+                    BinaryOp::Add { unchecked: true } => BinaryOp::Add { unchecked: false },
+                    BinaryOp::Sub { unchecked: true } => BinaryOp::Sub { unchecked: false },
+                    BinaryOp::Mul { unchecked: true } => BinaryOp::Mul { unchecked: false },
+                    _ => operator,
+                }
+            } else if lhs_type.is_bool() {
+                // Unchecked mul between bools doesn't make sense, so we convert that to non-unchecked
+                if let BinaryOp::Mul { unchecked: true } = operator {
+                    BinaryOp::Mul { unchecked: false }
+                } else {
+                    operator
+                }
+            } else {
+                operator
+            };
+
+            Instruction::Binary(Binary { operator, ..binary })
+        } else {
+            instruction_data
+        };
+
         let id = self.instructions.insert(instruction_data);
         self.make_instruction_results(id, ctrl_typevars);
         id

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

@@ -407,15 +407,20 @@
             // These can fail.
             Constrain(..) | RangeCheck { .. } => true,
 
             // This should never be side-effectful
             MakeArray { .. } | Noop => false,
 
             // Some binary math can overflow or underflow
             Binary(binary) => match binary.operator {
-                BinaryOp::Add | BinaryOp::Sub | BinaryOp::Mul | BinaryOp::Div | BinaryOp::Mod => {
-                    true
-                }
-                BinaryOp::Eq
+                BinaryOp::Add { unchecked: false }
+                | BinaryOp::Sub { unchecked: false }
+                | BinaryOp::Mul { unchecked: false }
+                | BinaryOp::Div
+                | BinaryOp::Mod => true,
+                BinaryOp::Add { unchecked: true }
+                | BinaryOp::Sub { unchecked: true }
+                | BinaryOp::Mul { unchecked: true }
+                | BinaryOp::Eq
                 | BinaryOp::Lt
                 | BinaryOp::And
                 | BinaryOp::Or
@@ -566,16 +571,19 @@
         match self {
             Instruction::Binary(binary) => {
                 match binary.operator {
-                    BinaryOp::Add
-                    | BinaryOp::Sub
-                    | BinaryOp::Mul
+                    BinaryOp::Add { unchecked: false }
+                    | BinaryOp::Sub { unchecked: false }
+                    | BinaryOp::Mul { unchecked: false }
                     | BinaryOp::Div
                     | BinaryOp::Mod => {
                         // Some binary math can overflow or underflow, but this is only the case
                         // for unsigned types (here we assume the type of binary.lhs is the same)
                         dfg.type_of_value(binary.rhs).is_unsigned()
                     }
-                    BinaryOp::Eq
+                    BinaryOp::Add { unchecked: true }
+                    | BinaryOp::Sub { unchecked: true }
+                    | BinaryOp::Mul { unchecked: true }
+                    | BinaryOp::Eq
                     | BinaryOp::Lt
                     | BinaryOp::And
                     | BinaryOp::Or

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

@@ -15,11 +15,11 @@
 #[derive(Debug, PartialEq, Eq, Hash, Copy, Clone, Serialize, Deserialize)]
 pub(crate) enum BinaryOp {
     /// Addition of lhs + rhs.
-    Add,
+    Add { unchecked: bool },
     /// Subtraction of lhs - rhs.
-    Sub,
+    Sub { unchecked: bool },
     /// Multiplication of lhs * rhs.
-    Mul,
+    Mul { unchecked: bool },
     /// Division of lhs / rhs.
     Div,
     /// Modulus of lhs % rhs.
@@ -39,18 +39,21 @@
     Or,
     /// Bitwise xor (^)
     Xor,
     /// Bitshift left (<<)
     Shl,
     /// Bitshift right (>>)
     Shr,
 }
 
 impl std::fmt::Display for BinaryOp {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            BinaryOp::Add => write!(f, "add"),
-            BinaryOp::Sub => write!(f, "sub"),
-            BinaryOp::Mul => write!(f, "mul"),
+            BinaryOp::Add { unchecked: false } => write!(f, "add"),
+            BinaryOp::Add { unchecked: true } => write!(f, "unchecked_add"),
+            BinaryOp::Sub { unchecked: false } => write!(f, "sub"),
+            BinaryOp::Sub { unchecked: true } => write!(f, "unchecked_sub"),
+            BinaryOp::Mul { unchecked: false } => write!(f, "mul"),
+            BinaryOp::Mul { unchecked: true } => write!(f, "unchecked_mul"),
             BinaryOp::Div => write!(f, "div"),
             BinaryOp::Eq => write!(f, "eq"),
             BinaryOp::Mod => write!(f, "mod"),
@@ -107,20 +110,20 @@
         let rhs_is_one = rhs.map_or(false, |rhs| rhs.is_one());
 
         match self.operator {
-            BinaryOp::Add => {
+            BinaryOp::Add { .. } => {
                 if lhs_is_zero {
                     return SimplifyResult::SimplifiedTo(self.rhs);
                 }
                 if rhs_is_zero {
                     return SimplifyResult::SimplifiedTo(self.lhs);
                 }
             }
-            BinaryOp::Sub => {
+            BinaryOp::Sub { .. } => {
                 if rhs_is_zero {
                     return SimplifyResult::SimplifiedTo(self.lhs);
                 }
             }
-            BinaryOp::Mul => {
+            BinaryOp::Mul { .. } => {
                 if lhs_is_one {
                     return SimplifyResult::SimplifiedTo(self.rhs);
                 }
@@ -141,7 +144,7 @@
                         if let Instruction::Binary(Binary { lhs, rhs, operator }) =
                             dfg[*instruction]
                         {
-                            if operator == BinaryOp::Mul
+                            if matches!(operator, BinaryOp::Mul { .. })
                                 && (dfg.resolve(self.lhs) == dfg.resolve(lhs)
                                     || dfg.resolve(self.lhs) == dfg.resolve(rhs))
                             {
@@ -156,7 +159,7 @@
                         if let Instruction::Binary(Binary { lhs, rhs, operator }) =
                             dfg[*instruction]
                         {
-                            if operator == BinaryOp::Mul
+                            if matches!(operator, BinaryOp::Mul { .. })
                                 && (dfg.resolve(self.rhs) == dfg.resolve(lhs)
                                     || dfg.resolve(self.rhs) == dfg.resolve(rhs))
                             {
@@ -247,7 +250,9 @@
                 }
                 if operand_type == NumericType::bool() {
                     // Boolean AND is equivalent to multiplication, which is a cheaper operation.
-                    let instruction = Instruction::binary(BinaryOp::Mul, self.lhs, self.rhs);
+                    // (mul unchecked because these are bools so it doesn't matter really)
+                    let instruction =
+                        Instruction::binary(BinaryOp::Mul { unchecked: true }, self.lhs, self.rhs);
                     return SimplifyResult::SimplifiedToInstruction(instruction);
                 }
                 if operand_type.is_unsigned() {
@@ -331,22 +336,22 @@
         let max_rhs_bits = dfg.get_value_max_num_bits(self.rhs);
 
         let msg = match self.operator {
-            BinaryOp::Add => {
+            BinaryOp::Add { unchecked: false } => {
                 if std::cmp::max(max_lhs_bits, max_rhs_bits) < bit_size {
                     // `lhs` and `rhs` have both been casted up from smaller types and so cannot overflow.
                     return None;
                 }
                 "attempt to add with overflow"
             }
-            BinaryOp::Sub => {
+            BinaryOp::Sub { unchecked: false } => {
                 if dfg.is_constant(self.lhs) && max_lhs_bits > max_rhs_bits {
                     // `lhs` is a fixed constant and `rhs` is restricted such that `lhs - rhs > 0`
                     // Note strict inequality as `rhs > lhs` while `max_lhs_bits == max_rhs_bits` is possible.
                     return None;
                 }
                 "attempt to subtract with overflow"
             }
-            BinaryOp::Mul => {
+            BinaryOp::Mul { unchecked: false } => {
                 if bit_size == 1
                     || max_lhs_bits + max_rhs_bits <= bit_size
                     || max_lhs_bits == 1
@@ -470,9 +475,9 @@
 impl BinaryOp {
     fn get_field_function(self) -> Option<fn(FieldElement, FieldElement) -> FieldElement> {
         match self {
-            BinaryOp::Add => Some(std::ops::Add::add),
-            BinaryOp::Sub => Some(std::ops::Sub::sub),
-            BinaryOp::Mul => Some(std::ops::Mul::mul),
+            BinaryOp::Add { .. } => Some(std::ops::Add::add),
+            BinaryOp::Sub { .. } => Some(std::ops::Sub::sub),
+            BinaryOp::Mul { .. } => Some(std::ops::Mul::mul),
             BinaryOp::Div => Some(std::ops::Div::div),
             BinaryOp::Eq => Some(|x, y| (x == y).into()),
             BinaryOp::Lt => Some(|x, y| (x < y).into()),
@@ -488,9 +493,9 @@
 
     fn get_u128_function(self) -> fn(u128, u128) -> Option<u128> {
         match self {
-            BinaryOp::Add => u128::checked_add,
-            BinaryOp::Sub => u128::checked_sub,
-            BinaryOp::Mul => u128::checked_mul,
+            BinaryOp::Add { .. } => u128::checked_add,
+            BinaryOp::Sub { .. } => u128::checked_sub,
+            BinaryOp::Mul { .. } => u128::checked_mul,
             BinaryOp::Div => u128::checked_div,
             BinaryOp::Mod => u128::checked_rem,
             BinaryOp::And => |x, y| Some(x & y),
@@ -505,9 +510,9 @@
 
     fn get_i128_function(self) -> fn(i128, i128) -> Option<i128> {
         match self {
-            BinaryOp::Add => i128::checked_add,
-            BinaryOp::Sub => i128::checked_sub,
-            BinaryOp::Mul => i128::checked_mul,
+            BinaryOp::Add { .. } => i128::checked_add,
+            BinaryOp::Sub { .. } => i128::checked_sub,
+            BinaryOp::Mul { .. } => i128::checked_mul,
             BinaryOp::Div => i128::checked_div,
             BinaryOp::Mod => i128::checked_rem,
             BinaryOp::And => |x, y| Some(x & y),