Index: libcfa/src/concurrency/coroutine.cfa
===================================================================
--- libcfa/src/concurrency/coroutine.cfa	(revision 9235192c894277ebb4a664a0fdb72e0d72b504f1)
+++ libcfa/src/concurrency/coroutine.cfa	(revision ea1bb945c6ba2262676128040e949a23557ed13d)
@@ -121,4 +121,7 @@
 	last = 0p;
 	cancellation = 0p;
+    ehm_state.ehm_buffer{};
+    ehm_state.buffer_lock{};
+    ehm_state.ehm_enabled = false;
 }
 
@@ -283,4 +286,56 @@
 }
 
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// non local ehm routines
+
+// helper for popping from coroutine's ehm buffer
+inline nonlocal_exception * pop_ehm_head( coroutine$ * this ) {
+    lock( this->ehm_state.buffer_lock __cfaabi_dbg_ctx2 );
+    nonlocal_exception * nl_ex = pop_head( this->ehm_state.ehm_buffer );
+    unlock( this->ehm_state.buffer_lock );
+    return nl_ex;
+}
+
+// user facing ehm operations
+forall(T & | is_coroutine(T)) {
+    // enable/disable non-local exceptions
+    void enable_ehm( T & cor ) libcfa_public { get_coroutine( cor )->ehm_state.ehm_enabled = true; }
+    void disable_ehm( T & cor ) libcfa_public { get_coroutine( cor )->ehm_state.ehm_enabled = false; }
+
+    // poll for non-local exceptions
+    bool poll( T & cor ) libcfa_public {
+        coroutine$ * base_cor = get_coroutine( cor );
+        nonlocal_exception * nl_ex = pop_ehm_head( base_cor );
+
+        // if no exceptions return false
+        if ( nl_ex == 0p ) return false;
+        
+        // otherwise loop and throwResume all pending exceptions
+        while ( nl_ex != 0p ){
+            exception_t * ex = nl_ex->the_exception;
+            free( nl_ex );
+            throwResume *ex;
+            nl_ex = pop_ehm_head( base_cor );
+        }
+        
+        return true;
+    }
+
+    // poll iff nonlocal ehm is enabled
+    bool checked_poll( T & cor ) libcfa_public { return get_coroutine( cor )->ehm_state.ehm_enabled ? poll( cor ) : false; }
+}
+
+// resume non local exception at receiver (i.e. enqueue in ehm buffer)
+forall(exceptT &, T & | ehm_resume_at( exceptT, T ))
+void resumeAt( T & receiver, exceptT & ex )  libcfa_public {
+    coroutine$ * cor = get_coroutine( receiver );
+    nonlocal_exception * nl_ex = alloc();
+    (*nl_ex){ (exception_t *)&ex };
+    lock( cor->ehm_state.buffer_lock __cfaabi_dbg_ctx2 );
+    append( cor->ehm_state.ehm_buffer, nl_ex ); 
+    unlock( cor->ehm_state.buffer_lock );
+}
+
 // Local Variables: //
 // mode: c //
Index: libcfa/src/concurrency/coroutine.hfa
===================================================================
--- libcfa/src/concurrency/coroutine.hfa	(revision 9235192c894277ebb4a664a0fdb72e0d72b504f1)
+++ libcfa/src/concurrency/coroutine.hfa	(revision ea1bb945c6ba2262676128040e949a23557ed13d)
@@ -19,4 +19,19 @@
 #include "invoke.h"
 #include "../exception.hfa"
+
+//-----------------------------------------------------------------------------
+// Type used to store and queue nonlocal exceptions on coroutines
+struct nonlocal_exception {
+    exception_t * the_exception;
+    nonlocal_exception * next;
+};
+static inline void ?{} ( nonlocal_exception & this, exception_t * ex ) with(this) {
+    the_exception = ex;
+    next = 0p;
+}
+
+static inline nonlocal_exception *& get_next( nonlocal_exception & this ) __attribute__((const)) {
+    return this.next;
+}
 
 //-----------------------------------------------------------------------------
@@ -203,4 +218,19 @@
 }
 
+// non local ehm routines
+forall(T & | is_coroutine(T)) {
+    void enable_ehm( T & cor );
+    void disable_ehm( T & cor );
+    bool poll( T & cor );
+    bool checked_poll( T & cor );
+}
+
+// trait for exceptions able to be resumed at another coroutine
+forall(exceptT &, T & | is_coroutine(T))
+trait ehm_resume_at { void $throwResume(exceptT &); };
+
+forall(exceptT &, T & | ehm_resume_at( exceptT, T ))
+void resumeAt( T & receiver, exceptT & ex );
+
 // Local Variables: //
 // mode: c //
Index: libcfa/src/concurrency/invoke.h
===================================================================
--- libcfa/src/concurrency/invoke.h	(revision 9235192c894277ebb4a664a0fdb72e0d72b504f1)
+++ libcfa/src/concurrency/invoke.h	(revision ea1bb945c6ba2262676128040e949a23557ed13d)
@@ -74,4 +74,15 @@
 	};
 
+    struct nonlocal_ehm {
+        // list of pending nonlocal exceptions
+        __queue_t(struct nonlocal_exception) ehm_buffer;
+
+        // lock to protect the buffer
+        struct __spinlock_t buffer_lock;
+
+        // enable/disabled flag
+        bool ehm_enabled;
+    };
+
 	enum __Coroutine_State { Halted, Start, Primed, Blocked, Ready, Active, Cancelled, Halting };
 
@@ -98,4 +109,6 @@
 		struct _Unwind_Exception * cancellation;
 
+        // Non-local exception handling information
+        struct nonlocal_ehm ehm_state;
 	};
 	// Wrapper for gdb
