Index: libcfa/src/concurrency/alarm.cfa
===================================================================
--- libcfa/src/concurrency/alarm.cfa	(revision bf0263c9b7b4fb1f0eeb41eb13f2e11fe44991d3)
+++ libcfa/src/concurrency/alarm.cfa	(revision 90a812553b6fb7bc8cf5dadc34f305f3df56721e)
@@ -141,5 +141,5 @@
 //=============================================================================================
 
-void sleep( Duration duration ) {
+void sleep( Duration duration ) libcfa_public {
 	alarm_node_t node = { active_thread(), duration, 0`s };
 
Index: libcfa/src/concurrency/clib/cfathread.cfa
===================================================================
--- libcfa/src/concurrency/clib/cfathread.cfa	(revision bf0263c9b7b4fb1f0eeb41eb13f2e11fe44991d3)
+++ libcfa/src/concurrency/clib/cfathread.cfa	(revision 90a812553b6fb7bc8cf5dadc34f305f3df56721e)
@@ -237,5 +237,5 @@
 
 typedef ThreadCancelled(cfathread_object) cfathread_exception;
-typedef ThreadCancelled_vtable(cfathread_object) cfathread_vtable;
+typedef vtable(ThreadCancelled(cfathread_object)) cfathread_vtable;
 
 void defaultResumptionHandler(ThreadCancelled(cfathread_object) & except) {
@@ -283,5 +283,5 @@
 
 typedef ThreadCancelled(__cfainit) __cfainit_exception;
-typedef ThreadCancelled_vtable(__cfainit) __cfainit_vtable;
+typedef vtable(ThreadCancelled(__cfainit)) __cfainit_vtable;
 
 void defaultResumptionHandler(ThreadCancelled(__cfainit) & except) {
@@ -326,17 +326,19 @@
 }
 
+#pragma GCC visibility push(default)
+
 //================================================================================
 // Main Api
 extern "C" {
-	int cfathread_cluster_create(cfathread_cluster_t * cl) __attribute__((nonnull(1))) {
+	int cfathread_cluster_create(cfathread_cluster_t * cl) __attribute__((nonnull(1))) libcfa_public {
 		*cl = new();
 		return 0;
 	}
 
-	cfathread_cluster_t cfathread_cluster_self(void) {
+	cfathread_cluster_t cfathread_cluster_self(void) libcfa_public {
 		return active_cluster();
 	}
 
-	int cfathread_cluster_print_stats( cfathread_cluster_t cl ) {
+	int cfathread_cluster_print_stats( cfathread_cluster_t cl ) libcfa_public {
 		#if !defined(__CFA_NO_STATISTICS__)
 			print_stats_at_exit( *cl, CFA_STATS_READY_Q | CFA_STATS_IO );
Index: libcfa/src/concurrency/coroutine.cfa
===================================================================
--- libcfa/src/concurrency/coroutine.cfa	(revision bf0263c9b7b4fb1f0eeb41eb13f2e11fe44991d3)
+++ libcfa/src/concurrency/coroutine.cfa	(revision 90a812553b6fb7bc8cf5dadc34f305f3df56721e)
@@ -48,5 +48,5 @@
 //-----------------------------------------------------------------------------
 forall(T &)
-void copy(CoroutineCancelled(T) * dst, CoroutineCancelled(T) * src) {
+void copy(CoroutineCancelled(T) * dst, CoroutineCancelled(T) * src) libcfa_public {
 	dst->virtual_table = src->virtual_table;
 	dst->the_coroutine = src->the_coroutine;
@@ -55,5 +55,5 @@
 
 forall(T &)
-const char * msg(CoroutineCancelled(T) *) {
+const char * msg(CoroutineCancelled(T) *) libcfa_public {
 	return "CoroutineCancelled(...)";
 }
@@ -62,5 +62,5 @@
 forall(T & | is_coroutine(T))
 void __cfaehm_cancelled_coroutine(
-		T & cor, coroutine$ * desc, EHM_DEFAULT_VTABLE(CoroutineCancelled, (T)) ) {
+		T & cor, coroutine$ * desc, EHM_DEFAULT_VTABLE(CoroutineCancelled(T)) ) libcfa_public {
 	verify( desc->cancellation );
 	desc->state = Cancelled;
@@ -89,5 +89,5 @@
 
 void __stack_prepare( __stack_info_t * this, size_t create_size );
-void __stack_clean  ( __stack_info_t * this );
+static void __stack_clean  ( __stack_info_t * this );
 
 //-----------------------------------------------------------------------------
@@ -114,5 +114,5 @@
 }
 
-void ?{}( coroutine$ & this, const char name[], void * storage, size_t storageSize ) with( this ) {
+void ?{}( coroutine$ & this, const char name[], void * storage, size_t storageSize ) libcfa_public with( this ) {
 	(this.context){0p, 0p};
 	(this.stack){storage, storageSize};
@@ -124,5 +124,5 @@
 }
 
-void ^?{}(coroutine$& this) {
+void ^?{}(coroutine$& this) libcfa_public {
 	if(this.state != Halted && this.state != Start && this.state != Primed) {
 		coroutine$ * src = active_coroutine();
@@ -146,6 +146,6 @@
 // Part of the Public API
 // Not inline since only ever called once per coroutine
-forall(T & | is_coroutine(T) | { EHM_DEFAULT_VTABLE(CoroutineCancelled, (T)); })
-void prime(T& cor) {
+forall(T & | is_coroutine(T) | { EHM_DEFAULT_VTABLE(CoroutineCancelled(T)); })
+void prime(T& cor) libcfa_public {
 	coroutine$* this = get_coroutine(cor);
 	assert(this->state == Start);
@@ -155,5 +155,5 @@
 }
 
-[void *, size_t] __stack_alloc( size_t storageSize ) {
+static [void *, size_t] __stack_alloc( size_t storageSize ) {
 	const size_t stack_data_size = libCeiling( sizeof(__stack_t), 16 ); // minimum alignment
 	assert(__page_size != 0l);
@@ -193,5 +193,5 @@
 }
 
-void __stack_clean  ( __stack_info_t * this ) {
+static void __stack_clean  ( __stack_info_t * this ) {
 	void * storage = this->storage->limit;
 
@@ -215,5 +215,5 @@
 }
 
-void __stack_prepare( __stack_info_t * this, size_t create_size ) {
+void __stack_prepare( __stack_info_t * this, size_t create_size ) libcfa_public {
 	const size_t stack_data_size = libCeiling( sizeof(__stack_t), 16 ); // minimum alignment
 	bool userStack;
Index: libcfa/src/concurrency/coroutine.hfa
===================================================================
--- libcfa/src/concurrency/coroutine.hfa	(revision bf0263c9b7b4fb1f0eeb41eb13f2e11fe44991d3)
+++ libcfa/src/concurrency/coroutine.hfa	(revision 90a812553b6fb7bc8cf5dadc34f305f3df56721e)
@@ -22,8 +22,9 @@
 //-----------------------------------------------------------------------------
 // Exception thrown from resume when a coroutine stack is cancelled.
-EHM_FORALL_EXCEPTION(CoroutineCancelled, (coroutine_t &), (coroutine_t)) (
+forall(coroutine_t &)
+exception CoroutineCancelled {
 	coroutine_t * the_coroutine;
 	exception_t * the_exception;
-);
+};
 
 forall(T &)
@@ -37,5 +38,5 @@
 // Anything that implements this trait can be resumed.
 // Anything that is resumed is a coroutine.
-trait is_coroutine(T & | IS_RESUMPTION_EXCEPTION(CoroutineCancelled, (T))) {
+trait is_coroutine(T & | IS_RESUMPTION_EXCEPTION(CoroutineCancelled(T))) {
 	void main(T & this);
 	coroutine$ * get_coroutine(T & this);
@@ -60,5 +61,5 @@
 //-----------------------------------------------------------------------------
 // Public coroutine API
-forall(T & | is_coroutine(T) | { EHM_DEFAULT_VTABLE(CoroutineCancelled, (T)); })
+forall(T & | is_coroutine(T) | { EHM_DEFAULT_VTABLE(CoroutineCancelled(T)); })
 void prime(T & cor);
 
@@ -113,6 +114,4 @@
 
 extern void __stack_prepare( __stack_info_t * this, size_t size /* ignored if storage already allocated */);
-extern void __stack_clean  ( __stack_info_t * this );
-
 
 // Suspend implementation inlined for performance
@@ -141,8 +140,8 @@
 forall(T & | is_coroutine(T))
 void __cfaehm_cancelled_coroutine(
-	T & cor, coroutine$ * desc, EHM_DEFAULT_VTABLE(CoroutineCancelled, (T)) );
+	T & cor, coroutine$ * desc, EHM_DEFAULT_VTABLE(CoroutineCancelled(T)) );
 
 // Resume implementation inlined for performance
-forall(T & | is_coroutine(T) | { EHM_DEFAULT_VTABLE(CoroutineCancelled, (T)); })
+forall(T & | is_coroutine(T) | { EHM_DEFAULT_VTABLE(CoroutineCancelled(T)); })
 static inline T & resume(T & cor) {
 	// optimization : read TLS once and reuse it
Index: libcfa/src/concurrency/exception.cfa
===================================================================
--- libcfa/src/concurrency/exception.cfa	(revision bf0263c9b7b4fb1f0eeb41eb13f2e11fe44991d3)
+++ libcfa/src/concurrency/exception.cfa	(revision 90a812553b6fb7bc8cf5dadc34f305f3df56721e)
@@ -64,9 +64,9 @@
 extern "C" {
 
-struct exception_context_t * this_exception_context(void) {
+struct exception_context_t * this_exception_context(void) libcfa_public {
 	return &__get_stack( active_coroutine() )->exception_context;
 }
 
-_Unwind_Reason_Code __cfaehm_cancellation_unwind( struct _Unwind_Exception * unwind_exception ) {
+_Unwind_Reason_Code __cfaehm_cancellation_unwind( struct _Unwind_Exception * unwind_exception ) libcfa_public {
 	_Unwind_Stop_Fn stop_func;
 	void * stop_param;
Index: libcfa/src/concurrency/invoke.c
===================================================================
--- libcfa/src/concurrency/invoke.c	(revision bf0263c9b7b4fb1f0eeb41eb13f2e11fe44991d3)
+++ libcfa/src/concurrency/invoke.c	(revision 90a812553b6fb7bc8cf5dadc34f305f3df56721e)
@@ -36,5 +36,5 @@
 extern void enable_interrupts( _Bool poll );
 
-void __cfactx_invoke_coroutine(
+libcfa_public void __cfactx_invoke_coroutine(
 	void (*main)(void *),
 	void *this
@@ -70,5 +70,5 @@
 }
 
-void __cfactx_coroutine_unwind(struct _Unwind_Exception * storage, struct coroutine$ * cor) __attribute__ ((__noreturn__));
+libcfa_public void __cfactx_coroutine_unwind(struct _Unwind_Exception * storage, struct coroutine$ * cor) __attribute__ ((__noreturn__));
 void __cfactx_coroutine_unwind(struct _Unwind_Exception * storage, struct coroutine$ * cor) {
 	_Unwind_Reason_Code ret = _Unwind_ForcedUnwind( storage, __cfactx_coroutine_unwindstop, cor );
@@ -77,5 +77,5 @@
 }
 
-void __cfactx_invoke_thread(
+libcfa_public void __cfactx_invoke_thread(
 	void (*main)(void *),
 	void *this
@@ -98,5 +98,5 @@
 }
 
-void __cfactx_start(
+libcfa_public void __cfactx_start(
 	void (*main)(void *),
 	struct coroutine$ * cor,
Index: libcfa/src/concurrency/io.cfa
===================================================================
--- libcfa/src/concurrency/io.cfa	(revision bf0263c9b7b4fb1f0eeb41eb13f2e11fe44991d3)
+++ libcfa/src/concurrency/io.cfa	(revision 90a812553b6fb7bc8cf5dadc34f305f3df56721e)
@@ -221,5 +221,5 @@
 			const unsigned long long ctsc = rdtscl();
 
-			if(proc->io.target == MAX) {
+			if(proc->io.target == UINT_MAX) {
 				uint64_t chaos = __tls_rand();
 				unsigned ext = chaos & 0xff;
@@ -232,5 +232,5 @@
 			else {
 				const unsigned target = proc->io.target;
-				/* paranoid */ verify( io.tscs[target].tv != MAX );
+				/* paranoid */ verify( io.tscs[target].tv != ULLONG_MAX );
 				HELP: if(target < ctxs_count) {
 					const unsigned long long cutoff = calc_cutoff(ctsc, ctx->cq.id, ctxs_count, io.data, io.tscs, __shard_factor.io);
@@ -246,5 +246,5 @@
 					__STATS__( true, io.calls.helped++; )
 				}
-				proc->io.target = MAX;
+				proc->io.target = UINT_MAX;
 			}
 		}
@@ -340,5 +340,5 @@
 	// for convenience, return both the index and the pointer to the sqe
 	// sqe == &sqes[idx]
-	struct $io_context * cfa_io_allocate(struct io_uring_sqe * sqes[], __u32 idxs[], __u32 want) {
+	struct $io_context * cfa_io_allocate(struct io_uring_sqe * sqes[], __u32 idxs[], __u32 want) libcfa_public {
 		// __cfadbg_print_safe(io, "Kernel I/O : attempting to allocate %u\n", want);
 
@@ -419,5 +419,5 @@
 	}
 
-	void cfa_io_submit( struct $io_context * inctx, __u32 idxs[], __u32 have, bool lazy ) __attribute__((nonnull (1))) {
+	void cfa_io_submit( struct $io_context * inctx, __u32 idxs[], __u32 have, bool lazy ) __attribute__((nonnull (1))) libcfa_public {
 		// __cfadbg_print_safe(io, "Kernel I/O : attempting to submit %u (%s)\n", have, lazy ? "lazy" : "eager");
 
Index: libcfa/src/concurrency/io/call.cfa.in
===================================================================
--- libcfa/src/concurrency/io/call.cfa.in	(revision bf0263c9b7b4fb1f0eeb41eb13f2e11fe44991d3)
+++ libcfa/src/concurrency/io/call.cfa.in	(revision 90a812553b6fb7bc8cf5dadc34f305f3df56721e)
@@ -139,4 +139,5 @@
 // I/O Interface
 //=============================================================================================
+#pragma GCC visibility push(default)
 """
 
Index: libcfa/src/concurrency/io/setup.cfa
===================================================================
--- libcfa/src/concurrency/io/setup.cfa	(revision bf0263c9b7b4fb1f0eeb41eb13f2e11fe44991d3)
+++ libcfa/src/concurrency/io/setup.cfa	(revision 90a812553b6fb7bc8cf5dadc34f305f3df56721e)
@@ -26,5 +26,5 @@
 
 #if !defined(CFA_HAVE_LINUX_IO_URING_H)
-	void ?{}(io_context_params & this) {}
+	void ?{}(io_context_params & this) libcfa_public {}
 
 	void  ?{}($io_context & this, struct cluster & cl) {}
@@ -66,5 +66,5 @@
 #pragma GCC diagnostic pop
 
-	void ?{}(io_context_params & this) {
+	void ?{}(io_context_params & this) libcfa_public {
 		this.num_entries = 256;
 	}
Index: libcfa/src/concurrency/io/types.hfa
===================================================================
--- libcfa/src/concurrency/io/types.hfa	(revision bf0263c9b7b4fb1f0eeb41eb13f2e11fe44991d3)
+++ libcfa/src/concurrency/io/types.hfa	(revision 90a812553b6fb7bc8cf5dadc34f305f3df56721e)
@@ -17,4 +17,6 @@
 #pragma once
 
+#include <limits.h>
+
 extern "C" {
 	#include <linux/types.h>
@@ -25,5 +27,4 @@
 #include "iofwd.hfa"
 #include "kernel/fwd.hfa"
-#include "limits.hfa"
 
 #if defined(CFA_HAVE_LINUX_IO_URING_H)
@@ -140,5 +141,5 @@
 		const __u32 tail = *this->cq.tail;
 
-		if(head == tail) return MAX;
+		if(head == tail) return ULLONG_MAX;
 
 		return this->cq.ts;
Index: libcfa/src/concurrency/kernel.cfa
===================================================================
--- libcfa/src/concurrency/kernel.cfa	(revision bf0263c9b7b4fb1f0eeb41eb13f2e11fe44991d3)
+++ libcfa/src/concurrency/kernel.cfa	(revision 90a812553b6fb7bc8cf5dadc34f305f3df56721e)
@@ -389,5 +389,5 @@
 
 // KERNEL_ONLY
-void returnToKernel() {
+static void returnToKernel() {
 	/* paranoid */ verify( ! __preemption_enabled() );
 	coroutine$ * proc_cor = get_coroutine(kernelTLS().this_processor->runner);
@@ -547,5 +547,5 @@
 }
 
-void unpark( thread$ * thrd, unpark_hint hint ) {
+void unpark( thread$ * thrd, unpark_hint hint ) libcfa_public {
 	if( !thrd ) return;
 
@@ -558,5 +558,5 @@
 }
 
-void park( void ) {
+void park( void ) libcfa_public {
 	__disable_interrupts_checked();
 		/* paranoid */ verify( kernelTLS().this_thread->preempted == __NO_PREEMPTION );
@@ -601,5 +601,5 @@
 
 // KERNEL ONLY
-bool force_yield( __Preemption_Reason reason ) {
+bool force_yield( __Preemption_Reason reason ) libcfa_public {
 	__disable_interrupts_checked();
 		thread$ * thrd = kernelTLS().this_thread;
@@ -849,5 +849,5 @@
 //-----------------------------------------------------------------------------
 // Debug
-bool threading_enabled(void) __attribute__((const)) {
+bool threading_enabled(void) __attribute__((const)) libcfa_public {
 	return true;
 }
@@ -856,5 +856,5 @@
 // Statistics
 #if !defined(__CFA_NO_STATISTICS__)
-	void print_halts( processor & this ) {
+	void print_halts( processor & this ) libcfa_public {
 		this.print_halts = true;
 	}
@@ -873,5 +873,5 @@
 	}
 
-	void crawl_cluster_stats( cluster & this ) {
+	static void crawl_cluster_stats( cluster & this ) {
 		// Stop the world, otherwise stats could get really messed-up
 		// this doesn't solve all problems but does solve many
@@ -889,5 +889,5 @@
 
 
-	void print_stats_now( cluster & this, int flags ) {
+	void print_stats_now( cluster & this, int flags ) libcfa_public {
 		crawl_cluster_stats( this );
 		__print_stats( this.stats, flags, "Cluster", this.name, (void*)&this );
Index: libcfa/src/concurrency/kernel.hfa
===================================================================
--- libcfa/src/concurrency/kernel.hfa	(revision bf0263c9b7b4fb1f0eeb41eb13f2e11fe44991d3)
+++ libcfa/src/concurrency/kernel.hfa	(revision 90a812553b6fb7bc8cf5dadc34f305f3df56721e)
@@ -49,5 +49,7 @@
 
 // Coroutine used py processors for the 2-step context switch
-coroutine processorCtx_t {
+
+struct processorCtx_t {
+	struct coroutine$ self;
 	struct processor * proc;
 };
Index: libcfa/src/concurrency/kernel/cluster.cfa
===================================================================
--- libcfa/src/concurrency/kernel/cluster.cfa	(revision bf0263c9b7b4fb1f0eeb41eb13f2e11fe44991d3)
+++ libcfa/src/concurrency/kernel/cluster.cfa	(revision 90a812553b6fb7bc8cf5dadc34f305f3df56721e)
@@ -49,5 +49,5 @@
 
 // returns the maximum number of processors the RWLock support
-__attribute__((weak)) unsigned __max_processors() {
+__attribute__((weak)) unsigned __max_processors() libcfa_public {
 	const char * max_cores_s = getenv("CFA_MAX_PROCESSORS");
 	if(!max_cores_s) {
@@ -233,9 +233,9 @@
 					if(is_empty(sl)) {
 						assert( sl.anchor.next == 0p );
-						assert( sl.anchor.ts   == -1llu );
+						assert( sl.anchor.ts   == MAX );
 						assert( mock_head(sl)  == sl.prev );
 					} else {
 						assert( sl.anchor.next != 0p );
-						assert( sl.anchor.ts   != -1llu );
+						assert( sl.anchor.ts   != MAX );
 						assert( mock_head(sl)  != sl.prev );
 					}
@@ -259,9 +259,9 @@
 		/* paranoid */ verifyf( it, "Unexpected null iterator, at index %u of %u\n", i, count);
 		it->rdq.id = valrq;
-		it->rdq.target = MAX;
+		it->rdq.target = UINT_MAX;
 		valrq += __shard_factor.readyq;
 		#if defined(CFA_HAVE_LINUX_IO_URING_H)
 			it->io.ctx->cq.id = valio;
-			it->io.target = MAX;
+			it->io.target = UINT_MAX;
 			valio += __shard_factor.io;
 		#endif
@@ -472,5 +472,5 @@
 	this.prev = mock_head(this);
 	this.anchor.next = 0p;
-	this.anchor.ts   = -1llu;
+	this.anchor.ts   = MAX;
 	#if !defined(__CFA_NO_STATISTICS__)
 		this.cnt  = 0;
@@ -484,5 +484,5 @@
 	/* paranoid */ verify( &mock_head(this)->link.ts   == &this.anchor.ts   );
 	/* paranoid */ verify( mock_head(this)->link.next == 0p );
-	/* paranoid */ verify( mock_head(this)->link.ts   == -1llu  );
+	/* paranoid */ verify( mock_head(this)->link.ts   == MAX );
 	/* paranoid */ verify( mock_head(this) == this.prev );
 	/* paranoid */ verify( __alignof__(__intrusive_lane_t) == 128 );
@@ -495,5 +495,5 @@
 	// Make sure the list is empty
 	/* paranoid */ verify( this.anchor.next == 0p );
-	/* paranoid */ verify( this.anchor.ts   == -1llu );
+	/* paranoid */ verify( this.anchor.ts   == MAX );
 	/* paranoid */ verify( mock_head(this)  == this.prev );
 }
Index: libcfa/src/concurrency/kernel/cluster.hfa
===================================================================
--- libcfa/src/concurrency/kernel/cluster.hfa	(revision bf0263c9b7b4fb1f0eeb41eb13f2e11fe44991d3)
+++ libcfa/src/concurrency/kernel/cluster.hfa	(revision 90a812553b6fb7bc8cf5dadc34f305f3df56721e)
@@ -19,5 +19,5 @@
 #include "kernel/private.hfa"
 
-#include "limits.hfa"
+#include <limits.h>
 
 //-----------------------------------------------------------------------
@@ -37,5 +37,5 @@
 
 static inline void touch_tsc(__timestamp_t * tscs, size_t idx, unsigned long long ts_prev, unsigned long long ts_next) {
-	if (ts_next == MAX) return;
+	if (ts_next == ULLONG_MAX) return;
 	unsigned long long now = rdtscl();
 	unsigned long long pma = __atomic_load_n(&tscs[ idx ].ma, __ATOMIC_RELAXED);
@@ -59,5 +59,5 @@
 	for(i; shard_factor) {
 		unsigned long long ptsc = ts(data[start + i]);
-		if(ptsc != -1ull) {
+		if(ptsc != ULLONG_MAX) {
 			/* paranoid */ verify( start + i < count );
 			unsigned long long tsc = moving_average(ctsc, ptsc, tscs[start + i].ma);
Index: libcfa/src/concurrency/kernel/private.hfa
===================================================================
--- libcfa/src/concurrency/kernel/private.hfa	(revision bf0263c9b7b4fb1f0eeb41eb13f2e11fe44991d3)
+++ libcfa/src/concurrency/kernel/private.hfa	(revision 90a812553b6fb7bc8cf5dadc34f305f3df56721e)
@@ -109,5 +109,6 @@
 //-----------------------------------------------------------------------------
 // Processor
-void main(processorCtx_t *);
+void main(processorCtx_t &);
+static inline coroutine$* get_coroutine(processorCtx_t & this) { return &this.self; }
 
 void * __create_pthread( pthread_t *, void * (*)(void *), void * );
Index: libcfa/src/concurrency/kernel/startup.cfa
===================================================================
--- libcfa/src/concurrency/kernel/startup.cfa	(revision bf0263c9b7b4fb1f0eeb41eb13f2e11fe44991d3)
+++ libcfa/src/concurrency/kernel/startup.cfa	(revision 90a812553b6fb7bc8cf5dadc34f305f3df56721e)
@@ -120,5 +120,5 @@
 #endif
 
-cluster              * mainCluster;
+cluster              * mainCluster libcfa_public;
 processor            * mainProcessor;
 thread$              * mainThread;
@@ -169,5 +169,5 @@
 };
 
-void ?{}( current_stack_info_t & this ) {
+static void ?{}( current_stack_info_t & this ) {
 	__stack_context_t ctx;
 	CtxGet( ctx );
@@ -209,6 +209,6 @@
 	// Construct the processor context of the main processor
 	void ?{}(processorCtx_t & this, processor * proc) {
-		(this.__cor){ "Processor" };
-		this.__cor.starter = 0p;
+		(this.self){ "Processor" };
+		this.self.starter = 0p;
 		this.proc = proc;
 	}
@@ -507,5 +507,5 @@
 	self_mon_p = &self_mon;
 	link.next = 0p;
-	link.ts   = -1llu;
+	link.ts   = MAX;
 	preferred = ready_queue_new_preferred();
 	last_proc = 0p;
@@ -526,5 +526,5 @@
 // Construct the processor context of non-main processors
 static void ?{}(processorCtx_t & this, processor * proc, current_stack_info_t * info) {
-	(this.__cor){ info };
+	(this.self){ info };
 	this.proc = proc;
 }
@@ -578,5 +578,5 @@
 }
 
-void ?{}(processor & this, const char name[], cluster & _cltr, thread$ * initT) {
+void ?{}(processor & this, const char name[], cluster & _cltr, thread$ * initT) libcfa_public {
 	( this.terminated ){};
 	( this.runner ){};
@@ -591,10 +591,10 @@
 }
 
-void ?{}(processor & this, const char name[], cluster & _cltr) {
+void ?{}(processor & this, const char name[], cluster & _cltr) libcfa_public {
 	(this){name, _cltr, 0p};
 }
 
 extern size_t __page_size;
-void ^?{}(processor & this) with( this ){
+void ^?{}(processor & this) libcfa_public with( this ) {
 	/* paranoid */ verify( !__atomic_load_n(&do_terminate, __ATOMIC_ACQUIRE) );
 	__cfadbg_print_safe(runtime_core, "Kernel : core %p signaling termination\n", &this);
@@ -623,5 +623,5 @@
 }
 
-void ?{}(cluster & this, const char name[], Duration preemption_rate, unsigned num_io, const io_context_params & io_params) with( this ) {
+void ?{}(cluster & this, const char name[], Duration preemption_rate, unsigned num_io, const io_context_params & io_params) libcfa_public with( this ) {
 	this.name = name;
 	this.preemption_rate = preemption_rate;
@@ -658,5 +658,5 @@
 }
 
-void ^?{}(cluster & this) {
+void ^?{}(cluster & this) libcfa_public {
 	destroy(this.io.arbiter);
 
Index: libcfa/src/concurrency/locks.cfa
===================================================================
--- libcfa/src/concurrency/locks.cfa	(revision bf0263c9b7b4fb1f0eeb41eb13f2e11fe44991d3)
+++ libcfa/src/concurrency/locks.cfa	(revision 90a812553b6fb7bc8cf5dadc34f305f3df56721e)
@@ -24,4 +24,6 @@
 #include <stdlib.hfa>
 
+#pragma GCC visibility push(default)
+
 //-----------------------------------------------------------------------------
 // info_thread
@@ -116,5 +118,5 @@
 }
 
-void pop_and_set_new_owner( blocking_lock & this ) with( this ) {
+static void pop_and_set_new_owner( blocking_lock & this ) with( this ) {
 	thread$ * t = &try_pop_front( blocked_threads );
 	owner = t;
@@ -192,5 +194,5 @@
 	void ^?{}( alarm_node_wrap(L) & this ) { }
 
-	void timeout_handler ( alarm_node_wrap(L) & this ) with( this ) {
+	static void timeout_handler ( alarm_node_wrap(L) & this ) with( this ) {
 		// This condition_variable member is called from the kernel, and therefore, cannot block, but it can spin.
 		lock( cond->lock __cfaabi_dbg_ctx2 );
@@ -216,5 +218,5 @@
 
 	// this casts the alarm node to our wrapped type since we used type erasure
-	void alarm_node_wrap_cast( alarm_node_t & a ) { timeout_handler( (alarm_node_wrap(L) &)a ); }
+	static void alarm_node_wrap_cast( alarm_node_t & a ) { timeout_handler( (alarm_node_wrap(L) &)a ); }
 }
 
@@ -233,5 +235,5 @@
 	void ^?{}( condition_variable(L) & this ){ }
 
-	void process_popped( condition_variable(L) & this, info_thread(L) & popped ) with( this ) {
+	static void process_popped( condition_variable(L) & this, info_thread(L) & popped ) with( this ) {
 		if(&popped != 0p) {
 			popped.signalled = true;
@@ -278,5 +280,5 @@
 	int counter( condition_variable(L) & this ) with(this) { return count; }
 
-	size_t queue_and_get_recursion( condition_variable(L) & this, info_thread(L) * i ) with(this) {
+	static size_t queue_and_get_recursion( condition_variable(L) & this, info_thread(L) * i ) with(this) {
 		// add info_thread to waiting queue
 		insert_last( blocked_threads, *i );
@@ -291,5 +293,5 @@
 
 	// helper for wait()'s' with no timeout
-	void queue_info_thread( condition_variable(L) & this, info_thread(L) & i ) with(this) {
+	static void queue_info_thread( condition_variable(L) & this, info_thread(L) & i ) with(this) {
 		lock( lock __cfaabi_dbg_ctx2 );
 		size_t recursion_count = queue_and_get_recursion(this, &i);
@@ -308,5 +310,5 @@
 
 	// helper for wait()'s' with a timeout
-	void queue_info_thread_timeout( condition_variable(L) & this, info_thread(L) & info, Duration t, Alarm_Callback callback ) with(this) {
+	static void queue_info_thread_timeout( condition_variable(L) & this, info_thread(L) & info, Duration t, Alarm_Callback callback ) with(this) {
 		lock( lock __cfaabi_dbg_ctx2 );
 		size_t recursion_count = queue_and_get_recursion(this, &info);
@@ -343,5 +345,5 @@
 	// fast_cond_var
 	void  ?{}( fast_cond_var(L) & this ){
-		this.blocked_threads{}; 
+		this.blocked_threads{};
 		#ifdef __CFA_DEBUG__
 		this.lock_used = 0p;
Index: libcfa/src/concurrency/monitor.cfa
===================================================================
--- libcfa/src/concurrency/monitor.cfa	(revision bf0263c9b7b4fb1f0eeb41eb13f2e11fe44991d3)
+++ libcfa/src/concurrency/monitor.cfa	(revision 90a812553b6fb7bc8cf5dadc34f305f3df56721e)
@@ -44,4 +44,8 @@
 static inline void restore( monitor$ * ctx [], __lock_size_t count, __spinlock_t * locks [], unsigned int /*in */ recursions [], __waitfor_mask_t /*in */ masks [] );
 
+static inline void ?{}(__condition_node_t & this, thread$ * waiting_thread, __lock_size_t count, uintptr_t user_info );
+static inline void ?{}(__condition_criterion_t & this );
+static inline void ?{}(__condition_criterion_t & this, monitor$ * target, __condition_node_t * owner );
+
 static inline void init     ( __lock_size_t count, monitor$ * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] );
 static inline void init_push( __lock_size_t count, monitor$ * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] );
@@ -243,5 +247,5 @@
 
 // Leave single monitor
-void __leave( monitor$ * this ) {
+static void __leave( monitor$ * this ) {
 	// Lock the monitor spinlock
 	lock( this->lock __cfaabi_dbg_ctx2 );
@@ -278,5 +282,5 @@
 
 // Leave single monitor for the last time
-void __dtor_leave( monitor$ * this, bool join ) {
+static void __dtor_leave( monitor$ * this, bool join ) {
 	__cfaabi_dbg_debug_do(
 		if( active_thread() != this->owner ) {
@@ -344,5 +348,5 @@
 // Ctor for monitor guard
 // Sorts monitors before entering
-void ?{}( monitor_guard_t & this, monitor$ * m [], __lock_size_t count, fptr_t func ) {
+void ?{}( monitor_guard_t & this, monitor$ * m [], __lock_size_t count, fptr_t func ) libcfa_public {
 	thread$ * thrd = active_thread();
 
@@ -369,5 +373,5 @@
 }
 
-void ?{}( monitor_guard_t & this, monitor$ * m [], __lock_size_t count ) {
+void ?{}( monitor_guard_t & this, monitor$ * m [], __lock_size_t count ) libcfa_public {
 	this{ m, count, 0p };
 }
@@ -375,5 +379,5 @@
 
 // Dtor for monitor guard
-void ^?{}( monitor_guard_t & this ) {
+void ^?{}( monitor_guard_t & this ) libcfa_public {
 	// __cfaabi_dbg_print_safe( "MGUARD : leaving %d\n", this.count);
 
@@ -389,5 +393,5 @@
 // Ctor for monitor guard
 // Sorts monitors before entering
-void ?{}( monitor_dtor_guard_t & this, monitor$ * m [], fptr_t func, bool join ) {
+void ?{}( monitor_dtor_guard_t & this, monitor$ * m [], fptr_t func, bool join ) libcfa_public {
 	// optimization
 	thread$ * thrd = active_thread();
@@ -409,5 +413,5 @@
 
 // Dtor for monitor guard
-void ^?{}( monitor_dtor_guard_t & this ) {
+void ^?{}( monitor_dtor_guard_t & this ) libcfa_public {
 	// Leave the monitors in order
 	__dtor_leave( this.m, this.join );
@@ -419,5 +423,5 @@
 //-----------------------------------------------------------------------------
 // Internal scheduling types
-void ?{}(__condition_node_t & this, thread$ * waiting_thread, __lock_size_t count, uintptr_t user_info ) {
+static void ?{}(__condition_node_t & this, thread$ * waiting_thread, __lock_size_t count, uintptr_t user_info ) {
 	this.waiting_thread = waiting_thread;
 	this.count = count;
@@ -426,5 +430,5 @@
 }
 
-void ?{}(__condition_criterion_t & this ) with( this ) {
+static void ?{}(__condition_criterion_t & this ) with( this ) {
 	ready  = false;
 	target = 0p;
@@ -433,5 +437,5 @@
 }
 
-void ?{}(__condition_criterion_t & this, monitor$ * target, __condition_node_t & owner ) {
+static void ?{}(__condition_criterion_t & this, monitor$ * target, __condition_node_t & owner ) {
 	this.ready  = false;
 	this.target = target;
@@ -442,5 +446,5 @@
 //-----------------------------------------------------------------------------
 // Internal scheduling
-void wait( condition & this, uintptr_t user_info = 0 ) {
+void wait( condition & this, uintptr_t user_info = 0 ) libcfa_public {
 	brand_condition( this );
 
@@ -496,5 +500,5 @@
 }
 
-bool signal( condition & this ) {
+bool signal( condition & this ) libcfa_public {
 	if( is_empty( this ) ) { return false; }
 
@@ -538,5 +542,5 @@
 }
 
-bool signal_block( condition & this ) {
+bool signal_block( condition & this ) libcfa_public {
 	if( !this.blocked.head ) { return false; }
 
@@ -586,5 +590,5 @@
 
 // Access the user_info of the thread waiting at the front of the queue
-uintptr_t front( condition & this ) {
+uintptr_t front( condition & this ) libcfa_public {
 	verifyf( !is_empty(this),
 		"Attempt to access user data on an empty condition.\n"
@@ -608,5 +612,5 @@
 // 		setup mask
 // 		block
-void __waitfor_internal( const __waitfor_mask_t & mask, int duration ) {
+void __waitfor_internal( const __waitfor_mask_t & mask, int duration ) libcfa_public {
 	// This statment doesn't have a contiguous list of monitors...
 	// Create one!
@@ -994,5 +998,5 @@
 // Can't be accepted since a mutex stmt is effectively an anonymous routine
 // Thus we do not need a monitor group
-void lock( monitor$ * this ) {
+void lock( monitor$ * this ) libcfa_public {
 	thread$ * thrd = active_thread();
 
@@ -1046,5 +1050,5 @@
 // Leave routine for mutex stmt
 // Is just a wrapper around __leave for the is_lock trait to see
-void unlock( monitor$ * this ) { __leave( this ); }
+void unlock( monitor$ * this ) libcfa_public { __leave( this ); }
 
 // Local Variables: //
Index: libcfa/src/concurrency/monitor.hfa
===================================================================
--- libcfa/src/concurrency/monitor.hfa	(revision bf0263c9b7b4fb1f0eeb41eb13f2e11fe44991d3)
+++ libcfa/src/concurrency/monitor.hfa	(revision 90a812553b6fb7bc8cf5dadc34f305f3df56721e)
@@ -119,7 +119,7 @@
 }
 
-void ?{}(__condition_node_t & this, thread$ * waiting_thread, __lock_size_t count, uintptr_t user_info );
-void ?{}(__condition_criterion_t & this );
-void ?{}(__condition_criterion_t & this, monitor$ * target, __condition_node_t * owner );
+// void ?{}(__condition_node_t & this, thread$ * waiting_thread, __lock_size_t count, uintptr_t user_info );
+// void ?{}(__condition_criterion_t & this );
+// void ?{}(__condition_criterion_t & this, monitor$ * target, __condition_node_t * owner );
 
 struct condition {
Index: libcfa/src/concurrency/preemption.cfa
===================================================================
--- libcfa/src/concurrency/preemption.cfa	(revision bf0263c9b7b4fb1f0eeb41eb13f2e11fe44991d3)
+++ libcfa/src/concurrency/preemption.cfa	(revision 90a812553b6fb7bc8cf5dadc34f305f3df56721e)
@@ -38,5 +38,5 @@
 #endif
 
-__attribute__((weak)) Duration default_preemption() {
+__attribute__((weak)) Duration default_preemption() libcfa_public {
 	const char * preempt_rate_s = getenv("CFA_DEFAULT_PREEMPTION");
 	if(!preempt_rate_s) {
@@ -238,5 +238,5 @@
 //----------
 // special case for preemption since used often
-__attribute__((optimize("no-reorder-blocks"))) bool __preemption_enabled() {
+__attribute__((optimize("no-reorder-blocks"))) bool __preemption_enabled() libcfa_public {
 	// create a assembler label before
 	// marked as clobber all to avoid movement
@@ -276,5 +276,5 @@
 // Get data from the TLS block
 // struct asm_region __cfaasm_get;
-uintptr_t __cfatls_get( unsigned long int offset ) __attribute__((__noinline__)); //no inline to avoid problems
+uintptr_t __cfatls_get( unsigned long int offset ) __attribute__((__noinline__, visibility("default"))); //no inline to avoid problems
 uintptr_t __cfatls_get( unsigned long int offset ) {
 	// create a assembler label before
@@ -295,5 +295,5 @@
 extern "C" {
 	// Disable interrupts by incrementing the counter
-	void disable_interrupts() {
+	__attribute__((__noinline__, visibility("default"))) void disable_interrupts() libcfa_public {
 		// create a assembler label before
 		// marked as clobber all to avoid movement
@@ -326,5 +326,5 @@
 	// Enable interrupts by decrementing the counter
 	// If counter reaches 0, execute any pending __cfactx_switch
-	void enable_interrupts( bool poll ) {
+	void enable_interrupts( bool poll ) libcfa_public {
 		// Cache the processor now since interrupts can start happening after the atomic store
 		processor   * proc = __cfaabi_tls.this_processor;
@@ -362,5 +362,5 @@
 //-----------------------------------------------------------------------------
 // Kernel Signal Debug
-void __cfaabi_check_preemption() {
+void __cfaabi_check_preemption() libcfa_public {
 	bool ready = __preemption_enabled();
 	if(!ready) { abort("Preemption should be ready"); }
Index: libcfa/src/concurrency/ready_queue.cfa
===================================================================
--- libcfa/src/concurrency/ready_queue.cfa	(revision bf0263c9b7b4fb1f0eeb41eb13f2e11fe44991d3)
+++ libcfa/src/concurrency/ready_queue.cfa	(revision 90a812553b6fb7bc8cf5dadc34f305f3df56721e)
@@ -125,5 +125,5 @@
 	const unsigned long long ctsc = rdtscl();
 
-	if(proc->rdq.target == MAX) {
+	if(proc->rdq.target == UINT_MAX) {
 		uint64_t chaos = __tls_rand();
 		unsigned ext = chaos & 0xff;
@@ -137,5 +137,5 @@
 		const unsigned target = proc->rdq.target;
 		__cfadbg_print_safe(ready_queue, "Kernel : %u considering helping %u, tcsc %llu\n", this, target, readyQ.tscs[target].tv);
-		/* paranoid */ verify( readyQ.tscs[target].tv != MAX );
+		/* paranoid */ verify( readyQ.tscs[target].tv != ULLONG_MAX );
 		if(target < lanes_count) {
 			const unsigned long long cutoff = calc_cutoff(ctsc, proc->rdq.id, lanes_count, cltr->sched.readyQ.data, cltr->sched.readyQ.tscs, __shard_factor.readyq);
@@ -147,5 +147,5 @@
 			}
 		}
-		proc->rdq.target = MAX;
+		proc->rdq.target = UINT_MAX;
 	}
 
@@ -245,5 +245,5 @@
 // get preferred ready for new thread
 unsigned ready_queue_new_preferred() {
-	unsigned pref = MAX;
+	unsigned pref = UINT_MAX;
 	if(struct thread$ * thrd = publicTLS_get( this_thread )) {
 		pref = thrd->preferred;
Index: libcfa/src/concurrency/ready_subqueue.hfa
===================================================================
--- libcfa/src/concurrency/ready_subqueue.hfa	(revision bf0263c9b7b4fb1f0eeb41eb13f2e11fe44991d3)
+++ libcfa/src/concurrency/ready_subqueue.hfa	(revision 90a812553b6fb7bc8cf5dadc34f305f3df56721e)
@@ -32,16 +32,16 @@
 	/* paranoid */ verify( this.lock );
 	/* paranoid */ verify( node->link.next == 0p );
-	/* paranoid */ verify( node->link.ts   == MAX  );
+	/* paranoid */ verify( __atomic_load_n(&node->link.ts, __ATOMIC_RELAXED) == MAX  );
 	/* paranoid */ verify( this.prev->link.next == 0p );
-	/* paranoid */ verify( this.prev->link.ts   == MAX  );
+	/* paranoid */ verify( __atomic_load_n(&this.prev->link.ts, __ATOMIC_RELAXED)   == MAX  );
 	if( this.anchor.next == 0p ) {
 		/* paranoid */ verify( this.anchor.next == 0p );
-		/* paranoid */ verify( this.anchor.ts   == MAX );
-		/* paranoid */ verify( this.anchor.ts   != 0  );
+		/* paranoid */ verify( __atomic_load_n(&this.anchor.ts, __ATOMIC_RELAXED) == MAX );
+		/* paranoid */ verify( __atomic_load_n(&this.anchor.ts, __ATOMIC_RELAXED) != 0  );
 		/* paranoid */ verify( this.prev == mock_head( this ) );
 	} else {
 		/* paranoid */ verify( this.anchor.next != 0p );
-		/* paranoid */ verify( this.anchor.ts   != MAX );
-		/* paranoid */ verify( this.anchor.ts   != 0  );
+		/* paranoid */ verify( __atomic_load_n(&this.anchor.ts, __ATOMIC_RELAXED) != MAX );
+		/* paranoid */ verify( __atomic_load_n(&this.anchor.ts, __ATOMIC_RELAXED) != 0  );
 		/* paranoid */ verify( this.prev != mock_head( this ) );
 	}
@@ -62,14 +62,14 @@
 	/* paranoid */ verify( this.lock );
 	/* paranoid */ verify( this.anchor.next != 0p );
-	/* paranoid */ verify( this.anchor.ts   != MAX );
-	/* paranoid */ verify( this.anchor.ts   != 0  );
+	/* paranoid */ verify( __atomic_load_n(&this.anchor.ts, __ATOMIC_RELAXED) != MAX );
+	/* paranoid */ verify( __atomic_load_n(&this.anchor.ts, __ATOMIC_RELAXED) != 0   );
 
 	// Get the relevant nodes locally
 	thread$ * node = this.anchor.next;
 	this.anchor.next = node->link.next;
-	this.anchor.ts   = node->link.ts;
+	__atomic_store_n(&this.anchor.ts, __atomic_load_n(&node->link.ts, __ATOMIC_RELAXED), __ATOMIC_RELAXED);
 	bool is_empty = this.anchor.next == 0p;
 	node->link.next = 0p;
-	node->link.ts   = MAX;
+	__atomic_store_n(&node->link.ts, ULLONG_MAX, __ATOMIC_RELAXED);
 	#if !defined(__CFA_NO_STATISTICS__)
 		this.cnt--;
@@ -79,10 +79,11 @@
 	if(is_empty) this.prev = mock_head( this );
 
+	unsigned long long ats = __atomic_load_n(&this.anchor.ts, __ATOMIC_RELAXED);
 	/* paranoid */ verify( node->link.next == 0p );
-	/* paranoid */ verify( node->link.ts   == MAX  );
-	/* paranoid */ verify( node->link.ts   != 0  );
-	/* paranoid */ verify( this.anchor.ts  != 0  );
-	/* paranoid */ verify( (this.anchor.ts  == MAX) == is_empty );
-	return [node, this.anchor.ts];
+	/* paranoid */ verify( __atomic_load_n(&node->link.ts , __ATOMIC_RELAXED) == MAX );
+	/* paranoid */ verify( __atomic_load_n(&node->link.ts , __ATOMIC_RELAXED) != 0   );
+	/* paranoid */ verify( ats != 0 );
+	/* paranoid */ verify( (ats == MAX) == is_empty );
+	return [node, ats];
 }
 
@@ -96,4 +97,5 @@
 	// Cannot verify 'emptiness' here since it may not be locked
 	/* paranoid */ verify(this.anchor.ts != 0);
-	return this.anchor.ts;
+	/* paranoid */ static_assert(__atomic_always_lock_free(sizeof(this.anchor.ts), &this.anchor.ts));
+	return __atomic_load_n(&this.anchor.ts, __ATOMIC_RELAXED);
 }
Index: libcfa/src/concurrency/thread.cfa
===================================================================
--- libcfa/src/concurrency/thread.cfa	(revision bf0263c9b7b4fb1f0eeb41eb13f2e11fe44991d3)
+++ libcfa/src/concurrency/thread.cfa	(revision 90a812553b6fb7bc8cf5dadc34f305f3df56721e)
@@ -19,6 +19,7 @@
 #include "thread.hfa"
 
+#include "exception.hfa"
 #include "kernel/private.hfa"
-#include "exception.hfa"
+#include "limits.hfa"
 
 #define __CFA_INVOKE_PRIVATE__
@@ -26,4 +27,6 @@
 
 extern uint32_t __global_random_seed, __global_random_prime, __global_random_mask;
+
+#pragma GCC visibility push(default)
 
 //-----------------------------------------------------------------------------
@@ -42,5 +45,5 @@
 	curr_cluster = &cl;
 	link.next = 0p;
-	link.ts   = -1llu;
+	link.ts   = MAX;
 	preferred = ready_queue_new_preferred();
 	last_proc = 0p;
@@ -86,6 +89,6 @@
 }
 
-forall(T & | is_thread(T) | IS_EXCEPTION(ThreadCancelled, (T))
-    | { EHM_DEFAULT_VTABLE(ThreadCancelled, (T)); })
+forall(T & | is_thread(T) | IS_EXCEPTION(ThreadCancelled(T))
+    | { EHM_DEFAULT_VTABLE(ThreadCancelled(T)); })
 void ?{}( thread_dtor_guard_t & this,
 		T & thrd, void(*cancelHandler)(ThreadCancelled(T) &)) {
@@ -165,6 +168,6 @@
 
 //-----------------------------------------------------------------------------
-forall(T & | is_thread(T) | IS_RESUMPTION_EXCEPTION(ThreadCancelled, (T))
-    | { EHM_DEFAULT_VTABLE(ThreadCancelled, (T)); })
+forall(T & | is_thread(T) | IS_RESUMPTION_EXCEPTION(ThreadCancelled(T))
+	| { EHM_DEFAULT_VTABLE(ThreadCancelled(T)); })
 T & join( T & this ) {
 	thread_dtor_guard_t guard = { this, defaultResumptionHandler };
Index: libcfa/src/concurrency/thread.hfa
===================================================================
--- libcfa/src/concurrency/thread.hfa	(revision bf0263c9b7b4fb1f0eeb41eb13f2e11fe44991d3)
+++ libcfa/src/concurrency/thread.hfa	(revision 90a812553b6fb7bc8cf5dadc34f305f3df56721e)
@@ -32,8 +32,9 @@
 };
 
-EHM_FORALL_EXCEPTION(ThreadCancelled, (thread_t &), (thread_t)) (
+forall(thread_t &)
+exception ThreadCancelled {
 	thread_t * the_thread;
 	exception_t * the_exception;
-);
+};
 
 forall(T &)
@@ -79,6 +80,6 @@
 };
 
-forall( T & | is_thread(T) | IS_EXCEPTION(ThreadCancelled, (T))
-    | { EHM_DEFAULT_VTABLE(ThreadCancelled, (T)); })
+forall( T & | is_thread(T) | IS_EXCEPTION(ThreadCancelled(T))
+	| { EHM_DEFAULT_VTABLE(ThreadCancelled(T)); })
 void ?{}( thread_dtor_guard_t & this, T & thrd, void(*)(ThreadCancelled(T) &) );
 void ^?{}( thread_dtor_guard_t & this );
@@ -126,6 +127,6 @@
 //----------
 // join
-forall( T & | is_thread(T) | IS_RESUMPTION_EXCEPTION(ThreadCancelled, (T))
-    | { EHM_DEFAULT_VTABLE(ThreadCancelled, (T)); })
+forall( T & | is_thread(T) | IS_RESUMPTION_EXCEPTION(ThreadCancelled(T))
+	| { EHM_DEFAULT_VTABLE(ThreadCancelled(T)); })
 T & join( T & this );