Index: src/libcfa/concurrency/alarm.c
===================================================================
--- src/libcfa/concurrency/alarm.c	(revision d43cd01b731d633364617d7978e9f2d0c29dfb85)
+++ src/libcfa/concurrency/alarm.c	(revision 2ac095d3d4c65b28ce001600da53f6e19c8d0ec1)
@@ -24,7 +24,8 @@
 }
 
+#include "libhdr.h"
+
 #include "alarm.h"
 #include "kernel_private.h"
-#include "libhdr.h"
 #include "preemption.h"
 
@@ -154,5 +155,5 @@
 	disable_interrupts();
 	verify( !systemProcessor->pending_alarm );
-	lock( &systemProcessor->alarm_lock, __PRETTY_FUNCTION__ );
+	lock( &systemProcessor->alarm_lock DEBUG_CTX2 );
 	{
 		verify( validate( &systemProcessor->alarms ) );
@@ -169,5 +170,5 @@
 	unlock( &systemProcessor->alarm_lock );
 	this->set = true;
-	enable_interrupts( __PRETTY_FUNCTION__ );
+	enable_interrupts( DEBUG_CTX );
 }
 
@@ -175,5 +176,5 @@
 	// LIB_DEBUG_PRINT_BUFFER_DECL( STDERR_FILENO, "Kernel : unregister %p start\n", this );
 	disable_interrupts();
-	lock( &systemProcessor->alarm_lock, __PRETTY_FUNCTION__ );
+	lock( &systemProcessor->alarm_lock DEBUG_CTX2 );
 	{
 		verify( validate( &systemProcessor->alarms ) );
@@ -181,5 +182,5 @@
 	}
 	unlock( &systemProcessor->alarm_lock );
-	disable_interrupts();
+	enable_interrupts( DEBUG_CTX );
 	this->set = false;
 	// LIB_DEBUG_PRINT_BUFFER_LOCAL( STDERR_FILENO, "Kernel : unregister %p end\n", this );
Index: src/libcfa/concurrency/invoke.c
===================================================================
--- src/libcfa/concurrency/invoke.c	(revision d43cd01b731d633364617d7978e9f2d0c29dfb85)
+++ src/libcfa/concurrency/invoke.c	(revision 2ac095d3d4c65b28ce001600da53f6e19c8d0ec1)
@@ -31,5 +31,5 @@
 extern void __leave_thread_monitor( struct thread_desc * this );
 extern void disable_interrupts();
-extern void enable_interrupts( const char * );
+extern void enable_interrupts( DEBUG_CTX_PARAM );
 
 void CtxInvokeCoroutine(
@@ -71,5 +71,5 @@
 
       // Officially start the thread by enabling preemption
-      enable_interrupts( __PRETTY_FUNCTION__ );
+      enable_interrupts( DEBUG_CTX );
 
       // Call the main of the thread
Index: src/libcfa/concurrency/kernel
===================================================================
--- src/libcfa/concurrency/kernel	(revision d43cd01b731d633364617d7978e9f2d0c29dfb85)
+++ src/libcfa/concurrency/kernel	(revision 2ac095d3d4c65b28ce001600da53f6e19c8d0ec1)
@@ -28,17 +28,7 @@
 //-----------------------------------------------------------------------------
 // Locks
-bool try_lock( spinlock *
-	#ifdef __CFA_DEBUG__
-		, const char * caller
-	#endif
-);
-
-void lock( spinlock *
-	#ifdef __CFA_DEBUG__
-		, const char * caller
-	#endif
-);
-
-void unlock( spinlock * );
+bool try_lock( spinlock * DEBUG_CTX_PARAM2 );
+void lock    ( spinlock * DEBUG_CTX_PARAM2 );
+void unlock  ( spinlock * );
 
 struct signal_once {
@@ -78,5 +68,5 @@
 	unsigned short thrd_count;
 };
-static inline void ?{}(FinishAction * this) { 
+static inline void ?{}(FinishAction * this) {
 	this->action_code = No_Action;
 	this->thrd = NULL;
@@ -89,5 +79,5 @@
 	cluster * cltr;
 	pthread_t kernel_thread;
-	
+
 	signal_once terminated;
 	volatile bool is_terminated;
Index: src/libcfa/concurrency/kernel.c
===================================================================
--- src/libcfa/concurrency/kernel.c	(revision d43cd01b731d633364617d7978e9f2d0c29dfb85)
+++ src/libcfa/concurrency/kernel.c	(revision 2ac095d3d4c65b28ce001600da53f6e19c8d0ec1)
@@ -15,12 +15,5 @@
 //
 
-#include "startup.h"
-
-//Start and stop routine for the kernel, declared first to make sure they run first
-void kernel_startup(void)  __attribute__(( constructor( STARTUP_PRIORITY_KERNEL ) ));
-void kernel_shutdown(void) __attribute__(( destructor ( STARTUP_PRIORITY_KERNEL ) ));
-
-//Header
-#include "kernel_private.h"
+#include "libhdr.h"
 
 //C Includes
@@ -35,10 +28,15 @@
 
 //CFA Includes
-#include "libhdr.h"
+#include "kernel_private.h"
 #include "preemption.h"
+#include "startup.h"
 
 //Private includes
 #define __CFA_INVOKE_PRIVATE__
 #include "invoke.h"
+
+//Start and stop routine for the kernel, declared first to make sure they run first
+void kernel_startup(void)  __attribute__(( constructor( STARTUP_PRIORITY_KERNEL ) ));
+void kernel_shutdown(void) __attribute__(( destructor ( STARTUP_PRIORITY_KERNEL ) ));
 
 //-----------------------------------------------------------------------------
@@ -369,5 +367,5 @@
 	verifyf( thrd->next == NULL, "Expected null got %p", thrd->next );
 
-	lock( &systemProcessor->proc.cltr->lock, __PRETTY_FUNCTION__ );
+	lock( &systemProcessor->proc.cltr->lock DEBUG_CTX2 );
 	append( &systemProcessor->proc.cltr->ready_queue, thrd );
 	unlock( &systemProcessor->proc.cltr->lock );
@@ -378,5 +376,5 @@
 thread_desc * nextThread(cluster * this) {
 	verify( disable_preempt_count > 0 );
-	lock( &this->lock, __PRETTY_FUNCTION__ );
+	lock( &this->lock DEBUG_CTX2 );
 	thread_desc * head = pop_head( &this->ready_queue );
 	unlock( &this->lock );
@@ -390,5 +388,5 @@
 	suspend();
 	verify( disable_preempt_count > 0 );
-	enable_interrupts( __PRETTY_FUNCTION__ );
+	enable_interrupts( DEBUG_CTX );
 }
 
@@ -402,5 +400,5 @@
 	verify( disable_preempt_count > 0 );
 
-	enable_interrupts( __PRETTY_FUNCTION__ );
+	enable_interrupts( DEBUG_CTX );
 }
 
@@ -415,5 +413,5 @@
 	verify( disable_preempt_count > 0 );
 
-	enable_interrupts( __PRETTY_FUNCTION__ );
+	enable_interrupts( DEBUG_CTX );
 }
 
@@ -428,5 +426,5 @@
 	verify( disable_preempt_count > 0 );
 
-	enable_interrupts( __PRETTY_FUNCTION__ );
+	enable_interrupts( DEBUG_CTX );
 }
 
@@ -441,5 +439,5 @@
 	verify( disable_preempt_count > 0 );
 
-	enable_interrupts( __PRETTY_FUNCTION__ );
+	enable_interrupts( DEBUG_CTX );
 }
 
@@ -456,5 +454,5 @@
 	verify( disable_preempt_count > 0 );
 
-	enable_interrupts( __PRETTY_FUNCTION__ );
+	enable_interrupts( DEBUG_CTX );
 }
 
@@ -510,5 +508,5 @@
 	LIB_DEBUG_PRINT_SAFE("Kernel : Started\n--------------------------------------------------\n\n");
 
-	enable_interrupts( __PRETTY_FUNCTION__ );
+	enable_interrupts( DEBUG_CTX );
 }
 
@@ -548,5 +546,5 @@
 	// abort cannot be recursively entered by the same or different processors because all signal handlers return when
 	// the globalAbort flag is true.
-	lock( &kernel_abort_lock, __PRETTY_FUNCTION__ );
+	lock( &kernel_abort_lock DEBUG_CTX2 );
 
 	// first task to abort ?
@@ -586,9 +584,9 @@
 extern "C" {
 	void __lib_debug_acquire() {
-		lock(&kernel_debug_lock, __PRETTY_FUNCTION__);
+		lock( &kernel_debug_lock DEBUG_CTX2 );
 	}
 
 	void __lib_debug_release() {
-		unlock(&kernel_debug_lock);
+		unlock( &kernel_debug_lock );
 	}
 }
@@ -606,15 +604,15 @@
 }
 
-bool try_lock( spinlock * this, const char * caller ) {
+bool try_lock( spinlock * this DEBUG_CTX_PARAM2 ) {
 	bool ret = this->lock == 0 && __sync_lock_test_and_set_4( &this->lock, 1 ) == 0;
-	this->prev = caller;
+	LIB_DEBUG_DO( this->prev = caller; )
 	return ret;
 }
 
-void lock( spinlock * this, const char * caller ) {
+void lock( spinlock * this DEBUG_CTX_PARAM2 ) {
 	for ( unsigned int i = 1;; i += 1 ) {
 	  	if ( this->lock == 0 && __sync_lock_test_and_set_4( &this->lock, 1 ) == 0 ) break;
 	}
-	this->prev = caller;
+	LIB_DEBUG_DO( this->prev = caller; )
 }
 
@@ -631,5 +629,5 @@
 
 void wait( signal_once * this ) {
-	lock( &this->lock, __PRETTY_FUNCTION__ );
+	lock( &this->lock DEBUG_CTX2 );
 	if( !this->cond ) {
 		append( &this->blocked, (thread_desc*)this_thread );
@@ -642,5 +640,5 @@
 
 void signal( signal_once * this ) {
-	lock( &this->lock, __PRETTY_FUNCTION__ );
+	lock( &this->lock DEBUG_CTX2 );
 	{
 		this->cond = true;
@@ -651,5 +649,5 @@
 			ScheduleThread( it );
 		}
-		enable_interrupts( __PRETTY_FUNCTION__ );
+		enable_interrupts( DEBUG_CTX );
 	}
 	unlock( &this->lock );
Index: src/libcfa/concurrency/kernel_private.h
===================================================================
--- src/libcfa/concurrency/kernel_private.h	(revision d43cd01b731d633364617d7978e9f2d0c29dfb85)
+++ src/libcfa/concurrency/kernel_private.h	(revision 2ac095d3d4c65b28ce001600da53f6e19c8d0ec1)
@@ -18,4 +18,6 @@
 #define KERNEL_PRIVATE_H
 
+#include "libhdr.h"
+
 #include "kernel"
 #include "thread"
@@ -23,5 +25,4 @@
 #include "alarm.h"
 
-#include "libhdr.h"
 
 //-----------------------------------------------------------------------------
@@ -31,5 +32,5 @@
 	void disable_interrupts();
 	void enable_interrupts_noRF();
-	void enable_interrupts( const char * );
+	void enable_interrupts( DEBUG_CTX_PARAM );
 }
 
@@ -40,5 +41,5 @@
 	disable_interrupts();
 	ScheduleThread( thrd );
-	enable_interrupts( __PRETTY_FUNCTION__ );
+	enable_interrupts( DEBUG_CTX );
 }
 thread_desc * nextThread(cluster * this);
Index: src/libcfa/concurrency/monitor.c
===================================================================
--- src/libcfa/concurrency/monitor.c	(revision d43cd01b731d633364617d7978e9f2d0c29dfb85)
+++ src/libcfa/concurrency/monitor.c	(revision 2ac095d3d4c65b28ce001600da53f6e19c8d0ec1)
@@ -19,6 +19,6 @@
 #include <stdlib>
 
+#include "libhdr.h"
 #include "kernel_private.h"
-#include "libhdr.h"
 
 //-----------------------------------------------------------------------------
@@ -45,5 +45,5 @@
 extern "C" {
 	void __enter_monitor_desc( monitor_desc * this ) {
-		lock( &this->lock, __PRETTY_FUNCTION__ );
+		lock( &this->lock DEBUG_CTX2 );
 		thread_desc * thrd = this_thread;
 
@@ -66,5 +66,5 @@
 
 			//BlockInternal will unlock spinlock, no need to unlock ourselves
-			return; 
+			return;
 		}
 
@@ -76,5 +76,5 @@
 	//	TODO
 	void __leave_monitor_desc( monitor_desc * this ) {
-		lock( &this->lock, __PRETTY_FUNCTION__ );
+		lock( &this->lock DEBUG_CTX2 );
 
 		// LIB_DEBUG_PRINT_SAFE("%p Leaving %p (o: %p, r: %i). ", this_thread, this, this->owner, this->recursion);
@@ -104,5 +104,5 @@
 	void __leave_thread_monitor( thread_desc * thrd ) {
 		monitor_desc * this = &thrd->mon;
-		lock( &this->lock, __PRETTY_FUNCTION__ );
+		lock( &this->lock DEBUG_CTX2 );
 
 		disable_interrupts();
@@ -260,5 +260,5 @@
 
 	unsigned short count = this->monitor_count;
-	
+
 	//Some more checking in debug
 	LIB_DEBUG_DO(
@@ -354,5 +354,5 @@
 
 uintptr_t front( condition * this ) {
-	verifyf( !is_empty(this), 
+	verifyf( !is_empty(this),
 		"Attempt to access user data on an empty condition.\n"
 		"Possible cause is not checking if the condition is empty before reading stored data."
@@ -422,5 +422,5 @@
 static inline void lock_all( spinlock ** locks, unsigned short count ) {
 	for( int i = 0; i < count; i++ ) {
-		lock( locks[i], __PRETTY_FUNCTION__ );
+		lock( locks[i] DEBUG_CTX2 );
 	}
 }
@@ -429,5 +429,5 @@
 	for( int i = 0; i < count; i++ ) {
 		spinlock * l = &source[i]->lock;
-		lock( l, __PRETTY_FUNCTION__ );
+		lock( l DEBUG_CTX2 );
 		if(locks) locks[i] = l;
 	}
Index: src/libcfa/concurrency/preemption.c
===================================================================
--- src/libcfa/concurrency/preemption.c	(revision d43cd01b731d633364617d7978e9f2d0c29dfb85)
+++ src/libcfa/concurrency/preemption.c	(revision 2ac095d3d4c65b28ce001600da53f6e19c8d0ec1)
@@ -15,6 +15,6 @@
 //
 
+#include "libhdr.h"
 #include "preemption.h"
-
 
 extern "C" {
@@ -33,5 +33,4 @@
 #include "fstream"
 #endif
-#include "libhdr.h"
 
 #define __CFA_DEFAULT_PREEMPTION__ 10000
@@ -167,9 +166,9 @@
 
 	void enable_interrupts_noRF() {
-		unsigned short prev = __atomic_fetch_add_2( &disable_preempt_count, -1, __ATOMIC_SEQ_CST );
+		__attribute__((unused)) unsigned short prev = __atomic_fetch_add_2( &disable_preempt_count, -1, __ATOMIC_SEQ_CST );
 		verify( prev != (unsigned short) 0 );
 	}
 
-	void enable_interrupts( const char * func ) {
+	void enable_interrupts( DEBUG_CTX_PARAM ) {
 		processor * proc   = this_processor;
 		thread_desc * thrd = this_thread;
@@ -183,5 +182,5 @@
 		}
 
-		proc->last_enable = func;
+		LIB_DEBUG_DO( proc->last_enable = caller; )
 	}
 }
@@ -238,5 +237,5 @@
 	// if( ((intptr_t)cxt->uc_mcontext.gregs[REG_RIP]) > 0xFFFFFF ) __debug_break();
 
-	if( try_lock( &systemProcessor->alarm_lock, __PRETTY_FUNCTION__ ) ) {
+	if( try_lock( &systemProcessor->alarm_lock DEBUG_CTX2 ) ) {
 		tick_preemption();
 		unlock( &systemProcessor->alarm_lock );
Index: src/libcfa/concurrency/thread.c
===================================================================
--- src/libcfa/concurrency/thread.c	(revision d43cd01b731d633364617d7978e9f2d0c29dfb85)
+++ src/libcfa/concurrency/thread.c	(revision 2ac095d3d4c65b28ce001600da53f6e19c8d0ec1)
@@ -83,5 +83,5 @@
 
 	ScheduleThread(thrd_h);
-	enable_interrupts( __PRETTY_FUNCTION__ );
+	enable_interrupts( DEBUG_CTX );
 }
 
Index: src/libcfa/libhdr/libalign.h
===================================================================
--- src/libcfa/libhdr/libalign.h	(revision d43cd01b731d633364617d7978e9f2d0c29dfb85)
+++ src/libcfa/libhdr/libalign.h	(revision 2ac095d3d4c65b28ce001600da53f6e19c8d0ec1)
@@ -1,3 +1,3 @@
-//                              -*- Mode: C++ -*- 
+//                              -*- Mode: C++ -*-
 //
 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
@@ -18,13 +18,13 @@
 // Free Software  Foundation; either  version 2.1 of  the License, or  (at your
 // option) any later version.
-// 
+//
 // This library is distributed in the  hope that it will be useful, but WITHOUT
 // ANY  WARRANTY;  without even  the  implied  warranty  of MERCHANTABILITY  or
 // FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
 // for more details.
-// 
+//
 // You should  have received a  copy of the  GNU Lesser General  Public License
 // along  with this library.
-// 
+//
 
 
@@ -33,6 +33,7 @@
 
 #include "assert"
+#include <stdbool.h>
 
-// Minimum size used to align memory boundaries for memory allocations. 
+// Minimum size used to align memory boundaries for memory allocations.
 #define libAlign() (sizeof(double))
 
Index: src/libcfa/libhdr/libdebug.h
===================================================================
--- src/libcfa/libhdr/libdebug.h	(revision d43cd01b731d633364617d7978e9f2d0c29dfb85)
+++ src/libcfa/libhdr/libdebug.h	(revision 2ac095d3d4c65b28ce001600da53f6e19c8d0ec1)
@@ -20,7 +20,15 @@
 	#define LIB_DEBUG_DO(...) __VA_ARGS__
 	#define LIB_NO_DEBUG_DO(...)
+	#define DEBUG_CTX __PRETTY_FUNCTION__
+	#define DEBUG_CTX2 , __PRETTY_FUNCTION__
+	#define DEBUG_CTX_PARAM const char * caller
+	#define DEBUG_CTX_PARAM2 , const char * caller
 #else
 	#define LIB_DEBUG_DO(...)
 	#define LIB_NO_DEBUG_DO(...) __VA_ARGS__
+	#define DEBUG_CTX
+	#define DEBUG_CTX2
+	#define DEBUG_CTX_PARAM
+	#define DEBUG_CTX_PARAM2
 #endif