Try #164:

Author: bors[bot]

.gitignore

@@ -1,3 +1,4 @@
 Cargo.lock
 layout.ld
+platform
 target

Cargo.toml

@@ -6,12 +6,14 @@ license = "MIT/Apache-2.0"
 edition = "2018"
 
 [features]
-alloc = [ "linked_list_allocator" ]
+alloc = ["libtock-core/alloc"]
+custom_panic_handler = ["libtock-core/custom_panic_handler"]
+custom_alloc_error_handler = ["libtock-core/custom_alloc_error_handler"]
 
 [dependencies]
 core = { package = "async-support", path = "async-support" }
+libtock-core = { path = "core" }
 libtock_codegen = { path = "codegen" }
-linked_list_allocator = { optional = true, version = "=0.6.5", default-features = false }
 futures = { version = "0.3.1", default-features = false, features = ["unstable", "cfg-target-has-atomic"] }
 
 [dev-dependencies]
@@ -52,4 +54,5 @@ lto = true
 members = [
     "async-support",
     "codegen",
+    "core"
 ]

core/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "libtock-core"
+version = "0.1.0"
+authors = ["torfmaster <[email protected]>", "Woyten <[email protected]>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[features]
+alloc = [ "linked_list_allocator" ]
+custom_panic_handler = []
+custom_alloc_error_handler = []
+
+[dependencies]
+linked_list_allocator = { optional = true, version = "=0.6.5", default-features = false }

core/src/alloc.rs

@@ -0,0 +1,40 @@
+use core::alloc::GlobalAlloc;
+use core::alloc::Layout;
+use core::ptr;
+use core::ptr::NonNull;
+use linked_list_allocator::Heap;
+
+pub static mut HEAP: Heap = Heap::empty();
+
+struct TockAllocator;
+
+unsafe impl GlobalAlloc for TockAllocator {
+    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
+        HEAP.allocate_first_fit(layout)
+            .ok()
+            .map_or(ptr::null_mut(), NonNull::as_ptr)
+    }
+
+    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
+        HEAP.deallocate(NonNull::new_unchecked(ptr), layout)
+    }
+}
+
+#[global_allocator]
+static ALLOCATOR: TockAllocator = TockAllocator;
+
+#[cfg(not(feature = "custom_alloc_error_handler"))]
+#[alloc_error_handler]
+unsafe fn alloc_error_handler(_: Layout) -> ! {
+    use crate::syscalls;
+
+    // Print 0x01 using the LowLevelDebug capsule (if available).
+    let _ = syscalls::command1_insecure(8, 2, 0x01);
+
+    // Signal a panic using the LowLevelDebug capsule (if available).
+    let _ = syscalls::command1_insecure(8, 1, 0x01);
+
+    loop {
+        syscalls::raw::yieldk();
+    }
+}

src/callback.rs renamed to core/src/callback.rs

@@ -0,0 +1,5 @@
+#[cfg_attr(target_arch = "arm", path = "platform_arm.rs")]
+#[cfg_attr(target_arch = "riscv32", path = "platform_riscv32.rs")]
+mod platform;
+
+pub use platform::*;

core/src/debug/mod.rs

@@ -0,0 +1,3 @@
+pub fn get_stack_pointer() -> usize {
+    panic!("Not implemented yet")
+}

core/src/debug/platform.rs

@@ -0,0 +1,5 @@
+pub fn get_stack_pointer() -> usize {
+    let stack_pointer;
+    unsafe { asm!("mov $0, sp" : "=r"(stack_pointer) : : : "volatile") };
+    stack_pointer
+}

core/src/debug/platform_arm.rs

@@ -0,0 +1,5 @@
+pub fn get_stack_pointer() -> usize {
+    let stack_pointer;
+    unsafe { asm!("mv $0, sp" : "=r"(stack_pointer) : : : "volatile") };
+    stack_pointer
+}

core/src/debug/platform_riscv32.rs

@@ -57,10 +57,6 @@ use core::ptr;
 
 #[cfg_attr(target_arch = "riscv32", path = "start_item_riscv32.rs")]
 #[cfg_attr(target_arch = "arm", path = "start_item_arm.rs")]
-#[cfg_attr(
-    not(any(target_arch = "arm", target_arch = "riscv32")),
-    path = "start_item_mock.rs"
-)]
 mod start_item;
 
 /// The header encoded at the beginning of .text by the linker script. It is

src/entry_point/mod.rs renamed to core/src/entry_point/mod.rs

@@ -18,14 +18,7 @@
 //! `rustc_main`. That's covered by the `_start` function in the root of this
 //! crate.
 
-use crate::drivers;
-use crate::leds::LedsDriver;
-use crate::result::TockResult;
-use crate::timer::Duration;
-use crate::timer::ParallelSleepDriver;
-use core::executor;
-use core::panic::PanicInfo;
-use futures::future;
+use crate::syscalls;
 
 #[lang = "start"]
 extern "C" fn start<T>(main: fn() -> T, _argc: isize, _argv: *const *const u8) -> bool
@@ -45,52 +38,25 @@ impl Termination for () {
     fn check_result(self) {}
 }
 
-impl Termination for TockResult<()> {
+impl<S, T> Termination for Result<S, T> {
     fn check_result(self) {
         if self.is_err() {
             unsafe { report_panic() };
         }
     }
 }
 
+#[cfg(not(feature = "custom_panic_handler"))]
 #[panic_handler]
-unsafe fn panic_handler(_info: &PanicInfo) -> ! {
+unsafe fn panic_handler(_info: &core::panic::PanicInfo) -> ! {
     report_panic()
 }
 
 unsafe fn report_panic() -> ! {
     // Signal a panic using the LowLevelDebug capsule (if available).
-    super::debug::low_level_status_code(1);
+    let _ = syscalls::command1_insecure(8, 1, 1);
 
-    // Flash all LEDs (if available).
-    executor::block_on(async {
-        let mut drivers = drivers::retrieve_drivers_unsafe();
-
-        let leds_driver = drivers.leds.init_driver();
-        let mut timer_driver = drivers.timer.create_timer_driver();
-        let timer_driver = timer_driver.activate();
-
-        if let (Ok(leds_driver), Ok(timer_driver)) = (leds_driver, timer_driver) {
-            let _ = blink_all_leds(&leds_driver, &timer_driver).await;
-        } else {
-            future::pending::<()>().await
-        }
-        loop {}
-    })
-}
-
-async fn blink_all_leds(
-    leds_driver: &LedsDriver<'_>,
-    timer_driver: &ParallelSleepDriver<'_>,
-) -> TockResult<()> {
     loop {
-        for led in leds_driver.leds() {
-            led.on()?;
-        }
-        timer_driver.sleep(Duration::from_ms(100)).await?;
-        for led in leds_driver.leds() {
-            led.off()?;
-        }
-        timer_driver.sleep(Duration::from_ms(100)).await?;
+        syscalls::raw::yieldk();
     }
 }

src/entry_point/start_item_mock.rs renamed to core/src/entry_point/start_item.rs

@@ -0,0 +1,17 @@
+#![feature(asm, lang_items, naked_functions)]
+#![cfg_attr(any(target_arch = "arm", target_arch = "riscv32"), no_std)]
+#![cfg_attr(feature = "alloc", feature(alloc_error_handler))]
+
+#[cfg(feature = "alloc")]
+mod alloc;
+mod entry_point;
+#[cfg(any(target_arch = "arm", target_arch = "riscv32"))]
+mod lang_items;
+
+pub mod callback;
+pub mod debug;
+pub mod memop;
+pub mod result;
+pub mod shared_memory;
+pub mod syscalls;
+pub mod unwind_symbols;

src/entry_point/start_item_arm.rs renamed to core/src/entry_point/start_item_arm.rs

@@ -0,0 +1,30 @@
+#[derive(Copy, Clone)]
+pub struct SubscribeError {
+    pub driver_number: usize,
+    pub subscribe_number: usize,
+    pub return_code: isize,
+}
+
+#[derive(Copy, Clone)]
+pub struct CommandError {
+    pub driver_number: usize,
+    pub command_number: usize,
+    pub arg1: usize,
+    pub arg2: usize,
+    pub return_code: isize,
+}
+
+#[derive(Copy, Clone)]
+pub struct AllowError {
+    pub driver_number: usize,
+    pub allow_number: usize,
+    pub return_code: isize,
+}
+
+pub const SUCCESS: isize = 0;
+pub const FAIL: isize = -1;
+pub const EBUSY: isize = -2;
+pub const EALREADY: isize = -3;
+pub const EINVAL: isize = -6;
+pub const ESIZE: isize = -7;
+pub const ENOMEM: isize = -9;

src/entry_point/start_item_riscv32.rs renamed to core/src/entry_point/start_item_riscv32.rs

@@ -1,9 +1,5 @@
 #[cfg_attr(target_arch = "riscv32", path = "platform_riscv32.rs")]
 #[cfg_attr(target_arch = "arm", path = "platform_arm.rs")]
-#[cfg_attr(
-    not(any(target_arch = "arm", target_arch = "riscv32")),
-    path = "platform_mock.rs"
-)]
 mod platform;
 
 use crate::callback::CallbackSubscription;

src/lang_items.rs renamed to core/src/lang_items.rs

@@ -3,6 +3,7 @@
 mod low_level_debug;
 
 use crate::drivers;
+use libtock_core::debug as core_debug;
 
 pub use low_level_debug::*;
 
@@ -21,22 +22,15 @@ pub fn print_as_hex(value: usize) {
     let _ = console.write(buffer);
 }
 
-#[cfg(target_arch = "arm")]
 pub fn print_stack_pointer() {
-    let stack_pointer;
-    unsafe { asm!("mov $0, sp" : "=r"(stack_pointer) : : : "volatile") };
-
     let mut buffer = [b'\n'; 15];
     buffer[0..4].clone_from_slice(b"SP: ");
-    write_as_hex(&mut buffer[4..15], stack_pointer);
+    write_as_hex(&mut buffer[4..15], core_debug::get_stack_pointer());
     let drivers = unsafe { drivers::retrieve_drivers_unsafe() };
     let mut console = drivers.console.create_console();
     let _ = console.write(buffer);
 }
 
-#[cfg(target_arch = "riscv32")]
-pub fn print_stack_pointer() {}
-
 #[inline(always)]
 /// Dumps address
 /// # Safety

core/src/lib.rs

@@ -1,35 +1,23 @@
-#![feature(asm, lang_items, naked_functions)]
-#![cfg_attr(feature = "alloc", feature(alloc_error_handler))]
 #![cfg_attr(any(target_arch = "arm", target_arch = "riscv32"), no_std)]
 
-#[cfg(feature = "alloc")]
-mod alloc;
-mod entry_point;
-#[cfg(any(target_arch = "arm", target_arch = "riscv32"))]
-mod lang_items;
-
 pub mod adc;
 pub mod ble_composer;
 pub mod ble_parser;
 pub mod buttons;
-pub mod callback;
 pub mod console;
 pub mod debug;
 pub mod drivers;
 pub mod electronics;
 pub mod futures;
 pub mod gpio;
 pub mod leds;
-pub mod memop;
 pub mod result;
 pub mod rng;
 pub mod sensors;
-pub mod shared_memory;
 pub mod simple_ble;
-pub mod syscalls;
 pub mod temperature;
 pub mod timer;
-pub mod unwind_symbols;
 
 pub use drivers::retrieve_drivers;
 pub use libtock_codegen::main;
+pub use libtock_core::*;