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 | BinaryOp::UncheckedAdd => self.acir_context.add_var(lhs, rhs),
+            BinaryOp::Sub | BinaryOp::UncheckedSub => self.acir_context.sub_var(lhs, rhs),
+            BinaryOp::Mul | BinaryOp::UncheckedMul => self.acir_context.mul_var(lhs, rhs),
             BinaryOp::Div => self.acir_context.div_var(
                 lhs,
                 rhs,
@@ -2071,6 +2071,7 @@ impl<'a> Context<'a> {
                 if matches!(
                     &dfg[*instruction],
                     Instruction::Binary(Binary { operator: BinaryOp::Sub, .. })
+                        | Instruction::Binary(Binary { operator: BinaryOp::UncheckedSub, .. })
                 ) {
                     // Subtractions must first have the integer modulus added before truncation can be
                     // applied. This is done in order to prevent underflow.

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 | BinaryOp::UncheckedAdd => BrilligBinaryOp::Add,
+            BinaryOp::Sub | BinaryOp::UncheckedSub => BrilligBinaryOp::Sub,
+            BinaryOp::Mul | BinaryOp::UncheckedMul => BrilligBinaryOp::Mul,
             BinaryOp::Eq => BrilligBinaryOp::Equals,
             BinaryOp::Lt => {
                 if is_signed {

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

@@ -415,7 +415,10 @@ impl Instruction {
                 BinaryOp::Add | BinaryOp::Sub | BinaryOp::Mul | BinaryOp::Div | BinaryOp::Mod => {
                     true
                 }
-                BinaryOp::Eq
+                BinaryOp::UncheckedAdd
+                | BinaryOp::UncheckedSub
+                | BinaryOp::UncheckedMul
+                | BinaryOp::Eq
                 | BinaryOp::Lt
                 | BinaryOp::And
                 | BinaryOp::Or
@@ -575,7 +578,10 @@ impl Instruction {
                         // 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::UncheckedAdd
+                    | BinaryOp::UncheckedSub
+                    | BinaryOp::UncheckedMul
+                    | BinaryOp::Eq
                     | BinaryOp::Lt
                     | BinaryOp::And
                     | BinaryOp::Or

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

@@ -16,10 +16,16 @@ use super::{
 pub(crate) enum BinaryOp {
     /// Addition of lhs + rhs.
     Add,
+    /// Addition of lhs + rhs without an overflow check.
+    UncheckedAdd,
     /// Subtraction of lhs - rhs.
     Sub,
+    /// Subtraction of lhs - rhs without an overflow check.
+    UncheckedSub,
     /// Multiplication of lhs * rhs.
     Mul,
+    /// Multiplication of lhs * rhs without an overflow check.
+    UncheckedMul,
     /// Division of lhs / rhs.
     Div,
     /// Modulus of lhs % rhs.
@@ -49,8 +55,11 @@ 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::UncheckedAdd => write!(f, "unchecked_add"),
             BinaryOp::Sub => write!(f, "sub"),
+            BinaryOp::UncheckedSub => write!(f, "unchecked_sub"),
             BinaryOp::Mul => write!(f, "mul"),
+            BinaryOp::UncheckedMul => write!(f, "unchecked_mul"),
             BinaryOp::Div => write!(f, "div"),
             BinaryOp::Eq => write!(f, "eq"),
             BinaryOp::Mod => write!(f, "mod"),
@@ -107,20 +116,20 @@ impl Binary {
         let rhs_is_one = rhs.map_or(false, |rhs| rhs.is_one());
 
         match self.operator {
-            BinaryOp::Add => {
+            BinaryOp::Add | BinaryOp::UncheckedAdd => {
                 if lhs_is_zero {
                     return SimplifyResult::SimplifiedTo(self.rhs);
                 }
                 if rhs_is_zero {
                     return SimplifyResult::SimplifiedTo(self.lhs);
                 }
             }
-            BinaryOp::Sub => {
+            BinaryOp::Sub | BinaryOp::UncheckedSub => {
                 if rhs_is_zero {
                     return SimplifyResult::SimplifiedTo(self.lhs);
                 }
             }
-            BinaryOp::Mul => {
+            BinaryOp::Mul | BinaryOp::UncheckedMul => {
                 if lhs_is_one {
                     return SimplifyResult::SimplifiedTo(self.rhs);
                 }
@@ -141,7 +150,7 @@ impl Binary {
                         if let Instruction::Binary(Binary { lhs, rhs, operator }) =
                             dfg[*instruction]
                         {
-                            if operator == BinaryOp::Mul
+                            if (operator == BinaryOp::Mul || operator == BinaryOp::UncheckedMul)
                                 && (dfg.resolve(self.lhs) == dfg.resolve(lhs)
                                     || dfg.resolve(self.lhs) == dfg.resolve(rhs))
                             {
@@ -156,7 +165,7 @@ impl Binary {
                         if let Instruction::Binary(Binary { lhs, rhs, operator }) =
                             dfg[*instruction]
                         {
-                            if operator == BinaryOp::Mul
+                            if (operator == BinaryOp::Mul || operator == BinaryOp::UncheckedMul)
                                 && (dfg.resolve(self.rhs) == dfg.resolve(lhs)
                                     || dfg.resolve(self.rhs) == dfg.resolve(rhs))
                             {
@@ -470,9 +479,9 @@ fn truncate(int: u128, bit_size: u32) -> u128 {
 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 | BinaryOp::UncheckedAdd => Some(std::ops::Add::add),
+            BinaryOp::Sub | BinaryOp::UncheckedSub => Some(std::ops::Sub::sub),
+            BinaryOp::Mul | BinaryOp::UncheckedMul => 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 +497,9 @@ impl BinaryOp {
 
     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 | BinaryOp::UncheckedAdd => u128::checked_add,
+            BinaryOp::Sub | BinaryOp::UncheckedSub => u128::checked_sub,
+            BinaryOp::Mul | BinaryOp::UncheckedMul => u128::checked_mul,
             BinaryOp::Div => u128::checked_div,
             BinaryOp::Mod => u128::checked_rem,
             BinaryOp::And => |x, y| Some(x & y),
@@ -505,9 +514,9 @@ impl BinaryOp {
 
     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 | BinaryOp::UncheckedAdd => i128::checked_add,
+            BinaryOp::Sub | BinaryOp::UncheckedSub => i128::checked_sub,
+            BinaryOp::Mul | BinaryOp::UncheckedMul => i128::checked_mul,
             BinaryOp::Div => i128::checked_div,
             BinaryOp::Mod => i128::checked_rem,
             BinaryOp::And => |x, y| Some(x & y),

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

@@ -45,6 +45,7 @@ pub(super) fn decompose_constrain(
                     }
 
                     Instruction::Binary(Binary { lhs, rhs, operator: BinaryOp::Mul })
+                    | Instruction::Binary(Binary { lhs, rhs, operator: BinaryOp::UncheckedMul })
                         if constant.is_one() && dfg.type_of_value(lhs) == Type::bool() =>
                     {
                         // Replace an equality assertion on a boolean multiplication

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

@@ -233,7 +233,10 @@ impl<'f> LoopInvariantContext<'f> {
                 }
             }
             Instruction::Binary(binary) => {
-                if !matches!(binary.operator, BinaryOp::Add | BinaryOp::Mul) {
+                if !matches!(
+                    binary.operator,
+                    BinaryOp::Add | BinaryOp::UncheckedAdd | BinaryOp::Mul | BinaryOp::UncheckedMul
+                ) {
                     return false;
                 }
 

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

@@ -126,9 +126,12 @@ impl Context {
         use Instruction::*;
         match instruction {
             Binary(binary) => match binary.operator {
-                BinaryOp::Add | BinaryOp::Sub | BinaryOp::Mul => {
-                    dfg.type_of_value(binary.lhs).is_unsigned()
-                }
+                BinaryOp::Add
+                | BinaryOp::UncheckedAdd
+                | BinaryOp::Sub
+                | BinaryOp::UncheckedSub
+                | BinaryOp::Mul
+                | BinaryOp::UncheckedMul => dfg.type_of_value(binary.lhs).is_unsigned(),
                 BinaryOp::Div | BinaryOp::Mod => {
                     if let Some(rhs) = dfg.get_numeric_constant(binary.rhs) {
                         rhs == FieldElement::zero()

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

@@ -619,10 +619,17 @@ impl Loop {
         let header = &function.dfg[self.header];
         let induction_var = header.parameters()[0];
 
-        back.instructions().iter().filter(|instruction|  {
-            let instruction = &function.dfg[**instruction];
-            matches!(instruction, Instruction::Binary(Binary { lhs, operator: BinaryOp::Add, rhs: _ }) if *lhs == induction_var)
-        }).count()
+        back.instructions()
+            .iter()
+            .filter(|instruction| {
+                let instruction = &function.dfg[**instruction];
+                matches!(instruction,
+                    Instruction::Binary(Binary { lhs, operator: BinaryOp::Add, rhs: _ }) |
+                    Instruction::Binary(Binary { lhs, operator: BinaryOp::UncheckedAdd, rhs: _ })
+                        if *lhs == induction_var
+                )
+            })
+            .count()
     }
 
     /// Decide if this loop is small enough that it can be inlined in a way that the number

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

@@ -298,6 +298,9 @@ impl<'a> Parser<'a> {
             Token::Keyword(Keyword::Xor) => BinaryOp::Xor,
             Token::Keyword(Keyword::Shl) => BinaryOp::Shl,
             Token::Keyword(Keyword::Shr) => BinaryOp::Shr,
+            Token::Keyword(Keyword::UncheckedAdd) => BinaryOp::UncheckedAdd,
+            Token::Keyword(Keyword::UncheckedSub) => BinaryOp::UncheckedSub,
+            Token::Keyword(Keyword::UncheckedMul) => BinaryOp::UncheckedMul,
             _ => return Ok(None),
         };
 

compiler/noirc_evaluator/src/ssa/parser/tests.rs

@@ -326,7 +326,23 @@ fn test_array_get_set_bug() {
 
 #[test]
 fn test_binary() {
-    for op in ["add", "sub", "mul", "div", "eq", "mod", "lt", "and", "or", "xor", "shl", "shr"] {
+    for op in [
+        "add",
+        "sub",
+        "mul",
+        "div",
+        "eq",
+        "mod",
+        "lt",
+        "and",
+        "or",
+        "xor",
+        "shl",
+        "shr",
+        "unchecked_add",
+        "unchecked_sub",
+        "unchecked_mul",
+    ] {
         let src = format!(
             "
             acir(inline) fn main f0 {{

compiler/noirc_evaluator/src/ssa/parser/token.rs

@@ -160,6 +160,9 @@ pub(crate) enum Keyword {
     Then,
     To,
     Truncate,
+    UncheckedAdd,
+    UncheckedSub,
+    UncheckedMul,
     Value,
     Xor,
 }
@@ -217,6 +220,9 @@ impl Keyword {
             "then" => Keyword::Then,
             "to" => Keyword::To,
             "truncate" => Keyword::Truncate,
+            "unchecked_add" => Keyword::UncheckedAdd,
+            "unchecked_sub" => Keyword::UncheckedSub,
+            "unchecked_mul" => Keyword::UncheckedMul,
             "value" => Keyword::Value,
             "xor" => Keyword::Xor,
             _ => return None,
@@ -278,6 +284,9 @@ impl Display for Keyword {
             Keyword::Then => write!(f, "then"),
             Keyword::To => write!(f, "to"),
             Keyword::Truncate => write!(f, "truncate"),
+            Keyword::UncheckedAdd => write!(f, "unchecked_add"),
+            Keyword::UncheckedSub => write!(f, "unchecked_sub"),
+            Keyword::UncheckedMul => write!(f, "unchecked_mul"),
             Keyword::Value => write!(f, "value"),
             Keyword::Xor => write!(f, "xor"),
         }

compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs

@@ -610,7 +610,7 @@ impl<'a> FunctionContext<'a> {
         if offset != 0 {
             let typ = self.builder.type_of_value(address).unwrap_numeric();
             let offset = self.builder.numeric_constant(offset, typ);
-            address = self.builder.insert_binary(address, BinaryOp::Add, offset);
+            address = self.builder.insert_binary(address, BinaryOp::UncheckedAdd, offset);
         }
         address
     }