feat: replace bitwise ANDs used for truncation with Instruction::Truncate

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

@@ -38,9 +38,9 @@
     Or,
     /// Bitwise xor (^)
     Xor,
     /// Bitshift left (<<)
     Shl,
     /// Bitshift right (>>)
     Shr,
 }
 
@@ -197,6 +197,32 @@
                     let instruction = Instruction::binary(BinaryOp::Mul, self.lhs, self.rhs);
                     return SimplifyResult::SimplifiedToInstruction(instruction);
                 }
+                if operand_type.is_unsigned() {
+                    // It's common in other programming languages to truncate values to a certain bit size using
+                    // a bitwise AND with a bit mask. However this operation is quite inefficient inside a snark.
+                    //
+                    // We then replace this bitwise operation with an equivalent truncation instruction.
+                    match (lhs, rhs) {
+                        (Some(bitmask), None) | (None, Some(bitmask)) => {
+                            // This substitution requires the bitmask to retain all of the lower bits.
+                            // The bitmask must then be one less than a power of 2.
+                            let bitmask_plus_one = bitmask.to_u128() + 1;
+                            if bitmask_plus_one.is_power_of_two() {
+                                let value = if lhs.is_some() { self.rhs } else { self.lhs };
+                                let num_bits = bitmask_plus_one.ilog2();
+                                return SimplifyResult::SimplifiedToInstruction(
+                                    Instruction::Truncate {
+                                        value,
+                                        bit_size: num_bits,
+                                        max_bit_size: operand_type.bit_size(),
+                                    },
+                                );
+                            }
+                        }
+
+                        _ => (),
+                    }
+                }
             }
             BinaryOp::Or => {
                 if lhs_is_zero {
@@ -231,7 +257,7 @@
                         return SimplifyResult::SimplifiedTo(zero);
                     }
 
                     // `two_pow_rhs` is limited to be at most `2 ^ {operand_bitsize - 1}` so it fits in `operand_type`.
                     let two_pow_rhs = FieldElement::from(2u128).pow(&rhs_const);
                     let two_pow_rhs = dfg.make_constant(two_pow_rhs, operand_type);
                     return SimplifyResult::SimplifiedToInstruction(Instruction::binary(

cspell.json

@@ -18,6 +18,7 @@
         "bincode",
         "bindgen",
         "bitand",
+        "bitmask",
         "blackbox",
         "boilerplate",
         "boilerplates",
@@ -83,6 +84,7 @@
         "higher-kinded",
         "Hindley-Milner",
         "idents",
+        "ilog",
         "impls",
         "indexmap",
         "injective",