add panic, stdio, and alloc support to armv7a-vex-v5

Author: max-niederman

compiler/rustc_target/src/spec/targets/armv7a_vex_v5_linker_script.ld

@@ -18,7 +18,7 @@ I'm not sure why subtracting anything is necessary, but it fixes memory permissi
 __heap_end = __cold_end - __stack_length - 0x1000;
 
 SECTIONS {
-    .code_signature {
+    .code_signature : {
         KEEP(*(.code_signature))
         . = __cold_start + 0x20;
     } > COLD

library/panic_abort/src/lib.rs

@@ -51,6 +51,7 @@ pub unsafe fn __rust_start_panic(_payload: &mut dyn PanicPayload) -> u32 {
                             all(target_vendor = "fortanix", target_env = "sgx"),
                             target_os = "xous",
                             target_os = "uefi",
+                            target_os = "vexos",
         ))] {
             unsafe fn abort() -> ! {
                 // call std::sys::abort_internal

library/std/Cargo.toml

@@ -68,7 +68,7 @@ path = "../windows_targets"
 rand = { version = "0.8.5", default-features = false, features = ["alloc"] }
 rand_xorshift = "0.3.0"
 
-[target.'cfg(any(all(target_family = "wasm", target_os = "unknown"), target_os = "xous", all(target_vendor = "fortanix", target_env = "sgx")))'.dependencies]
+[target.'cfg(any(all(target_family = "wasm", target_os = "unknown"), target_os = "vexos", target_os = "xous", all(target_vendor = "fortanix", target_env = "sgx")))'.dependencies]
 dlmalloc = { version = "0.2.4", features = ['rustc-dep-of-std'] }
 
 [target.x86_64-fortanix-unknown-sgx.dependencies]

library/std/src/sys/pal/vexos/alloc.rs

@@ -0,0 +1,97 @@
+use crate::{
+    alloc::{GlobalAlloc, Layout, System},
+    ptr,
+    sync::atomic::{AtomicBool, Ordering},
+};
+
+static mut DLMALLOC: dlmalloc::Dlmalloc<Vexos> = dlmalloc::Dlmalloc::new_with_allocator(Vexos);
+
+extern "C" {
+    static mut __heap_start: u8;
+    static mut __heap_end: u8;
+}
+
+struct Vexos;
+
+unsafe impl dlmalloc::Allocator for Vexos {
+    /// Allocs system resources
+    fn alloc(&self, _size: usize) -> (*mut u8, usize, u32) {
+        static INIT: AtomicBool = AtomicBool::new(false);
+
+        if !INIT.swap(true, Ordering::Relaxed) {
+            unsafe {
+                (
+                    ptr::addr_of_mut!(__heap_start).cast(),
+                    ptr::addr_of!(__heap_end).byte_offset_from(ptr::addr_of!(__heap_start)) as _,
+                    0,
+                )
+            }
+        } else {
+            (ptr::null_mut(), 0, 0)
+        }
+    }
+
+    fn remap(&self, _ptr: *mut u8, _oldsize: usize, _newsize: usize, _can_move: bool) -> *mut u8 {
+        ptr::null_mut()
+    }
+
+    fn free_part(&self, _ptr: *mut u8, _oldsize: usize, _newsize: usize) -> bool {
+        false
+    }
+
+    fn free(&self, _ptr: *mut u8, _size: usize) -> bool {
+        return false;
+    }
+
+    fn can_release_part(&self, _flags: u32) -> bool {
+        false
+    }
+
+    fn allocates_zeros(&self) -> bool {
+        false
+    }
+
+    fn page_size(&self) -> usize {
+        0x1000
+    }
+}
+
+#[stable(feature = "alloc_system_type", since = "1.28.0")]
+unsafe impl GlobalAlloc for System {
+    #[inline]
+    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
+        // SAFETY: DLMALLOC access is guaranteed to be safe because the lock gives us unique and non-reentrant access.
+        // Calling malloc() is safe because preconditions on this function match the trait method preconditions.
+        let _lock = lock::lock();
+        unsafe { DLMALLOC.malloc(layout.size(), layout.align()) }
+    }
+
+    #[inline]
+    unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 {
+        // SAFETY: DLMALLOC access is guaranteed to be safe because the lock gives us unique and non-reentrant access.
+        // Calling calloc() is safe because preconditions on this function match the trait method preconditions.
+        let _lock = lock::lock();
+        unsafe { DLMALLOC.calloc(layout.size(), layout.align()) }
+    }
+
+    #[inline]
+    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
+        // SAFETY: DLMALLOC access is guaranteed to be safe because the lock gives us unique and non-reentrant access.
+        // Calling free() is safe because preconditions on this function match the trait method preconditions.
+        let _lock = lock::lock();
+        unsafe { DLMALLOC.free(ptr, layout.size(), layout.align()) }
+    }
+
+    #[inline]
+    unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
+        // SAFETY: DLMALLOC access is guaranteed to be safe because the lock gives us unique and non-reentrant access.
+        // Calling realloc() is safe because preconditions on this function match the trait method preconditions.
+        let _lock = lock::lock();
+        unsafe { DLMALLOC.realloc(ptr, layout.size(), layout.align(), new_size) }
+    }
+}
+
+mod lock {
+    #[inline]
+    pub fn lock() {} // we don't have threads, which makes this real easy
+}

library/std/src/sys/pal/vexos/mod.rs

@@ -1,4 +1,3 @@
-#[path = "../unsupported/alloc.rs"]
 pub mod alloc;
 #[path = "../unsupported/args.rs"]
 pub mod args;
@@ -16,7 +15,6 @@ pub mod os;
 pub mod pipe;
 #[path = "../unsupported/process.rs"]
 pub mod process;
-#[path = "../unsupported/stdio.rs"]
 pub mod stdio;
 #[path = "../unsupported/thread.rs"]
 pub mod thread;
@@ -29,3 +27,18 @@ pub mod time;
 #[deny(unsafe_op_in_unsafe_fn)]
 mod common;
 pub use common::*;
+
+// This function is needed by the panic runtime. The symbol is named in
+// pre-link args for the target specification, so keep that in sync.
+#[cfg(not(test))]
+#[no_mangle]
+// NB. used by both libunwind and libpanic_abort
+pub extern "C" fn __rust_abort() -> ! {
+    unsafe {
+        vex_sdk::vexSystemExitRequest();
+    }
+
+    loop {
+        crate::hint::spin_loop()
+    }
+}

library/std/src/sys/pal/vexos/stdio.rs

@@ -0,0 +1,86 @@
+use crate::io;
+
+pub struct Stdin(());
+pub struct Stdout(());
+pub struct Stderr(());
+
+const STDIO_CHANNEL: u32 = 1;
+
+impl Stdin {
+    pub const fn new() -> Stdin {
+        Stdin(())
+    }
+}
+
+impl io::Read for Stdin {
+    fn read(&mut self, mut buf: &mut [u8]) -> io::Result<usize> {
+        let mut written = 0;
+
+        while let Some((out_byte, new_buf)) = buf.split_first_mut() {
+            buf = new_buf;
+
+            let byte = unsafe { vex_sdk::vexSerialReadChar(STDIO_CHANNEL) };
+            if byte < 0 {
+                break;
+            }
+
+            *out_byte = byte as u8;
+            written += 1;
+        }
+
+        Ok(written)
+    }
+}
+
+impl Stdout {
+    pub const fn new() -> Stdout {
+        Stdout(())
+    }
+}
+
+impl io::Write for Stdout {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        let written =
+            unsafe { vex_sdk::vexSerialWriteBuffer(STDIO_CHANNEL, buf.as_ptr(), buf.len() as u32) };
+
+        if written < 0 {
+            return Err(io::Error::new(io::ErrorKind::Other, "Internal write error occurred."));
+        }
+
+        Ok(written as usize)
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        unsafe {
+            vex_sdk::vexTasksRun();
+        }
+
+        Ok(())
+    }
+}
+
+impl Stderr {
+    pub const fn new() -> Stderr {
+        Stderr(())
+    }
+}
+
+impl io::Write for Stderr {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        Ok(buf.len())
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+pub const STDIN_BUF_SIZE: usize = 0;
+
+pub fn is_ebadf(_err: &io::Error) -> bool {
+    true
+}
+
+pub fn panic_output() -> Option<impl io::Write> {
+    Some(Stdout::new())
+}