revert interface change, and check the limbs number

Author: guipublic

acvm-repo/brillig/src/black_box.rs

@@ -50,19 +50,19 @@ pub enum BlackBoxOp {
     Sha256Compression { input: HeapArray, hash_values: HeapArray, output: HeapArray },
     /// Returns a decomposition in `num_limbs` limbs of the given input over the given radix.
     ///
-    /// - The value stored at `input` must be a `Field`.
-    /// - The value stored at `radix` must be a `U32` in the range [2, 256].
-    /// - `num_limbs` must be at least one if the value stored at `input` is not zero.
-    /// - `output_bits` specifies whether we should decompose into bits.
-    ///   The value stored at `radix` must be two if `output_bits` is true.
+    /// - The value stored in `radix` must be in the range [2, 256]
+    /// - `num_limbs` must be at least one if the value stored in `input` is not zero.
+    /// - The value stored in `output_bits` must have a `bit_size` of one.
+    ///   That value specifies whether we should decompose into bits. The value stored in
+    ///   the `radix` address must be two if the value stored in `output_bits` is equal to one.
     ///
     /// Native to the Brillig VM and not supported as an ACIR black box function.
     ToRadix {
         input: MemoryAddress,
         radix: MemoryAddress,
         output_pointer: MemoryAddress,
-        num_limbs: u32,
-        output_bits: bool,
+        num_limbs: MemoryAddress,
+        output_bits: MemoryAddress,
     },
 }
 

acvm-repo/brillig_vm/src/black_box.rs

@@ -297,8 +297,12 @@ pub(crate) fn evaluate_black_box<F: AcirField, Solver: BlackBoxFunctionSolver<F>
             let MemoryValue::U32(radix) = memory.read(*radix) else {
                 panic!("ToRadix opcode's radix bit size does not match expected bit size 32")
             };
+            let num_limbs = memory.read(*num_limbs).to_u32();
+            let MemoryValue::U1(output_bits) = memory.read(*output_bits) else {
+                panic!("ToRadix opcode's output_bits size does not match expected bit size 1")
+            };
 
-            let output = to_be_radix(input, radix, assert_usize(*num_limbs), *output_bits)?;
+            let output = to_be_radix(input, radix, assert_usize(num_limbs), output_bits)?;
 
             memory.write_slice(memory.read_ref(*output_pointer), &output);
 

compiler/noirc_evaluator/src/brillig/brillig_check.rs

@@ -608,9 +608,11 @@ trait OpcodeAddressVisitor {
                 self.read_heap_array(hash_values, location);
                 self.write_heap_array(output, location);
             }
-            BlackBoxOp::ToRadix { input, radix, output_pointer, num_limbs: _, output_bits: _ } => {
+            BlackBoxOp::ToRadix { input, radix, output_pointer, num_limbs, output_bits } => {
                 self.read(input, location);
                 self.read(radix, location);
+                self.read(num_limbs, location);
+                self.read(output_bits, location);
                 self.read(output_pointer, location); // indirect
             }
         }

compiler/noirc_evaluator/src/brillig/brillig_gen/tests/call.rs

@@ -136,21 +136,37 @@ fn brillig_to_bits() {
     assert_artifact_snapshot!(foo, @r"
     fn foo
      0: sp[4] = const u32 2
-     1: sp[3] = @1
-     2: sp[5] = const u32 9
-     3: @1 = u32 add @1, sp[5]
-     4: sp[3] = indirect const u32 1
-     5: sp[5] = u32 add sp[3], @2
-     6: sp[6] = const u32 8
-     7: to_radix(input: sp[2], radix: sp[4], num_limbs: 8, output_pointer: sp[5], output_bits: true)
-     8: @3 = sp[5]
-     9: @4 = sp[6]
-    10: call 0 // -> ArrayReverse
-    11: sp[2] = sp[3]
-    12: return
+     1: sp[5] = const bool 1
+     2: sp[3] = @1
+     3: sp[6] = const u32 9
+     4: @1 = u32 add @1, sp[6]
+     5: sp[3] = indirect const u32 1
+     6: sp[6] = u32 add sp[3], @2
+     7: sp[7] = const u32 8
+     8: to_radix(input: sp[2], radix: sp[4], num_limbs: sp[7], output_pointer: sp[6], output_bits: sp[5])
+     9: @3 = sp[6]
+    10: @4 = sp[7]
+    11: call 0 // -> ArrayReverse
+    12: sp[2] = sp[3]
+    13: return
     ");
 }
 
+// `to_le_bits::<N>` requesting more limbs than the field is rejected at compile time.
+#[test]
+#[should_panic(expected = "ToRadix num_limbs")]
+fn brillig_to_bits_rejects_more_limbs_than_field_bits() {
+    let src = "
+    brillig(inline) fn foo f0 {
+      b0(v0: Field):
+        v1 = call to_le_bits(v0) -> [u1; 255]
+        return v1
+    }
+    ";
+
+    let _ = ssa_to_brillig_artifacts(src);
+}
+
 // Tests ToRadix intrinsic code-gen for Brillig.
 #[test]
 fn brillig_to_radix() {
@@ -166,18 +182,19 @@ fn brillig_to_radix() {
     let foo = &brillig.ssa_function_to_brillig[&Id::test_new(0)];
     assert_artifact_snapshot!(foo, @r"
     fn foo
-     0: sp[4] = @1
-     1: sp[5] = const u32 9
-     2: @1 = u32 add @1, sp[5]
-     3: sp[4] = indirect const u32 1
-     4: sp[5] = u32 add sp[4], @2
-     5: sp[6] = const u32 8
-     6: to_radix(input: sp[2], radix: sp[3], num_limbs: 8, output_pointer: sp[5], output_bits: false)
-     7: @3 = sp[5]
-     8: @4 = sp[6]
-     9: call 0 // -> ArrayReverse
-    10: sp[2] = sp[4]
-    11: return
+     0: sp[5] = const bool 0
+     1: sp[4] = @1
+     2: sp[6] = const u32 9
+     3: @1 = u32 add @1, sp[6]
+     4: sp[4] = indirect const u32 1
+     5: sp[6] = u32 add sp[4], @2
+     6: sp[7] = const u32 8
+     7: to_radix(input: sp[2], radix: sp[3], num_limbs: sp[7], output_pointer: sp[6], output_bits: sp[5])
+     8: @3 = sp[6]
+     9: @4 = sp[7]
+    10: call 0 // -> ArrayReverse
+    11: sp[2] = sp[4]
+    12: return
     ");
 }
 

compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_intrinsic.rs

@@ -78,29 +78,29 @@ impl<F: AcirField + DebugToString, Registers: RegisterAllocator> BrilligContext<
     ) {
         assert!(source_field.bit_size == F::max_num_bits());
         assert!(radix.bit_size == 32);
-
-        let num_limbs: u32 = target_array.size.0;
         assert!(
-            num_limbs <= F::max_num_bits(),
-            "ToRadix num_limbs ({num_limbs}) exceeds the maximum useful number of limbs ({}) for this field",
+            target_array.size.0 <= F::max_num_bits(),
+            "ToRadix num_limbs ({}) exceeds the maximum useful number of limbs ({}) for this field",
+            target_array.size.0,
             F::max_num_bits()
         );
 
+        let bits_register = self.make_constant_instruction(output_bits.into(), 1);
         self.codegen_initialize_array(target_array);
         let pointer = self.codegen_make_array_items_pointer(target_array);
-        let num_limbs_register = self.make_usize_constant_instruction(num_limbs.into());
+        let num_limbs = self.make_usize_constant_instruction(target_array.size.0.into());
 
         // Perform big-endian ToRadix
         self.black_box_op_instruction(BlackBoxOp::ToRadix {
             input: source_field.address,
             radix: radix.address,
             output_pointer: *pointer,
-            num_limbs,
-            output_bits,
+            num_limbs: num_limbs.address,
+            output_bits: bits_register.address,
         });
 
         if little_endian {
-            self.codegen_array_reverse(*pointer, num_limbs_register.address);
+            self.codegen_array_reverse(*pointer, num_limbs.address);
         }
     }
 }