feat(tests): Add revm test program

Cargo.toml

@@ -45,6 +45,8 @@ thiserror = { version = "2.0.11", default-features = false }
 num-traits = { version = "0.2", default-features = false }
 
 # Testing + Benchmarking
+tracing = "0.1"
+tracing-subscriber = "0.3"
 rstest = "0.26.0"
 criterion = "0.5.1"
 

crates/emu/Cargo.toml

@@ -21,14 +21,18 @@ elf = { version = "0.8.0", default-features = false }
 
 # `test-utils` feature
 rstest = { workspace = true, optional = true }
+tracing = { workspace = true, optional = true }
+tracing-subscriber = { workspace = true, optional = true }
 
 [dev-dependencies]
+tracing.workspace = true
+tracing-subscriber.workspace = true
 rstest.workspace = true
 criterion.workspace = true
 
 [features]
 default = [ "64-bit", "a", "c", "m" ]
-test-utils = [ "dep:rstest" ]
+test-utils = [ "dep:rstest", "dep:tracing", "dep:tracing-subscriber" ]
 
 # Architecture features
 64-bit = [ "brisc-hw/64-bit" ]

crates/emu/benches/rs_programs.rs

@@ -9,11 +9,11 @@ use std::fs;
 
 /// Benchmarks for the RISC-V Rust programs in the `rv-tests` directory.
 fn bench_rs_programs(c: &mut Criterion) {
-    let programs = fs::read_dir("./rv-tests/bin")
+    let programs = fs::read_dir("../../rv-tests/bin")
         .expect("Failed to read rs_programs directory")
         .filter_map(Result::ok)
         .filter(|entry| entry.path().is_file())
-        .filter(|entry| entry.file_name().to_string_lossy().starts_with("rs-"))
+        .filter(|entry| entry.file_name().to_string_lossy().starts_with("rs-64"))
         .map(|entry| entry.path())
         .collect::<Vec<_>>();
 

crates/emu/src/st/mod.rs

@@ -89,7 +89,7 @@ mod test {
         rv64um ~ glob = "rv64um-p-*" ~ must_have = ["64-bit", "m"],
         rv64ua ~ glob = "rv64ua-p-*" ~ must_have = ["64-bit", "a"],
         rv64uc ~ glob = "rv64uc-p-*" ~ must_have = ["64-bit", "c"],
-        rs_program_32 ~ glob = "rs-32bit-*" ~ must_have = ["m", "a", "c"],
+        rs_program_32 ~ glob = "rs-32bit-*" ~ must_have = ["m", "a", "c"] ~ must_not_have = ["64-bit"],
         rs_program_64 ~ glob = "rs-64bit-*" ~ must_have = ["64-bit", "m", "a", "c"]
     );
 }

crates/emu/src/test_utils.rs

@@ -6,27 +6,36 @@ use brisc_hw::{
     kernel::Kernel,
     memory::{Memory, SimpleMemory},
     pipeline::PipelineRegister,
-    XWord, REG_A0,
+    XWord, REG_A0, REG_A1, REG_A2,
 };
-use rstest as _;
 use std::{fs, path::PathBuf};
 
+use rstest as _;
+use tracing_subscriber as _;
+
 /// Creates a set of Rust tests for the RISC-V test suites passed.
 #[macro_export]
 macro_rules! test_suites {
     (
         base_dir = $base_dir:literal,
-        $($name:ident ~ glob = $glob:literal$( ~ must_have = [$($feature:literal$(,)?)+])?$(,)?)+
+        $($name:ident ~ glob = $glob:literal$( ~ must_have = [$($feature:literal$(,)?)+])?$( ~ must_not_have = [$($no_feature:literal$(,)?)+])?$(,)?)+
     ) => {
         $(
             #[rstest::rstest]
             $(#[cfg(all($(feature = $feature,)+))])?
+            $(#[cfg(all(not($(feature = $no_feature,)+)))])?
             fn $name(
                 #[base_dir = $base_dir]
                 #[files($glob)]
                 #[exclude("\\.dump$")]
                 path: std::path::PathBuf,
             ) {
+                // Init global tracing subscriber
+                tracing_subscriber::fmt()
+                    .with_max_level(tracing::Level::DEBUG)
+                    .init();
+                tracing::info!(target: "test-runner", "Running test: {:?}", path.file_name().unwrap());
+
                 $crate::test_utils::run_riscv_test(&path);
             }
         )+
@@ -52,7 +61,7 @@ pub fn run_riscv_test(test_path: &PathBuf) -> f64 {
     }
 
     let ips = clock as f64 / now.elapsed().as_secs_f64();
-    println!("ips: {ips}");
+    tracing::info!(target: "test-runner", "ips: {ips}");
 
     // Check the exit code
     assert_eq!(
@@ -82,7 +91,7 @@ impl Kernel for RiscvTestKernel {
     fn syscall<M: Memory>(
         &mut self,
         sysno: XWord,
-        _: &mut M,
+        mem: &mut M,
         p_reg: &mut PipelineRegister,
     ) -> PipelineResult<XWord> {
         match sysno {
@@ -91,6 +100,20 @@ impl Kernel for RiscvTestKernel {
                 p_reg.exit_code = exit_code;
                 p_reg.exit = true;
             }
+            0x40 => {
+                let fd = p_reg.registers[REG_A0 as usize];
+                let ptr = p_reg.registers[REG_A1 as usize];
+                let len = p_reg.registers[REG_A2 as usize];
+
+                let raw_msg = mem.read_memory_range(ptr, len).unwrap();
+                let msg = String::from_utf8_lossy(&raw_msg);
+
+                if fd == 1 {
+                    tracing::info!(target: "test-runner", "stdout: {}", msg);
+                } else if fd == 2 {
+                    tracing::error!(target: "test-runner", "stderr: {}", msg);
+                }
+            }
             _ => unimplemented!(),
         }
 

crates/hw/src/memory/interface.rs

@@ -3,7 +3,7 @@
 use crate::memory::{
     MemoryResult, Page, PageIndex, PAGE_ADDRESS_MASK, PAGE_ADDRESS_SIZE, PAGE_SIZE,
 };
-use alloc::{format, string::String};
+use alloc::{format, string::String, vec::Vec};
 use brisc_isa::{Byte, DoubleWord, HalfWord, Word, XWord};
 
 /// Length (in bytes) of a [HalfWord].
@@ -263,6 +263,38 @@ pub trait Memory {
         Ok(())
     }
 
+    /// Read a range of memory at a given [Address].
+    ///
+    /// ## Takes
+    /// - `address`: The address to set the memory at.
+    /// - `len`: The number of bytes to read.
+    ///
+    /// ## Returns
+    /// - `Ok(())` if the memory was successfully read.
+    /// - `Err(_)` if the memory could not be read.
+    fn read_memory_range(&mut self, address: Address, len: XWord) -> MemoryResult<Vec<u8>> {
+        let mut data = Vec::with_capacity(len as usize);
+
+        let mut address = address;
+        while data.len() < len as usize {
+            let page_index = address >> PAGE_ADDRESS_SIZE as u64;
+            let page_address = address as usize & PAGE_ADDRESS_MASK;
+
+            let page = if let Some(page) = self.page(page_index) {
+                page
+            } else {
+                return Err(super::MemoryError::PageNotFound(page_index));
+            };
+
+            let read_len = (len as usize - data.len()).min(PAGE_SIZE - page_address);
+            data.extend_from_slice(&page[page_address..page_address + read_len]);
+
+            address += read_len as Address;
+        }
+
+        Ok(data)
+    }
+
     /// Returns a human-readable string describing the size of the [Memory].
     fn usage(&self) -> String {
         let total = (self.page_count() * PAGE_SIZE) as u64;

crates/hw/src/pipeline/register.rs

@@ -60,6 +60,6 @@ impl PipelineRegister {
     /// Computes the effective address of the memory operation if [Self::rs1_value] and
     /// [Self::immediate] are [Some].
     pub fn effective_address(&self) -> Option<Address> {
-        self.rs1_value.and_then(|rs1| self.immediate.map(|imm| rs1 + imm))
+        self.rs1_value.and_then(|rs1| self.immediate.map(|imm| rs1.wrapping_add(imm)))
     }
 }