chore: revert some foreign call changes

AztecProtocol · Jun 26, 2024 · 64f579f · 64f579f
1 parent f7b6ab5
commit 64f579f
Show file tree

Hide file tree

Showing 3 changed files with 13 additions and 111 deletions.
diff --git a/noir/noir-repo/acvm-repo/brillig_vm/src/lib.rs b/noir/noir-repo/acvm-repo/brillig_vm/src/lib.rs
@@ -500,25 +500,16 @@ impl<'a, F: AcirField, B: BlackBoxFunctionSolver<F>> VM<'a, F, B> {
                     match output {
                         ForeignCallParam::Array(values) => {
                             if values.len() != *size {
-                                // foreign call returning flattened values into a nested type, so the sizes do not match
-                               let destination = self.memory.read_ref(*pointer_index);
-                               let return_type = value_type;
-                               let mut flatten_values_idx = 0; //index of values read from flatten_values
-                               self.write_slice_of_values_to_memory(destination, &output.fields(), &mut flatten_values_idx, return_type)?;
-                            } else {
+                                    return Err("Foreign call result array doesn't match expected size".to_string());
+                                }
                                 self.write_values_to_memory_slice(*pointer_index, values, value_types)?;
                             }
-                        }
                         _ => {
                             return Err("Function result size does not match brillig bytecode size".to_string());
                         }
                     }
                 } else {
-                    // foreign call returning flattened values into a nested type, so the sizes do not match
-                    let destination = self.memory.read_ref(*pointer_index);
-                    let return_type = value_type;
-                    let mut flatten_values_idx = 0; //index of values read from flatten_values
-                    self.write_slice_of_values_to_memory(destination, &output.fields(), &mut flatten_values_idx, return_type)?;
+                        unimplemented!("deflattening heap arrays from foreign calls");
             }
         }
             (
@@ -530,8 +521,8 @@ impl<'a, F: AcirField, B: BlackBoxFunctionSolver<F>> VM<'a, F, B> {
                         ForeignCallParam::Array(values) => {
                             // Set our size in the size address
                             self.memory.write(*size_index, values.len().into());
-                            self.write_values_to_memory_slice(*pointer_index, values, value_types)?;
 
+                            self.write_values_to_memory_slice(*pointer_index, values, value_types)?;
                         }
                         _ => {
                             return Err("Function result size does not match brillig bytecode size".to_string());
@@ -605,66 +596,6 @@ impl<'a, F: AcirField, B: BlackBoxFunctionSolver<F>> VM<'a, F, B> {
         Ok(())
     }
 
-    /// Writes flattened values to memory, using the provided type
-    /// Function calls itself recursively in order to work with recursive types (nested arrays)
-    /// values_idx is the current index in the values vector and is incremented every time
-    /// a value is written to memory
-    /// The function returns the address of the next value to be written
-    fn write_slice_of_values_to_memory(
-        &mut self,
-        destination: MemoryAddress,
-        values: &Vec<F>,
-        values_idx: &mut usize,
-        value_type: &HeapValueType,
-    ) -> Result<MemoryAddress, String> {
-        let mut current_pointer = destination;
-        match value_type {
-            HeapValueType::Simple(bit_size) => {
-                self.write_value_to_memory(destination, &values[*values_idx], *bit_size)?;
-                *values_idx += 1;
-                Ok(MemoryAddress(destination.to_usize() + 1))
-            }
-            HeapValueType::Array { value_types, size } => {
-                for _ in 0..*size {
-                    for typ in value_types {
-                        match typ {
-                            HeapValueType::Simple(len) => {
-                                self.write_value_to_memory(
-                                    current_pointer,
-                                    &values[*values_idx],
-                                    *len,
-                                )?;
-                                *values_idx += 1;
-                                current_pointer = MemoryAddress(current_pointer.to_usize() + 1);
-                            }
-                            HeapValueType::Array { .. } => {
-                                let destination = self.memory.read_ref(current_pointer);
-                                let destination = self.memory.read_ref(destination);
-                                self.write_slice_of_values_to_memory(
-                                    destination,
-                                    values,
-                                    values_idx,
-                                    typ,
-                                )?;
-                                current_pointer = MemoryAddress(current_pointer.to_usize() + 1);
-                            }
-                            HeapValueType::Vector { .. } => {
-                                return Err(format!(
-                                    "Unsupported returned type in foreign calls {:?}",
-                                    typ
-                                ));
-                            }
-                        }
-                    }
-                }
-                Ok(current_pointer)
-            }
-            HeapValueType::Vector { .. } => {
-                Err(format!("Unsupported returned type in foreign calls {:?}", value_type))
-            }
-        }
-    }
-
     /// Process a binary operation.
     /// This method will not modify the program counter.
     fn process_binary_field_op(

diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs b/noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs
@@ -1737,7 +1737,8 @@ impl<'block> BrilligBlock<'block> {
                     dfg,
                 );
                 let array = variable.extract_array();
-                self.allocate_nested_array(typ, Some(array));
+                self.brillig_context.codegen_allocate_fixed_length_array(array.pointer, array.size);
+                self.brillig_context.usize_const_instruction(array.rc, 1_usize.into());
 
                 variable
             }
@@ -1764,43 +1765,6 @@ impl<'block> BrilligBlock<'block> {
         }
     }
 
-    fn allocate_nested_array(
-        &mut self,
-        typ: &Type,
-        array: Option<BrilligArray>,
-    ) -> BrilligVariable {
-        match typ {
-            Type::Array(types, size) => {
-                let array = array.unwrap_or(BrilligArray {
-                    pointer: self.brillig_context.allocate_register(),
-                    size: *size,
-                    rc: self.brillig_context.allocate_register(),
-                });
-                self.brillig_context.codegen_allocate_fixed_length_array(array.pointer, array.size);
-                self.brillig_context.usize_const_instruction(array.rc, 1_usize.into());
-
-                let mut index = 0_usize;
-                for _ in 0..*size {
-                    for element_type in types.iter() {
-                        match element_type {
-                            Type::Array(_, _) => {
-                                let inner_array = self.allocate_nested_array(element_type, None);
-                                let idx =
-                                    self.brillig_context.make_usize_constant_instruction(index.into());
-                                self.store_variable_in_array(array.pointer, idx, inner_array);
-                            }
-                            Type::Slice(_) => unreachable!("ICE: unsupported slice type in allocate_nested_array(), expects an array or a numeric type"),
-                            _ => (),
-                        }
-                        index += 1;
-                    }
-                }
-                BrilligVariable::BrilligArray(array)
-            }
-            _ => unreachable!("ICE: allocate_nested_array() expects an array, got {typ:?}"),
-        }
-    }
-
     /// Gets the "user-facing" length of an array.
     /// An array of structs with two fields would be stored as an 2 * array.len() array/vector.
     /// So we divide the length by the number of subitems in an item to get the user-facing length.

diff --git a/noir/noir-repo/test_programs/benchmarks/bench_sha256/Nargo.toml b/noir/noir-repo/test_programs/benchmarks/bench_sha256/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "bench_sha256"
+version = "0.1.0"
+type = "bin"
+authors = [""]
+
+[dependencies]