diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_bit_shifts.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_bit_shifts.rs index 35a0c408c59..8ec6d9e267c 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/remove_bit_shifts.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/remove_bit_shifts.rs @@ -93,7 +93,7 @@ impl Function { /// If this is an ACIR function, go through every instruction, replacing bit shifts with /// more primitive arithmetic operations, fn remove_bit_shifts(&mut self) { - if self.runtime().is_brillig() { + if !self.runtime().is_acir() { return; } @@ -141,7 +141,7 @@ struct Context<'m, 'dfg, 'mapping> { impl Context<'_, '_, '_> { /// Insert ssa instructions which computes lhs << rhs by doing lhs*2^rhs /// and truncate the result to bit_size - pub(crate) fn insert_wrapping_shift_left(&mut self, lhs: ValueId, rhs: ValueId) -> ValueId { + fn insert_wrapping_shift_left(&mut self, lhs: ValueId, rhs: ValueId) -> ValueId { let typ = self.context.dfg.type_of_value(lhs).unwrap_numeric(); let max_lhs_bits = self.context.dfg.get_value_max_num_bits(lhs); let max_bit_shift_size = self.context.dfg.get_numeric_constant(rhs).map_or_else( @@ -213,7 +213,7 @@ impl Context<'_, '_, '_> { /// Insert ssa instructions which computes lhs >> rhs by doing lhs/2^rhs /// For negative signed integers, we do the division on the 1-complement representation of lhs, /// before converting back the result to the 2-complement representation. - pub(crate) fn insert_shift_right(&mut self, lhs: ValueId, rhs: ValueId) -> ValueId { + fn insert_shift_right(&mut self, lhs: ValueId, rhs: ValueId) -> ValueId { let lhs_typ = self.context.dfg.type_of_value(lhs).unwrap_numeric(); let pow = self.two_pow(rhs); @@ -233,11 +233,8 @@ impl Context<'_, '_, '_> { let lhs_as_field = self.insert_cast(lhs, NumericType::NativeField); // For negative numbers, convert to 1-complement using wrapping addition of a + 1 // Unchecked add as these are fields - let one_complement = self.insert_binary( - lhs_sign_as_field, - BinaryOp::Add { unchecked: true }, - lhs_as_field, - ); + let add = BinaryOp::Add { unchecked: true }; + let one_complement = self.insert_binary(lhs_sign_as_field, add, lhs_as_field); let one_complement = self.insert_truncate(one_complement, bit_size, bit_size + 1); let one_complement = self.insert_cast(one_complement, NumericType::signed(bit_size)); @@ -251,11 +248,8 @@ impl Context<'_, '_, '_> { // - ones_complement(lhs) / (2^rhs) == 0 // As the upper bit is set for the ones complement of negative numbers we'd need 2^rhs // to be larger than the lhs bitsize for this to overflow. - let shifted = self.insert_binary( - shifted_complement, - BinaryOp::Sub { unchecked: true }, - lhs_sign_as_int, - ); + let sub = BinaryOp::Sub { unchecked: true }; + let shifted = self.insert_binary(shifted_complement, sub, lhs_sign_as_int); self.insert_truncate(shifted, bit_size, bit_size + 1) } @@ -358,34 +352,25 @@ impl Context<'_, '_, '_> { self.insert_constrain(overflow, one, assert_message.map(Into::into)); } - pub(crate) fn field_constant(&mut self, constant: FieldElement) -> ValueId { + fn field_constant(&mut self, constant: FieldElement) -> ValueId { self.context.dfg.make_constant(constant, NumericType::NativeField) } /// Insert a numeric constant into the current function - pub(crate) fn numeric_constant( - &mut self, - value: impl Into, - typ: NumericType, - ) -> ValueId { + fn numeric_constant(&mut self, value: impl Into, typ: NumericType) -> ValueId { self.context.dfg.make_constant(value.into(), typ) } /// Insert a binary instruction at the end of the current block. /// Returns the result of the binary instruction. - pub(crate) fn insert_binary( - &mut self, - lhs: ValueId, - operator: BinaryOp, - rhs: ValueId, - ) -> ValueId { + fn insert_binary(&mut self, lhs: ValueId, operator: BinaryOp, rhs: ValueId) -> ValueId { let instruction = Instruction::Binary(Binary { lhs, rhs, operator }); self.context.insert_instruction(instruction, None).first() } /// Insert a not instruction at the end of the current block. /// Returns the result of the instruction. - pub(crate) fn insert_not(&mut self, rhs: ValueId) -> ValueId { + fn insert_not(&mut self, rhs: ValueId) -> ValueId { self.context.insert_instruction(Instruction::Not(rhs), None).first() } @@ -401,12 +386,7 @@ impl Context<'_, '_, '_> { /// Insert a truncate instruction at the end of the current block. /// Returns the result of the truncate instruction. - pub(crate) fn insert_truncate( - &mut self, - value: ValueId, - bit_size: u32, - max_bit_size: u32, - ) -> ValueId { + fn insert_truncate(&mut self, value: ValueId, bit_size: u32, max_bit_size: u32) -> ValueId { self.context .insert_instruction(Instruction::Truncate { value, bit_size, max_bit_size }, None) .first() @@ -414,13 +394,13 @@ impl Context<'_, '_, '_> { /// Insert a cast instruction at the end of the current block. /// Returns the result of the cast instruction. - pub(crate) fn insert_cast(&mut self, value: ValueId, typ: NumericType) -> ValueId { + fn insert_cast(&mut self, value: ValueId, typ: NumericType) -> ValueId { self.context.insert_instruction(Instruction::Cast(value, typ), None).first() } /// Insert a call instruction at the end of the current block and return /// the results of the call. - pub(crate) fn insert_call( + fn insert_call( &mut self, func: ValueId, arguments: Vec, @@ -432,12 +412,7 @@ impl Context<'_, '_, '_> { } /// Insert an instruction to extract an element from an array - pub(crate) fn insert_array_get( - &mut self, - array: ValueId, - index: ValueId, - element_type: Type, - ) -> ValueId { + fn insert_array_get(&mut self, array: ValueId, index: ValueId, element_type: Type) -> ValueId { let element_type = Some(vec![element_type]); let offset = ArrayOffset::None; let instruction = Instruction::ArrayGet { array, index, offset };