Index: libcfa/src/concurrency/coroutine.cfa
===================================================================
--- libcfa/src/concurrency/coroutine.cfa	(revision 0ebbca40873f4e872ca756a8ae284370c8977e5f)
+++ libcfa/src/concurrency/coroutine.cfa	(revision 9ef96449b6fa707000709413547abf0df2ec8683)
@@ -85,6 +85,9 @@
 // minimum feasible stack size in bytes
 static const size_t MinStackSize = 1000;
-extern size_t __page_size;				// architecture pagesize HACK, should go in proper runtime singleton
-extern int __map_prot;
+
+extern "C" {
+	extern size_t __cfa_page_size;				// architecture pagesize HACK, should go in proper runtime singleton
+	extern int __map_prot;
+}
 
 void __stack_prepare( __stack_info_t * this, size_t create_size );
@@ -157,22 +160,22 @@
 [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);
+	assert(__cfa_page_size != 0l);
 	size_t size = libCeiling( storageSize, 16 ) + stack_data_size;
-	size = ceiling(size, __page_size);
+	size = ceiling(size, __cfa_page_size);
 
 	// If we are running debug, we also need to allocate a guardpage to catch stack overflows.
 	void * storage;
 	#if CFA_COROUTINE_USE_MMAP
-		storage = mmap(0p, size + __page_size, PROT_EXEC | PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
+		storage = mmap(0p, size + __cfa_page_size, PROT_EXEC | PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
 		if(storage == ((void*)-1)) {
 			abort( "coroutine stack creation : internal error, mmap failure, error(%d) %s.", errno, strerror( errno ) );
 		}
-		if ( mprotect( storage, __page_size, PROT_NONE ) == -1 ) {
+		if ( mprotect( storage, __cfa_page_size, PROT_NONE ) == -1 ) {
 			abort( "coroutine stack creation : internal error, mprotect failure, error(%d) %s.", errno, strerror( errno ) );
 		} // if
-		storage = (void *)(((intptr_t)storage) + __page_size);
+		storage = (void *)(((intptr_t)storage) + __cfa_page_size);
 	#else
 		__cfaabi_dbg_debug_do(
-			storage = memalign( __page_size, size + __page_size );
+			storage = memalign( __cfa_page_size, size + __cfa_page_size );
 		);
 		__cfaabi_dbg_no_debug_do(
@@ -181,8 +184,8 @@
 
 		__cfaabi_dbg_debug_do(
-			if ( mprotect( storage, __page_size, PROT_NONE ) == -1 ) {
+			if ( mprotect( storage, __cfa_page_size, PROT_NONE ) == -1 ) {
 				abort( "__stack_alloc : internal error, mprotect failure, error(%d) %s.", (int)errno, strerror( (int)errno ) );
 			}
-			storage = (void *)(((intptr_t)storage) + __page_size);
+			storage = (void *)(((intptr_t)storage) + __cfa_page_size);
 		);
 	#endif
@@ -198,12 +201,12 @@
 	#if CFA_COROUTINE_USE_MMAP
 		size_t size = ((intptr_t)this->storage->base) - ((intptr_t)this->storage->limit) + sizeof(__stack_t);
-		storage = (void *)(((intptr_t)storage) - __page_size);
-		if(munmap(storage, size + __page_size) == -1) {
+		storage = (void *)(((intptr_t)storage) - __cfa_page_size);
+		if(munmap(storage, size + __cfa_page_size) == -1) {
 			abort( "coroutine stack destruction : internal error, munmap failure, error(%d) %s.", errno, strerror( errno ) );
 		}
 	#else
 		__cfaabi_dbg_debug_do(
-			storage = (char*)(storage) - __page_size;
-			if ( mprotect( storage, __page_size, __map_prot ) == -1 ) {
+			storage = (char*)(storage) - __cfa_page_size;
+			if ( mprotect( storage, __cfa_page_size, __map_prot ) == -1 ) {
 				abort( "(coStack_t *)%p.^?{}() : internal error, mprotect failure, error(%d) %s.", &this, errno, strerror( errno ) );
 			}
Index: libcfa/src/concurrency/kernel/startup.cfa
===================================================================
--- libcfa/src/concurrency/kernel/startup.cfa	(revision 0ebbca40873f4e872ca756a8ae284370c8977e5f)
+++ libcfa/src/concurrency/kernel/startup.cfa	(revision 9ef96449b6fa707000709413547abf0df2ec8683)
@@ -122,8 +122,7 @@
 extern "C" {
 	struct { __dllist_t(cluster) list; __spinlock_t lock; } __cfa_dbg_global_clusters;
-}
-
-extern size_t __page_size;
-extern int __map_prot;
+	extern size_t __cfa_page_size;
+	extern int __map_prot;
+}
 
 //-----------------------------------------------------------------------------
@@ -574,5 +573,4 @@
 }
 
-extern size_t __page_size;
 void ^?{}(processor & this) with( this ){
 	/* paranoid */ verify( !__atomic_load_n(&do_terminate, __ATOMIC_ACQUIRE) );
@@ -740,17 +738,17 @@
 	void * stack;
 	#if CFA_PROCESSOR_USE_MMAP
-		stacksize = ceiling( stacksize, __page_size ) + __page_size;
+		stacksize = ceiling( stacksize, __cfa_page_size ) + __cfa_page_size;
 		stack = mmap(0p, stacksize, __map_prot, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
 		if(stack == ((void*)-1)) {
 			abort( "pthread stack creation : internal error, mmap failure, error(%d) %s.", errno, strerror( errno ) );
 		}
-		if ( mprotect( stack, __page_size, PROT_NONE ) == -1 ) {
+		if ( mprotect( stack, __cfa_page_size, PROT_NONE ) == -1 ) {
 			abort( "pthread stack creation : internal error, mprotect failure, error(%d) %s.", errno, strerror( errno ) );
 		} // if
 	#else
 		__cfaabi_dbg_debug_do(
-			stack = memalign( __page_size, stacksize + __page_size );
+			stack = memalign( __cfa_page_size, stacksize + __cfa_page_size );
 			// pthread has no mechanism to create the guard page in user supplied stack.
-			if ( mprotect( stack, __page_size, PROT_NONE ) == -1 ) {
+			if ( mprotect( stack, __cfa_page_size, PROT_NONE ) == -1 ) {
 				abort( "mprotect : internal error, mprotect failure, error(%d) %s.", errno, strerror( errno ) );
 			} // if
@@ -779,5 +777,5 @@
 		check( pthread_attr_getstacksize( &attr, &stacksize ), "pthread_attr_getstacksize" );
 		assert( stacksize >= PTHREAD_STACK_MIN );
-		stacksize += __page_size;
+		stacksize += __cfa_page_size;
 
 		if(munmap(stack, stacksize) == -1) {
@@ -787,5 +785,5 @@
 		__cfaabi_dbg_debug_do(
 			// pthread has no mechanism to create the guard page in user supplied stack.
-			if ( mprotect( stack, __page_size, __map_prot ) == -1 ) {
+			if ( mprotect( stack, __cfa_page_size, __map_prot ) == -1 ) {
 				abort( "mprotect : internal error, mprotect failure, error(%d) %s.", errno, strerror( errno ) );
 			} // if