✨ Add a project example from @willemolding's Cannon-rs project

crates/mipsevm/src/mips/instrumented.rs

@@ -227,6 +227,38 @@ mod test {
         }
     }
 
+    #[test]
+    fn test_hello_rs_willem() {
+        let elf_bytes = include_bytes!("../../../../example/bin/hello-willem-rs.elf");
+        let mut state = load_elf(elf_bytes).unwrap();
+        patch::patch_go(elf_bytes, &mut state).unwrap();
+        patch::patch_stack(&mut state).unwrap();
+
+        let out = BufWriter::new(Vec::default());
+        let err = BufWriter::new(Vec::default());
+        let mut ins =
+            InstrumentedState::new(state, StaticOracle::new(b"hello world".to_vec()), out, err);
+
+        for _ in 0..400_000 {
+            if ins.state.exited {
+                break;
+            }
+            ins.step(false).unwrap();
+        }
+
+        assert!(ins.state.exited, "must exit");
+        assert_eq!(ins.state.exit_code, 0, "must exit with 0");
+
+        assert_eq!(
+            String::from_utf8(ins.std_out.buffer().to_vec()).unwrap(),
+            "hello world!\n"
+        );
+        assert_eq!(
+            String::from_utf8(ins.std_err.buffer().to_vec()).unwrap(),
+            ""
+        );
+    }
+
     #[test]
     fn test_hello() {
         let elf_bytes = include_bytes!("../../../../example/bin/hello.elf");

crates/mipsevm/src/patch.rs

@@ -69,12 +69,12 @@ pub fn load_elf(raw: &[u8]) -> Result<State> {
                     );
                 }
             } else {
-                anyhow::bail!(
-                    "Program segment {} has different file size ({}) than mem size ({}): filling for non PT_LOAD segments is not supported",
-                    i,
-                    header.p_filesz,
-                    header.p_memsz
-                );
+                // anyhow::bail!(
+                //     "Program segment {} has different file size ({}) than mem size ({}): filling for non PT_LOAD segments is not supported",
+                //     i,
+                //     header.p_filesz,
+                //     header.p_memsz
+                // );
             }
         }
 

example/Makefile

@@ -6,6 +6,13 @@ elf: $(patsubst %/go.mod,bin/%.elf,$(wildcard */go.mod))
 .PHONY: dump
 dump: $(patsubst %/go.mod,bin/%.dump,$(wildcard */go.mod))
 
+# .PHONY: ex-rs
+# ex-rs:
+# 	cd hello-rs && \
+# 		RUSTFLAGS='-C link-arg=-no-pie -C target-cpu=mips32 -C target-feature=-mips32r2,-fpxx,-nooddspreg,+mips32,+crt-static,+soft-float' \
+# 			cross build --release --target ../mips-unknown-linux-gnu.json -Z build-std -Z build-std-features=panic-unwind && \
+# 		cp ../../target/mips-unknown-linux-gnu/release/hello-rs ../bin/hello-rs.elf
+
 bin:
 	mkdir bin
 

example/hello-rs-willem/.gitignore

@@ -0,0 +1,2 @@
+# Rust target dir
+target

example/hello-rs-willem/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "hello-rs-willem"
+edition = "2021"
+version = "0.0.1"
+authors = ["Willem Olding"]
+
+[dependencies]
+linked_list_allocator = "0.10.5"
+
+[profile.release]
+panic = "abort"

example/hello-rs-willem/README.md

@@ -0,0 +1,14 @@
+# [`Cannon-rs`][cannon-rs-willem] example program
+
+This is an example Rust program for Cannon that uses Willem Olding's [program template][program-template-willem].
+
+## Building
+
+The program can be built using Badboilabs' provided container:
+
+```sh
+docker run --rm --platform linux/amd64 -v `pwd`/:/code -w="/code" ghcr.io/badboilabs/cannon-rs/builder:main cargo build --release -Zbuild-std 
+```
+
+[cannon-rs-willem]: https://github.com/BadBoiLabs/Cannon-rs
+[program-template-willem]: https://github.com/BadBoiLabs/Cannon-rs/tree/main/project-template

example/hello-rs-willem/mips-unknown-linux-gnu.json

@@ -0,0 +1,29 @@
+{
+  "arch": "mips",
+  "cpu": "mips32",
+  "crt-objects-fallback": "false",
+  "crt-static-respected": true,
+  "data-layout": "E-m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32-S64",
+  "dynamic-linking": true,
+  "env": "gnu",
+  "features": "-mips32r2,-fpxx,-nooddspreg,+mips32,+crt-static,+soft-float",
+  "has-rpath": true,
+  "has-thread-local": true,
+  "linker-flavor": "gnu-cc",
+  "llvm-target": "mips-unknown-linux-gnu",
+  "max-atomic-width": 32,
+  "os": "linux",
+  "position-independent-executables": true,
+  "relro-level": "full",
+  "supported-split-debuginfo": [
+    "packed",
+    "unpacked",
+    "off"
+  ],
+  "target-endian": "big",
+  "target-family": [
+    "unix"
+  ],
+  "target-mcount": "_mcount",
+  "target-pointer-width": "32"
+}

example/hello-rs-willem/src/heap.rs

@@ -0,0 +1,52 @@
+///! This is actually just a wrapper around linked_list_allocator that allows it to work in our environment
+///! Different allocator can be used if desired
+use core::alloc::{GlobalAlloc, Layout};
+use core::cell::RefCell;
+use core::mem::MaybeUninit;
+use core::ptr::{self, NonNull};
+struct Alloc {
+    heap: RefCell<linked_list_allocator::Heap>,
+}
+
+impl Alloc {
+    const fn new() -> Self {
+        Self {
+            heap: RefCell::new(linked_list_allocator::Heap::empty()),
+        }
+    }
+}
+
+unsafe impl GlobalAlloc for Alloc {
+    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
+        self.heap
+            .borrow_mut()
+            .allocate_first_fit(layout)
+            .ok()
+            .map_or(ptr::null_mut(), |allocation| allocation.as_ptr())
+    }
+
+    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
+        self.heap
+            .borrow_mut()
+            .deallocate(NonNull::new_unchecked(ptr), layout)
+    }
+}
+
+#[global_allocator]
+static mut ALLOCATOR: Alloc = Alloc::new();
+
+pub unsafe fn init(heap: &mut [MaybeUninit<u8>]) {
+    ALLOCATOR
+        .heap
+        .borrow_mut()
+        .init(heap.as_mut_ptr() as *mut u8, heap.len())
+}
+
+#[macro_export]
+macro_rules! init_heap {
+    ( $x:expr ) => {{
+        use core::mem::MaybeUninit;
+        static mut HEAP: [MaybeUninit<u8>; $x] = [MaybeUninit::uninit(); $x];
+        unsafe { crate::heap::init(&mut HEAP) }
+    }};
+}