Issue 51 Unwind error if the Coroutine::yield_with is inlined

src/coroutine.rs

@@ -48,6 +48,8 @@ extern "C" fn coroutine_entry(t: Transfer) -> ! {
         next: None,
 
         stack: Some(stack),
+
+        unwind_flag: ::std::sync::atomic::AtomicBool::new(false),
     };
 
     {
@@ -98,7 +100,10 @@ extern "C" fn coroutine_exit(mut t: Transfer) -> Transfer {
     t
 }
 
-extern "C" fn coroutine_unwind(t: Transfer) -> Transfer {
+//extern "C" fn coroutine_unwind(t: Transfer) -> Transfer {
+    // Inlining actually didn't trigger issue 51 on MINGW64, so
+    // stubbing this out.
+    /*
     let coro = unsafe { &mut *(t.data as *mut Coroutine) };
 
     // Save the Context in the Coroutine object because `coroutine_entry()` needs
@@ -107,7 +112,9 @@ extern "C" fn coroutine_unwind(t: Transfer) -> Transfer {
 
     trace!("{:?}: unwinding", coro);
     panic::resume_unwind(Box::new(ForceUnwind));
-}
+    */
+//    t
+//}
 
 #[derive(Debug)]
 pub struct ForceUnwind;
@@ -136,6 +143,10 @@ pub struct Coroutine {
     next: Option<Handle>,
 
     stack: Option<Stack>,
+
+    // Proof-of-concept
+    unwind_flag: ::std::sync::atomic::AtomicBool,
+
 }
 
 unsafe impl Send for Coroutine {}
@@ -228,15 +239,33 @@ impl Coroutine {
     //
     // Tracking issue: https://github.com/zonyitoo/coio-rs/issues/51
     #[doc(hidden)]
-    #[inline(never)]
+    #[inline(always)]
     pub fn yield_with(&mut self, state: State, data: usize) -> usize {
         let context = self.take_context();
 
         trace!("{:?}: yielding to {:?}", self, &context);
 
         self.state = state;
 
+        // yield ...
         let Transfer { context, data } = context.resume(data);
+        // ...continue
+
+        // Check if it is time to unwind
+        if self.unwind_flag.load(::std::sync::atomic::Ordering::Acquire) {
+            // contents from `coroutine_unwind`
+
+            let coro = unsafe { &mut *(data as *mut Coroutine) };
+
+            // Save the Context in the Coroutine object because
+            // `coroutine_entry()` needs to get a hold of the callee Context
+            // after exiting the callback.
+            coro.context = Some(context);
+
+            trace!("{:?}: unwinding", coro);
+            panic::resume_unwind(Box::new(ForceUnwind));
+        }
+
 
         // We've returned from a yield to the Processor, because it resume()d us!
         // `context` is the Context of the Processor which we store so we can yield back to it.
@@ -315,7 +344,9 @@ impl Drop for Handle {
         if state == State::Finished {
             ctx.resume(0);
         } else {
-            ctx.resume_ontop(self.0 as *mut _ as usize, coroutine_unwind);
+            self.unwind_flag.store(true, ::std::sync::atomic::Ordering::Release);
+            //ctx.resume_ontop(self.0 as *mut _ as usize, coroutine_unwind);
+            ctx.resume(self.0 as *mut _ as usize);
         }
     }
 }