Use Void to ensure that the new thread diverges

.gitignore

@@ -1,2 +1,3 @@
 /target
 /Cargo.lock
+*~

Cargo.toml

@@ -7,6 +7,9 @@ build = "build.rs"
 [build-dependencies]
 gcc = "0.3.3"
 
+[dependencies]
+void = "0.0.5"
+
 [features]
 default = ["os", "valgrind"]
 os = ["libc"]

examples/basic.rs

@@ -15,6 +15,7 @@ fn main() {
     let mut ctx = Context::new(stack, move || {
       println!("it's alive!");
       (*ctx_slot).swap();
+      panic!("Do not come back!")
     });
 
     ctx_slot = &mut ctx;

src/arch/common.rs

@@ -6,10 +6,14 @@ use core::mem::{size_of, align_of};
 use core::cmp::max;
 use core::ptr;
 
+use void::{self, Void};
+
 use super::imp::STACK_ALIGN;
 
-pub unsafe extern "C" fn rust_trampoline<F: FnOnce()>(f: *const F) {
-  ptr::read(f)()
+pub unsafe extern "C" fn rust_trampoline<F>(f: *const F) -> !
+  where F: FnOnce<(), Output=Void>
+{
+  void::unreachable(ptr::read(f)())
 }
 
 pub unsafe fn push<T>(spp: &mut *mut usize, value: T) -> *mut T {

src/arch/x86/init.s

@@ -35,9 +35,6 @@ movl $$0, %ebp
 // call the function pointer with the data pointer (top of the stack is the first argument)
 call *%eax
 
-// crash if it ever returns
-ud2
-
 1:
   // save our neatly-setup new stack
   xchg %esp, %eax

src/arch/x86/mod.rs

@@ -3,6 +3,8 @@
 // See the LICENSE file included in this distribution.
 use core::prelude::*;
 
+use void::Void;
+
 use stack::Stack;
 use super::common::{push, rust_trampoline};
 
@@ -16,7 +18,9 @@ pub struct Registers {
 
 impl Registers {
   #[inline]
-  pub unsafe fn new<S, F>(stack: &mut S, f: F) -> Registers where S: Stack, F: FnOnce() {
+  pub unsafe fn new<S, F>(stack: &mut S, f: F) -> Registers
+    where S: Stack, F: FnOnce<(), Output=Void>
+  {
     let sp_limit = stack.limit();
     let mut sp = stack.top() as *mut usize;
     let f_ptr = push(&mut sp, f);

src/arch/x86_64/init.s

@@ -35,9 +35,6 @@ movq $$0, %rbp
 // call the function pointer with the data pointer (rdi is the first argument)
 call *%rax
 
-// crash if it ever returns
-ud2
-
 1:
   // save our neatly-setup new stack
   xchg %rsp, %rdi

src/context.rs

@@ -3,6 +3,9 @@
 // See the LICENSE file included in this distribution.
 use core::prelude::*;
 use core::marker::PhantomData;
+
+use void::Void;
+
 use arch::Registers;
 use stack;
 use debug::StackId;
@@ -28,10 +31,9 @@ unsafe impl<'a, Stack> Send for Context<'a, Stack>
 impl<'a, Stack> Context<'a, Stack> where Stack: stack::Stack {
   /// Create a new Context. When it is swapped into,
   /// it will call the passed closure.
-  /// The closure shouldn't return - doing that will abort the process.
   #[inline]
   pub unsafe fn new<F>(mut stack: Stack, f: F) -> Context<'a, Stack>
-    where F: FnOnce() + Send + 'a {
+    where F: FnOnce<(), Output=Void> + Send + 'a {
     let stack_id = StackId::register(&mut stack);
     let regs = Registers::new(&mut stack, f);
     Context {

src/debug/mod.rs

@@ -1,28 +1,21 @@
 // This file is part of libfringe, a low-level green threading library.
 // Copyright (c) 2015, Nathan Zadoks <nathan@nathan7.eu>
 // See the LICENSE file included in this distribution.
-use core::prelude::*;
-use stack;
+pub use self::imp::*;
 
-mod valgrind;
+#[cfg(feature = "valgrind")]
+#[path = "valgrind/mod.rs"]
+mod imp;
 
-#[derive(Debug)]
-pub struct StackId(valgrind::stack_id_t);
-
-impl StackId {
-  #[inline(always)]
-  pub fn register<Stack: stack::Stack>(stack: &mut Stack) -> StackId {
-    StackId(unsafe {
-      valgrind::stack_register(stack.limit(), stack.top())
-    })
-  }
-}
-
-impl Drop for StackId {
-  #[inline(always)]
-  fn drop(&mut self) {
-    unsafe {
-      valgrind::stack_deregister(self.0)
+#[cfg(not(feature = "valgrind"))]
+mod imp {
+  use stack;
+  #[derive(Debug)]
+  pub struct StackId;
+  /// No-op since no valgrind
+  impl StackId {
+    pub unsafe fn register<Stack: stack::Stack>(_stack: &mut Stack) -> StackId {
+      StackId
     }
   }
 }

src/debug/valgrind/mod.rs

@@ -1,17 +1,45 @@
 // This file is part of libfringe, a low-level green threading library.
 // Copyright (c) 2015, Nathan Zadoks <nathan@nathan7.eu>
 // See the LICENSE file included in this distribution.
-pub use self::imp::*;
+#![allow(non_camel_case_types)]
+//! In order for Valgrind to keep track of stack overflows and such, it needs
+//! a little help. That help unfortunately comes in the form of a set of C
+//! macros. Calling out to un-inlineable C code for this is pointlessly slow,
+//! but that's the way it is for now.
+use core::prelude::*;
+use stack;
 
-#[cfg(feature = "valgrind")]
-#[path = "native.rs"]
-mod imp;
+pub type stack_id_t = u32;
+extern "C" {
+  #[link_name = "valgrind_stack_register"]
+  /// Register a stack with Valgrind. Returns an integer ID that can
+  /// be used to deregister the stack when it's deallocated.
+  /// `start < end`.
+  pub fn stack_register(start: *const u8, end: *const u8) -> stack_id_t;
 
-#[cfg(not(feature = "valgrind"))]
-mod imp {
-  //! Stub for the Valgrind functions
-  #![allow(non_camel_case_types)]
-  pub type stack_id_t = ();
-  pub unsafe fn stack_register(_start: *const u8, _end: *const u8) -> stack_id_t {}
-  pub unsafe fn stack_deregister(_id: stack_id_t) {}
+  #[link_name = "valgrind_stack_deregister"]
+  /// Deregister a stack from Valgrind. Takes the integer ID that was returned
+  /// on registration.
+  pub fn stack_deregister(id: stack_id_t);
+}
+
+#[derive(Debug)]
+pub struct StackId(stack_id_t);
+
+impl StackId {
+  #[inline(always)]
+  pub fn register<Stack: stack::Stack>(stack: &mut Stack) -> StackId {
+    StackId(unsafe {
+      stack_register(stack.limit(), stack.top())
+    })
+  }
+}
+
+impl Drop for StackId {
+  #[inline(always)]
+  fn drop(&mut self) {
+    unsafe {
+      stack_deregister(self.0)
+    }
+  }
 }

src/lib.rs

@@ -2,7 +2,7 @@
 // Copyright (c) 2015, Nathan Zadoks <nathan@nathan7.eu>
 // See the LICENSE file included in this distribution.
 #![feature(no_std)]
-#![feature(asm, core, core_prelude)]
+#![feature(asm, core, core_prelude, unboxed_closures)]
 #![no_std]
 
 //! libfringe is a low-level green threading library.
@@ -15,6 +15,8 @@ extern crate core;
 #[macro_use]
 extern crate std;
 
+extern crate void;
+
 pub use context::Context;
 pub use stack::Stack;