chore: apply sync fixes

noir-lang · Jun 26, 2024 · 2918c23 · 2918c23
1 parent 7de19f5
commit 2918c23
Show file tree

Hide file tree

Showing 265 changed files with 2,544 additions and 3,335 deletions.
diff --git a/.aztec-sync-commit b/.aztec-sync-commit
@@ -1 +1 @@
-12af650f0d27c37dca06bb329bf76a5574534d78
+9be0ad6b41a69c35ad9737d60da7a16300b87642
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -22,6 +22,7 @@ members = [
     "tooling/noirc_abi",
     "tooling/noirc_abi_wasm",
     "tooling/acvm_cli",
+    "tooling/profiler",
     # ACVM
     "acvm-repo/acir_field",
     "acvm-repo/acir",
@@ -34,7 +35,7 @@ members = [
     # Utility crates
     "utils/iter-extended",
 ]
-default-members = ["tooling/nargo_cli", "tooling/acvm_cli"]
+default-members = ["tooling/nargo_cli", "tooling/acvm_cli", "tooling/profiler"]
 resolver = "2"
 
 [workspace.package]
@@ -80,7 +81,7 @@ acvm_cli = { path = "tooling/acvm_cli" }
 # Arkworks
 ark-bn254 = { version = "^0.4.0", default-features = false, features = ["curve"] }
 ark-bls12-381 = { version = "^0.4.0", default-features = false, features = ["curve"] }
-grumpkin = { version = "0.1.0", package = "noir_grumpkin", features = ["std"] } 
+grumpkin = { version = "0.1.0", package = "noir_grumpkin", features = ["std"] }
 ark-ec = { version = "^0.4.0", default-features = false }
 ark-ff = { version = "^0.4.0", default-features = false }
 ark-std = { version = "^0.4.0", default-features = false }
@@ -139,11 +140,9 @@ similar-asserts = "1.5.0"
 tempfile = "3.6.0"
 jsonrpc = { version = "0.16.0", features = ["minreq_http"] }
 flate2 = "1.0.24"
+color-eyre = "0.6.2"
 rand = "0.8.5"
 proptest = "1.2.0"
-proptest-derive = "0.4.0"
-
-
 im = { version = "15.1", features = ["serde"] }
 tracing = "0.1.40"
 tracing-web = "0.1.3"

diff --git a/acvm-repo/brillig_vm/src/lib.rs b/acvm-repo/brillig_vm/src/lib.rs
@@ -482,64 +482,60 @@ impl<'a, F: AcirField, B: BlackBoxFunctionSolver<F>> VM<'a, F, B> {
             destinations.iter().zip(destination_value_types).zip(&values)
         {
             match (destination, value_type) {
-            (ValueOrArray::MemoryAddress(value_index), HeapValueType::Simple(bit_size)) => {
-                match output {
-                    ForeignCallParam::Single(value) => {
-                        self.write_value_to_memory(*value_index, value, *bit_size)?;
+                (ValueOrArray::MemoryAddress(value_index), HeapValueType::Simple(bit_size)) => {
+                    match output {
+                        ForeignCallParam::Single(value) => {
+                            self.write_value_to_memory(*value_index, value, *bit_size)?;
+                        }
+                        _ => return Err(format!(
+                            "Function result size does not match brillig bytecode. Expected 1 result but got {output:?}")
+                        ),
                     }
-                    _ => return Err(format!(
-                        "Function result size does not match brillig bytecode. Expected 1 result but got {output:?}")
-                    ),
                 }
-            }
-            (
-                ValueOrArray::HeapArray(HeapArray { pointer: pointer_index, size }),
-                HeapValueType::Array { value_types, size: type_size },
-            ) if size == type_size => {
-                if HeapValueType::all_simple(value_types) {
-                    match output {
-                        ForeignCallParam::Array(values) => {
-                            if values.len() != *size {
-                                return Err("Foreign call result array doesn't match expected size".to_string());
+                (
+                    ValueOrArray::HeapArray(HeapArray { pointer: pointer_index, size }),
+                    HeapValueType::Array { value_types, size: type_size },
+                ) if size == type_size => {
+                    if HeapValueType::all_simple(value_types) {
+                         match output {
+                            ForeignCallParam::Array(values) => {
+                                if values.len() != *size {
+                                    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());
                             }
-                            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 {
+                        unimplemented!("deflattening heap arrays from foreign calls");
                     }
-                } 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)?;
-            }
-        }
-            (
-                ValueOrArray::HeapVector(HeapVector {pointer: pointer_index, size: size_index }),
-                HeapValueType::Vector { value_types },
-            ) => {
-                if HeapValueType::all_simple(value_types) {
-                    match output {
-                        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)?;
-
-                        }
-                        _ => {
-                            return Err("Function result size does not match brillig bytecode size".to_string());
+                }
+                (
+                    ValueOrArray::HeapVector(HeapVector {pointer: pointer_index, size: size_index }),
+                    HeapValueType::Vector { value_types },
+                ) => {
+                    if HeapValueType::all_simple(value_types) {
+                        match output {
+                            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)?;
+                            }
+                            _ => {
+                                return Err("Function result size does not match brillig bytecode size".to_string());
+                            }
                         }
+                    } else {
+                        unimplemented!("deflattening heap vectors from foreign calls");
                     }
-                } else {
-                    unimplemented!("deflattening heap vectors from foreign calls");
+                }
+                _ => {
+                    return Err(format!("Unexpected value type {value_type:?} for destination {destination:?}"));
                 }
             }
-            _ => {
-                return Err(format!("Unexpected value type {value_type:?} for destination {destination:?}"));
-            }
-        }
         }
 
         let _ =
@@ -600,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/aztec_macros/Cargo.toml b/aztec_macros/Cargo.toml
@@ -16,4 +16,4 @@ noirc_errors.workspace = true
 iter-extended.workspace = true
 convert_case = "0.6.0"
 regex = "1.10"
-
+tiny-keccak = { version = "2.0.0", features = ["keccak"] }