Create bus.asm call to expose native BusInteraction to the backend (#2510)

Currently just the bus.asm call is created. Next step will be editing
`bus.rs` linker to do this call for backends that needs the native bus
interaction.

A key quesiton remains whether we need to import the backend crate or
create another linker mode in the linker crate in order to distinguish
which cases to pass down the native bus interaction vs which cases to
call `bus_multi_linker`.

A third solution is to make both `bus_multi_linker` and
`bus_native_linker` call in `bus.rs`, and this will create both
`BusInteraction` and `PhantomBusInteraction` for all backends, and some
backends can just ignore the native `BusInteraction`, similar to what
we've done for native lookup and permutation.

Author: qwang98

linker/Cargo.toml

@@ -12,6 +12,8 @@ powdr-analysis.workspace = true
 powdr-ast.workspace = true
 powdr-number.workspace = true
 powdr-parser-util.workspace = true
+powdr-pil-analyzer.workspace = true
+powdr-pilopt.workspace = true
 strum = { version = "0.24.1", features = ["derive"] }
 
 pretty_assertions = "1.4.0"

linker/src/bus.rs

@@ -312,6 +312,7 @@ impl BusLinker {
 mod test {
     use std::{fs, path::PathBuf};
 
+    use powdr_ast::analyzed::{Analyzed, Identity};
     use powdr_ast::object::MachineInstanceGraph;
     use powdr_number::{FieldElement, GoldilocksField};
 
@@ -377,4 +378,33 @@ namespace main__rom(4);
         let pil = BusLinker::link(graph, crate::DegreeMode::Vadcop).unwrap();
         assert_eq!(extract_main(&format!("{pil}")), expectation);
     }
+
+    #[test]
+    fn pass_native_bus_interaction_to_backend() {
+        let file_name = "../test_data/asm/empty_vm.asm";
+        let graph = parse_analyze_and_compile_file::<GoldilocksField>(file_name);
+        let pil = BusLinker::link(graph, crate::DegreeMode::Vadcop).unwrap();
+        let analyzed: Analyzed<GoldilocksField> = powdr_pil_analyzer::analyze_ast(pil).unwrap();
+        let optimized = powdr_pilopt::optimize(analyzed);
+        let native_bus_interactions = optimized
+            .identities
+            .iter()
+            .filter_map(|i| match i {
+                Identity::BusInteraction(interaction) => Some(interaction),
+                _ => None,
+            })
+            .collect::<Vec<_>>();
+
+        let expectation = r#"Constr::BusInteraction(1, 0, [0, main::pc, main::instr__jump_to_operation, main::instr__reset, main::instr__loop, main::instr_return], 1);
+Constr::BusInteraction(-main__rom::multiplicity, 0, [0, main__rom::p_line, main__rom::p_instr__jump_to_operation, main__rom::p_instr__reset, main__rom::p_instr__loop, 0], 1);
+"#;
+        let native_bus_interactions =
+            native_bus_interactions
+                .iter()
+                .fold(String::new(), |mut acc, i| {
+                    acc.push_str(&format!("{i}\n"));
+                    acc
+                });
+        assert_eq!(native_bus_interactions, expectation);
+    }
 }

std/protocols/bus.asm

@@ -202,6 +202,17 @@ let bus_multi_interaction: expr[], expr[][], expr[], expr[] -> () = constr |ids,
             )
         }
     );
+
+    // Add array of native bus interactions
+    array::new(
+        input_len,
+        |i| Constr::BusInteraction(
+            multiplicities[i], 
+            ids[i], 
+            payloads[i], 
+            latches[i]
+        )
+    );
 };
 
 /// Compute acc' = acc * (1 - is_first') + multiplicity' / fingerprint(id, payload...),