feat(brillig): foreign call/oracle compilation

.gitignore

@@ -18,3 +18,4 @@ result
 *.pk
 *.vk
 **/Verifier.toml
+**/target

Cargo.toml

@@ -24,7 +24,7 @@ edition = "2021"
 rust-version = "1.66"
 
 [workspace.dependencies]
-acvm = "=0.14.1"
+acvm = "=0.14.2"
 arena = { path = "crates/arena" }
 fm = { path = "crates/fm" }
 iter-extended = { path = "crates/iter-extended" }

crates/nargo/src/ops/execute.rs

@@ -1,4 +1,6 @@
-use acvm::pwg::{solve, PartialWitnessGeneratorStatus};
+use acvm::acir::brillig_vm::ForeignCallResult;
+use acvm::acir::circuit::Opcode;
+use acvm::pwg::{solve, PartialWitnessGeneratorStatus, UnresolvedBrilligCall};
 use acvm::PartialWitnessGenerator;
 use acvm::{acir::circuit::Circuit, acir::native_types::WitnessMap, pwg::block::Blocks};
 
@@ -11,8 +13,39 @@ pub fn execute_circuit(
 ) -> Result<WitnessMap, NargoError> {
     let mut blocks = Blocks::default();
     let solver_status = solve(backend, &mut initial_witness, &mut blocks, circuit.opcodes)?;
-    if matches!(solver_status, PartialWitnessGeneratorStatus::RequiresOracleData { .. }) {
-        todo!("Add oracle support to nargo execute")
+
+    // TODO(#1615): Nargo only supports "oracle_print_impl" functions that print a singular value and nothing else
+    // expand this in a general logging refactor
+    if let PartialWitnessGeneratorStatus::RequiresOracleData {
+        unresolved_brillig_calls,
+        required_oracle_data,
+        unsolved_opcodes,
+    } = solver_status
+    {
+        if !required_oracle_data.is_empty() {
+            unreachable!("oracles are not supported by nargo execute")
+        }
+        for unresolved_brillig_call in unresolved_brillig_calls {
+            let UnresolvedBrilligCall { foreign_call_wait_info, mut brillig } =
+                unresolved_brillig_call;
+            let value = foreign_call_wait_info.inputs[0];
+
+            // Execute foreign call "oracle_print_impl"
+            println!("{:?}", value.to_field().to_hex());
+
+            // TODO(#1615): "oracle_print_impl" is just an identity func
+            brillig.foreign_call_results.push(ForeignCallResult { values: vec![value] });
+
+            let mut next_opcodes_for_solving = vec![Opcode::Brillig(brillig)];
+            next_opcodes_for_solving.extend_from_slice(&unsolved_opcodes[..]);
+
+            let solver_status =
+                solve(backend, &mut initial_witness, &mut blocks, next_opcodes_for_solving)?;
+            if matches!(solver_status, PartialWitnessGeneratorStatus::RequiresOracleData { .. }) {
+                todo!("Add multiple foreign call support to nargo execute")
+                // TODO 1557
+            }
+        }
     }
 
     Ok(initial_witness)

crates/nargo_cli/tests/test_data_ssa_refactor/brillig_conditional/Nargo.toml

@@ -0,0 +1,5 @@
+[package]
+authors = [""]
+compiler_version = "0.1"
+
+[dependencies]

crates/nargo_cli/tests/test_data_ssa_refactor/brillig_conditional/Prover.toml

@@ -0,0 +1 @@
+x = "1"

crates/nargo_cli/tests/test_data_ssa_refactor/brillig_conditional/src/main.nr

@@ -0,0 +1,14 @@
+// Tests a very simple program.
+// 
+// The features being tested is basic conditonal on brillig
+fn main(x: Field)  {
+    assert(4 == conditional(x as bool));
+}
+
+unconstrained fn conditional(x : bool) -> Field {
+    if x {
+        4
+    }else {
+        5
+    }
+}

crates/nargo_cli/tests/test_data_ssa_refactor/brillig_field_binary_operations/Nargo.toml

@@ -0,0 +1,5 @@
+[package]
+authors = [""]
+compiler_version = "0.1"
+
+[dependencies]

crates/nargo_cli/tests/test_data_ssa_refactor/brillig_field_binary_operations/src/main.nr

@@ -0,0 +1,25 @@
+// Tests arithmetic operations on fields
+fn main()  {
+    let x = 4;
+    let y = 2;
+    assert((x + y) == add(x, y));
+    assert((x - y) == sub(x, y));
+    assert((x * y) == mul(x, y));
+    assert((x / y) == div(x, y));
+}
+
+unconstrained fn add(x : Field, y : Field) -> Field {
+    x + y
+}
+
+unconstrained fn sub(x : Field, y : Field) -> Field {
+    x - y
+}
+
+unconstrained fn mul(x : Field, y : Field) -> Field {
+    x * y
+}
+
+unconstrained fn div(x : Field, y : Field) -> Field {
+    x / y
+}

crates/nargo_cli/tests/test_data_ssa_refactor/brillig_identity_function/Nargo.toml

@@ -0,0 +1,5 @@
+[package]
+authors = [""]
+compiler_version = "0.1"
+
+[dependencies]

crates/nargo_cli/tests/test_data_ssa_refactor/brillig_identity_function/Prover.toml

@@ -0,0 +1,2 @@
+x = "3"
+

crates/nargo_cli/tests/test_data_ssa_refactor/brillig_identity_function/src/main.nr

@@ -0,0 +1,10 @@
+// Tests a very simple program.
+// 
+// The features being tested is the identity function in Brillig
+fn main(x : Field)  {
+    assert(x == identity(x));
+}
+
+unconstrained fn identity(x : Field) -> Field {
+  x
+}

crates/nargo_cli/tests/test_data_ssa_refactor/brillig_integer_binary_operations/Nargo.toml

@@ -0,0 +1,5 @@
+[package]
+authors = [""]
+compiler_version = "0.1"
+
+[dependencies]

crates/nargo_cli/tests/test_data_ssa_refactor/brillig_integer_binary_operations/src/main.nr

@@ -0,0 +1,80 @@
+// Tests arithmetic operations on integers
+fn main()  {
+    let x: u32 = 6;
+    let y: u32 = 2;
+
+    assert((x + y) == add(x, y));
+
+    assert((x - y) == sub(x, y));
+
+    assert((x * y) == mul(x, y));
+
+    assert((x / y) == div(x, y));
+
+    // TODO SSA => ACIR has some issues with i32 ops
+    assert(check_signed_div(6, 2, 3));
+
+    assert(eq(1, 2) == false);
+    assert(eq(1, 1));
+
+    assert(lt(x, y) == false);
+    assert(lt(y, x));
+
+    assert((x & y) == and(x, y));
+    assert((x | y) == or(x, y));
+
+    // TODO SSA => ACIR has some issues with xor ops
+
+    assert(check_xor(x, y, 4));
+    assert((x >> y) == shr(x, y));
+    assert((x << y) == shl(x, y));
+}
+
+unconstrained fn add(x : u32, y : u32) -> u32 {
+    x + y
+}
+
+unconstrained fn sub(x : u32, y : u32) -> u32 {
+    x - y
+}
+
+unconstrained fn mul(x : u32, y : u32) -> u32 {
+    x * y
+}
+
+unconstrained fn div(x : u32, y : u32) -> u32 {
+    x / y
+}
+
+unconstrained fn check_signed_div(x: i32, y: i32, result: i32) -> bool {
+    (x / y) == result
+}
+
+unconstrained fn eq(x : u32, y : u32) -> bool {
+    x == y
+}
+
+unconstrained fn lt(x : u32, y : u32) -> bool {
+    x < y
+}
+
+unconstrained fn and(x : u32, y : u32) -> u32 {
+    x & y
+}
+
+unconstrained fn or(x : u32, y : u32) -> u32 {
+    x | y
+}
+
+unconstrained fn check_xor(x : u32, y : u32, result: u32) -> bool {
+    (x ^ y) == result
+}
+
+unconstrained fn shr(x : u32, y : u32) -> u32 {
+    x >> y
+}
+
+unconstrained fn shl(x : u32, y : u32) -> u32 {
+    x << y
+}
+

crates/nargo_cli/tests/test_data_ssa_refactor/brillig_loop/Nargo.toml

@@ -0,0 +1,5 @@
+[package]
+authors = [""]
+compiler_version = "0.1"
+
+[dependencies]

crates/nargo_cli/tests/test_data_ssa_refactor/brillig_loop/Prover.toml

@@ -0,0 +1 @@
+sum = "6"

crates/nargo_cli/tests/test_data_ssa_refactor/brillig_loop/src/main.nr

@@ -0,0 +1,14 @@
+// Tests a very simple program.
+// 
+// The features being tested is basic looping on brillig
+fn main(sum: u32){
+    assert(loop(4) == sum);
+}
+
+unconstrained fn loop(x: u32) -> u32 {
+    let mut sum = 0;
+    for i in 0..x {
+        sum = sum + i;
+    }
+    sum
+}

crates/nargo_cli/tests/test_data_ssa_refactor/brillig_not/Nargo.toml

@@ -0,0 +1,5 @@
+[package]
+authors = [""]
+compiler_version = "0.1"
+
+[dependencies]

crates/nargo_cli/tests/test_data_ssa_refactor/brillig_not/Prover.toml

@@ -0,0 +1,2 @@
+x = "1"
+y = "0"

crates/nargo_cli/tests/test_data_ssa_refactor/brillig_not/src/main.nr

@@ -0,0 +1,11 @@
+// Tests a very simple Brillig function.
+// 
+// The features being tested is not instruction on brillig
+fn main(x: Field, y : Field)  {
+    assert(false == not_operator(x as bool));
+    assert(true == not_operator(y as bool));
+}
+
+unconstrained fn not_operator(x : bool) -> bool {
+    !x
+}

crates/nargo_cli/tests/test_data_ssa_refactor/brillig_oracle/Nargo.toml

@@ -0,0 +1,5 @@
+[package]
+authors = [""]
+compiler_version = "0.1"
+
+[dependencies]

crates/nargo_cli/tests/test_data_ssa_refactor/brillig_oracle/Prover.toml

@@ -0,0 +1,2 @@
+x = "10"
+

crates/nargo_cli/tests/test_data_ssa_refactor/brillig_oracle/src/main.nr

@@ -0,0 +1,15 @@
+// Tests oracle usage in brillig/unconstrained functions
+fn main(x: Field)  {
+    // call through a brillig wrapper
+    oracle_print_wrapper(x);
+}
+
+
+#[oracle(oracle_print_impl)]
+unconstrained fn oracle_print(_x : Field) {}
+
+unconstrained fn oracle_print_wrapper(x: Field) {
+    oracle_print(x);
+}
+
+