Index: src/CodeGen/FixNames.cc
===================================================================
--- src/CodeGen/FixNames.cc	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ src/CodeGen/FixNames.cc	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
@@ -19,4 +19,5 @@
 #include <string>                  // for string, operator!=, operator==
 
+#include "Common/PassVisitor.h"
 #include "Common/SemanticError.h"  // for SemanticError
 #include "FixMain.h"               // for FixMain
@@ -32,10 +33,10 @@
 
 namespace CodeGen {
-	class FixNames : public Visitor {
+	class FixNames : public WithGuards {
 	  public:
-		virtual void visit( ObjectDecl *objectDecl );
-		virtual void visit( FunctionDecl *functionDecl );
+		void postvisit( ObjectDecl *objectDecl );
+		void postvisit( FunctionDecl *functionDecl );
 
-		virtual void visit( CompoundStmt *compoundStmt );
+		void previsit( CompoundStmt *compoundStmt );
 	  private:
 		int scopeLevel = 1;
@@ -93,10 +94,10 @@
 	}
 
-	void fixNames( std::list< Declaration* > translationUnit ) {
-		FixNames fixer;
+	void fixNames( std::list< Declaration* > & translationUnit ) {
+		PassVisitor<FixNames> fixer;
 		acceptAll( translationUnit, fixer );
 	}
 
-	void FixNames::fixDWT( DeclarationWithType *dwt ) {
+	void FixNames::fixDWT( DeclarationWithType * dwt ) {
 		if ( dwt->get_name() != "" ) {
 			if ( LinkageSpec::isMangled( dwt->get_linkage() ) ) {
@@ -107,11 +108,9 @@
 	}
 
-	void FixNames::visit( ObjectDecl *objectDecl ) {
-		Visitor::visit( objectDecl );
+	void FixNames::postvisit( ObjectDecl * objectDecl ) {
 		fixDWT( objectDecl );
 	}
 
-	void FixNames::visit( FunctionDecl *functionDecl ) {
-		Visitor::visit( functionDecl );
+	void FixNames::postvisit( FunctionDecl * functionDecl ) {
 		fixDWT( functionDecl );
 
@@ -121,13 +120,12 @@
 				throw SemanticError("Main expected to have 0, 2 or 3 arguments\n", functionDecl);
 			}
-			functionDecl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, new ConstantExpr( Constant::from_int( 0 ) ) ) );
+			functionDecl->get_statements()->get_kids().push_back( new ReturnStmt( new ConstantExpr( Constant::from_int( 0 ) ) ) );
 			CodeGen::FixMain::registerMain( functionDecl );
 		}
 	}
 
-	void FixNames::visit( CompoundStmt *compoundStmt ) {
+	void FixNames::previsit( CompoundStmt * ) {
 		scopeLevel++;
-		Visitor::visit( compoundStmt );
-		scopeLevel--;
+		GuardAction( [this](){ scopeLevel--; } );
 	}
 } // namespace CodeGen
Index: src/CodeGen/FixNames.h
===================================================================
--- src/CodeGen/FixNames.h	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ src/CodeGen/FixNames.h	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
@@ -5,5 +5,5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// FixNames.h -- 
+// FixNames.h --
 //
 // Author           : Richard C. Bilson
@@ -22,5 +22,5 @@
 namespace CodeGen {
 	/// mangles object and function names
-	void fixNames( std::list< Declaration* > translationUnit );
+	void fixNames( std::list< Declaration* > & translationUnit );
 } // namespace CodeGen
 
Index: src/Common/PassVisitor.impl.h
===================================================================
--- src/Common/PassVisitor.impl.h	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ src/Common/PassVisitor.impl.h	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
@@ -55,5 +55,5 @@
 		it,
 		[](Declaration * decl) -> auto {
-			return new DeclStmt( noLabels, decl );
+			return new DeclStmt( decl );
 		}
 	);
@@ -251,5 +251,5 @@
 	    || ( empty( beforeDecls ) && empty( afterDecls )) );
 
-	CompoundStmt *compound = new CompoundStmt( noLabels );
+	CompoundStmt *compound = new CompoundStmt();
 	if( !empty(beforeDecls) ) { splice( std::back_inserter( compound->get_kids() ), beforeDecls ); }
 	if( !empty(beforeStmts) ) { compound->get_kids().splice( compound->get_kids().end(), *beforeStmts ); }
Index: src/Concurrency/Keywords.cc
===================================================================
--- src/Concurrency/Keywords.cc	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ src/Concurrency/Keywords.cc	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
@@ -38,12 +38,4 @@
 
 namespace Concurrency {
-
-	namespace {
-		const std::list<Label> noLabels;
-		const std::list< Attribute * > noAttributes;
-		Type::StorageClasses noStorage;
-		Type::Qualifiers noQualifiers;
-	}
-
 	//=============================================================================================
 	// Pass declarations
@@ -296,5 +288,5 @@
 		ObjectDecl * this_decl = new ObjectDecl(
 			"this",
-			noStorage,
+			noStorageClasses,
 			LinkageSpec::Cforall,
 			nullptr,
@@ -313,5 +305,5 @@
 			new ObjectDecl(
 				"ret",
-				noStorage,
+				noStorageClasses,
 				LinkageSpec::Cforall,
 				nullptr,
@@ -346,5 +338,5 @@
 			main_decl = new FunctionDecl(
 				"main",
-				noStorage,
+				noStorageClasses,
 				LinkageSpec::Cforall,
 				main_type,
@@ -363,5 +355,5 @@
 		ObjectDecl * field = new ObjectDecl(
 			field_name,
-			noStorage,
+			noStorageClasses,
 			LinkageSpec::Cforall,
 			nullptr,
@@ -379,8 +371,7 @@
 
 	void ConcurrentSueKeyword::addRoutines( ObjectDecl * field, FunctionDecl * func ) {
-		CompoundStmt * statement = new CompoundStmt( noLabels );
+		CompoundStmt * statement = new CompoundStmt();
 		statement->push_back(
 			new ReturnStmt(
-				noLabels,
 				new AddressExpr(
 					new MemberExpr(
@@ -488,5 +479,5 @@
 		ObjectDecl * monitors = new ObjectDecl(
 			"__monitor",
-			noStorage,
+			noStorageClasses,
 			LinkageSpec::Cforall,
 			nullptr,
@@ -509,7 +500,7 @@
 		// monitor_guard_t __guard = { __monitors, #, func };
 		body->push_front(
-			new DeclStmt( noLabels, new ObjectDecl(
+			new DeclStmt( new ObjectDecl(
 				"__guard",
-				noStorage,
+				noStorageClasses,
 				LinkageSpec::Cforall,
 				nullptr,
@@ -530,5 +521,5 @@
 
 		//monitor_desc * __monitors[] = { get_monitor(a), get_monitor(b) };
-		body->push_front( new DeclStmt( noLabels, monitors) );
+		body->push_front( new DeclStmt( monitors) );
 	}
 
@@ -536,5 +527,5 @@
 		ObjectDecl * monitors = new ObjectDecl(
 			"__monitors",
-			noStorage,
+			noStorageClasses,
 			LinkageSpec::Cforall,
 			nullptr,
@@ -569,7 +560,7 @@
 		// monitor_guard_t __guard = { __monitors, #, func };
 		body->push_front(
-			new DeclStmt( noLabels, new ObjectDecl(
+			new DeclStmt( new ObjectDecl(
 				"__guard",
-				noStorage,
+				noStorageClasses,
 				LinkageSpec::Cforall,
 				nullptr,
@@ -591,5 +582,5 @@
 
 		//monitor_desc * __monitors[] = { get_monitor(a), get_monitor(b) };
-		body->push_front( new DeclStmt( noLabels, monitors) );
+		body->push_front( new DeclStmt( monitors) );
 	}
 
@@ -631,5 +622,4 @@
 		stmt->push_back(
 			new ExprStmt(
-				noLabels,
 				new UntypedExpr(
 					new NameExpr( "__thrd_start" ),
Index: src/Concurrency/Waitfor.cc
===================================================================
--- src/Concurrency/Waitfor.cc	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ src/Concurrency/Waitfor.cc	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
@@ -100,12 +100,4 @@
 
 namespace Concurrency {
-
-	namespace {
-		const std::list<Label> noLabels;
-		const std::list< Attribute * > noAttributes;
-		Type::StorageClasses noStorage;
-		Type::Qualifiers noQualifiers;
-	}
-
 	//=============================================================================================
 	// Pass declarations
@@ -203,5 +195,5 @@
 			ResolvExpr::findVoidExpression( expr, indexer );
 
-			return new ExprStmt( noLabels, expr );
+			return new ExprStmt( expr );
 		}
 
@@ -259,5 +251,5 @@
 		if( !decl_monitor || !decl_acceptable || !decl_mask ) throw SemanticError( "waitfor keyword requires monitors to be in scope, add #include <monitor>", waitfor );
 
-		CompoundStmt * stmt = new CompoundStmt( noLabels );
+		CompoundStmt * stmt = new CompoundStmt();
 
 		ObjectDecl * acceptables = declare( waitfor->clauses.size(), stmt );
@@ -281,7 +273,6 @@
 		);
 
-		CompoundStmt * compound = new CompoundStmt( noLabels );
+		CompoundStmt * compound = new CompoundStmt();
 		stmt->push_back( new IfStmt(
-			noLabels,
 			safeCond( new VariableExpr( flag ) ),
 			compound,
@@ -313,5 +304,5 @@
 		);
 
-		stmt->push_back( new DeclStmt( noLabels, acceptables) );
+		stmt->push_back( new DeclStmt( acceptables) );
 
 		Expression * set = new UntypedExpr(
@@ -326,5 +317,5 @@
 		ResolvExpr::findVoidExpression( set, indexer );
 
-		stmt->push_back( new ExprStmt( noLabels, set ) );
+		stmt->push_back( new ExprStmt( set ) );
 
 		return acceptables;
@@ -341,5 +332,5 @@
 		);
 
-		stmt->push_back( new DeclStmt( noLabels, flag) );
+		stmt->push_back( new DeclStmt( flag) );
 
 		return flag;
@@ -357,5 +348,5 @@
 		ResolvExpr::findVoidExpression( expr, indexer );
 
-		return new ExprStmt( noLabels, expr );
+		return new ExprStmt( expr );
 	}
 
@@ -399,5 +390,5 @@
 		);
 
-		stmt->push_back( new DeclStmt( noLabels, mon) );
+		stmt->push_back( new DeclStmt( mon) );
 
 		return mon;
@@ -411,5 +402,4 @@
 
 		stmt->push_back( new IfStmt(
-			noLabels,
 			safeCond( clause.condition ),
 			new CompoundStmt({
@@ -447,13 +437,11 @@
 		);
 
-		stmt->push_back( new DeclStmt( noLabels, timeout ) );
+		stmt->push_back( new DeclStmt( timeout ) );
 
 		if( time ) {
 			stmt->push_back( new IfStmt(
-				noLabels,
 				safeCond( time_cond ),
 				new CompoundStmt({
 					new ExprStmt(
-						noLabels,
 						makeOpAssign(
 							new VariableExpr( timeout ),
@@ -471,9 +459,7 @@
 		if( has_else ) {
 			stmt->push_back( new IfStmt(
-				noLabels,
 				safeCond( else_cond ),
 				new CompoundStmt({
 					new ExprStmt(
-						noLabels,
 						makeOpAssign(
 							new VariableExpr( timeout ),
@@ -511,5 +497,5 @@
 		);
 
-		stmt->push_back( new DeclStmt( noLabels, index ) );
+		stmt->push_back( new DeclStmt( index ) );
 
 		ObjectDecl * mask = ObjectDecl::newObject(
@@ -526,8 +512,7 @@
 		);
 
-		stmt->push_back( new DeclStmt( noLabels, mask ) );
+		stmt->push_back( new DeclStmt( mask ) );
 
 		stmt->push_back( new ExprStmt(
-			noLabels,
 			new ApplicationExpr(
 				VariableExpr::functionPointer( decl_waitfor ),
@@ -557,5 +542,4 @@
 	) {
 		SwitchStmt * swtch = new SwitchStmt(
-			noLabels,
 			result,
 			std::list<Statement *>()
@@ -566,10 +550,8 @@
 			swtch->statements.push_back(
 				new CaseStmt(
-					noLabels,
 					new ConstantExpr( Constant::from_ulong( i++ ) ),
 					{
 						clause.statement,
 						new BranchStmt(
-							noLabels,
 							"",
 							BranchStmt::Break
@@ -583,10 +565,8 @@
 			swtch->statements.push_back(
 				new CaseStmt(
-					noLabels,
 					new ConstantExpr( Constant::from_int( -2 ) ),
 					{
 						waitfor->timeout.statement,
 						new BranchStmt(
-							noLabels,
 							"",
 							BranchStmt::Break
@@ -600,10 +580,8 @@
 			swtch->statements.push_back(
 				new CaseStmt(
-					noLabels,
 					new ConstantExpr( Constant::from_int( -1 ) ),
 					{
 						waitfor->orelse.statement,
 						new BranchStmt(
-							noLabels,
 							"",
 							BranchStmt::Break
Index: src/ControlStruct/ExceptTranslate.cc
===================================================================
--- src/ControlStruct/ExceptTranslate.cc	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ src/ControlStruct/ExceptTranslate.cc	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
@@ -30,5 +30,5 @@
 #include "SynTree/Expression.h"       // for UntypedExpr, ConstantExpr, Name...
 #include "SynTree/Initializer.h"      // for SingleInit, ListInit
-#include "SynTree/Label.h"            // for Label, noLabels
+#include "SynTree/Label.h"            // for Label
 #include "SynTree/Mutator.h"          // for mutateAll
 #include "SynTree/Statement.h"        // for CompoundStmt, CatchStmt, ThrowStmt
@@ -57,5 +57,5 @@
 
 	void appendDeclStmt( CompoundStmt * block, Declaration * item ) {
-		block->push_back(new DeclStmt(noLabels, item));
+		block->push_back(new DeclStmt(item));
 	}
 
@@ -205,5 +205,5 @@
 		throwStmt->set_expr( nullptr );
 		delete throwStmt;
-		return new ExprStmt( noLabels, call );
+		return new ExprStmt( call );
 	}
 
@@ -211,5 +211,5 @@
 			ThrowStmt *throwStmt ) {
 		// __throw_terminate( `throwStmt->get_name()` ); }
-		return create_given_throw( "__cfaehm__throw_terminate", throwStmt );
+		return create_given_throw( "__cfaabi_ehm__throw_terminate", throwStmt );
 	}
 
@@ -220,6 +220,7 @@
 		assert( handler_except_decl );
 
-		CompoundStmt * result = new CompoundStmt( throwStmt->get_labels() );
-		result->push_back( new ExprStmt( noLabels, UntypedExpr::createAssign(
+		CompoundStmt * result = new CompoundStmt();
+		result->labels =  throwStmt->labels;
+		result->push_back( new ExprStmt( UntypedExpr::createAssign(
 			nameOf( handler_except_decl ),
 			new ConstantExpr( Constant::null(
@@ -231,6 +232,5 @@
 			) ) );
 		result->push_back( new ExprStmt(
-			noLabels,
-			new UntypedExpr( new NameExpr( "__cfaehm__rethrow_terminate" ) )
+			new UntypedExpr( new NameExpr( "__cfaabi_ehm__rethrow_terminate" ) )
 			) );
 		delete throwStmt;
@@ -241,5 +241,5 @@
 			ThrowStmt *throwStmt ) {
 		// __throw_resume( `throwStmt->get_name` );
-		return create_given_throw( "__cfaehm__throw_resume", throwStmt );
+		return create_given_throw( "__cfaabi_ehm__throw_resume", throwStmt );
 	}
 
@@ -248,7 +248,7 @@
 		// return false;
 		Statement * result = new ReturnStmt(
-			throwStmt->get_labels(),
 			new ConstantExpr( Constant::from_bool( false ) )
 			);
+		result->labels = throwStmt->labels;
 		delete throwStmt;
 		return result;
@@ -291,5 +291,5 @@
 			// }
 			// return;
-			CompoundStmt * block = new CompoundStmt( noLabels );
+			CompoundStmt * block = new CompoundStmt();
 
 			// Just copy the exception value. (Post Validation)
@@ -304,10 +304,10 @@
 					) })
 				);
-			block->push_back( new DeclStmt( noLabels, local_except ) );
+			block->push_back( new DeclStmt( local_except ) );
 
 			// Add the cleanup attribute.
 			local_except->get_attributes().push_back( new Attribute(
 				"cleanup",
-				{ new NameExpr( "__cfaehm__cleanup_terminate" ) }
+				{ new NameExpr( "__cfaabi_ehm__cleanup_terminate" ) }
 				) );
 
@@ -324,7 +324,6 @@
 
 			std::list<Statement *> caseBody
-					{ block, new ReturnStmt( noLabels, nullptr ) };
+					{ block, new ReturnStmt( nullptr ) };
 			handler_wrappers.push_back( new CaseStmt(
-				noLabels,
 				new ConstantExpr( Constant::from_int( index ) ),
 				caseBody
@@ -340,9 +339,8 @@
 
 		SwitchStmt * handler_lookup = new SwitchStmt(
-			noLabels,
 			nameOf( index_obj ),
 			stmt_handlers
 			);
-		CompoundStmt * body = new CompoundStmt( noLabels );
+		CompoundStmt * body = new CompoundStmt();
 		body->push_back( handler_lookup );
 
@@ -363,5 +361,5 @@
 		// }
 
-		CompoundStmt * block = new CompoundStmt( noLabels );
+		CompoundStmt * block = new CompoundStmt();
 
 		// Local Declaration
@@ -369,5 +367,5 @@
 			dynamic_cast<ObjectDecl *>( modded_handler->get_decl() );
 		assert( local_except );
-		block->push_back( new DeclStmt( noLabels, local_except ) );
+		block->push_back( new DeclStmt( local_except ) );
 
 		// Check for type match.
@@ -381,5 +379,5 @@
 		}
 		// Construct the match condition.
-		block->push_back( new IfStmt( noLabels,
+		block->push_back( new IfStmt(
 			cond, modded_handler->get_body(), nullptr ) );
 
@@ -397,5 +395,5 @@
 		// }
 
-		CompoundStmt * body = new CompoundStmt( noLabels );
+		CompoundStmt * body = new CompoundStmt();
 
 		FunctionType * func_type = match_func_t.clone();
@@ -413,5 +411,5 @@
 
 			// Create new body.
-			handler->set_body( new ReturnStmt( noLabels,
+			handler->set_body( new ReturnStmt(
 				new ConstantExpr( Constant::from_int( index ) ) ) );
 
@@ -421,5 +419,5 @@
 		}
 
-		body->push_back( new ReturnStmt( noLabels,
+		body->push_back( new ReturnStmt(
 			new ConstantExpr( Constant::from_int( 0 ) ) ) );
 
@@ -432,8 +430,8 @@
 			FunctionDecl * terminate_catch,
 			FunctionDecl * terminate_match ) {
-		// { __cfaehm__try_terminate(`try`, `catch`, `match`); }
+		// { __cfaabi_ehm__try_terminate(`try`, `catch`, `match`); }
 
 		UntypedExpr * caller = new UntypedExpr( new NameExpr(
-			"__cfaehm__try_terminate" ) );
+			"__cfaabi_ehm__try_terminate" ) );
 		std::list<Expression *>& args = caller->get_args();
 		args.push_back( nameOf( try_wrapper ) );
@@ -441,6 +439,6 @@
 		args.push_back( nameOf( terminate_match ) );
 
-		CompoundStmt * callStmt = new CompoundStmt( noLabels );
-		callStmt->push_back( new ExprStmt( noLabels, caller ) );
+		CompoundStmt * callStmt = new CompoundStmt();
+		callStmt->push_back( new ExprStmt( caller ) );
 		return callStmt;
 	}
@@ -451,5 +449,5 @@
 		//     HANDLER WRAPPERS { `hander->body`; return true; }
 		// }
-		CompoundStmt * body = new CompoundStmt( noLabels );
+		CompoundStmt * body = new CompoundStmt();
 
 		FunctionType * func_type = handle_func_t.clone();
@@ -464,8 +462,8 @@
 				dynamic_cast<CompoundStmt*>( handler->get_body() );
 			if ( ! handling_code ) {
-				handling_code = new CompoundStmt( noLabels );
+				handling_code = new CompoundStmt();
 				handling_code->push_back( handler->get_body() );
 			}
-			handling_code->push_back( new ReturnStmt( noLabels,
+			handling_code->push_back( new ReturnStmt(
 				new ConstantExpr( Constant::from_bool( true ) ) ) );
 			handler->set_body( handling_code );
@@ -476,5 +474,5 @@
 		}
 
-		body->push_back( new ReturnStmt( noLabels,
+		body->push_back( new ReturnStmt(
 			new ConstantExpr( Constant::from_bool( false ) ) ) );
 
@@ -486,11 +484,11 @@
 			Statement * wraps,
 			FunctionDecl * resume_handler ) {
-		CompoundStmt * body = new CompoundStmt( noLabels );
+		CompoundStmt * body = new CompoundStmt();
 
 		// struct __try_resume_node __resume_node
-		//  	__attribute__((cleanup( __cfaehm__try_resume_cleanup )));
+		//  	__attribute__((cleanup( __cfaabi_ehm__try_resume_cleanup )));
 		// ** unwinding of the stack here could cause problems **
 		// ** however I don't think that can happen currently **
-		// __cfaehm__try_resume_setup( &__resume_node, resume_handler );
+		// __cfaabi_ehm__try_resume_setup( &__resume_node, resume_handler );
 
 		std::list< Attribute * > attributes;
@@ -498,5 +496,5 @@
 			std::list< Expression * > attr_params;
 			attr_params.push_back( new NameExpr(
-				"__cfaehm__try_resume_cleanup" ) );
+				"__cfaabi_ehm__try_resume_cleanup" ) );
 			attributes.push_back( new Attribute( "cleanup", attr_params ) );
 		}
@@ -517,9 +515,9 @@
 
 		UntypedExpr *setup = new UntypedExpr( new NameExpr(
-			"__cfaehm__try_resume_setup" ) );
+			"__cfaabi_ehm__try_resume_setup" ) );
 		setup->get_args().push_back( new AddressExpr( nameOf( obj ) ) );
 		setup->get_args().push_back( nameOf( resume_handler ) );
 
-		body->push_back( new ExprStmt( noLabels, setup ) );
+		body->push_back( new ExprStmt( setup ) );
 
 		body->push_back( wraps );
@@ -542,5 +540,5 @@
 	ObjectDecl * ExceptionMutatorCore::create_finally_hook(
 			FunctionDecl * finally_wrapper ) {
-		// struct __cfaehm__cleanup_hook __finally_hook
+		// struct __cfaabi_ehm__cleanup_hook __finally_hook
 		//   	__attribute__((cleanup( finally_wrapper )));
 
@@ -596,12 +594,12 @@
 			// Skip children?
 			return;
-		} else if ( structDecl->get_name() == "__cfaehm__base_exception_t" ) {
+		} else if ( structDecl->get_name() == "__cfaabi_ehm__base_exception_t" ) {
 			assert( nullptr == except_decl );
 			except_decl = structDecl;
 			init_func_types();
-		} else if ( structDecl->get_name() == "__cfaehm__try_resume_node" ) {
+		} else if ( structDecl->get_name() == "__cfaabi_ehm__try_resume_node" ) {
 			assert( nullptr == node_decl );
 			node_decl = structDecl;
-		} else if ( structDecl->get_name() == "__cfaehm__cleanup_hook" ) {
+		} else if ( structDecl->get_name() == "__cfaabi_ehm__cleanup_hook" ) {
 			assert( nullptr == hook_decl );
 			hook_decl = structDecl;
@@ -646,5 +644,5 @@
 		// Generate a prefix for the function names?
 
-		CompoundStmt * block = new CompoundStmt( noLabels );
+		CompoundStmt * block = new CompoundStmt();
 		CompoundStmt * inner = take_try_block( tryStmt );
 
Index: src/ControlStruct/ForExprMutator.cc
===================================================================
--- src/ControlStruct/ForExprMutator.cc	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ src/ControlStruct/ForExprMutator.cc	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
@@ -29,5 +29,5 @@
 		// Create compound statement, move initializers outside,
 		// the resut of the original stays as is.
-		CompoundStmt *block = new CompoundStmt( std::list< Label >() );
+		CompoundStmt *block = new CompoundStmt();
 		std::list<Statement *> &stmts = block->get_kids();
 		stmts.splice( stmts.end(), init );
Index: src/ControlStruct/LabelFixer.cc
===================================================================
--- src/ControlStruct/LabelFixer.cc	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ src/ControlStruct/LabelFixer.cc	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
@@ -37,21 +37,17 @@
 	}
 
-	void LabelFixer::visit( FunctionDecl *functionDecl ) {
+	void LabelFixer::previsit( FunctionDecl * ) {
 		// need to go into a nested function in a fresh state
-		std::map < Label, Entry *> oldLabelTable = labelTable;
+		GuardValue( labelTable );
 		labelTable.clear();
+	}
 
-		maybeAccept( functionDecl->get_statements(), *this );
-
+	void LabelFixer::postvisit( FunctionDecl * functionDecl ) {
 		MLEMutator mlemut( resolveJumps(), generator );
 		functionDecl->acceptMutator( mlemut );
-
-		// and remember the outer function's labels when
-		// returning to it
-		labelTable = oldLabelTable;
 	}
 
 	// prune to at most one label definition for each statement
-	void LabelFixer::visit( Statement *stmt ) {
+	void LabelFixer::previsit( Statement *stmt ) {
 		std::list< Label > &labels = stmt->get_labels();
 
@@ -62,6 +58,6 @@
 	}
 
-	void LabelFixer::visit( BranchStmt *branchStmt ) {
-		visit ( ( Statement * )branchStmt );
+	void LabelFixer::previsit( BranchStmt *branchStmt ) {
+		previsit( ( Statement *)branchStmt );
 
 		// for labeled branches, add an entry to the label table
@@ -72,15 +68,8 @@
 	}
 
-	void LabelFixer::visit( UntypedExpr *untyped ) {
-		if ( NameExpr * func = dynamic_cast< NameExpr * >( untyped->get_function() ) ) {
-			if ( func->get_name() == "&&" ) {
-				NameExpr * arg = dynamic_cast< NameExpr * >( untyped->get_args().front() );
-				Label target = arg->get_name();
-				assert( target != "" );
-				setLabelsUsg( target, untyped );
-			} else {
-				Visitor::visit( untyped );
-			}
-		}
+	void LabelFixer::previsit( LabelAddressExpr * addrExpr ) {
+		Label & target = addrExpr->arg;
+		assert( target != "" );
+		setLabelsUsg( target, addrExpr );
 	}
 
Index: src/ControlStruct/LabelFixer.h
===================================================================
--- src/ControlStruct/LabelFixer.h	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ src/ControlStruct/LabelFixer.h	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
@@ -19,4 +19,5 @@
 #include <map>                     // for map
 
+#include "Common/PassVisitor.h"
 #include "Common/SemanticError.h"  // for SemanticError
 #include "SynTree/Label.h"         // for Label
@@ -26,8 +27,7 @@
 namespace ControlStruct {
 	/// normalizes label definitions and generates multi-level exit labels
-class LabelGenerator;
+	class LabelGenerator;
 
-	class LabelFixer final : public Visitor {
-		typedef Visitor Parent;
+	class LabelFixer final : public WithGuards {
 	  public:
 		LabelFixer( LabelGenerator *gen = 0 );
@@ -35,26 +35,14 @@
 		std::map < Label, Statement * > *resolveJumps() throw ( SemanticError );
 
-		using Visitor::visit;
-
 		// Declarations
-		virtual void visit( FunctionDecl *functionDecl ) override;
+		void previsit( FunctionDecl *functionDecl );
+		void postvisit( FunctionDecl *functionDecl );
 
 		// Statements
-		void visit( Statement *stmt );
+		void previsit( Statement *stmt );
+		void previsit( BranchStmt *branchStmt );
 
-		virtual void visit( CompoundStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
-		virtual void visit( NullStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
-		virtual void visit( ExprStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
-		virtual void visit( IfStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
-		virtual void visit( WhileStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
-		virtual void visit( ForStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
-		virtual void visit( SwitchStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
-		virtual void visit( CaseStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
-		virtual void visit( ReturnStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
-		virtual void visit( TryStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
-		virtual void visit( CatchStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
-		virtual void visit( DeclStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
-		virtual void visit( BranchStmt *branchStmt ) override;
-		virtual void visit( UntypedExpr *untyped ) override;
+		// Expressions
+		void previsit( LabelAddressExpr *addrExpr );
 
 		Label setLabelsDef( std::list< Label > &, Statement *definition );
Index: src/ControlStruct/MLEMutator.cc
===================================================================
--- src/ControlStruct/MLEMutator.cc	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ src/ControlStruct/MLEMutator.cc	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
@@ -149,6 +149,7 @@
 
 			if ( CaseStmt * c = dynamic_cast< CaseStmt * >( statements.back() ) ) {
-				std::list<Label> temp; temp.push_back( brkLabel );
-				c->get_statements().push_back( new BranchStmt( temp, Label("brkLabel"), BranchStmt::Break ) );
+				Statement * stmt = new BranchStmt( Label("brkLabel"), BranchStmt::Break );
+				stmt->labels.push_back( brkLabel );
+				c->get_statements().push_back( stmt );
 			} else assert(0); // as of this point, all statements of a switch are still CaseStmts
 		} // if
@@ -232,5 +233,5 @@
 		// transform break/continue statements into goto to simplify later handling of branches
 		delete branchStmt;
-		return new BranchStmt( std::list<Label>(), exitLabel, BranchStmt::Goto );
+		return new BranchStmt( exitLabel, BranchStmt::Goto );
 	}
 
@@ -239,5 +240,5 @@
 		CompoundStmt *newBody;
 		if ( ! (newBody = dynamic_cast<CompoundStmt *>( bodyLoop )) ) {
-			newBody = new CompoundStmt( std::list< Label >() );
+			newBody = new CompoundStmt();
 			newBody->get_kids().push_back( bodyLoop );
 		} // if
Index: src/ControlStruct/Mutate.cc
===================================================================
--- src/ControlStruct/Mutate.cc	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ src/ControlStruct/Mutate.cc	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
@@ -24,5 +24,4 @@
 #include "SynTree/Declaration.h"   // for Declaration
 #include "SynTree/Mutator.h"       // for mutateAll
-//#include "ExceptMutator.h"
 
 #include "Common/PassVisitor.h"    // for PassVisitor
@@ -37,11 +36,8 @@
 
 		// normalizes label definitions and generates multi-level exit labels
-		LabelFixer lfix;
-
-		//ExceptMutator exc;
+		PassVisitor<LabelFixer> lfix;
 
 		mutateAll( translationUnit, formut );
 		acceptAll( translationUnit, lfix );
-		//mutateAll( translationUnit, exc );
 	}
 } // namespace CodeGen
Index: src/GenPoly/Box.cc
===================================================================
--- src/GenPoly/Box.cc	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ src/GenPoly/Box.cc	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
@@ -49,5 +49,5 @@
 #include "SynTree/Expression.h"          // for ApplicationExpr, UntypedExpr
 #include "SynTree/Initializer.h"         // for SingleInit, Initializer, Lis...
-#include "SynTree/Label.h"               // for Label, noLabels
+#include "SynTree/Label.h"               // for Label
 #include "SynTree/Mutator.h"             // for maybeMutate, Mutator, mutateAll
 #include "SynTree/Statement.h"           // for ExprStmt, DeclStmt, ReturnStmt
@@ -293,5 +293,5 @@
 		FunctionDecl *layoutDecl = new FunctionDecl( layoutofName( typeDecl ),
 													 functionNesting > 0 ? Type::StorageClasses() : Type::StorageClasses( Type::Static ),
-													 LinkageSpec::AutoGen, layoutFnType, new CompoundStmt( noLabels ),
+													 LinkageSpec::AutoGen, layoutFnType, new CompoundStmt(),
 													 std::list< Attribute * >(), Type::FuncSpecifiers( Type::Inline ) );
 		layoutDecl->fixUniqueId();
@@ -321,5 +321,5 @@
 	/// makes an if-statement with a single-expression if-block and no then block
 	Statement *makeCond( Expression *cond, Expression *ifPart ) {
-		return new IfStmt( noLabels, cond, new ExprStmt( noLabels, ifPart ), 0 );
+		return new IfStmt( cond, new ExprStmt( ifPart ), 0 );
 	}
 
@@ -340,5 +340,5 @@
 	/// adds an expression to a compound statement
 	void addExpr( CompoundStmt *stmts, Expression *expr ) {
-		stmts->get_kids().push_back( new ExprStmt( noLabels, expr ) );
+		stmts->get_kids().push_back( new ExprStmt( expr ) );
 	}
 
@@ -629,5 +629,5 @@
 		ObjectDecl *Pass1::makeTemporary( Type *type ) {
 			ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, type, 0 );
-			stmtsToAddBefore.push_back( new DeclStmt( noLabels, newObj ) );
+			stmtsToAddBefore.push_back( new DeclStmt( newObj ) );
 			return newObj;
 		}
@@ -740,9 +740,9 @@
 				ObjectDecl *newObj = ObjectDecl::newObject( tempNamer.newName(), newType, nullptr );
 				newObj->get_type()->get_qualifiers() = Type::Qualifiers(); // TODO: is this right???
-				stmtsToAddBefore.push_back( new DeclStmt( noLabels, newObj ) );
+				stmtsToAddBefore.push_back( new DeclStmt( newObj ) );
 				UntypedExpr *assign = new UntypedExpr( new NameExpr( "?=?" ) ); // TODO: why doesn't this just use initialization syntax?
 				assign->get_args().push_back( new VariableExpr( newObj ) );
 				assign->get_args().push_back( arg );
-				stmtsToAddBefore.push_back( new ExprStmt( noLabels, assign ) );
+				stmtsToAddBefore.push_back( new ExprStmt( assign ) );
 				arg = new AddressExpr( new VariableExpr( newObj ) );
 			} // if
@@ -888,5 +888,5 @@
 				// void return
 				addAdapterParams( adapteeApp, arg, param, adapterType->get_parameters().end(), realParam, tyVars );
-				bodyStmt = new ExprStmt( noLabels, adapteeApp );
+				bodyStmt = new ExprStmt( adapteeApp );
 			} else if ( isDynType( adaptee->get_returnVals().front()->get_type(), tyVars ) ) {
 				// return type T
@@ -900,11 +900,11 @@
 				addAdapterParams( adapteeApp, arg, param, adapterType->get_parameters().end(), realParam, tyVars );
 				assign->get_args().push_back( adapteeApp );
-				bodyStmt = new ExprStmt( noLabels, assign );
+				bodyStmt = new ExprStmt( assign );
 			} else {
 				// adapter for a function that returns a monomorphic value
 				addAdapterParams( adapteeApp, arg, param, adapterType->get_parameters().end(), realParam, tyVars );
-				bodyStmt = new ReturnStmt( noLabels, adapteeApp );
+				bodyStmt = new ReturnStmt( adapteeApp );
 			} // if
-			CompoundStmt *adapterBody = new CompoundStmt( noLabels );
+			CompoundStmt *adapterBody = new CompoundStmt();
 			adapterBody->get_kids().push_back( bodyStmt );
 			std::string adapterName = makeAdapterName( mangleName );
@@ -952,5 +952,5 @@
 						std::pair< AdapterIter, bool > answer = adapters.insert( std::pair< std::string, DeclarationWithType *>( mangleName, newAdapter ) );
 						adapter = answer.first;
-						stmtsToAddBefore.push_back( new DeclStmt( noLabels, newAdapter ) );
+						stmtsToAddBefore.push_back( new DeclStmt( newAdapter ) );
 					} // if
 					assert( adapter != adapters.end() );
@@ -1279,5 +1279,5 @@
 						retval->set_name( "_retval" );
 					}
-					functionDecl->get_statements()->get_kids().push_front( new DeclStmt( noLabels, retval ) );
+					functionDecl->get_statements()->get_kids().push_front( new DeclStmt( retval ) );
 					DeclarationWithType * newRet = retval->clone(); // for ownership purposes
 					ftype->get_returnVals().front() = newRet;
@@ -1519,5 +1519,5 @@
 					// (alloca was previously used, but can't be safely used in loops)
 					ObjectDecl *newBuf = ObjectDecl::newObject( bufNamer.newName(), polyToMonoType( objectDecl->type ), nullptr );
-					stmtsToAddBefore.push_back( new DeclStmt( noLabels, newBuf ) );
+					stmtsToAddBefore.push_back( new DeclStmt( newBuf ) );
 
 					delete objectDecl->get_init();
@@ -1598,5 +1598,5 @@
 		ObjectDecl *PolyGenericCalculator::makeVar( const std::string &name, Type *type, Initializer *init ) {
 			ObjectDecl *newObj = new ObjectDecl( name, Type::StorageClasses(), LinkageSpec::C, 0, type, init );
-			stmtsToAddBefore.push_back( new DeclStmt( noLabels, newObj ) );
+			stmtsToAddBefore.push_back( new DeclStmt( newObj ) );
 			return newObj;
 		}
@@ -1677,5 +1677,5 @@
 					addOtypeParamsToLayoutCall( layoutCall, otypeParams );
 
-					stmtsToAddBefore.push_back( new ExprStmt( noLabels, layoutCall ) );
+					stmtsToAddBefore.push_back( new ExprStmt( layoutCall ) );
 				}
 
@@ -1703,5 +1703,5 @@
 				addOtypeParamsToLayoutCall( layoutCall, otypeParams );
 
-				stmtsToAddBefore.push_back( new ExprStmt( noLabels, layoutCall ) );
+				stmtsToAddBefore.push_back( new ExprStmt( layoutCall ) );
 
 				return true;
Index: src/GenPoly/InstantiateGeneric.cc
===================================================================
--- src/GenPoly/InstantiateGeneric.cc	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ src/GenPoly/InstantiateGeneric.cc	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
@@ -517,5 +517,5 @@
 					Expression * init = new CastExpr( new AddressExpr( memberExpr ), new PointerType( Type::Qualifiers(), concType->clone() ) );
 					ObjectDecl * tmp = ObjectDecl::newObject( tmpNamer.newName(), new ReferenceType( Type::Qualifiers(), concType ), new SingleInit( init ) );
-					stmtsToAddBefore.push_back( new DeclStmt( noLabels, tmp ) );
+					stmtsToAddBefore.push_back( new DeclStmt( tmp ) );
 					return new VariableExpr( tmp );
 				} else {
Index: src/GenPoly/Specialize.cc
===================================================================
--- src/GenPoly/Specialize.cc	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ src/GenPoly/Specialize.cc	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
@@ -35,5 +35,5 @@
 #include "SynTree/Declaration.h"         // for FunctionDecl, DeclarationWit...
 #include "SynTree/Expression.h"          // for ApplicationExpr, Expression
-#include "SynTree/Label.h"               // for Label, noLabels
+#include "SynTree/Label.h"               // for Label
 #include "SynTree/Mutator.h"             // for mutateAll
 #include "SynTree/Statement.h"           // for CompoundStmt, DeclStmt, Expr...
@@ -234,5 +234,5 @@
 		} // if
 		// create new thunk with same signature as formal type (C linkage, empty body)
-		FunctionDecl *thunkFunc = new FunctionDecl( thunkNamer.newName(), Type::StorageClasses(), LinkageSpec::C, newType, new CompoundStmt( noLabels ) );
+		FunctionDecl *thunkFunc = new FunctionDecl( thunkNamer.newName(), Type::StorageClasses(), LinkageSpec::C, newType, new CompoundStmt() );
 		thunkFunc->fixUniqueId();
 
@@ -287,12 +287,12 @@
 		Statement *appStmt;
 		if ( funType->returnVals.empty() ) {
-			appStmt = new ExprStmt( noLabels, appExpr );
-		} else {
-			appStmt = new ReturnStmt( noLabels, appExpr );
+			appStmt = new ExprStmt( appExpr );
+		} else {
+			appStmt = new ReturnStmt( appExpr );
 		} // if
 		thunkFunc->statements->kids.push_back( appStmt );
 
 		// add thunk definition to queue of statements to add
-		stmtsToAddBefore.push_back( new DeclStmt( noLabels, thunkFunc ) );
+		stmtsToAddBefore.push_back( new DeclStmt( thunkFunc ) );
 		// return address of thunk function as replacement expression
 		return new AddressExpr( new VariableExpr( thunkFunc ) );
Index: src/InitTweak/FixGlobalInit.cc
===================================================================
--- src/InitTweak/FixGlobalInit.cc	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ src/InitTweak/FixGlobalInit.cc	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
@@ -20,4 +20,5 @@
 #include <algorithm>               // for replace_if
 
+#include "Common/PassVisitor.h"
 #include "Common/SemanticError.h"  // for SemanticError
 #include "Common/UniqueName.h"     // for UniqueName
@@ -29,5 +30,5 @@
 #include "SynTree/Expression.h"    // for ConstantExpr, Expression (ptr only)
 #include "SynTree/Initializer.h"   // for ConstructorInit, Initializer
-#include "SynTree/Label.h"         // for Label, noLabels
+#include "SynTree/Label.h"         // for Label
 #include "SynTree/Statement.h"     // for CompoundStmt, Statement (ptr only)
 #include "SynTree/Type.h"          // for Type, Type::StorageClasses, Functi...
@@ -35,15 +36,15 @@
 
 namespace InitTweak {
-	class GlobalFixer : public Visitor {
+	class GlobalFixer : public WithShortCircuiting {
 	  public:
 		GlobalFixer( const std::string & name, bool inLibrary );
 
-		virtual void visit( ObjectDecl *objDecl );
-		virtual void visit( FunctionDecl *functionDecl );
-		virtual void visit( StructDecl *aggregateDecl );
-		virtual void visit( UnionDecl *aggregateDecl );
-		virtual void visit( EnumDecl *aggregateDecl );
-		virtual void visit( TraitDecl *aggregateDecl );
-		virtual void visit( TypeDecl *typeDecl );
+		void previsit( ObjectDecl *objDecl );
+		void previsit( FunctionDecl *functionDecl );
+		void previsit( StructDecl *aggregateDecl );
+		void previsit( UnionDecl *aggregateDecl );
+		void previsit( EnumDecl *aggregateDecl );
+		void previsit( TraitDecl *aggregateDecl );
+		void previsit( TypeDecl *typeDecl );
 
 		UniqueName tempNamer;
@@ -53,6 +54,7 @@
 
 	void fixGlobalInit( std::list< Declaration * > & translationUnit, const std::string & name, bool inLibrary ) {
-		GlobalFixer fixer( name, inLibrary );
-		acceptAll( translationUnit, fixer );
+		PassVisitor<GlobalFixer> visitor( name, inLibrary );
+		acceptAll( translationUnit, visitor );
+		GlobalFixer & fixer = visitor.pass;
 		// don't need to include function if it's empty
 		if ( fixer.initFunction->get_statements()->get_kids().empty() ) {
@@ -92,11 +94,11 @@
 			dtorParameters.push_back( new ConstantExpr( Constant::from_int( 102 ) ) );
 		}
-		initFunction = new FunctionDecl( "_init_" + fixedName, Type::StorageClasses( Type::Static ), LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ) );
+		initFunction = new FunctionDecl( "_init_" + fixedName, Type::StorageClasses( Type::Static ), LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt() );
 		initFunction->get_attributes().push_back( new Attribute( "constructor", ctorParameters ) );
-		destroyFunction = new FunctionDecl( "_destroy_" + fixedName, Type::StorageClasses( Type::Static ), LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ) );
+		destroyFunction = new FunctionDecl( "_destroy_" + fixedName, Type::StorageClasses( Type::Static ), LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt() );
 		destroyFunction->get_attributes().push_back( new Attribute( "destructor", dtorParameters ) );
 	}
 
-	void GlobalFixer::visit( ObjectDecl *objDecl ) {
+	void GlobalFixer::previsit( ObjectDecl *objDecl ) {
 		std::list< Statement * > & initStatements = initFunction->get_statements()->get_kids();
 		std::list< Statement * > & destroyStatements = destroyFunction->get_statements()->get_kids();
@@ -134,10 +136,10 @@
 
 	// only modify global variables
-	void GlobalFixer::visit( __attribute__((unused)) FunctionDecl *functionDecl ) {}
-	void GlobalFixer::visit( __attribute__((unused)) StructDecl *aggregateDecl ) {}
-	void GlobalFixer::visit( __attribute__((unused)) UnionDecl *aggregateDecl ) {}
-	void GlobalFixer::visit( __attribute__((unused)) EnumDecl *aggregateDecl ) {}
-	void GlobalFixer::visit( __attribute__((unused)) TraitDecl *aggregateDecl ) {}
-	void GlobalFixer::visit( __attribute__((unused)) TypeDecl *typeDecl ) {}
+	void GlobalFixer::previsit( FunctionDecl * ) { visit_children = false; }
+	void GlobalFixer::previsit( StructDecl * ) { visit_children = false; }
+	void GlobalFixer::previsit( UnionDecl * ) { visit_children = false; }
+	void GlobalFixer::previsit( EnumDecl * ) { visit_children = false; }
+	void GlobalFixer::previsit( TraitDecl * ) { visit_children = false; }
+	void GlobalFixer::previsit( TypeDecl * ) { visit_children = false; }
 
 } // namespace InitTweak
Index: src/InitTweak/FixInit.cc
===================================================================
--- src/InitTweak/FixInit.cc	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ src/InitTweak/FixInit.cc	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
@@ -49,5 +49,5 @@
 #include "SynTree/Expression.h"        // for UniqueExpr, VariableExpr, Unty...
 #include "SynTree/Initializer.h"       // for ConstructorInit, SingleInit
-#include "SynTree/Label.h"             // for Label, noLabels, operator<
+#include "SynTree/Label.h"             // for Label, operator<
 #include "SynTree/Mutator.h"           // for mutateAll, Mutator, maybeMutate
 #include "SynTree/Statement.h"         // for ExprStmt, CompoundStmt, Branch...
@@ -544,13 +544,13 @@
 			// add all temporary declarations and their constructors
 			for ( ObjectDecl * obj : tempDecls ) {
-				stmtsToAddBefore.push_back( new DeclStmt( noLabels, obj ) );
+				stmtsToAddBefore.push_back( new DeclStmt( obj ) );
 			} // for
 			for ( ObjectDecl * obj : returnDecls ) {
-				stmtsToAddBefore.push_back( new DeclStmt( noLabels, obj ) );
+				stmtsToAddBefore.push_back( new DeclStmt( obj ) );
 			} // for
 
 			// add destructors after current statement
 			for ( Expression * dtor : dtors ) {
-				stmtsToAddAfter.push_back( new ExprStmt( noLabels, dtor ) );
+				stmtsToAddAfter.push_back( new ExprStmt( dtor ) );
 			} // for
 
@@ -598,14 +598,14 @@
 			if ( ! result->isVoid() ) {
 				for ( ObjectDecl * obj : stmtExpr->get_returnDecls() ) {
-					stmtsToAddBefore.push_back( new DeclStmt( noLabels, obj ) );
+					stmtsToAddBefore.push_back( new DeclStmt( obj ) );
 				} // for
 				// add destructors after current statement
 				for ( Expression * dtor : stmtExpr->get_dtors() ) {
-					stmtsToAddAfter.push_back( new ExprStmt( noLabels, dtor ) );
+					stmtsToAddAfter.push_back( new ExprStmt( dtor ) );
 				} // for
 				// must have a non-empty body, otherwise it wouldn't have a result
 				assert( ! stmts.empty() );
 				assert( ! stmtExpr->get_returnDecls().empty() );
-				stmts.push_back( new ExprStmt( noLabels, new VariableExpr( stmtExpr->get_returnDecls().front() ) ) );
+				stmts.push_back( new ExprStmt( new VariableExpr( stmtExpr->get_returnDecls().front() ) ) );
 				stmtExpr->get_returnDecls().clear();
 				stmtExpr->get_dtors().clear();
@@ -685,12 +685,12 @@
 
 						// generate body of if
-						CompoundStmt * initStmts = new CompoundStmt( noLabels );
+						CompoundStmt * initStmts = new CompoundStmt();
 						std::list< Statement * > & body = initStmts->get_kids();
 						body.push_back( ctor );
-						body.push_back( new ExprStmt( noLabels, setTrue ) );
+						body.push_back( new ExprStmt( setTrue ) );
 
 						// put it all together
-						IfStmt * ifStmt = new IfStmt( noLabels, new VariableExpr( isUninitializedVar ), initStmts, 0 );
-						stmtsToAddAfter.push_back( new DeclStmt( noLabels, isUninitializedVar ) );
+						IfStmt * ifStmt = new IfStmt( new VariableExpr( isUninitializedVar ), initStmts, 0 );
+						stmtsToAddAfter.push_back( new DeclStmt( isUninitializedVar ) );
 						stmtsToAddAfter.push_back( ifStmt );
 
@@ -707,5 +707,5 @@
 
 							// void __objName_dtor_atexitN(...) {...}
-							FunctionDecl * dtorCaller = new FunctionDecl( objDecl->get_mangleName() + dtorCallerNamer.newName(), Type::StorageClasses( Type::Static ), LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ) );
+							FunctionDecl * dtorCaller = new FunctionDecl( objDecl->get_mangleName() + dtorCallerNamer.newName(), Type::StorageClasses( Type::Static ), LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt() );
 							dtorCaller->fixUniqueId();
 							dtorCaller->get_statements()->push_back( dtorStmt );
@@ -715,5 +715,5 @@
 							callAtexit->get_args().push_back( new VariableExpr( dtorCaller ) );
 
-							body.push_back( new ExprStmt( noLabels, callAtexit ) );
+							body.push_back( new ExprStmt( callAtexit ) );
 
 							// hoist variable and dtor caller decls to list of decls that will be added into global scope
Index: src/InitTweak/InitTweak.cc
===================================================================
--- src/InitTweak/InitTweak.cc	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ src/InitTweak/InitTweak.cc	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
@@ -5,4 +5,5 @@
 #include <memory>                  // for __shared_ptr
 
+#include "Common/PassVisitor.h"
 #include "Common/SemanticError.h"  // for SemanticError
 #include "Common/UniqueName.h"     // for UniqueName
@@ -19,5 +20,5 @@
 #include "SynTree/Expression.h"    // for Expression, UntypedExpr, Applicati...
 #include "SynTree/Initializer.h"   // for Initializer, ListInit, Designation
-#include "SynTree/Label.h"         // for Label, noLabels
+#include "SynTree/Label.h"         // for Label
 #include "SynTree/Statement.h"     // for CompoundStmt, ExprStmt, BranchStmt
 #include "SynTree/Type.h"          // for FunctionType, ArrayType, PointerType
@@ -29,15 +30,23 @@
 namespace InitTweak {
 	namespace {
-		class HasDesignations : public Visitor {
-		public:
+		struct HasDesignations : public WithShortCircuiting {
 			bool hasDesignations = false;
-			virtual void visit( Designation * des ) {
-				if ( ! des->get_designators().empty() ) hasDesignations = true;
-				else Visitor::visit( des );
+
+			void previsit( BaseSyntaxNode * ) {
+				// short circuit if we already know there are designations
+				if ( hasDesignations ) visit_children = false;
+			}
+
+			void previsit( Designation * des ) {
+				// short circuit if we already know there are designations
+				if ( hasDesignations ) visit_children = false;
+				else if ( ! des->get_designators().empty() ) {
+					hasDesignations = true;
+					visit_children = false;
+				}
 			}
 		};
 
-		class InitDepthChecker : public Visitor {
-		public:
+		struct InitDepthChecker : public WithGuards {
 			bool depthOkay = true;
 			Type * type;
@@ -51,48 +60,37 @@
 				maxDepth++;
 			}
-			virtual void visit( ListInit * listInit ) {
+			void previsit( ListInit * ) {
 				curDepth++;
+				GuardAction( [this]() { curDepth--; } );
 				if ( curDepth > maxDepth ) depthOkay = false;
-				Visitor::visit( listInit );
-				curDepth--;
 			}
 		};
 
-		class InitFlattener : public Visitor {
-			public:
-			virtual void visit( SingleInit * singleInit );
-			virtual void visit( ListInit * listInit );
+		struct InitFlattener : public WithShortCircuiting {
+			void previsit( SingleInit * singleInit ) {
+				visit_children = false;
+				argList.push_back( singleInit->value->clone() );
+			}
 			std::list< Expression * > argList;
 		};
 
-		void InitFlattener::visit( SingleInit * singleInit ) {
-			argList.push_back( singleInit->get_value()->clone() );
-		}
-
-		void InitFlattener::visit( ListInit * listInit ) {
-			// flatten nested list inits
-			std::list<Initializer*>::iterator it = listInit->begin();
-			for ( ; it != listInit->end(); ++it ) {
-				(*it)->accept( *this );
-			}
-		}
 	}
 
 	std::list< Expression * > makeInitList( Initializer * init ) {
-		InitFlattener flattener;
+		PassVisitor<InitFlattener> flattener;
 		maybeAccept( init, flattener );
-		return flattener.argList;
+		return flattener.pass.argList;
 	}
 
 	bool isDesignated( Initializer * init ) {
-		HasDesignations finder;
+		PassVisitor<HasDesignations> finder;
 		maybeAccept( init, finder );
-		return finder.hasDesignations;
+		return finder.pass.hasDesignations;
 	}
 
 	bool checkInitDepth( ObjectDecl * objDecl ) {
-		InitDepthChecker checker( objDecl->get_type() );
-		maybeAccept( objDecl->get_init(), checker );
-		return checker.depthOkay;
+		PassVisitor<InitDepthChecker> checker( objDecl->type );
+		maybeAccept( objDecl->init, checker );
+		return checker.pass.depthOkay;
 	}
 
@@ -195,9 +193,9 @@
 			callExpr->get_args().splice( callExpr->get_args().end(), args );
 
-			*out++ = new IfStmt( noLabels, cond, new ExprStmt( noLabels, callExpr ), nullptr );
+			*out++ = new IfStmt( cond, new ExprStmt( callExpr ), nullptr );
 
 			UntypedExpr * increment = new UntypedExpr( new NameExpr( "++?" ) );
 			increment->get_args().push_back( index->clone() );
-			*out++ = new ExprStmt( noLabels, increment );
+			*out++ = new ExprStmt( increment );
 		}
 
@@ -244,10 +242,10 @@
 					std::list< Statement * > stmts;
 					build( callExpr, idx, idxEnd, init, back_inserter( stmts ) );
-					stmts.push_back( new BranchStmt( noLabels, switchLabel, BranchStmt::Break ) );
-					CaseStmt * caseStmt = new CaseStmt( noLabels, condition, stmts );
+					stmts.push_back( new BranchStmt( switchLabel, BranchStmt::Break ) );
+					CaseStmt * caseStmt = new CaseStmt( condition, stmts );
 					branches.push_back( caseStmt );
 				}
-				*out++ = new SwitchStmt( noLabels, index->clone(), branches );
-				*out++ = new NullStmt( std::list<Label>{ switchLabel } );
+				*out++ = new SwitchStmt( index->clone(), branches );
+				*out++ = new NullStmt( { switchLabel } );
 			}
 		}
@@ -262,5 +260,5 @@
 	Statement * InitImpl::buildListInit( UntypedExpr * dst, std::list< Expression * > & indices ) {
 		if ( ! init ) return nullptr;
-		CompoundStmt * block = new CompoundStmt( noLabels );
+		CompoundStmt * block = new CompoundStmt();
 		build( dst, indices.begin(), indices.end(), init, back_inserter( block->get_kids() ) );
 		if ( block->get_kids().empty() ) {
@@ -309,14 +307,12 @@
 	}
 
-	class CallFinder : public Visitor {
-	public:
-		typedef Visitor Parent;
+	struct CallFinder {
 		CallFinder( const std::list< std::string > & names ) : names( names ) {}
 
-		virtual void visit( ApplicationExpr * appExpr ) {
+		void postvisit( ApplicationExpr * appExpr ) {
 			handleCallExpr( appExpr );
 		}
 
-		virtual void visit( UntypedExpr * untypedExpr ) {
+		void postvisit( UntypedExpr * untypedExpr ) {
 			handleCallExpr( untypedExpr );
 		}
@@ -328,5 +324,4 @@
 		template< typename CallExpr >
 		void handleCallExpr( CallExpr * expr ) {
-			Parent::visit( expr );
 			std::string fname = getFunctionName( expr );
 			if ( std::find( names.begin(), names.end(), fname ) != names.end() ) {
@@ -337,6 +332,6 @@
 
 	void collectCtorDtorCalls( Statement * stmt, std::list< Expression * > & matches ) {
-		static CallFinder finder( std::list< std::string >{ "?{}", "^?{}" } );
-		finder.matches = &matches;
+		static PassVisitor<CallFinder> finder( std::list< std::string >{ "?{}", "^?{}" } );
+		finder.pass.matches = &matches;
 		maybeAccept( stmt, finder );
 	}
@@ -544,48 +539,37 @@
 	}
 
-	class ConstExprChecker : public Visitor {
-	public:
-		ConstExprChecker() : isConstExpr( true ) {}
-
-		using Visitor::visit;
-
-		virtual void visit( ApplicationExpr * ) { isConstExpr = false; }
-		virtual void visit( UntypedExpr * ) { isConstExpr = false; }
-		virtual void visit( NameExpr * ) { isConstExpr = false; }
-		// virtual void visit( CastExpr *castExpr ) { isConstExpr = false; }
-		virtual void visit( AddressExpr *addressExpr ) {
+	struct ConstExprChecker : public WithShortCircuiting {
+		// most expressions are not const expr
+		void previsit( Expression * ) { isConstExpr = false; visit_children = false; }
+
+		void previsit( AddressExpr *addressExpr ) {
+			visit_children = false;
+
 			// address of a variable or member expression is constexpr
 			Expression * arg = addressExpr->get_arg();
 			if ( ! dynamic_cast< NameExpr * >( arg) && ! dynamic_cast< VariableExpr * >( arg ) && ! dynamic_cast< MemberExpr * >( arg ) && ! dynamic_cast< UntypedMemberExpr * >( arg ) ) isConstExpr = false;
 		}
-		virtual void visit( UntypedMemberExpr * ) { isConstExpr = false; }
-		virtual void visit( MemberExpr * ) { isConstExpr = false; }
-		virtual void visit( VariableExpr * ) { isConstExpr = false; }
-		// these might be okay?
-		// virtual void visit( SizeofExpr *sizeofExpr );
-		// virtual void visit( AlignofExpr *alignofExpr );
-		// virtual void visit( UntypedOffsetofExpr *offsetofExpr );
-		// virtual void visit( OffsetofExpr *offsetofExpr );
-		// virtual void visit( OffsetPackExpr *offsetPackExpr );
-		// virtual void visit( AttrExpr *attrExpr );
-		// virtual void visit( CommaExpr *commaExpr );
-		// virtual void visit( LogicalExpr *logicalExpr );
-		// virtual void visit( ConditionalExpr *conditionalExpr );
-		virtual void visit( TypeExpr * ) { isConstExpr = false; }
-		virtual void visit( AsmExpr * ) { isConstExpr = false; }
-		virtual void visit( UntypedValofExpr * ) { isConstExpr = false; }
-		virtual void visit( CompoundLiteralExpr * ) { isConstExpr = false; }
-		virtual void visit( UntypedTupleExpr * ) { isConstExpr = false; }
-		virtual void visit( TupleExpr * ) { isConstExpr = false; }
-		virtual void visit( TupleAssignExpr * ) { isConstExpr = false; }
-
-		bool isConstExpr;
+
+		// these expressions may be const expr, depending on their children
+		void previsit( SizeofExpr * ) {}
+		void previsit( AlignofExpr * ) {}
+		void previsit( UntypedOffsetofExpr * ) {}
+		void previsit( OffsetofExpr * ) {}
+		void previsit( OffsetPackExpr * ) {}
+		void previsit( AttrExpr * ) {}
+		void previsit( CommaExpr * ) {}
+		void previsit( LogicalExpr * ) {}
+		void previsit( ConditionalExpr * ) {}
+		void previsit( CastExpr * ) {}
+		void previsit( ConstantExpr * ) {}
+
+		bool isConstExpr = true;
 	};
 
 	bool isConstExpr( Expression * expr ) {
 		if ( expr ) {
-			ConstExprChecker checker;
+			PassVisitor<ConstExprChecker> checker;
 			expr->accept( checker );
-			return checker.isConstExpr;
+			return checker.pass.isConstExpr;
 		}
 		return true;
@@ -594,7 +578,7 @@
 	bool isConstExpr( Initializer * init ) {
 		if ( init ) {
-			ConstExprChecker checker;
+			PassVisitor<ConstExprChecker> checker;
 			init->accept( checker );
-			return checker.isConstExpr;
+			return checker.pass.isConstExpr;
 		} // if
 		// for all intents and purposes, no initializer means const expr
Index: src/MakeLibCfa.cc
===================================================================
--- src/MakeLibCfa.cc	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ src/MakeLibCfa.cc	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
@@ -116,5 +116,5 @@
 			} // for
 
-			funcDecl->set_statements( new CompoundStmt( std::list< Label >() ) );
+			funcDecl->set_statements( new CompoundStmt() );
 			newDecls.push_back( funcDecl );
 
@@ -130,10 +130,10 @@
 			  case CodeGen::OT_INFIXASSIGN:
 					// return the recursive call
-					stmt = new ReturnStmt( noLabels, newExpr );
+					stmt = new ReturnStmt( newExpr );
 					break;
 			  case CodeGen::OT_CTOR:
 			  case CodeGen::OT_DTOR:
 					// execute the recursive call
-					stmt = new ExprStmt( noLabels, newExpr );
+					stmt = new ExprStmt( newExpr );
 					break;
 			  case CodeGen::OT_CONSTANT:
Index: src/Makefile.in
===================================================================
--- src/Makefile.in	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ src/Makefile.in	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
@@ -215,6 +215,4 @@
 	SymTab/driver_cfa_cpp-Validate.$(OBJEXT) \
 	SymTab/driver_cfa_cpp-FixFunction.$(OBJEXT) \
-	SymTab/driver_cfa_cpp-ImplementationType.$(OBJEXT) \
-	SymTab/driver_cfa_cpp-TypeEquality.$(OBJEXT) \
 	SymTab/driver_cfa_cpp-Autogen.$(OBJEXT) \
 	SynTree/driver_cfa_cpp-Type.$(OBJEXT) \
@@ -514,6 +512,5 @@
 	ResolvExpr/CurrentObject.cc ResolvExpr/ExplodedActual.cc \
 	SymTab/Indexer.cc SymTab/Mangler.cc SymTab/Validate.cc \
-	SymTab/FixFunction.cc SymTab/ImplementationType.cc \
-	SymTab/TypeEquality.cc SymTab/Autogen.cc SynTree/Type.cc \
+	SymTab/FixFunction.cc SymTab/Autogen.cc SynTree/Type.cc \
 	SynTree/VoidType.cc SynTree/BasicType.cc \
 	SynTree/PointerType.cc SynTree/ArrayType.cc \
@@ -844,8 +841,4 @@
 SymTab/driver_cfa_cpp-FixFunction.$(OBJEXT): SymTab/$(am__dirstamp) \
 	SymTab/$(DEPDIR)/$(am__dirstamp)
-SymTab/driver_cfa_cpp-ImplementationType.$(OBJEXT):  \
-	SymTab/$(am__dirstamp) SymTab/$(DEPDIR)/$(am__dirstamp)
-SymTab/driver_cfa_cpp-TypeEquality.$(OBJEXT): SymTab/$(am__dirstamp) \
-	SymTab/$(DEPDIR)/$(am__dirstamp)
 SymTab/driver_cfa_cpp-Autogen.$(OBJEXT): SymTab/$(am__dirstamp) \
 	SymTab/$(DEPDIR)/$(am__dirstamp)
@@ -1040,8 +1033,6 @@
 @AMDEP_TRUE@@am__include@ @am__quote@SymTab/$(DEPDIR)/driver_cfa_cpp-Autogen.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SymTab/$(DEPDIR)/driver_cfa_cpp-FixFunction.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@SymTab/$(DEPDIR)/driver_cfa_cpp-ImplementationType.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SymTab/$(DEPDIR)/driver_cfa_cpp-Indexer.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SymTab/$(DEPDIR)/driver_cfa_cpp-Mangler.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@SymTab/$(DEPDIR)/driver_cfa_cpp-TypeEquality.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SymTab/$(DEPDIR)/driver_cfa_cpp-Validate.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-AddressExpr.Po@am__quote@
@@ -2039,32 +2030,4 @@
 @AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SymTab/driver_cfa_cpp-FixFunction.obj `if test -f 'SymTab/FixFunction.cc'; then $(CYGPATH_W) 'SymTab/FixFunction.cc'; else $(CYGPATH_W) '$(srcdir)/SymTab/FixFunction.cc'; fi`
-
-SymTab/driver_cfa_cpp-ImplementationType.o: SymTab/ImplementationType.cc
-@am__fastdepCXX_TRUE@	$(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SymTab/driver_cfa_cpp-ImplementationType.o -MD -MP -MF SymTab/$(DEPDIR)/driver_cfa_cpp-ImplementationType.Tpo -c -o SymTab/driver_cfa_cpp-ImplementationType.o `test -f 'SymTab/ImplementationType.cc' || echo '$(srcdir)/'`SymTab/ImplementationType.cc
-@am__fastdepCXX_TRUE@	$(AM_V_at)$(am__mv) SymTab/$(DEPDIR)/driver_cfa_cpp-ImplementationType.Tpo SymTab/$(DEPDIR)/driver_cfa_cpp-ImplementationType.Po
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@	$(AM_V_CXX)source='SymTab/ImplementationType.cc' object='SymTab/driver_cfa_cpp-ImplementationType.o' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SymTab/driver_cfa_cpp-ImplementationType.o `test -f 'SymTab/ImplementationType.cc' || echo '$(srcdir)/'`SymTab/ImplementationType.cc
-
-SymTab/driver_cfa_cpp-ImplementationType.obj: SymTab/ImplementationType.cc
-@am__fastdepCXX_TRUE@	$(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SymTab/driver_cfa_cpp-ImplementationType.obj -MD -MP -MF SymTab/$(DEPDIR)/driver_cfa_cpp-ImplementationType.Tpo -c -o SymTab/driver_cfa_cpp-ImplementationType.obj `if test -f 'SymTab/ImplementationType.cc'; then $(CYGPATH_W) 'SymTab/ImplementationType.cc'; else $(CYGPATH_W) '$(srcdir)/SymTab/ImplementationType.cc'; fi`
-@am__fastdepCXX_TRUE@	$(AM_V_at)$(am__mv) SymTab/$(DEPDIR)/driver_cfa_cpp-ImplementationType.Tpo SymTab/$(DEPDIR)/driver_cfa_cpp-ImplementationType.Po
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@	$(AM_V_CXX)source='SymTab/ImplementationType.cc' object='SymTab/driver_cfa_cpp-ImplementationType.obj' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SymTab/driver_cfa_cpp-ImplementationType.obj `if test -f 'SymTab/ImplementationType.cc'; then $(CYGPATH_W) 'SymTab/ImplementationType.cc'; else $(CYGPATH_W) '$(srcdir)/SymTab/ImplementationType.cc'; fi`
-
-SymTab/driver_cfa_cpp-TypeEquality.o: SymTab/TypeEquality.cc
-@am__fastdepCXX_TRUE@	$(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SymTab/driver_cfa_cpp-TypeEquality.o -MD -MP -MF SymTab/$(DEPDIR)/driver_cfa_cpp-TypeEquality.Tpo -c -o SymTab/driver_cfa_cpp-TypeEquality.o `test -f 'SymTab/TypeEquality.cc' || echo '$(srcdir)/'`SymTab/TypeEquality.cc
-@am__fastdepCXX_TRUE@	$(AM_V_at)$(am__mv) SymTab/$(DEPDIR)/driver_cfa_cpp-TypeEquality.Tpo SymTab/$(DEPDIR)/driver_cfa_cpp-TypeEquality.Po
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@	$(AM_V_CXX)source='SymTab/TypeEquality.cc' object='SymTab/driver_cfa_cpp-TypeEquality.o' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SymTab/driver_cfa_cpp-TypeEquality.o `test -f 'SymTab/TypeEquality.cc' || echo '$(srcdir)/'`SymTab/TypeEquality.cc
-
-SymTab/driver_cfa_cpp-TypeEquality.obj: SymTab/TypeEquality.cc
-@am__fastdepCXX_TRUE@	$(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SymTab/driver_cfa_cpp-TypeEquality.obj -MD -MP -MF SymTab/$(DEPDIR)/driver_cfa_cpp-TypeEquality.Tpo -c -o SymTab/driver_cfa_cpp-TypeEquality.obj `if test -f 'SymTab/TypeEquality.cc'; then $(CYGPATH_W) 'SymTab/TypeEquality.cc'; else $(CYGPATH_W) '$(srcdir)/SymTab/TypeEquality.cc'; fi`
-@am__fastdepCXX_TRUE@	$(AM_V_at)$(am__mv) SymTab/$(DEPDIR)/driver_cfa_cpp-TypeEquality.Tpo SymTab/$(DEPDIR)/driver_cfa_cpp-TypeEquality.Po
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@	$(AM_V_CXX)source='SymTab/TypeEquality.cc' object='SymTab/driver_cfa_cpp-TypeEquality.obj' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SymTab/driver_cfa_cpp-TypeEquality.obj `if test -f 'SymTab/TypeEquality.cc'; then $(CYGPATH_W) 'SymTab/TypeEquality.cc'; else $(CYGPATH_W) '$(srcdir)/SymTab/TypeEquality.cc'; fi`
 
 SymTab/driver_cfa_cpp-Autogen.o: SymTab/Autogen.cc
Index: src/Parser/StatementNode.cc
===================================================================
--- src/Parser/StatementNode.cc	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ src/Parser/StatementNode.cc	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
@@ -37,5 +37,5 @@
 	DeclarationNode *agg = decl->extractAggregate();
 	if ( agg ) {
-		StatementNode *nextStmt = new StatementNode( new DeclStmt( noLabels, maybeBuild< Declaration >( decl ) ) );
+		StatementNode *nextStmt = new StatementNode( new DeclStmt( maybeBuild< Declaration >( decl ) ) );
 		set_next( nextStmt );
 		if ( decl->get_next() ) {
@@ -50,5 +50,5 @@
 		agg = decl;
 	} // if
-	stmt.reset( new DeclStmt( noLabels, maybeMoveBuild< Declaration >(agg) ) );
+	stmt.reset( new DeclStmt( maybeMoveBuild< Declaration >(agg) ) );
 } // StatementNode::StatementNode
 
@@ -75,7 +75,7 @@
 
 	if ( e )
-		return new ExprStmt( noLabels, e );
+		return new ExprStmt( e );
 	else
-		return new NullStmt( noLabels );
+		return new NullStmt();
 }
 
@@ -113,5 +113,5 @@
 	}
 	delete ctl;
-	return new IfStmt( noLabels, cond, thenb, elseb, init );
+	return new IfStmt( cond, thenb, elseb, init );
 }
 
@@ -120,13 +120,13 @@
 	buildMoveList< Statement, StatementNode >( stmt, branches );
 	// branches.size() == 0 for switch (...) {}, i.e., no declaration or statements
-	return new SwitchStmt( noLabels, maybeMoveBuild< Expression >(ctl), branches );
+	return new SwitchStmt( maybeMoveBuild< Expression >(ctl), branches );
 }
 Statement *build_case( ExpressionNode *ctl ) {
 	std::list< Statement * > branches;
-	return new CaseStmt( noLabels, maybeMoveBuild< Expression >(ctl), branches );
+	return new CaseStmt( maybeMoveBuild< Expression >(ctl), branches );
 }
 Statement *build_default() {
 	std::list< Statement * > branches;
-	return new CaseStmt( noLabels, nullptr, branches, true );
+	return new CaseStmt( nullptr, branches, true );
 }
 
@@ -135,5 +135,5 @@
 	buildMoveList< Statement, StatementNode >( stmt, branches );
 	assert( branches.size() == 1 );
-	return new WhileStmt( noLabels, notZeroExpr( maybeMoveBuild< Expression >(ctl) ), branches.front(), kind );
+	return new WhileStmt( notZeroExpr( maybeMoveBuild< Expression >(ctl) ), branches.front(), kind );
 }
 
@@ -157,18 +157,18 @@
 
 	delete forctl;
-	return new ForStmt( noLabels, init, cond, incr, branches.front() );
+	return new ForStmt( init, cond, incr, branches.front() );
 }
 
 Statement *build_branch( BranchStmt::Type kind ) {
-	Statement * ret = new BranchStmt( noLabels, "", kind );
+	Statement * ret = new BranchStmt( "", kind );
 	return ret;
 }
 Statement *build_branch( std::string *identifier, BranchStmt::Type kind ) {
-	Statement * ret = new BranchStmt( noLabels, *identifier, kind );
+	Statement * ret = new BranchStmt( *identifier, kind );
 	delete identifier; 									// allocated by lexer
 	return ret;
 }
 Statement *build_computedgoto( ExpressionNode *ctl ) {
-	return new BranchStmt( noLabels, maybeMoveBuild< Expression >(ctl), BranchStmt::Goto );
+	return new BranchStmt( maybeMoveBuild< Expression >(ctl), BranchStmt::Goto );
 }
 
@@ -176,5 +176,5 @@
 	std::list< Expression * > exps;
 	buildMoveList( ctl, exps );
-	return new ReturnStmt( noLabels, exps.size() > 0 ? exps.back() : nullptr );
+	return new ReturnStmt( exps.size() > 0 ? exps.back() : nullptr );
 }
 
@@ -183,5 +183,5 @@
 	buildMoveList( ctl, exps );
 	assertf( exps.size() < 2, "This means we are leaking memory");
-	return new ThrowStmt( noLabels, ThrowStmt::Terminate, !exps.empty() ? exps.back() : nullptr );
+	return new ThrowStmt( ThrowStmt::Terminate, !exps.empty() ? exps.back() : nullptr );
 }
 
@@ -190,5 +190,5 @@
 	buildMoveList( ctl, exps );
 	assertf( exps.size() < 2, "This means we are leaking memory");
-	return new ThrowStmt( noLabels, ThrowStmt::Resume, !exps.empty() ? exps.back() : nullptr );
+	return new ThrowStmt( ThrowStmt::Resume, !exps.empty() ? exps.back() : nullptr );
 }
 
@@ -204,5 +204,5 @@
 	CompoundStmt *tryBlock = strict_dynamic_cast< CompoundStmt * >(maybeMoveBuild< Statement >(try_stmt));
 	FinallyStmt *finallyBlock = dynamic_cast< FinallyStmt * >(maybeMoveBuild< Statement >(finally_stmt) );
-	return new TryStmt( noLabels, tryBlock, branches, finallyBlock );
+	return new TryStmt( tryBlock, branches, finallyBlock );
 }
 Statement *build_catch( CatchStmt::Kind kind, DeclarationNode *decl, ExpressionNode *cond, StatementNode *body ) {
@@ -210,5 +210,5 @@
 	buildMoveList< Statement, StatementNode >( body, branches );
 	assert( branches.size() == 1 );
-	return new CatchStmt( noLabels, kind, maybeMoveBuild< Declaration >(decl), maybeMoveBuild< Expression >(cond), branches.front() );
+	return new CatchStmt( kind, maybeMoveBuild< Declaration >(decl), maybeMoveBuild< Expression >(cond), branches.front() );
 }
 Statement *build_finally( StatementNode *stmt ) {
@@ -216,5 +216,5 @@
 	buildMoveList< Statement, StatementNode >( stmt, branches );
 	assert( branches.size() == 1 );
-	return new FinallyStmt( noLabels, dynamic_cast< CompoundStmt * >( branches.front() ) );
+	return new FinallyStmt( dynamic_cast< CompoundStmt * >( branches.front() ) );
 }
 
@@ -296,5 +296,5 @@
 
 Statement *build_compound( StatementNode *first ) {
-	CompoundStmt *cs = new CompoundStmt( noLabels );
+	CompoundStmt *cs = new CompoundStmt();
 	buildMoveList( first, cs->get_kids() );
 	return cs;
@@ -308,5 +308,5 @@
 	buildMoveList( input, in );
 	buildMoveList( clobber, clob );
-	return new AsmStmt( noLabels, voltile, instruction, out, in, clob, gotolabels ? gotolabels->labels : noLabels );
+	return new AsmStmt( voltile, instruction, out, in, clob, gotolabels ? gotolabels->labels : noLabels );
 }
 
Index: src/ResolvExpr/Resolver.cc
===================================================================
--- src/ResolvExpr/Resolver.cc	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ src/ResolvExpr/Resolver.cc	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
@@ -370,5 +370,5 @@
 		if ( throwStmt->get_expr() ) {
 			StructDecl * exception_decl =
-				indexer.lookupStruct( "__cfaehm__base_exception_t" );
+				indexer.lookupStruct( "__cfaabi_ehm__base_exception_t" );
 			assert( exception_decl );
 			Type * exceptType = new PointerType( noQualifiers, new StructInstType( noQualifiers, exception_decl ) );
Index: src/SymTab/AddVisit.h
===================================================================
--- src/SymTab/AddVisit.h	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ src/SymTab/AddVisit.h	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
@@ -24,5 +24,5 @@
 			// add any new declarations after the previous statement
 			for ( std::list< Declaration* >::iterator decl = visitor.declsToAddAfter.begin(); decl != visitor.declsToAddAfter.end(); ++decl ) {
-				DeclStmt *declStmt = new DeclStmt( noLabels, *decl );
+				DeclStmt *declStmt = new DeclStmt( *decl );
 				stmts.insert( stmt, declStmt );
 			}
@@ -36,5 +36,5 @@
 			// add any new declarations before the statement
 			for ( std::list< Declaration* >::iterator decl = visitor.declsToAdd.begin(); decl != visitor.declsToAdd.end(); ++decl ) {
-				DeclStmt *declStmt = new DeclStmt( noLabels, *decl );
+				DeclStmt *declStmt = new DeclStmt( *decl );
 				stmts.insert( stmt, declStmt );
 			}
Index: src/SymTab/Autogen.cc
===================================================================
--- src/SymTab/Autogen.cc	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ src/SymTab/Autogen.cc	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
@@ -264,5 +264,5 @@
 		Type::StorageClasses scs = functionNesting > 0 ? Type::StorageClasses() : Type::StorageClasses( Type::Static );
 		LinkageSpec::Spec spec = isIntrinsic ? LinkageSpec::Intrinsic : LinkageSpec::AutoGen;
-		FunctionDecl * decl = new FunctionDecl( fname, scs, spec, ftype, new CompoundStmt( noLabels ),
+		FunctionDecl * decl = new FunctionDecl( fname, scs, spec, ftype, new CompoundStmt(),
 												std::list< Attribute * >(), Type::FuncSpecifiers( Type::Inline ) );
 		decl->fixUniqueId();
@@ -299,5 +299,5 @@
 				assert( assignType->returnVals.size() == 1 );
 				ObjectDecl * dstParam = strict_dynamic_cast< ObjectDecl * >( assignType->parameters.front() );
-				dcl->statements->push_back( new ReturnStmt( noLabels, new VariableExpr( dstParam ) ) );
+				dcl->statements->push_back( new ReturnStmt( new VariableExpr( dstParam ) ) );
 			}
 			resolve( dcl );
@@ -468,5 +468,5 @@
 		copy->args.push_back( new AddressExpr( new VariableExpr( srcParam ) ) );
 		copy->args.push_back( new SizeofExpr( srcParam->get_type()->clone() ) );
-		*out++ = new ExprStmt( noLabels, copy );
+		*out++ = new ExprStmt( copy );
 	}
 
@@ -544,5 +544,5 @@
 			callExpr->get_args().push_back( new VariableExpr( dstParam ) );
 			callExpr->get_args().push_back( new VariableExpr( srcParam ) );
-			funcDecl->statements->push_back( new ExprStmt( noLabels, callExpr ) );
+			funcDecl->statements->push_back( new ExprStmt( callExpr ) );
 		} else {
 			// default ctor/dtor body is empty - add unused attribute to parameter to silence warnings
@@ -569,5 +569,5 @@
 		expr->args.push_back( new CastExpr( new VariableExpr( dst ), new ReferenceType( Type::Qualifiers(), typeDecl->base->clone() ) ) );
 		if ( src ) expr->args.push_back( new CastExpr( new VariableExpr( src ), typeDecl->base->clone() ) );
-		dcl->statements->kids.push_back( new ExprStmt( noLabels, expr ) );
+		dcl->statements->kids.push_back( new ExprStmt( expr ) );
 	};
 
@@ -664,6 +664,6 @@
 			untyped->get_args().push_back( new VariableExpr( ftype->get_parameters().back() ) );
 		}
-		function->get_statements()->get_kids().push_back( new ExprStmt( noLabels, untyped ) );
-		function->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, UntypedExpr::createDeref( new VariableExpr( ftype->get_parameters().front() ) ) ) );
+		function->get_statements()->get_kids().push_back( new ExprStmt( untyped ) );
+		function->get_statements()->get_kids().push_back( new ReturnStmt( UntypedExpr::createDeref( new VariableExpr( ftype->get_parameters().front() ) ) ) );
 	}
 
Index: src/SymTab/Autogen.h
===================================================================
--- src/SymTab/Autogen.h	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ src/SymTab/Autogen.h	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
@@ -104,5 +104,5 @@
 		fExpr->args.splice( fExpr->args.end(), args );
 
-		*out++ = new ExprStmt( noLabels, fExpr );
+		*out++ = new ExprStmt( fExpr );
 
 		srcParam.clearArrayIndices();
@@ -162,13 +162,13 @@
 
 		// for stmt's body, eventually containing call
-		CompoundStmt * body = new CompoundStmt( noLabels );
+		CompoundStmt * body = new CompoundStmt();
 		Statement * listInit = genCall( srcParam, dstParam, fname, back_inserter( body->kids ), array->base, addCast, forward );
 
 		// block containing for stmt and index variable
 		std::list<Statement *> initList;
-		CompoundStmt * block = new CompoundStmt( noLabels );
-		block->push_back( new DeclStmt( noLabels, index ) );
+		CompoundStmt * block = new CompoundStmt();
+		block->push_back( new DeclStmt( index ) );
 		if ( listInit ) block->get_kids().push_back( listInit );
-		block->push_back( new ForStmt( noLabels, initList, cond, inc, body ) );
+		block->push_back( new ForStmt( initList, cond, inc, body ) );
 
 		*out++ = block;
Index: src/SymTab/ImplementationType.cc
===================================================================
--- src/SymTab/ImplementationType.cc	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ 	(revision )
@@ -1,114 +1,0 @@
-//
-// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
-//
-// The contents of this file are covered under the licence agreement in the
-// file "LICENCE" distributed with Cforall.
-//
-// ImplementationType.cc --
-//
-// Author           : Richard C. Bilson
-// Created On       : Sun May 17 21:32:01 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Mar 16 15:54:08 2017
-// Update Count     : 4
-//
-
-#include "ImplementationType.h"
-
-#include <list>                   // for list, _List_iterator, list<>::iterator
-
-#include "SymTab/Indexer.h"       // for Indexer
-#include "SynTree/Declaration.h"  // for NamedTypeDecl
-#include "SynTree/Type.h"         // for TupleType, Type, ArrayType, Pointer...
-#include "SynTree/Visitor.h"      // for Visitor
-
-
-namespace SymTab {
-	class ImplementationType : public Visitor {
-	  public:
-		ImplementationType( const SymTab::Indexer &indexer );
-
-		Type *get_result() { return result; }
-	  private:
-		virtual void visit(VoidType *voidType);
-		virtual void visit(BasicType *basicType);
-		virtual void visit(PointerType *pointerType);
-		virtual void visit(ArrayType *arrayType);
-		virtual void visit(FunctionType *functionType);
-		virtual void visit(StructInstType *aggregateUseType);
-		virtual void visit(UnionInstType *aggregateUseType);
-		virtual void visit(EnumInstType *aggregateUseType);
-		virtual void visit(TraitInstType *aggregateUseType);
-		virtual void visit(TypeInstType *aggregateUseType);
-		virtual void visit(TupleType *tupleType);
-		virtual void visit(VarArgsType *varArgsType);
-		virtual void visit(ZeroType *zeroType);
-		virtual void visit(OneType *oneType);
-
-		Type *result;			// synthesized
-		const SymTab::Indexer &indexer;
-	};
-
-	Type * implementationType( Type *type, const SymTab::Indexer& indexer ) {
-		ImplementationType implementor( indexer );
-		type->accept( implementor );
-		if ( implementor.get_result() == 0 ) {
-			return type->clone();
-		} else {
-			return implementor.get_result();
-		} // if
-	}
-
-	ImplementationType::ImplementationType( const SymTab::Indexer &indexer ) : result( 0 ), indexer( indexer ) {
-	}
-
-	void ImplementationType::visit( __attribute__((unused)) VoidType *voidType ) {}
-	void ImplementationType::visit( __attribute__((unused)) BasicType *basicType ) {}
-
-	void ImplementationType::visit(PointerType *pointerType) {
-		PointerType *newType = pointerType->clone();
-		newType->set_base( implementationType( pointerType->get_base(), indexer ) );
-		result = newType;
-	}
-
-	void ImplementationType::visit(ArrayType *arrayType) {
-		ArrayType *newType = arrayType->clone();
-		newType->set_base( implementationType( arrayType->get_base(), indexer ) );
-		result = newType;
-	}
-
-	void ImplementationType::visit( __attribute__((unused)) FunctionType *functionType ) {}
-	void ImplementationType::visit( __attribute__((unused)) StructInstType * aggregateUseType ) {}
-	void ImplementationType::visit( __attribute__((unused)) UnionInstType * aggregateUseType ) {}
-	void ImplementationType::visit( __attribute__((unused)) EnumInstType * aggregateUseType ) {}
-	void ImplementationType::visit( __attribute__((unused)) TraitInstType * aggregateUseType ) {}
-
-	void ImplementationType::visit(TypeInstType *inst) {
-		NamedTypeDecl *typeDecl = indexer.lookupType( inst->get_name() );
-		if ( typeDecl && typeDecl->get_base() ) {
-			Type *base = implementationType( typeDecl->get_base(), indexer );
-			base->get_qualifiers() |= inst->get_qualifiers();
-			result = base;
-		} // if
-	}
-
-	void ImplementationType::visit(TupleType *tupleType) {
-		std::list< Type * > types;
-		for ( std::list< Type* >::iterator i = tupleType->get_types().begin(); i != tupleType->get_types().end(); ++i ) {
-			Type *implType = implementationType( *i, indexer );
-			implType->get_qualifiers() |= tupleType->get_qualifiers();
-			types.push_back( implType );
-		} // for
-		result = new TupleType( Type::Qualifiers(), types );
-	}
-
-	void ImplementationType::visit( __attribute__((unused)) VarArgsType *varArgsType ) {}
-	void ImplementationType::visit( __attribute__((unused)) ZeroType *zeroType ) {}
-	void ImplementationType::visit( __attribute__((unused)) OneType *oneType ) {}
-} // namespace SymTab
-
-// Local Variables: //
-// tab-width: 4 //
-// mode: c++ //
-// compile-command: "make install" //
-// End: //
Index: src/SymTab/ImplementationType.h
===================================================================
--- src/SymTab/ImplementationType.h	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ 	(revision )
@@ -1,37 +1,0 @@
-//
-// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
-//
-// The contents of this file are covered under the licence agreement in the
-// file "LICENCE" distributed with Cforall.
-//
-// ImplementationType.h -- 
-//
-// Author           : Richard C. Bilson
-// Created On       : Sun May 17 21:35:41 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jul 22 09:46:19 2017
-// Update Count     : 3
-//
-
-#pragma once
-
-class Type;
-
-namespace SymTab {
-class Indexer;
-
-	Type *implementationType( Type *, const SymTab::Indexer &indexer );
-
-	template< typename InputIterator, typename OutputIterator >
-	void implementationTypeList( InputIterator begin, InputIterator end, OutputIterator out, const SymTab::Indexer &indexer ) {
-		while ( begin != end ) {
-			*out++ = implementationType( *begin++, indexer );
-		} // while
-	}
-} // namespace SymTab
-
-// Local Variables: //
-// tab-width: 4 //
-// mode: c++ //
-// compile-command: "make install" //
-// End: //
Index: src/SymTab/TypeEquality.cc
===================================================================
--- src/SymTab/TypeEquality.cc	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ 	(revision )
@@ -1,218 +1,0 @@
-//
-// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
-//
-// The contents of this file are covered under the licence agreement in the
-// file "LICENCE" distributed with Cforall.
-//
-// TypeEquality.cc --
-//
-// Author           : Rob Schluntz
-// Created On       : Tue Jul 07 16:28:29 2015
-// Last Modified By : Rob Schluntz
-// Last Modified On : Mon Jul 20 14:16:11 2015
-// Update Count     : 37
-//
-#include "TypeEquality.h"
-
-#include <cassert>                // for assert
-#include <list>                   // for list, list<>::iterator, _List_iterator
-#include <string>                 // for operator==, string, basic_string
-
-#include "SynTree/Constant.h"     // for Constant
-#include "SynTree/Declaration.h"  // for DeclarationWithType
-#include "SynTree/Expression.h"   // for ConstantExpr, Expression
-#include "SynTree/Type.h"         // for Type, ArrayType, FunctionType, Enum...
-#include "SynTree/Visitor.h"      // for Visitor
-
-namespace SymTab {
-	class TypeEquality : public Visitor {
-  public:
-		TypeEquality( Type * other, bool vlaErr ) : result( true ), other( other ),
-			vlaErr( vlaErr ) {}
-		bool result;
-
-  private:
-		virtual void visit( FunctionType *funcType );
-		virtual void visit( VoidType *voidType );
-		virtual void visit( BasicType *basicType );
-		virtual void visit( PointerType *pointerType );
-		virtual void visit( ArrayType *arrayType );
-		virtual void visit( StructInstType *structInst );
-		virtual void visit( UnionInstType *unionInst );
-		virtual void visit( EnumInstType *enumInst );
-		virtual void visit( TypeInstType *typeInst );
-		virtual void visit( VarArgsType *varArgsType );
-		virtual void visit( ZeroType *zeroType );
-		virtual void visit( OneType *oneType );
-
-		void handleQualifiers( Type * t );
-
-		Type * other;
-		bool vlaErr;
-	};
-
-	bool typeEquals( Type * t1, Type * t2, bool vlaErr ) {
-		TypeEquality teq( t2, vlaErr );
-		t1->accept( teq );
-		return teq.result;
-	}
-
-	void TypeEquality::handleQualifiers( Type * t ) {
-		result = result && t->get_qualifiers() == other->get_qualifiers();
-	}
-
-	void TypeEquality::visit( VoidType *voidType ) {
-		handleQualifiers( voidType );
-		if ( ! dynamic_cast< VoidType * >( other ) ) {
-			result = false;
-		}
-	}
-
-	void TypeEquality::visit( BasicType *basicType ) {
-		handleQualifiers( basicType );
-		if ( BasicType * bt = dynamic_cast< BasicType * >( other ) ) {
-			result = result && basicType->get_kind() == bt->get_kind();
-		} else {
-			result = false;
-		}
-	}
-
-	void TypeEquality::visit( PointerType *pointerType ) {
-		handleQualifiers( pointerType );
-		if ( PointerType * pt = dynamic_cast< PointerType * >( other ) ) {
-			other = pt->get_base();
-			pointerType->get_base()->accept( *this );
-		} else {
-			result = false;
-		}
-	}
-
-	void TypeEquality::visit( ArrayType *arrayType ) {
-		handleQualifiers( arrayType );
-
-		if ( ArrayType * at = dynamic_cast< ArrayType * >( other ) ) {
-			// to be equal, array types must both be VLA or both not VLA
-			// and must both have a dimension expression or not have a dimension
-			result = result	&& arrayType->get_isVarLen() == at->get_isVarLen()
-				&& ((arrayType->get_dimension() != 0 && at->get_dimension() != 0)
-					|| (arrayType->get_dimension() == 0 && at->get_dimension() == 0));
-
-			if ( vlaErr ) {
-				// useful for comparing typedef types - in this case, we
-				// want types to appear distinct if either is a VLA type
-				if ( arrayType->get_isVarLen() || at->get_isVarLen() ) {
-					result = false;
-				}
-			}
-
-			if ( ! arrayType->get_isVarLen() && ! at->get_isVarLen() &&
-				arrayType->get_dimension() != 0 && at->get_dimension() != 0 ) {
-				ConstantExpr * ce1 = dynamic_cast< ConstantExpr * >( arrayType->get_dimension() );
-				ConstantExpr * ce2 = dynamic_cast< ConstantExpr * >( at->get_dimension() );
-				assert(ce1 && ce2);
-
-				Constant * c1 = ce1->get_constant();
-				Constant * c2 = ce2->get_constant();
-
-				result = result && c1->get_value() == c2->get_value();
-			}
-
-			other = at->get_base();
-			arrayType->get_base()->accept( *this );
-		} else {
-			result = false;
-		}
-	}
-
-	void TypeEquality::visit( FunctionType *funcType ) {
-		handleQualifiers( funcType );
-
-		if ( FunctionType * ft = dynamic_cast< FunctionType * >( other ) ) {
-			// function types must have the same number of return types
-			// and parameters to be equivalent
-			result = result && funcType->get_returnVals().size() == ft->get_returnVals().size()
-				&& funcType->get_parameters().size() == ft->get_parameters().size()
-				&& funcType->get_isVarArgs() == ft->get_isVarArgs();
-
-			std::list< DeclarationWithType * >::iterator it1, it2;
-
-			// return types must be equivalent
-			it1 = funcType->get_returnVals().begin();
-			it2 = ft->get_returnVals().begin();
-			for ( ; it1 != funcType->get_returnVals().end(); ++it1, ++it2 ) {
-				if ( ! result ) return;
-				other = (*it2)->get_type();
-				(*it1)->get_type()->accept( *this );
-			}
-
-			// parameter types must be equivalent
-			it1 = funcType->get_parameters().begin();
-			it2 = ft->get_parameters().begin();
-			for ( ; it1 != funcType->get_parameters().end(); ++it1, ++it2 ) {
-				if ( ! result ) return;
-				other = (*it2)->get_type();
-				(*it1)->get_type()->accept( *this );
-			}
-		} else {
-			result = false;
-		}
-	}
-
-	// aggregate types only need to have the same name
-	void TypeEquality::visit( StructInstType *structInst )  {
-		handleQualifiers( structInst );
-		if ( StructInstType * st = dynamic_cast< StructInstType * >( other ) ) {
-			result = result && structInst->get_name() == st->get_name();
-		} else {
-			result = false;
-		}
-	}
-
-	void TypeEquality::visit( UnionInstType *unionInst ) {
-		handleQualifiers( unionInst );
-		if ( UnionInstType * ut = dynamic_cast< UnionInstType * >( other ) ) {
-			result = result && unionInst->get_name() == ut->get_name();
-		} else {
-			result = false;
-		}
-	}
-
-	void TypeEquality::visit( EnumInstType *enumInst ) {
-		handleQualifiers( enumInst );
-		if ( EnumInstType * et = dynamic_cast< EnumInstType * >( other ) ) {
-			result = result && enumInst->get_name() == et->get_name();
-		} else {
-			result = false;
-		}
-	}
-
-	void TypeEquality::visit( TypeInstType *typeInst ) {
-		handleQualifiers( typeInst );
-		if ( TypeInstType * tt = dynamic_cast< TypeInstType * >( other ) ) {
-			result = result && typeInst->get_name() == tt->get_name();
-		} else {
-			result = false;
-		}
-	}
-
-	void TypeEquality::visit( VarArgsType *varArgsType ) {
-		handleQualifiers( varArgsType );
-		if ( ! dynamic_cast< VarArgsType * >( other ) ) {
-			result = false;
-		}
-	}
-
-	void TypeEquality::visit( ZeroType *zeroType ) {
-		handleQualifiers( zeroType );
-		if ( ! dynamic_cast< ZeroType * >( other ) ) {
-			result = false;
-		}
-	}
-
-	void TypeEquality::visit( OneType *oneType ) {
-		handleQualifiers( oneType );
-		if ( ! dynamic_cast< OneType * >( other ) ) {
-			result = false;
-		}
-	}
-} // namespace SymTab
Index: src/SymTab/TypeEquality.h
===================================================================
--- src/SymTab/TypeEquality.h	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ 	(revision )
@@ -1,23 +1,0 @@
-//
-// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
-//
-// The contents of this file are covered under the licence agreement in the
-// file "LICENCE" distributed with Cforall.
-//
-// TypeEquality.h --
-//
-// Author           : Rob Schluntz
-// Created On       : Tue Jul 07 16:30:07 2015
-// Last Modified By : Rob Schluntz
-// Last Modified On : Wed Jul 08 12:41:15 2015
-// Update Count     : 6
-//
-
-class Type;
-
-namespace SymTab {
-  // compare types t1 and t2 for equality
-  // if vlaErr is true, then if at least one of the types is a
-  // variable-length array type, then the result will be false
-  bool typeEquals( Type * t1, Type * t2, bool vlaErr = false );
-} // namespace SymTab
Index: src/SymTab/Validate.cc
===================================================================
--- src/SymTab/Validate.cc	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ src/SymTab/Validate.cc	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
@@ -81,30 +81,18 @@
 
 namespace SymTab {
-	class HoistStruct final : public Visitor {
-		template< typename Visitor >
-		friend void acceptAndAdd( std::list< Declaration * > &translationUnit, Visitor &visitor );
-	    template< typename Visitor >
-	    friend void addVisitStatementList( std::list< Statement* > &stmts, Visitor &visitor );
-	  public:
+	struct HoistStruct final : public WithDeclsToAdd, public WithGuards {
 		/// Flattens nested struct types
 		static void hoistStruct( std::list< Declaration * > &translationUnit );
 
-		std::list< Declaration * > &get_declsToAdd() { return declsToAdd; }
-
-		virtual void visit( EnumInstType *enumInstType );
-		virtual void visit( StructInstType *structInstType );
-		virtual void visit( UnionInstType *unionInstType );
-		virtual void visit( StructDecl *aggregateDecl );
-		virtual void visit( UnionDecl *aggregateDecl );
-
-		virtual void visit( CompoundStmt *compoundStmt );
-		virtual void visit( SwitchStmt *switchStmt );
+		void previsit( EnumInstType * enumInstType );
+		void previsit( StructInstType * structInstType );
+		void previsit( UnionInstType * unionInstType );
+		void previsit( StructDecl * aggregateDecl );
+		void previsit( UnionDecl * aggregateDecl );
+
 	  private:
-		HoistStruct();
-
 		template< typename AggDecl > void handleAggregate( AggDecl *aggregateDecl );
 
-		std::list< Declaration * > declsToAdd, declsToAddAfter;
-		bool inStruct;
+		bool inStruct = false;
 	};
 
@@ -305,9 +293,6 @@
 
 	void HoistStruct::hoistStruct( std::list< Declaration * > &translationUnit ) {
-		HoistStruct hoister;
-		acceptAndAdd( translationUnit, hoister );
-	}
-
-	HoistStruct::HoistStruct() : inStruct( false ) {
+		PassVisitor<HoistStruct> hoister;
+		acceptAll( translationUnit, hoister );
 	}
 
@@ -320,47 +305,37 @@
 		if ( inStruct ) {
 			// Add elements in stack order corresponding to nesting structure.
-			declsToAdd.push_front( aggregateDecl );
-			Visitor::visit( aggregateDecl );
+			declsToAddBefore.push_front( aggregateDecl );
 		} else {
+			GuardValue( inStruct );
 			inStruct = true;
-			Visitor::visit( aggregateDecl );
-			inStruct = false;
 		} // if
 		// Always remove the hoisted aggregate from the inner structure.
-		filter( aggregateDecl->get_members(), isStructOrUnion, false );
-	}
-
-	void HoistStruct::visit( EnumInstType *structInstType ) {
-		if ( structInstType->get_baseEnum() ) {
-			declsToAdd.push_front( structInstType->get_baseEnum() );
-		}
-	}
-
-	void HoistStruct::visit( StructInstType *structInstType ) {
-		if ( structInstType->get_baseStruct() ) {
-			declsToAdd.push_front( structInstType->get_baseStruct() );
-		}
-	}
-
-	void HoistStruct::visit( UnionInstType *structInstType ) {
-		if ( structInstType->get_baseUnion() ) {
-			declsToAdd.push_front( structInstType->get_baseUnion() );
-		}
-	}
-
-	void HoistStruct::visit( StructDecl *aggregateDecl ) {
+		GuardAction( [this, aggregateDecl]() { filter( aggregateDecl->members, isStructOrUnion, false ); } );
+	}
+
+	void HoistStruct::previsit( EnumInstType * inst ) {
+		if ( inst->baseEnum ) {
+			declsToAddBefore.push_front( inst->baseEnum );
+		}
+	}
+
+	void HoistStruct::previsit( StructInstType * inst ) {
+		if ( inst->baseStruct ) {
+			declsToAddBefore.push_front( inst->baseStruct );
+		}
+	}
+
+	void HoistStruct::previsit( UnionInstType * inst ) {
+		if ( inst->baseUnion ) {
+			declsToAddBefore.push_front( inst->baseUnion );
+		}
+	}
+
+	void HoistStruct::previsit( StructDecl * aggregateDecl ) {
 		handleAggregate( aggregateDecl );
 	}
 
-	void HoistStruct::visit( UnionDecl *aggregateDecl ) {
+	void HoistStruct::previsit( UnionDecl * aggregateDecl ) {
 		handleAggregate( aggregateDecl );
-	}
-
-	void HoistStruct::visit( CompoundStmt *compoundStmt ) {
-		addVisit( compoundStmt, *this );
-	}
-
-	void HoistStruct::visit( SwitchStmt *switchStmt ) {
-		addVisit( switchStmt, *this );
 	}
 
Index: src/SymTab/module.mk
===================================================================
--- src/SymTab/module.mk	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ src/SymTab/module.mk	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
@@ -19,5 +19,3 @@
        SymTab/Validate.cc \
        SymTab/FixFunction.cc \
-       SymTab/ImplementationType.cc \
-       SymTab/TypeEquality.cc \
        SymTab/Autogen.cc
Index: src/SynTree/CompoundStmt.cc
===================================================================
--- src/SynTree/CompoundStmt.cc	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ src/SynTree/CompoundStmt.cc	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
@@ -28,8 +28,8 @@
 using std::endl;
 
-CompoundStmt::CompoundStmt( std::list<Label> labels ) : Statement( labels ) {
+CompoundStmt::CompoundStmt() : Statement() {
 }
 
-CompoundStmt::CompoundStmt( std::list<Statement *> stmts ) : Statement( noLabels ), kids( stmts ) {
+CompoundStmt::CompoundStmt( std::list<Statement *> stmts ) : Statement(), kids( stmts ) {
 }
 
Index: src/SynTree/DeclStmt.cc
===================================================================
--- src/SynTree/DeclStmt.cc	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ src/SynTree/DeclStmt.cc	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
@@ -23,5 +23,5 @@
 #include "SynTree/Label.h"   // for Label
 
-DeclStmt::DeclStmt( std::list<Label> labels, Declaration *decl ) : Statement( labels ), decl( decl ) {
+DeclStmt::DeclStmt( Declaration *decl ) : Statement(), decl( decl ) {
 }
 
Index: src/SynTree/Statement.cc
===================================================================
--- src/SynTree/Statement.cc	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ src/SynTree/Statement.cc	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
@@ -32,5 +32,5 @@
 using std::endl;
 
-Statement::Statement( std::list<Label> labels ) : labels( labels ) {}
+Statement::Statement( const std::list<Label> & labels ) : labels( labels ) {}
 
 void Statement::print( std::ostream & os, Indenter ) const {
@@ -46,5 +46,5 @@
 Statement::~Statement() {}
 
-ExprStmt::ExprStmt( std::list<Label> labels, Expression *expr ) : Statement( labels ), expr( expr ) {}
+ExprStmt::ExprStmt( Expression *expr ) : Statement(), expr( expr ) {}
 
 ExprStmt::ExprStmt( const ExprStmt &other ) : Statement( other ), expr( maybeClone( other.expr ) ) {}
@@ -60,5 +60,5 @@
 
 
-AsmStmt::AsmStmt( std::list<Label> labels, bool voltile, Expression *instruction, std::list<Expression *> output, std::list<Expression *> input, std::list<ConstantExpr *> clobber, std::list<Label> gotolabels ) : Statement( labels ), voltile( voltile ), instruction( instruction ), output( output ), input( input ), clobber( clobber ), gotolabels( gotolabels ) {}
+AsmStmt::AsmStmt( bool voltile, Expression *instruction, std::list<Expression *> output, std::list<Expression *> input, std::list<ConstantExpr *> clobber, std::list<Label> gotolabels ) : Statement(), voltile( voltile ), instruction( instruction ), output( output ), input( input ), clobber( clobber ), gotolabels( gotolabels ) {}
 
 AsmStmt::AsmStmt( const AsmStmt & other ) : Statement( other ), voltile( other.voltile ), instruction( maybeClone( other.instruction ) ), gotolabels( other.gotolabels ) {
@@ -96,6 +96,6 @@
 const char *BranchStmt::brType[] = { "Goto", "Break", "Continue" };
 
-BranchStmt::BranchStmt( std::list<Label> labels, Label target, Type type ) throw ( SemanticError ) :
-	Statement( labels ), originalTarget( target ), target( target ), computedTarget( nullptr ), type( type ) {
+BranchStmt::BranchStmt( Label target, Type type ) throw ( SemanticError ) :
+	Statement(), originalTarget( target ), target( target ), computedTarget( nullptr ), type( type ) {
 	//actually this is a syntactic error signaled by the parser
 	if ( type == BranchStmt::Goto && target.empty() ) {
@@ -104,6 +104,6 @@
 }
 
-BranchStmt::BranchStmt( std::list<Label> labels, Expression *computedTarget, Type type ) throw ( SemanticError ) :
-	Statement( labels ), computedTarget( computedTarget ), type( type ) {
+BranchStmt::BranchStmt( Expression *computedTarget, Type type ) throw ( SemanticError ) :
+	Statement(), computedTarget( computedTarget ), type( type ) {
 	if ( type != BranchStmt::Goto || computedTarget == nullptr ) {
 		throw SemanticError("Computed target not valid in branch statement");
@@ -118,5 +118,5 @@
 }
 
-ReturnStmt::ReturnStmt( std::list<Label> labels, Expression *expr ) : Statement( labels ), expr( expr ) {}
+ReturnStmt::ReturnStmt( Expression *expr ) : Statement(), expr( expr ) {}
 
 ReturnStmt::ReturnStmt( const ReturnStmt & other ) : Statement( other ), expr( maybeClone( other.expr ) ) {}
@@ -135,6 +135,6 @@
 }
 
-IfStmt::IfStmt( std::list<Label> labels, Expression *condition, Statement *thenPart, Statement *elsePart, std::list<Statement *> initialization ):
-	Statement( labels ), condition( condition ), thenPart( thenPart ), elsePart( elsePart ), initialization( initialization ) {}
+IfStmt::IfStmt( Expression *condition, Statement *thenPart, Statement *elsePart, std::list<Statement *> initialization ):
+	Statement(), condition( condition ), thenPart( thenPart ), elsePart( elsePart ), initialization( initialization ) {}
 
 IfStmt::IfStmt( const IfStmt & other ) :
@@ -176,6 +176,6 @@
 }
 
-SwitchStmt::SwitchStmt( std::list<Label> labels, Expression * condition, const std::list<Statement *> &statements ):
-	Statement( labels ), condition( condition ), statements( statements ) {
+SwitchStmt::SwitchStmt( Expression * condition, const std::list<Statement *> &statements ):
+	Statement(), condition( condition ), statements( statements ) {
 }
 
@@ -201,6 +201,6 @@
 }
 
-CaseStmt::CaseStmt( std::list<Label> labels, Expression *condition, const std::list<Statement *> &statements, bool deflt ) throw ( SemanticError ) :
-	Statement( labels ), condition( condition ), stmts( statements ), _isDefault( deflt ) {
+CaseStmt::CaseStmt( Expression *condition, const std::list<Statement *> &statements, bool deflt ) throw ( SemanticError ) :
+	Statement(), condition( condition ), stmts( statements ), _isDefault( deflt ) {
 	if ( isDefault() && condition != 0 ) throw SemanticError("default case with condition: ", condition);
 }
@@ -216,6 +216,8 @@
 }
 
-CaseStmt * CaseStmt::makeDefault( std::list<Label> labels, std::list<Statement *> stmts ) {
-	return new CaseStmt( labels, 0, stmts, true );
+CaseStmt * CaseStmt::makeDefault( const std::list<Label> & labels, std::list<Statement *> stmts ) {
+	CaseStmt * stmt = new CaseStmt( nullptr, stmts, true );
+	stmt->labels = labels;
+	return stmt;
 }
 
@@ -233,6 +235,6 @@
 }
 
-WhileStmt::WhileStmt( std::list<Label> labels, Expression *condition, Statement *body, bool isDoWhile ):
-	Statement( labels ), condition( condition), body( body), isDoWhile( isDoWhile) {
+WhileStmt::WhileStmt( Expression *condition, Statement *body, bool isDoWhile ):
+	Statement(), condition( condition), body( body), isDoWhile( isDoWhile) {
 }
 
@@ -255,6 +257,6 @@
 }
 
-ForStmt::ForStmt( std::list<Label> labels, std::list<Statement *> initialization, Expression *condition, Expression *increment, Statement *body ):
-	Statement( labels ), initialization( initialization ), condition( condition ), increment( increment ), body( body ) {
+ForStmt::ForStmt( std::list<Statement *> initialization, Expression *condition, Expression *increment, Statement *body ):
+	Statement(), initialization( initialization ), condition( condition ), increment( increment ), body( body ) {
 }
 
@@ -302,6 +304,6 @@
 }
 
-ThrowStmt::ThrowStmt( std::list<Label> labels, Kind kind, Expression * expr, Expression * target ) :
-		Statement( labels ), kind(kind), expr(expr), target(target)	{
+ThrowStmt::ThrowStmt( Kind kind, Expression * expr, Expression * target ) :
+		Statement(), kind(kind), expr(expr), target(target)	{
 	assertf(Resume == kind || nullptr == target, "Non-local termination throw is not accepted." );
 }
@@ -326,6 +328,6 @@
 }
 
-TryStmt::TryStmt( std::list<Label> labels, CompoundStmt *tryBlock, std::list<CatchStmt *> &handlers, FinallyStmt *finallyBlock ) :
-	Statement( labels ), block( tryBlock ),  handlers( handlers ), finallyBlock( finallyBlock ) {
+TryStmt::TryStmt( CompoundStmt *tryBlock, std::list<CatchStmt *> &handlers, FinallyStmt *finallyBlock ) :
+	Statement(), block( tryBlock ),  handlers( handlers ), finallyBlock( finallyBlock ) {
 }
 
@@ -359,6 +361,6 @@
 }
 
-CatchStmt::CatchStmt( std::list<Label> labels, Kind kind, Declaration *decl, Expression *cond, Statement *body ) :
-	Statement( labels ), kind ( kind ), decl ( decl ), cond ( cond ), body( body ) {
+CatchStmt::CatchStmt( Kind kind, Declaration *decl, Expression *cond, Statement *body ) :
+	Statement(), kind ( kind ), decl ( decl ), cond ( cond ), body( body ) {
 		assertf( decl, "Catch clause must have a declaration." );
 }
@@ -391,6 +393,5 @@
 
 
-FinallyStmt::FinallyStmt( std::list<Label> labels, CompoundStmt *block ) : Statement( labels ), block( block ) {
-	assert( labels.empty() ); // finally statement cannot be labeled
+FinallyStmt::FinallyStmt( CompoundStmt *block ) : Statement(), block( block ) {
 }
 
@@ -408,5 +409,5 @@
 }
 
-WaitForStmt::WaitForStmt( std::list<Label> labels ) : Statement( labels ) {
+WaitForStmt::WaitForStmt() : Statement() {
 	timeout.time      = nullptr;
 	timeout.statement = nullptr;
@@ -456,5 +457,5 @@
 
 
-WithStmt::WithStmt( const std::list< Expression * > & exprs, Statement * stmt ) : Statement( std::list<Label>() ), exprs( exprs ), stmt( stmt ) {}
+WithStmt::WithStmt( const std::list< Expression * > & exprs, Statement * stmt ) : Statement(), exprs( exprs ), stmt( stmt ) {}
 WithStmt::WithStmt( const WithStmt & other ) : Statement( other ), stmt( maybeClone( other.stmt ) ) {
 	cloneAll( other.exprs, exprs );
@@ -472,6 +473,6 @@
 
 
-NullStmt::NullStmt( std::list<Label> labels ) : Statement( labels ) {}
-NullStmt::NullStmt() : Statement( std::list<Label>() ) {}
+NullStmt::NullStmt( const std::list<Label> & labels ) : Statement( labels ) {
+}
 
 void NullStmt::print( std::ostream &os, Indenter ) const {
@@ -479,5 +480,5 @@
 }
 
-ImplicitCtorDtorStmt::ImplicitCtorDtorStmt( Statement * callStmt ) : Statement( std::list<Label>() ), callStmt( callStmt ) {
+ImplicitCtorDtorStmt::ImplicitCtorDtorStmt( Statement * callStmt ) : Statement(), callStmt( callStmt ) {
 	assert( callStmt );
 }
Index: src/SynTree/Statement.h
===================================================================
--- src/SynTree/Statement.h	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ src/SynTree/Statement.h	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
@@ -37,5 +37,5 @@
 	std::list<Label> labels;
 
-	Statement( std::list<Label> labels );
+	Statement( const std::list<Label> & labels = {} );
 	virtual ~Statement();
 
@@ -53,5 +53,5 @@
 	std::list<Statement*> kids;
 
-	CompoundStmt( std::list<Label> labels );
+	CompoundStmt();
 	CompoundStmt( std::list<Statement *> stmts );
 	CompoundStmt( const CompoundStmt &other );
@@ -70,6 +70,5 @@
 class NullStmt : public Statement {
   public:
-	NullStmt();
-	NullStmt( std::list<Label> labels );
+	NullStmt( const std::list<Label> & labels = {} );
 
 	virtual NullStmt *clone() const override { return new NullStmt( *this ); }
@@ -83,5 +82,5 @@
 	Expression *expr;
 
-	ExprStmt( std::list<Label> labels, Expression *expr );
+	ExprStmt( Expression *expr );
 	ExprStmt( const ExprStmt &other );
 	virtual ~ExprStmt();
@@ -104,5 +103,5 @@
 	std::list<Label> gotolabels;
 
-	AsmStmt( std::list<Label> labels, bool voltile, Expression *instruction, std::list<Expression *> output, std::list<Expression *> input, std::list<ConstantExpr *> clobber, std::list<Label> gotolabels );
+	AsmStmt( bool voltile, Expression *instruction, std::list<Expression *> output, std::list<Expression *> input, std::list<ConstantExpr *> clobber, std::list<Label> gotolabels );
 	AsmStmt( const AsmStmt &other );
 	virtual ~AsmStmt();
@@ -134,5 +133,5 @@
 	std::list<Statement *> initialization;
 
-	IfStmt( std::list<Label> labels, Expression *condition, Statement *thenPart, Statement *elsePart,
+	IfStmt( Expression *condition, Statement *thenPart, Statement *elsePart,
 			std::list<Statement *> initialization = std::list<Statement *>() );
 	IfStmt( const IfStmt &other );
@@ -158,5 +157,5 @@
 	std::list<Statement *> statements;
 
-	SwitchStmt( std::list<Label> labels, Expression *condition, const std::list<Statement *> &statements );
+	SwitchStmt( Expression *condition, const std::list<Statement *> &statements );
 	SwitchStmt( const SwitchStmt &other );
 	virtual ~SwitchStmt();
@@ -180,9 +179,9 @@
 	std::list<Statement *> stmts;
 
-	CaseStmt( std::list<Label> labels, Expression *conditions, const std::list<Statement *> &stmts, bool isdef = false ) throw(SemanticError);
+	CaseStmt( Expression *conditions, const std::list<Statement *> &stmts, bool isdef = false ) throw(SemanticError);
 	CaseStmt( const CaseStmt &other );
 	virtual ~CaseStmt();
 
-	static CaseStmt * makeDefault( std::list<Label> labels = std::list<Label>(), std::list<Statement *> stmts = std::list<Statement *>() );
+	static CaseStmt * makeDefault( const std::list<Label> & labels = {}, std::list<Statement *> stmts = std::list<Statement *>() );
 
 	bool isDefault() const { return _isDefault; }
@@ -210,5 +209,5 @@
 	bool isDoWhile;
 
-	WhileStmt( std::list<Label> labels, Expression *condition,
+	WhileStmt( Expression *condition,
 	       Statement *body, bool isDoWhile = false );
 	WhileStmt( const WhileStmt &other );
@@ -235,5 +234,5 @@
 	Statement *body;
 
-	ForStmt( std::list<Label> labels, std::list<Statement *> initialization,
+	ForStmt( std::list<Statement *> initialization,
 	     Expression *condition = 0, Expression *increment = 0, Statement *body = 0 );
 	ForStmt( const ForStmt &other );
@@ -264,6 +263,6 @@
 	Type type;
 
-	BranchStmt( std::list<Label> labels, Label target, Type ) throw (SemanticError);
-	BranchStmt( std::list<Label> labels, Expression *computedTarget, Type ) throw (SemanticError);
+	BranchStmt( Label target, Type ) throw (SemanticError);
+	BranchStmt( Expression *computedTarget, Type ) throw (SemanticError);
 
 	Label get_originalTarget() { return originalTarget; }
@@ -289,5 +288,5 @@
 	Expression *expr;
 
-	ReturnStmt( std::list<Label> labels, Expression *expr );
+	ReturnStmt( Expression *expr );
 	ReturnStmt( const ReturnStmt &other );
 	virtual ~ReturnStmt();
@@ -310,5 +309,5 @@
 	Expression * target;
 
-	ThrowStmt( std::list<Label> labels, Kind kind, Expression * expr, Expression * target = nullptr );
+	ThrowStmt( Kind kind, Expression * expr, Expression * target = nullptr );
 	ThrowStmt( const ThrowStmt &other );
 	virtual ~ThrowStmt();
@@ -332,5 +331,5 @@
 	FinallyStmt * finallyBlock;
 
-	TryStmt( std::list<Label> labels, CompoundStmt *tryBlock, std::list<CatchStmt *> &handlers, FinallyStmt *finallyBlock = 0 );
+	TryStmt( CompoundStmt *tryBlock, std::list<CatchStmt *> &handlers, FinallyStmt *finallyBlock = 0 );
 	TryStmt( const TryStmt &other );
 	virtual ~TryStmt();
@@ -358,5 +357,5 @@
 	Statement *body;
 
-	CatchStmt( std::list<Label> labels, Kind kind, Declaration *decl,
+	CatchStmt( Kind kind, Declaration *decl,
 	           Expression *cond, Statement *body );
 	CatchStmt( const CatchStmt &other );
@@ -381,5 +380,5 @@
 	CompoundStmt *block;
 
-	FinallyStmt( std::list<Label> labels, CompoundStmt *block );
+	FinallyStmt( CompoundStmt *block );
 	FinallyStmt( const FinallyStmt &other );
 	virtual ~FinallyStmt();
@@ -408,5 +407,5 @@
 	};
 
-	WaitForStmt( std::list<Label> labels = noLabels );
+	WaitForStmt();
 	WaitForStmt( const WaitForStmt & );
 	virtual ~WaitForStmt();
@@ -453,5 +452,5 @@
 	Declaration *decl;
 
-	DeclStmt( std::list<Label> labels, Declaration *decl );
+	DeclStmt( Declaration *decl );
 	DeclStmt( const DeclStmt &other );
 	virtual ~DeclStmt();
Index: src/SynTree/TupleExpr.cc
===================================================================
--- src/SynTree/TupleExpr.cc	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ src/SynTree/TupleExpr.cc	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
@@ -23,5 +23,5 @@
 #include "Declaration.h"        // for ObjectDecl
 #include "Expression.h"         // for Expression, TupleExpr, TupleIndexExpr
-#include "SynTree/Label.h"      // for Label, noLabels
+#include "SynTree/Label.h"      // for Label
 #include "SynTree/Statement.h"  // for CompoundStmt, DeclStmt, ExprStmt, Sta...
 #include "Tuples/Tuples.h"      // for makeTupleType
@@ -89,12 +89,12 @@
 	// convert internally into a StmtExpr which contains the declarations and produces the tuple of the assignments
 	set_result( Tuples::makeTupleType( assigns ) );
-	CompoundStmt * compoundStmt = new CompoundStmt( noLabels );
+	CompoundStmt * compoundStmt = new CompoundStmt();
 	std::list< Statement * > & stmts = compoundStmt->get_kids();
 	for ( ObjectDecl * obj : tempDecls ) {
-		stmts.push_back( new DeclStmt( noLabels, obj ) );
+		stmts.push_back( new DeclStmt( obj ) );
 	}
 	TupleExpr * tupleExpr = new TupleExpr( assigns );
 	assert( tupleExpr->get_result() );
-	stmts.push_back( new ExprStmt( noLabels, tupleExpr ) );
+	stmts.push_back( new ExprStmt( tupleExpr ) );
 	stmtExpr = new StmtExpr( compoundStmt );
 }
Index: src/Tuples/TupleAssignment.cc
===================================================================
--- src/Tuples/TupleAssignment.cc	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ src/Tuples/TupleAssignment.cc	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
@@ -23,4 +23,5 @@
 
 #include "CodeGen/OperatorTable.h"
+#include "Common/PassVisitor.h"
 #include "Common/UniqueName.h"             // for UniqueName
 #include "Common/utility.h"                // for zipWith
@@ -61,5 +62,5 @@
 		struct Matcher {
 		  public:
-			Matcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList& lhs, const 
+			Matcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList& lhs, const
 				ResolvExpr::AltList& rhs );
 			virtual ~Matcher() {}
@@ -75,5 +76,5 @@
 		struct MassAssignMatcher : public Matcher {
 		  public:
-			MassAssignMatcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList& lhs, 
+			MassAssignMatcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList& lhs,
 				const ResolvExpr::AltList& rhs ) : Matcher(spotter, lhs, rhs) {}
 			virtual void match( std::list< Expression * > &out );
@@ -82,5 +83,5 @@
 		struct MultipleAssignMatcher : public Matcher {
 		  public:
-			MultipleAssignMatcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList& lhs, 
+			MultipleAssignMatcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList& lhs,
 				const ResolvExpr::AltList& rhs ) : Matcher(spotter, lhs, rhs) {}
 			virtual void match( std::list< Expression * > &out );
@@ -119,5 +120,5 @@
 	}
 
-	void handleTupleAssignment( ResolvExpr::AlternativeFinder & currentFinder, UntypedExpr * expr, 
+	void handleTupleAssignment( ResolvExpr::AlternativeFinder & currentFinder, UntypedExpr * expr,
 				std::vector<ResolvExpr::AlternativeFinder> &args ) {
 		TupleAssignSpotter spotter( currentFinder );
@@ -128,5 +129,5 @@
 		: currentFinder(f) {}
 
-	void TupleAssignSpotter::spot( UntypedExpr * expr, 
+	void TupleAssignSpotter::spot( UntypedExpr * expr,
 			std::vector<ResolvExpr::AlternativeFinder> &args ) {
 		if (  NameExpr *op = dynamic_cast< NameExpr * >(expr->get_function()) ) {
@@ -137,5 +138,5 @@
 				if ( args.size() == 0 ) return;
 
-				// if an assignment only takes 1 argument, that's odd, but maybe someone wrote 
+				// if an assignment only takes 1 argument, that's odd, but maybe someone wrote
 				// the function, in which case AlternativeFinder will handle it normally
 				if ( args.size() == 1 && CodeGen::isAssignment( fname ) ) return;
@@ -146,11 +147,11 @@
 					if ( ! refToTuple(lhsAlt.expr) ) continue;
 
-					// explode is aware of casts - ensure every LHS expression is sent into explode 
+					// explode is aware of casts - ensure every LHS expression is sent into explode
 					// with a reference cast
-					// xxx - this seems to change the alternatives before the normal 
+					// xxx - this seems to change the alternatives before the normal
 					//  AlternativeFinder flow; maybe this is desired?
 					if ( ! dynamic_cast<CastExpr*>( lhsAlt.expr ) ) {
-						lhsAlt.expr = new CastExpr( lhsAlt.expr, 
-								new ReferenceType( Type::Qualifiers(), 
+						lhsAlt.expr = new CastExpr( lhsAlt.expr,
+								new ReferenceType( Type::Qualifiers(),
 									lhsAlt.expr->get_result()->clone() ) );
 					}
@@ -160,9 +161,9 @@
 					explode( lhsAlt, currentFinder.get_indexer(), back_inserter(lhs), true );
 					for ( ResolvExpr::Alternative& alt : lhs ) {
-						// each LHS value must be a reference - some come in with a cast expression, 
+						// each LHS value must be a reference - some come in with a cast expression,
 						// if not just cast to reference here
 						if ( ! dynamic_cast<ReferenceType*>( alt.expr->get_result() ) ) {
-							alt.expr = new CastExpr( alt.expr, 
-								new ReferenceType( Type::Qualifiers(), 
+							alt.expr = new CastExpr( alt.expr,
+								new ReferenceType( Type::Qualifiers(),
 									alt.expr->get_result()->clone() ) );
 						}
@@ -178,10 +179,10 @@
 						// TODO build iterative version of this instead of using combos
 						std::vector< ResolvExpr::AltList > rhsAlts;
-						combos( std::next(args.begin(), 1), args.end(), 
+						combos( std::next(args.begin(), 1), args.end(),
 							std::back_inserter( rhsAlts ) );
 						for ( const ResolvExpr::AltList& rhsAlt : rhsAlts ) {
 							// multiple assignment
 							ResolvExpr::AltList rhs;
-							explode( rhsAlt, currentFinder.get_indexer(), 
+							explode( rhsAlt, currentFinder.get_indexer(),
 								std::back_inserter(rhs), true );
 							matcher.reset( new MultipleAssignMatcher( *this, lhs, rhs ) );
@@ -193,5 +194,5 @@
 							if ( isTuple(rhsAlt.expr) ) {
 								// multiple assignment
-								explode( rhsAlt, currentFinder.get_indexer(),  
+								explode( rhsAlt, currentFinder.get_indexer(),
 									std::back_inserter(rhs), true );
 								matcher.reset( new MultipleAssignMatcher( *this, lhs, rhs ) );
@@ -222,5 +223,5 @@
 		ResolvExpr::AltList current;
 		// now resolve new assignments
-		for ( std::list< Expression * >::iterator i = new_assigns.begin(); 
+		for ( std::list< Expression * >::iterator i = new_assigns.begin();
 				i != new_assigns.end(); ++i ) {
 			PRINT(
@@ -229,5 +230,5 @@
 			)
 
-			ResolvExpr::AlternativeFinder finder{ currentFinder.get_indexer(), 
+			ResolvExpr::AlternativeFinder finder{ currentFinder.get_indexer(),
 				currentFinder.get_environ() };
 			try {
@@ -253,11 +254,11 @@
 		// xxx -- was push_front
 		currentFinder.get_alternatives().push_back( ResolvExpr::Alternative(
-			new TupleAssignExpr(solved_assigns, matcher->tmpDecls), matcher->compositeEnv, 
+			new TupleAssignExpr(solved_assigns, matcher->tmpDecls), matcher->compositeEnv,
 			ResolvExpr::sumCost( current ) + matcher->baseCost ) );
 	}
 
-	TupleAssignSpotter::Matcher::Matcher( TupleAssignSpotter &spotter, 
-		const ResolvExpr::AltList &lhs, const ResolvExpr::AltList &rhs ) 
-	: lhs(lhs), rhs(rhs), spotter(spotter), 
+	TupleAssignSpotter::Matcher::Matcher( TupleAssignSpotter &spotter,
+		const ResolvExpr::AltList &lhs, const ResolvExpr::AltList &rhs )
+	: lhs(lhs), rhs(rhs), spotter(spotter),
 	  baseCost( ResolvExpr::sumCost( lhs ) + ResolvExpr::sumCost( rhs ) ) {
 		simpleCombineEnvironments( lhs.begin(), lhs.end(), compositeEnv );
@@ -277,9 +278,8 @@
 	// xxx - maybe this should happen in alternative finder for every StmtExpr?
 	// xxx - it's possible that these environments could contain some useful information. Maybe the right thing to do is aggregate the environments and pass the aggregate back to be added into the compositeEnv
-	struct EnvRemover : public Visitor {
-		virtual void visit( ExprStmt * stmt ) {
-			delete stmt->get_expr()->get_env();
-			stmt->get_expr()->set_env( nullptr );
-			Visitor::visit( stmt );
+	struct EnvRemover {
+		void previsit( ExprStmt * stmt ) {
+			delete stmt->expr->env;
+			stmt->expr->env = nullptr;
 		}
 	};
@@ -293,5 +293,5 @@
 			ret->set_init( ctorInit );
 			ResolvExpr::resolveCtorInit( ctorInit, spotter.currentFinder.get_indexer() ); // resolve ctor/dtors for the new object
-			EnvRemover rm; // remove environments from subexpressions of StmtExprs
+			PassVisitor<EnvRemover> rm; // remove environments from subexpressions of StmtExprs
 			ctorInit->accept( rm );
 		}
Index: src/Tuples/TupleExpansion.cc
===================================================================
--- src/Tuples/TupleExpansion.cc	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ src/Tuples/TupleExpansion.cc	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
@@ -315,15 +315,14 @@
 	namespace {
 		/// determines if impurity (read: side-effects) may exist in a piece of code. Currently gives a very crude approximation, wherein any function call expression means the code may be impure
-		class ImpurityDetector : public Visitor {
-		public:
+		struct ImpurityDetector : public WithShortCircuiting {
 			ImpurityDetector( bool ignoreUnique ) : ignoreUnique( ignoreUnique ) {}
 
-			typedef Visitor Parent;
-			virtual void visit( ApplicationExpr * appExpr ) {
+			void previsit( ApplicationExpr * appExpr ) {
+				visit_children = false;
 				if ( DeclarationWithType * function = InitTweak::getFunction( appExpr ) ) {
 					if ( function->get_linkage() == LinkageSpec::Intrinsic ) {
 						if ( function->get_name() == "*?" || function->get_name() == "?[?]" ) {
 							// intrinsic dereference, subscript are pure, but need to recursively look for impurity
-							Parent::visit( appExpr );
+							visit_children = true;
 							return;
 						}
@@ -332,13 +331,13 @@
 				maybeImpure = true;
 			}
-			virtual void visit( UntypedExpr * ) { maybeImpure = true; }
-			virtual void visit( UniqueExpr * unq ) {
+			void previsit( UntypedExpr * ) { maybeImpure = true; visit_children = false; }
+			void previsit( UniqueExpr * ) {
 				if ( ignoreUnique ) {
 					// bottom out at unique expression.
 					// The existence of a unique expression doesn't change the purity of an expression.
 					// That is, even if the wrapped expression is impure, the wrapper protects the rest of the expression.
+					visit_children = false;
 					return;
 				}
-				maybeAccept( unq->expr, *this );
 			}
 
@@ -349,13 +348,13 @@
 
 	bool maybeImpure( Expression * expr ) {
-		ImpurityDetector detector( false );
+		PassVisitor<ImpurityDetector> detector( false );
 		expr->accept( detector );
-		return detector.maybeImpure;
+		return detector.pass.maybeImpure;
 	}
 
 	bool maybeImpureIgnoreUnique( Expression * expr ) {
-		ImpurityDetector detector( true );
+		PassVisitor<ImpurityDetector> detector( true );
 		expr->accept( detector );
-		return detector.maybeImpure;
+		return detector.pass.maybeImpure;
 	}
 } // namespace Tuples
Index: src/driver/cfa.cc
===================================================================
--- src/driver/cfa.cc	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ src/driver/cfa.cc	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
@@ -275,5 +275,5 @@
 		args[nargs] = "-Xlinker";
 		nargs += 1;
-		args[nargs] = "--undefined=__lib_debug_write";
+		args[nargs] = "--undefined=__cfaabi_dbg_bits_write";
 		nargs += 1;
 
Index: src/libcfa/Makefile.am
===================================================================
--- src/libcfa/Makefile.am	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ src/libcfa/Makefile.am	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
@@ -55,5 +55,5 @@
 
 libobjs = ${headers:=.o}
-libsrc = libcfa-prelude.c interpose.c libhdr/libdebug.c ${headers:=.c} \
+libsrc = libcfa-prelude.c interpose.c bits/debug.c ${headers:=.c} \
 	 assert.c exception.c virtual.c
 
@@ -100,12 +100,10 @@
 	math 				\
 	gmp 				\
+	bits/align.h 		\
 	bits/containers.h		\
 	bits/defs.h 		\
+	bits/debug.h 		\
 	bits/locks.h 		\
-	concurrency/invoke.h 	\
-	libhdr.h 			\
-	libhdr/libalign.h 	\
-	libhdr/libdebug.h 	\
-	libhdr/libtools.h
+	concurrency/invoke.h
 
 CLEANFILES = libcfa-prelude.c
Index: src/libcfa/Makefile.in
===================================================================
--- src/libcfa/Makefile.in	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ src/libcfa/Makefile.in	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
@@ -149,5 +149,5 @@
 libcfa_d_a_LIBADD =
 am__libcfa_d_a_SOURCES_DIST = libcfa-prelude.c interpose.c \
-	libhdr/libdebug.c fstream.c iostream.c iterator.c limits.c \
+	bits/debug.c fstream.c iostream.c iterator.c limits.c \
 	rational.c stdlib.c containers/maybe.c containers/pair.c \
 	containers/result.c containers/vector.c \
@@ -175,21 +175,20 @@
 @BUILD_CONCURRENCY_TRUE@	concurrency/libcfa_d_a-preemption.$(OBJEXT)
 am__objects_4 = libcfa_d_a-libcfa-prelude.$(OBJEXT) \
-	libcfa_d_a-interpose.$(OBJEXT) \
-	libhdr/libcfa_d_a-libdebug.$(OBJEXT) $(am__objects_2) \
-	libcfa_d_a-assert.$(OBJEXT) libcfa_d_a-exception.$(OBJEXT) \
-	libcfa_d_a-virtual.$(OBJEXT) $(am__objects_3)
+	libcfa_d_a-interpose.$(OBJEXT) bits/libcfa_d_a-debug.$(OBJEXT) \
+	$(am__objects_2) libcfa_d_a-assert.$(OBJEXT) \
+	libcfa_d_a-exception.$(OBJEXT) libcfa_d_a-virtual.$(OBJEXT) \
+	$(am__objects_3)
 am_libcfa_d_a_OBJECTS = $(am__objects_4)
 libcfa_d_a_OBJECTS = $(am_libcfa_d_a_OBJECTS)
 libcfa_a_AR = $(AR) $(ARFLAGS)
 libcfa_a_LIBADD =
-am__libcfa_a_SOURCES_DIST = libcfa-prelude.c interpose.c \
-	libhdr/libdebug.c fstream.c iostream.c iterator.c limits.c \
-	rational.c stdlib.c containers/maybe.c containers/pair.c \
-	containers/result.c containers/vector.c \
-	concurrency/coroutine.c concurrency/thread.c \
-	concurrency/kernel.c concurrency/monitor.c assert.c \
-	exception.c virtual.c concurrency/CtxSwitch-@MACHINE_TYPE@.S \
-	concurrency/alarm.c concurrency/invoke.c \
-	concurrency/preemption.c
+am__libcfa_a_SOURCES_DIST = libcfa-prelude.c interpose.c bits/debug.c \
+	fstream.c iostream.c iterator.c limits.c rational.c stdlib.c \
+	containers/maybe.c containers/pair.c containers/result.c \
+	containers/vector.c concurrency/coroutine.c \
+	concurrency/thread.c concurrency/kernel.c \
+	concurrency/monitor.c assert.c exception.c virtual.c \
+	concurrency/CtxSwitch-@MACHINE_TYPE@.S concurrency/alarm.c \
+	concurrency/invoke.c concurrency/preemption.c
 @BUILD_CONCURRENCY_TRUE@am__objects_5 = concurrency/libcfa_a-coroutine.$(OBJEXT) \
 @BUILD_CONCURRENCY_TRUE@	concurrency/libcfa_a-thread.$(OBJEXT) \
@@ -208,8 +207,8 @@
 @BUILD_CONCURRENCY_TRUE@	concurrency/libcfa_a-preemption.$(OBJEXT)
 am__objects_8 = libcfa_a-libcfa-prelude.$(OBJEXT) \
-	libcfa_a-interpose.$(OBJEXT) \
-	libhdr/libcfa_a-libdebug.$(OBJEXT) $(am__objects_6) \
-	libcfa_a-assert.$(OBJEXT) libcfa_a-exception.$(OBJEXT) \
-	libcfa_a-virtual.$(OBJEXT) $(am__objects_7)
+	libcfa_a-interpose.$(OBJEXT) bits/libcfa_a-debug.$(OBJEXT) \
+	$(am__objects_6) libcfa_a-assert.$(OBJEXT) \
+	libcfa_a-exception.$(OBJEXT) libcfa_a-virtual.$(OBJEXT) \
+	$(am__objects_7)
 am_libcfa_a_OBJECTS = $(am__objects_8)
 libcfa_a_OBJECTS = $(am_libcfa_a_OBJECTS)
@@ -264,7 +263,6 @@
 	containers/result containers/vector concurrency/coroutine \
 	concurrency/thread concurrency/kernel concurrency/monitor \
-	${shell echo stdhdr/*} math gmp bits/containers.h bits/defs.h \
-	bits/locks.h concurrency/invoke.h libhdr.h libhdr/libalign.h \
-	libhdr/libdebug.h libhdr/libtools.h
+	${shell echo stdhdr/*} math gmp bits/align.h bits/containers.h \
+	bits/defs.h bits/debug.h bits/locks.h concurrency/invoke.h
 HEADERS = $(nobase_cfa_include_HEADERS)
 am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
@@ -424,5 +422,5 @@
 	containers/vector $(am__append_3)
 libobjs = ${headers:=.o}
-libsrc = libcfa-prelude.c interpose.c libhdr/libdebug.c ${headers:=.c} \
+libsrc = libcfa-prelude.c interpose.c bits/debug.c ${headers:=.c} \
 	assert.c exception.c virtual.c $(am__append_4)
 libcfa_a_SOURCES = ${libsrc}
@@ -437,12 +435,10 @@
 	math 				\
 	gmp 				\
+	bits/align.h 		\
 	bits/containers.h		\
 	bits/defs.h 		\
+	bits/debug.h 		\
 	bits/locks.h 		\
-	concurrency/invoke.h 	\
-	libhdr.h 			\
-	libhdr/libalign.h 	\
-	libhdr/libdebug.h 	\
-	libhdr/libtools.h
+	concurrency/invoke.h
 
 CLEANFILES = libcfa-prelude.c
@@ -511,12 +507,12 @@
 clean-libLIBRARIES:
 	-test -z "$(lib_LIBRARIES)" || rm -f $(lib_LIBRARIES)
-libhdr/$(am__dirstamp):
-	@$(MKDIR_P) libhdr
-	@: > libhdr/$(am__dirstamp)
-libhdr/$(DEPDIR)/$(am__dirstamp):
-	@$(MKDIR_P) libhdr/$(DEPDIR)
-	@: > libhdr/$(DEPDIR)/$(am__dirstamp)
-libhdr/libcfa_d_a-libdebug.$(OBJEXT): libhdr/$(am__dirstamp) \
-	libhdr/$(DEPDIR)/$(am__dirstamp)
+bits/$(am__dirstamp):
+	@$(MKDIR_P) bits
+	@: > bits/$(am__dirstamp)
+bits/$(DEPDIR)/$(am__dirstamp):
+	@$(MKDIR_P) bits/$(DEPDIR)
+	@: > bits/$(DEPDIR)/$(am__dirstamp)
+bits/libcfa_d_a-debug.$(OBJEXT): bits/$(am__dirstamp) \
+	bits/$(DEPDIR)/$(am__dirstamp)
 containers/$(am__dirstamp):
 	@$(MKDIR_P) containers
@@ -563,6 +559,6 @@
 	$(AM_V_AR)$(libcfa_d_a_AR) libcfa-d.a $(libcfa_d_a_OBJECTS) $(libcfa_d_a_LIBADD)
 	$(AM_V_at)$(RANLIB) libcfa-d.a
-libhdr/libcfa_a-libdebug.$(OBJEXT): libhdr/$(am__dirstamp) \
-	libhdr/$(DEPDIR)/$(am__dirstamp)
+bits/libcfa_a-debug.$(OBJEXT): bits/$(am__dirstamp) \
+	bits/$(DEPDIR)/$(am__dirstamp)
 containers/libcfa_a-maybe.$(OBJEXT): containers/$(am__dirstamp) \
 	containers/$(DEPDIR)/$(am__dirstamp)
@@ -596,7 +592,7 @@
 mostlyclean-compile:
 	-rm -f *.$(OBJEXT)
+	-rm -f bits/*.$(OBJEXT)
 	-rm -f concurrency/*.$(OBJEXT)
 	-rm -f containers/*.$(OBJEXT)
-	-rm -f libhdr/*.$(OBJEXT)
 
 distclean-compile:
@@ -625,4 +621,6 @@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_d_a-stdlib.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_d_a-virtual.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@bits/$(DEPDIR)/libcfa_a-debug.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@bits/$(DEPDIR)/libcfa_d_a-debug.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/CtxSwitch-@MACHINE_TYPE@.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_a-alarm.Po@am__quote@
@@ -648,6 +646,4 @@
 @AMDEP_TRUE@@am__include@ @am__quote@containers/$(DEPDIR)/libcfa_d_a-result.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@containers/$(DEPDIR)/libcfa_d_a-vector.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@libhdr/$(DEPDIR)/libcfa_a-libdebug.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@libhdr/$(DEPDIR)/libcfa_d_a-libdebug.Po@am__quote@
 
 .S.o:
@@ -704,17 +700,17 @@
 @am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o libcfa_d_a-interpose.obj `if test -f 'interpose.c'; then $(CYGPATH_W) 'interpose.c'; else $(CYGPATH_W) '$(srcdir)/interpose.c'; fi`
 
-libhdr/libcfa_d_a-libdebug.o: libhdr/libdebug.c
-@am__fastdepCC_TRUE@	$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libhdr/libcfa_d_a-libdebug.o -MD -MP -MF libhdr/$(DEPDIR)/libcfa_d_a-libdebug.Tpo -c -o libhdr/libcfa_d_a-libdebug.o `test -f 'libhdr/libdebug.c' || echo '$(srcdir)/'`libhdr/libdebug.c
-@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) libhdr/$(DEPDIR)/libcfa_d_a-libdebug.Tpo libhdr/$(DEPDIR)/libcfa_d_a-libdebug.Po
-@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='libhdr/libdebug.c' object='libhdr/libcfa_d_a-libdebug.o' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o libhdr/libcfa_d_a-libdebug.o `test -f 'libhdr/libdebug.c' || echo '$(srcdir)/'`libhdr/libdebug.c
-
-libhdr/libcfa_d_a-libdebug.obj: libhdr/libdebug.c
-@am__fastdepCC_TRUE@	$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libhdr/libcfa_d_a-libdebug.obj -MD -MP -MF libhdr/$(DEPDIR)/libcfa_d_a-libdebug.Tpo -c -o libhdr/libcfa_d_a-libdebug.obj `if test -f 'libhdr/libdebug.c'; then $(CYGPATH_W) 'libhdr/libdebug.c'; else $(CYGPATH_W) '$(srcdir)/libhdr/libdebug.c'; fi`
-@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) libhdr/$(DEPDIR)/libcfa_d_a-libdebug.Tpo libhdr/$(DEPDIR)/libcfa_d_a-libdebug.Po
-@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='libhdr/libdebug.c' object='libhdr/libcfa_d_a-libdebug.obj' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o libhdr/libcfa_d_a-libdebug.obj `if test -f 'libhdr/libdebug.c'; then $(CYGPATH_W) 'libhdr/libdebug.c'; else $(CYGPATH_W) '$(srcdir)/libhdr/libdebug.c'; fi`
+bits/libcfa_d_a-debug.o: bits/debug.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT bits/libcfa_d_a-debug.o -MD -MP -MF bits/$(DEPDIR)/libcfa_d_a-debug.Tpo -c -o bits/libcfa_d_a-debug.o `test -f 'bits/debug.c' || echo '$(srcdir)/'`bits/debug.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) bits/$(DEPDIR)/libcfa_d_a-debug.Tpo bits/$(DEPDIR)/libcfa_d_a-debug.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='bits/debug.c' object='bits/libcfa_d_a-debug.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o bits/libcfa_d_a-debug.o `test -f 'bits/debug.c' || echo '$(srcdir)/'`bits/debug.c
+
+bits/libcfa_d_a-debug.obj: bits/debug.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT bits/libcfa_d_a-debug.obj -MD -MP -MF bits/$(DEPDIR)/libcfa_d_a-debug.Tpo -c -o bits/libcfa_d_a-debug.obj `if test -f 'bits/debug.c'; then $(CYGPATH_W) 'bits/debug.c'; else $(CYGPATH_W) '$(srcdir)/bits/debug.c'; fi`
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) bits/$(DEPDIR)/libcfa_d_a-debug.Tpo bits/$(DEPDIR)/libcfa_d_a-debug.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='bits/debug.c' object='bits/libcfa_d_a-debug.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o bits/libcfa_d_a-debug.obj `if test -f 'bits/debug.c'; then $(CYGPATH_W) 'bits/debug.c'; else $(CYGPATH_W) '$(srcdir)/bits/debug.c'; fi`
 
 libcfa_d_a-fstream.o: fstream.c
@@ -998,17 +994,17 @@
 @am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o libcfa_a-interpose.obj `if test -f 'interpose.c'; then $(CYGPATH_W) 'interpose.c'; else $(CYGPATH_W) '$(srcdir)/interpose.c'; fi`
 
-libhdr/libcfa_a-libdebug.o: libhdr/libdebug.c
-@am__fastdepCC_TRUE@	$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libhdr/libcfa_a-libdebug.o -MD -MP -MF libhdr/$(DEPDIR)/libcfa_a-libdebug.Tpo -c -o libhdr/libcfa_a-libdebug.o `test -f 'libhdr/libdebug.c' || echo '$(srcdir)/'`libhdr/libdebug.c
-@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) libhdr/$(DEPDIR)/libcfa_a-libdebug.Tpo libhdr/$(DEPDIR)/libcfa_a-libdebug.Po
-@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='libhdr/libdebug.c' object='libhdr/libcfa_a-libdebug.o' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o libhdr/libcfa_a-libdebug.o `test -f 'libhdr/libdebug.c' || echo '$(srcdir)/'`libhdr/libdebug.c
-
-libhdr/libcfa_a-libdebug.obj: libhdr/libdebug.c
-@am__fastdepCC_TRUE@	$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libhdr/libcfa_a-libdebug.obj -MD -MP -MF libhdr/$(DEPDIR)/libcfa_a-libdebug.Tpo -c -o libhdr/libcfa_a-libdebug.obj `if test -f 'libhdr/libdebug.c'; then $(CYGPATH_W) 'libhdr/libdebug.c'; else $(CYGPATH_W) '$(srcdir)/libhdr/libdebug.c'; fi`
-@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) libhdr/$(DEPDIR)/libcfa_a-libdebug.Tpo libhdr/$(DEPDIR)/libcfa_a-libdebug.Po
-@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='libhdr/libdebug.c' object='libhdr/libcfa_a-libdebug.obj' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o libhdr/libcfa_a-libdebug.obj `if test -f 'libhdr/libdebug.c'; then $(CYGPATH_W) 'libhdr/libdebug.c'; else $(CYGPATH_W) '$(srcdir)/libhdr/libdebug.c'; fi`
+bits/libcfa_a-debug.o: bits/debug.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT bits/libcfa_a-debug.o -MD -MP -MF bits/$(DEPDIR)/libcfa_a-debug.Tpo -c -o bits/libcfa_a-debug.o `test -f 'bits/debug.c' || echo '$(srcdir)/'`bits/debug.c
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) bits/$(DEPDIR)/libcfa_a-debug.Tpo bits/$(DEPDIR)/libcfa_a-debug.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='bits/debug.c' object='bits/libcfa_a-debug.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o bits/libcfa_a-debug.o `test -f 'bits/debug.c' || echo '$(srcdir)/'`bits/debug.c
+
+bits/libcfa_a-debug.obj: bits/debug.c
+@am__fastdepCC_TRUE@	$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT bits/libcfa_a-debug.obj -MD -MP -MF bits/$(DEPDIR)/libcfa_a-debug.Tpo -c -o bits/libcfa_a-debug.obj `if test -f 'bits/debug.c'; then $(CYGPATH_W) 'bits/debug.c'; else $(CYGPATH_W) '$(srcdir)/bits/debug.c'; fi`
+@am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) bits/$(DEPDIR)/libcfa_a-debug.Tpo bits/$(DEPDIR)/libcfa_a-debug.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='bits/debug.c' object='bits/libcfa_a-debug.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o bits/libcfa_a-debug.obj `if test -f 'bits/debug.c'; then $(CYGPATH_W) 'bits/debug.c'; else $(CYGPATH_W) '$(srcdir)/bits/debug.c'; fi`
 
 libcfa_a-fstream.o: fstream.c
@@ -1411,10 +1407,10 @@
 	-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
 	-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
+	-rm -f bits/$(DEPDIR)/$(am__dirstamp)
+	-rm -f bits/$(am__dirstamp)
 	-rm -f concurrency/$(DEPDIR)/$(am__dirstamp)
 	-rm -f concurrency/$(am__dirstamp)
 	-rm -f containers/$(DEPDIR)/$(am__dirstamp)
 	-rm -f containers/$(am__dirstamp)
-	-rm -f libhdr/$(DEPDIR)/$(am__dirstamp)
-	-rm -f libhdr/$(am__dirstamp)
 
 maintainer-clean-generic:
@@ -1426,5 +1422,5 @@
 
 distclean: distclean-am
-	-rm -rf ./$(DEPDIR) concurrency/$(DEPDIR) containers/$(DEPDIR) libhdr/$(DEPDIR)
+	-rm -rf ./$(DEPDIR) bits/$(DEPDIR) concurrency/$(DEPDIR) containers/$(DEPDIR)
 	-rm -f Makefile
 distclean-am: clean-am distclean-compile distclean-generic \
@@ -1472,5 +1468,5 @@
 
 maintainer-clean: maintainer-clean-am
-	-rm -rf ./$(DEPDIR) concurrency/$(DEPDIR) containers/$(DEPDIR) libhdr/$(DEPDIR)
+	-rm -rf ./$(DEPDIR) bits/$(DEPDIR) concurrency/$(DEPDIR) containers/$(DEPDIR)
 	-rm -f Makefile
 maintainer-clean-am: distclean-am maintainer-clean-generic \
Index: src/libcfa/assert.c
===================================================================
--- src/libcfa/assert.c	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ src/libcfa/assert.c	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
@@ -17,5 +17,5 @@
 #include <stdarg.h>								// varargs
 #include <stdio.h>								// fprintf
-#include "libhdr/libdebug.h"
+#include "bits/debug.h"
 
 extern "C" {
@@ -26,5 +26,5 @@
 	// called by macro assert in assert.h
 	void __assert_fail( const char *assertion, const char *file, unsigned int line, const char *function ) {
-		__lib_debug_print_safe( CFA_ASSERT_FMT ".\n", __progname, function, line, file );
+		__cfaabi_dbg_bits_print_safe( CFA_ASSERT_FMT ".\n", __progname, function, line, file );
 		abort();
 	}
@@ -32,14 +32,14 @@
 	// called by macro assertf
 	void __assert_fail_f( const char *assertion, const char *file, unsigned int line, const char *function, const char *fmt, ... ) {
-		__lib_debug_acquire();
-		__lib_debug_print_nolock( CFA_ASSERT_FMT ": ", __progname, function, line, file );
+		__cfaabi_dbg_bits_acquire();
+		__cfaabi_dbg_bits_print_nolock( CFA_ASSERT_FMT ": ", __progname, function, line, file );
 
 		va_list args;
 		va_start( args, fmt );
-		__lib_debug_print_vararg( fmt, args );
+		__cfaabi_dbg_bits_print_vararg( fmt, args );
 		va_end( args );
 
-		__lib_debug_print_nolock( "\n" );
-		__lib_debug_release();
+		__cfaabi_dbg_bits_print_nolock( "\n" );
+		__cfaabi_dbg_bits_release();
 		abort();
 	}
Index: src/libcfa/bits/align.h
===================================================================
--- src/libcfa/bits/align.h	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
+++ src/libcfa/bits/align.h	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
@@ -0,0 +1,62 @@
+//
+// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// align.h --
+//
+// Author           : Thierry Delisle
+// Created On       : Mon Nov 28 12:27:26 2016
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Fri Jul 21 23:05:35 2017
+// Update Count     : 2
+//
+// This  library is free  software; you  can redistribute  it and/or  modify it
+// under the terms of the GNU Lesser General Public License as published by the
+// 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.
+//
+
+#pragma once
+
+#include <assert.h>
+#include <stdbool.h>
+
+// Minimum size used to align memory boundaries for memory allocations.
+#define libAlign() (sizeof(double))
+
+// Check for power of 2
+static inline bool libPow2( unsigned long int value ) {
+    // clears all bits below value, rounding value down to the next lower multiple of value
+    return (value & (value - 1ul)) == 0ul;
+} // libPow2
+
+
+// Returns value aligned at the floor of align.
+static inline unsigned long int libFloor( unsigned long int value, unsigned long int align ) {
+    assert( libPow2( align ) );
+    // clears all bits above or equal to align, getting (value % align), the phase of value with regards to align
+    return value & -align;
+} // libFloor
+
+
+// Returns value aligned at the ceiling of align.
+
+static inline unsigned long int libCeiling( unsigned long int value, unsigned long int align ) {
+    assert( libPow2( align ) );
+    // "negate, round down, negate" is the same as round up
+    return -libFloor( -value, align );
+} // uCeiling
+
+// Local Variables: //
+// compile-command: "make install" //
+// End: //
Index: src/libcfa/bits/containers.h
===================================================================
--- src/libcfa/bits/containers.h	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ src/libcfa/bits/containers.h	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
@@ -15,6 +15,6 @@
 #pragma once
 
+#include "bits/align.h"
 #include "bits/defs.h"
-#include "libhdr.h"
 
 //-----------------------------------------------------------------------------
Index: src/libcfa/bits/debug.c
===================================================================
--- src/libcfa/bits/debug.c	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
+++ src/libcfa/bits/debug.c	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
@@ -0,0 +1,88 @@
+//
+// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// debug.c --
+//
+// Author           : Thierry Delisle
+// Created On       : Thu Mar 30 12:30:01 2017
+// Last Modified By :
+// Last Modified On :
+// Update Count     : 0
+//
+
+extern "C" {
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <stdarg.h>
+#include <unistd.h>
+}
+
+enum { buffer_size = 512 };
+static char buffer[ buffer_size ];
+
+extern "C" {
+
+	void __cfaabi_dbg_bits_write( const char *in_buffer, int len ) {
+		// ensure all data is written
+		for ( int count = 0, retcode; count < len; count += retcode ) {
+			in_buffer += count;
+
+			for ( ;; ) {
+				retcode = write( STDERR_FILENO, in_buffer, len - count );
+
+				// not a timer interrupt ?
+				if ( retcode != -1 || errno != EINTR ) break;
+			}
+
+			if ( retcode == -1 ) _exit( EXIT_FAILURE );
+		}
+	}
+
+	void __cfaabi_dbg_bits_acquire() __attribute__((__weak__)) {}
+	void __cfaabi_dbg_bits_release() __attribute__((__weak__)) {}
+
+	void __cfaabi_dbg_bits_print_safe  ( const char fmt[], ... ) __attribute__(( format (printf, 1, 2) )) {
+		va_list args;
+
+		va_start( args, fmt );
+		__cfaabi_dbg_bits_acquire();
+
+		int len = vsnprintf( buffer, buffer_size, fmt, args );
+		__cfaabi_dbg_bits_write( buffer, len );
+
+		__cfaabi_dbg_bits_release();
+		va_end( args );
+	}
+
+	void __cfaabi_dbg_bits_print_nolock( const char fmt[], ... ) __attribute__(( format (printf, 1, 2) )) {
+		va_list args;
+
+		va_start( args, fmt );
+
+		int len = vsnprintf( buffer, buffer_size, fmt, args );
+		__cfaabi_dbg_bits_write( buffer, len );
+
+		va_end( args );
+	}
+
+	void __cfaabi_dbg_bits_print_vararg( const char fmt[], va_list args ) {
+		int len = vsnprintf( buffer, buffer_size, fmt, args );
+		__cfaabi_dbg_bits_write( buffer, len );
+	}
+
+	void __cfaabi_dbg_bits_print_buffer( char in_buffer[], int in_buffer_size, const char fmt[], ... ) __attribute__(( format (printf, 3, 4) )) {
+		va_list args;
+
+		va_start( args, fmt );
+
+		int len = vsnprintf( in_buffer, in_buffer_size, fmt, args );
+		__cfaabi_dbg_bits_write( in_buffer, len );
+
+		va_end( args );
+	}
+}
Index: src/libcfa/bits/debug.h
===================================================================
--- src/libcfa/bits/debug.h	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
+++ src/libcfa/bits/debug.h	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
@@ -0,0 +1,74 @@
+//
+// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// debug.h --
+//
+// Author           : Thierry Delisle
+// Created On       : Mon Nov 28 12:27:26 2016
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sat Jul 22 10:02:24 2017
+// Update Count     : 1
+//
+
+#pragma once
+
+#ifdef __CFA_DEBUG__
+	#define __cfaabi_dbg_debug_do(...) __VA_ARGS__
+	#define __cfaabi_dbg_no_debug_do(...)
+	#define __cfaabi_dbg_ctx __PRETTY_FUNCTION__
+	#define __cfaabi_dbg_ctx2 , __PRETTY_FUNCTION__
+	#define __cfaabi_dbg_ctx_param const char * caller
+	#define __cfaabi_dbg_ctx_param2 , const char * caller
+#else
+	#define __cfaabi_dbg_debug_do(...)
+	#define __cfaabi_dbg_no_debug_do(...) __VA_ARGS__
+	#define __cfaabi_dbg_ctx
+	#define __cfaabi_dbg_ctx2
+	#define __cfaabi_dbg_ctx_param
+	#define __cfaabi_dbg_ctx_param2
+#endif
+
+#ifdef __cforall
+extern "C" {
+#endif
+	#include <stdarg.h>
+	#include <stdio.h>
+
+      extern void __cfaabi_dbg_bits_write( const char *buffer, int len );
+      extern void __cfaabi_dbg_bits_acquire();
+      extern void __cfaabi_dbg_bits_release();
+      extern void __cfaabi_dbg_bits_print_safe  ( const char fmt[], ... ) __attribute__(( format (printf, 1, 2) ));
+      extern void __cfaabi_dbg_bits_print_nolock( const char fmt[], ... ) __attribute__(( format (printf, 1, 2) ));
+      extern void __cfaabi_dbg_bits_print_vararg( const char fmt[], va_list arg );
+      extern void __cfaabi_dbg_bits_print_buffer( char buffer[], int buffer_size, const char fmt[], ... ) __attribute__(( format (printf, 3, 4) ));
+#ifdef __cforall
+}
+#endif
+
+#ifdef __CFA_DEBUG_PRINT__
+	#define __cfaabi_dbg_write( buffer, len )         __cfaabi_dbg_bits_write( buffer, len )
+	#define __cfaabi_dbg_acquire()                    __cfaabi_dbg_bits_acquire()
+	#define __cfaabi_dbg_release()                    __cfaabi_dbg_bits_release()
+	#define __cfaabi_dbg_print_safe(...)              __cfaabi_dbg_bits_print_safe   (__VA_ARGS__)
+	#define __cfaabi_dbg_print_nolock(...)            __cfaabi_dbg_bits_print_nolock (__VA_ARGS__)
+	#define __cfaabi_dbg_print_buffer(...)            __cfaabi_dbg_bits_print_buffer (__VA_ARGS__)
+	#define __cfaabi_dbg_print_buffer_decl(...)       char __dbg_text[256]; int __dbg_len = snprintf( __dbg_text, 256, __VA_ARGS__ ); __cfaabi_dbg_bits_write( __dbg_text, __dbg_len );
+	#define __cfaabi_dbg_print_buffer_local(...)      __dbg_len = snprintf( __dbg_text, 256, __VA_ARGS__ ); __cfaabi_dbg_bits_write( __dbg_text, __dbg_len );
+#else
+	#define __cfaabi_dbg_write(...)               ((void)0)
+	#define __cfaabi_dbg_acquire()                ((void)0)
+	#define __cfaabi_dbg_release()                ((void)0)
+	#define __cfaabi_dbg_print_safe(...)          ((void)0)
+	#define __cfaabi_dbg_print_nolock(...)        ((void)0)
+	#define __cfaabi_dbg_print_buffer(...)        ((void)0)
+	#define __cfaabi_dbg_print_buffer_decl(...)   ((void)0)
+	#define __cfaabi_dbg_print_buffer_local(...)  ((void)0)
+#endif
+
+// Local Variables: //
+// mode: c //
+// tab-width: 4 //
+// End: //
Index: src/libcfa/bits/defs.h
===================================================================
--- src/libcfa/bits/defs.h	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ src/libcfa/bits/defs.h	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
@@ -32,2 +32,10 @@
 #define __cfa_anonymous_object __cfa_anonymous_object
 #endif
+
+#ifdef __cforall
+extern "C" {
+#endif
+void abortf( const char fmt[], ... ) __attribute__ ((__nothrow__, __leaf__, __noreturn__));
+#ifdef __cforall
+}
+#endif
Index: src/libcfa/bits/locks.h
===================================================================
--- src/libcfa/bits/locks.h	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ src/libcfa/bits/locks.h	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
@@ -16,7 +16,6 @@
 #pragma once
 
+#include "bits/debug.h"
 #include "bits/defs.h"
-
-#include "libhdr.h"
 
 // pause to prevent excess processor bus usage
@@ -65,7 +64,7 @@
 
 	// Lock the spinlock, return false if already acquired
-	static inline _Bool try_lock  ( __spinlock_t & this DEBUG_CTX_PARAM2 ) {
+	static inline _Bool try_lock  ( __spinlock_t & this __cfaabi_dbg_ctx_param2 ) {
 		_Bool result = __lock_test_and_test_and_set( this.lock );
-		LIB_DEBUG_DO(
+		__cfaabi_dbg_debug_do(
 			if( result ) {
 				this.prev_name = caller;
@@ -77,5 +76,5 @@
 
 	// Lock the spinlock, spin if already acquired
-	static inline void lock( __spinlock_t & this DEBUG_CTX_PARAM2 ) {
+	static inline void lock( __spinlock_t & this __cfaabi_dbg_ctx_param2 ) {
 		#ifndef NOEXPBACK
 			enum { SPIN_START = 4, SPIN_END = 64 * 1024, };
@@ -98,5 +97,5 @@
 			#endif
 		}
-		LIB_DEBUG_DO(
+		__cfaabi_dbg_debug_do(
 			this.prev_name = caller;
 			this.prev_thrd = this_thread;
@@ -105,10 +104,10 @@
 
 	// Lock the spinlock, spin if already acquired
-	static inline void lock_yield( __spinlock_t & this DEBUG_CTX_PARAM2 ) {
+	static inline void lock_yield( __spinlock_t & this __cfaabi_dbg_ctx_param2 ) {
 		for ( unsigned int i = 1;; i += 1 ) {
 			if ( __lock_test_and_test_and_set( this.lock ) ) break;
 			yield( i );
 		}
-		LIB_DEBUG_DO(
+		__cfaabi_dbg_debug_do(
 			this.prev_name = caller;
 			this.prev_thrd = this_thread;
Index: src/libcfa/concurrency/alarm.c
===================================================================
--- src/libcfa/concurrency/alarm.c	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ src/libcfa/concurrency/alarm.c	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
@@ -23,6 +23,4 @@
 }
 
-#include "libhdr.h"
-
 #include "alarm.h"
 #include "kernel_private.h"
@@ -110,5 +108,5 @@
 }
 
-LIB_DEBUG_DO( bool validate( alarm_list_t * this ) {
+__cfaabi_dbg_debug_do( bool validate( alarm_list_t * this ) {
 	alarm_node_t ** it = &this->head;
 	while( (*it) ) {
@@ -186,5 +184,5 @@
 
 	disable_interrupts();
-	lock( event_kernel->lock DEBUG_CTX2 );
+	lock( event_kernel->lock __cfaabi_dbg_ctx2 );
 	{
 		verify( validate( alarms ) );
@@ -198,10 +196,10 @@
 	unlock( event_kernel->lock );
 	this->set = true;
-	enable_interrupts( DEBUG_CTX );
+	enable_interrupts( __cfaabi_dbg_ctx );
 }
 
 void unregister_self( alarm_node_t * this ) {
 	disable_interrupts();
-	lock( event_kernel->lock DEBUG_CTX2 );
+	lock( event_kernel->lock __cfaabi_dbg_ctx2 );
 	{
 		verify( validate( &event_kernel->alarms ) );
@@ -209,5 +207,5 @@
 	}
 	unlock( event_kernel->lock );
-	enable_interrupts( DEBUG_CTX );
+	enable_interrupts( __cfaabi_dbg_ctx );
 	this->set = false;
 }
Index: src/libcfa/concurrency/coroutine.c
===================================================================
--- src/libcfa/concurrency/coroutine.c	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ src/libcfa/concurrency/coroutine.c	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
@@ -29,5 +29,4 @@
 #define __CFA_INVOKE_PRIVATE__
 #include "invoke.h"
-
 
 //-----------------------------------------------------------------------------
@@ -76,5 +75,5 @@
 void ^?{}(coStack_t & this) {
 	if ( ! this.userStack && this.storage ) {
-		LIB_DEBUG_DO(
+		__cfaabi_dbg_debug_do(
 			if ( mprotect( this.storage, pageSize, PROT_READ | PROT_WRITE ) == -1 ) {
 				abortf( "(coStack_t *)%p.^?{}() : internal error, mprotect failure, error(%d) %s.", &this, errno, strerror( errno ) );
@@ -131,8 +130,8 @@
 
 		// assume malloc has 8 byte alignment so add 8 to allow rounding up to 16 byte alignment
-		LIB_DEBUG_DO( this->storage = memalign( pageSize, cxtSize + this->size + pageSize ) );
-		LIB_NO_DEBUG_DO( this->storage = malloc( cxtSize + this->size + 8 ) );
+		__cfaabi_dbg_debug_do( this->storage = memalign( pageSize, cxtSize + this->size + pageSize ) );
+		__cfaabi_dbg_no_debug_do( this->storage = malloc( cxtSize + this->size + 8 ) );
 
-		LIB_DEBUG_DO(
+		__cfaabi_dbg_debug_do(
 			if ( mprotect( this->storage, pageSize, PROT_NONE ) == -1 ) {
 				abortf( "(uMachContext &)%p.createContext() : internal error, mprotect failure, error(%d) %s.", this, (int)errno, strerror( (int)errno ) );
@@ -144,6 +143,6 @@
 		} // if
 
-		LIB_DEBUG_DO( this->limit = (char *)this->storage + pageSize );
-		LIB_NO_DEBUG_DO( this->limit = (char *)libCeiling( (unsigned long)this->storage, 16 ) ); // minimum alignment
+		__cfaabi_dbg_debug_do( this->limit = (char *)this->storage + pageSize );
+		__cfaabi_dbg_no_debug_do( this->limit = (char *)libCeiling( (unsigned long)this->storage, 16 ) ); // minimum alignment
 
 	} else {
Index: src/libcfa/concurrency/invoke.c
===================================================================
--- src/libcfa/concurrency/invoke.c	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ src/libcfa/concurrency/invoke.c	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
@@ -18,5 +18,4 @@
 #include <stdio.h>
 
-#include "libhdr.h"
 #include "invoke.h"
 
@@ -31,70 +30,66 @@
 extern void __leave_thread_monitor( struct thread_desc * this );
 extern void disable_interrupts();
-extern void enable_interrupts( DEBUG_CTX_PARAM );
+extern void enable_interrupts( __cfaabi_dbg_ctx_param );
 
 void CtxInvokeCoroutine(
-      void (*main)(void *),
-      struct coroutine_desc *(*get_coroutine)(void *),
-      void *this
+	void (*main)(void *),
+	struct coroutine_desc *(*get_coroutine)(void *),
+	void *this
 ) {
-      // LIB_DEBUG_PRINTF("Invoke Coroutine : Received %p (main %p, get_c %p)\n", this, main, get_coroutine);
+	struct coroutine_desc* cor = get_coroutine( this );
 
-      struct coroutine_desc* cor = get_coroutine( this );
+	if(cor->state == Primed) {
+		__suspend_internal();
+	}
 
-      if(cor->state == Primed) {
-            __suspend_internal();
-      }
+	cor->state = Active;
 
-      cor->state = Active;
+	main( this );
 
-      main( this );
+	cor->state = Halted;
 
-      cor->state = Halted;
-
-      //Final suspend, should never return
-      __leave_coroutine();
-      abortf("Resumed dead coroutine");
+	//Final suspend, should never return
+	__leave_coroutine();
+	abortf("Resumed dead coroutine");
 }
 
 void CtxInvokeThread(
-      void (*dtor)(void *),
-      void (*main)(void *),
-      struct thread_desc *(*get_thread)(void *),
-      void *this
+	void (*dtor)(void *),
+	void (*main)(void *),
+	struct thread_desc *(*get_thread)(void *),
+	void *this
 ) {
-      // First suspend, once the thread arrives here,
-      // the function pointer to main can be invalidated without risk
-      __suspend_internal();
+	// First suspend, once the thread arrives here,
+	// the function pointer to main can be invalidated without risk
+	__suspend_internal();
 
-      // Fetch the thread handle from the user defined thread structure
-      struct thread_desc* thrd = get_thread( this );
+	// Fetch the thread handle from the user defined thread structure
+	struct thread_desc* thrd = get_thread( this );
 
-      // Officially start the thread by enabling preemption
-      enable_interrupts( DEBUG_CTX );
+	// Officially start the thread by enabling preemption
+	enable_interrupts( __cfaabi_dbg_ctx );
 
-      // Call the main of the thread
-      main( this );
+	// Call the main of the thread
+	main( this );
 
-      // To exit a thread we must :
-      // 1 - Mark it as halted
-      // 2 - Leave its monitor
-      // 3 - Disable the interupts
-      // 4 - Final suspend
-      // The order of these 4 operations is very important
-      //Final suspend, should never return
-      __leave_thread_monitor( thrd );
-      abortf("Resumed dead thread");
+	// To exit a thread we must :
+	// 1 - Mark it as halted
+	// 2 - Leave its monitor
+	// 3 - Disable the interupts
+	// 4 - Final suspend
+	// The order of these 4 operations is very important
+	//Final suspend, should never return
+	__leave_thread_monitor( thrd );
+	abortf("Resumed dead thread");
 }
 
 
 void CtxStart(
-      void (*main)(void *),
-      struct coroutine_desc *(*get_coroutine)(void *),
-      void *this,
-      void (*invoke)(void *)
+	void (*main)(void *),
+	struct coroutine_desc *(*get_coroutine)(void *),
+	void *this,
+	void (*invoke)(void *)
 ) {
-      // LIB_DEBUG_PRINTF("StartCoroutine : Passing in %p (main %p) to invoke (%p) from start (%p)\n", this, main, invoke, CtxStart);
-
-      struct coStack_t* stack = &get_coroutine( this )->stack;
+	struct coStack_t* stack = &get_coroutine( this )->stack;
 
 #if defined( __i386__ )
@@ -103,5 +98,5 @@
 	    void *fixedRegisters[3];		  	// fixed registers ebx, edi, esi (popped on 1st uSwitch, values unimportant)
 	    uint32_t mxcr;                        // SSE Status and Control bits (control bits are preserved across function calls)
-          uint16_t fcw;                         // X97 FPU control word (preserved across function calls)
+	    uint16_t fcw;                         // X97 FPU control word (preserved across function calls)
 	    void *rturn;                          // where to go on return from uSwitch
 	    void *dummyReturn;				// fake return compiler would have pushed on call to uInvoke
@@ -116,28 +111,28 @@
 	((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->argument[0] = this;     // argument to invoke
 	((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->rturn = invoke;
-      ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->mxcr = 0x1F80; //Vol. 2A 3-520
-      ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->fcw = 0x037F;  //Vol. 1 8-7
+	((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->mxcr = 0x1F80; //Vol. 2A 3-520
+	((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->fcw = 0x037F;  //Vol. 1 8-7
 
 #elif defined( __x86_64__ )
 
-      struct FakeStack {
-            void *fixedRegisters[5];            // fixed registers rbx, r12, r13, r14, r15
-            uint32_t mxcr;                      // SSE Status and Control bits (control bits are preserved across function calls)
-            uint16_t fcw;                       // X97 FPU control word (preserved across function calls)
-            void *rturn;                        // where to go on return from uSwitch
-            void *dummyReturn;                  // NULL return address to provide proper alignment
-      };
+	struct FakeStack {
+		void *fixedRegisters[5];            // fixed registers rbx, r12, r13, r14, r15
+		uint32_t mxcr;                      // SSE Status and Control bits (control bits are preserved across function calls)
+		uint16_t fcw;                       // X97 FPU control word (preserved across function calls)
+		void *rturn;                        // where to go on return from uSwitch
+		void *dummyReturn;                  // NULL return address to provide proper alignment
+	};
 
-      ((struct machine_context_t *)stack->context)->SP = (char *)stack->base - sizeof( struct FakeStack );
-      ((struct machine_context_t *)stack->context)->FP = NULL;		// terminate stack with NULL fp
+	((struct machine_context_t *)stack->context)->SP = (char *)stack->base - sizeof( struct FakeStack );
+	((struct machine_context_t *)stack->context)->FP = NULL;		// terminate stack with NULL fp
 
-      ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->dummyReturn = NULL;
-      ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->rturn = CtxInvokeStub;
-      ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->fixedRegisters[0] = this;
-      ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->fixedRegisters[1] = invoke;
-      ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->mxcr = 0x1F80; //Vol. 2A 3-520
-      ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->fcw = 0x037F;  //Vol. 1 8-7
+	((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->dummyReturn = NULL;
+	((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->rturn = CtxInvokeStub;
+	((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->fixedRegisters[0] = this;
+	((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->fixedRegisters[1] = invoke;
+	((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->mxcr = 0x1F80; //Vol. 2A 3-520
+	((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->fcw = 0x037F;  //Vol. 1 8-7
 #else
-      #error Only __i386__ and __x86_64__ is supported for threads in cfa
+	#error Only __i386__ and __x86_64__ is supported for threads in cfa
 #endif
 }
Index: src/libcfa/concurrency/kernel.c
===================================================================
--- src/libcfa/concurrency/kernel.c	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ src/libcfa/concurrency/kernel.c	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
@@ -14,6 +14,4 @@
 //
 
-#include "libhdr.h"
-
 //C Includes
 #include <stddef.h>
@@ -150,5 +148,5 @@
 
 	this.runner = &runner;
-	LIB_DEBUG_PRINT_SAFE("Kernel : constructing main processor context %p\n", &runner);
+	__cfaabi_dbg_print_safe("Kernel : constructing main processor context %p\n", &runner);
 	runner{ &this };
 }
@@ -156,5 +154,5 @@
 void ^?{}(processor & this) {
 	if( ! this.do_terminate ) {
-		LIB_DEBUG_PRINT_SAFE("Kernel : core %p signaling termination\n", &this);
+		__cfaabi_dbg_print_safe("Kernel : core %p signaling termination\n", &this);
 		this.do_terminate = true;
 		P( this.terminated );
@@ -181,5 +179,5 @@
 	processor * this = runner.proc;
 
-	LIB_DEBUG_PRINT_SAFE("Kernel : core %p starting\n", this);
+	__cfaabi_dbg_print_safe("Kernel : core %p starting\n", this);
 
 	{
@@ -187,5 +185,5 @@
 		preemption_scope scope = { this };
 
-		LIB_DEBUG_PRINT_SAFE("Kernel : core %p started\n", this);
+		__cfaabi_dbg_print_safe("Kernel : core %p started\n", this);
 
 		thread_desc * readyThread = NULL;
@@ -213,10 +211,10 @@
 		}
 
-		LIB_DEBUG_PRINT_SAFE("Kernel : core %p stopping\n", this);
+		__cfaabi_dbg_print_safe("Kernel : core %p stopping\n", this);
 	}
 
 	V( this->terminated );
 
-	LIB_DEBUG_PRINT_SAFE("Kernel : core %p terminated\n", this);
+	__cfaabi_dbg_print_safe("Kernel : core %p terminated\n", this);
 }
 
@@ -292,5 +290,5 @@
 	processorCtx_t proc_cor_storage = { proc, &info };
 
-	LIB_DEBUG_PRINT_SAFE("Coroutine : created stack %p\n", proc_cor_storage.__cor.stack.base);
+	__cfaabi_dbg_print_safe("Coroutine : created stack %p\n", proc_cor_storage.__cor.stack.base);
 
 	//Set global state
@@ -299,5 +297,5 @@
 
 	//We now have a proper context from which to schedule threads
-	LIB_DEBUG_PRINT_SAFE("Kernel : core %p created (%p, %p)\n", proc, proc->runner, &ctx);
+	__cfaabi_dbg_print_safe("Kernel : core %p created (%p, %p)\n", proc, proc->runner, &ctx);
 
 	// SKULLDUGGERY: Since the coroutine doesn't have its own stack, we can't
@@ -310,5 +308,5 @@
 
 	// Main routine of the core returned, the core is now fully terminated
-	LIB_DEBUG_PRINT_SAFE("Kernel : core %p main ended (%p)\n", proc, proc->runner);
+	__cfaabi_dbg_print_safe("Kernel : core %p main ended (%p)\n", proc, proc->runner);
 
 	return NULL;
@@ -316,9 +314,9 @@
 
 void start(processor * this) {
-	LIB_DEBUG_PRINT_SAFE("Kernel : Starting core %p\n", this);
+	__cfaabi_dbg_print_safe("Kernel : Starting core %p\n", this);
 
 	pthread_create( &this->kernel_thread, NULL, CtxInvokeProcessor, (void*)this );
 
-	LIB_DEBUG_PRINT_SAFE("Kernel : core %p started\n", this);
+	__cfaabi_dbg_print_safe("Kernel : core %p started\n", this);
 }
 
@@ -334,5 +332,5 @@
 	verifyf( thrd->next == NULL, "Expected null got %p", thrd->next );
 
-	lock(   this_processor->cltr->ready_queue_lock DEBUG_CTX2 );
+	lock(   this_processor->cltr->ready_queue_lock __cfaabi_dbg_ctx2 );
 	append( this_processor->cltr->ready_queue, thrd );
 	unlock( this_processor->cltr->ready_queue_lock );
@@ -343,5 +341,5 @@
 thread_desc * nextThread(cluster * this) {
 	verify( disable_preempt_count > 0 );
-	lock( this->ready_queue_lock DEBUG_CTX2 );
+	lock( this->ready_queue_lock __cfaabi_dbg_ctx2 );
 	thread_desc * head = pop_head( this->ready_queue );
 	unlock( this->ready_queue_lock );
@@ -355,5 +353,5 @@
 	suspend();
 	verify( disable_preempt_count > 0 );
-	enable_interrupts( DEBUG_CTX );
+	enable_interrupts( __cfaabi_dbg_ctx );
 }
 
@@ -367,5 +365,5 @@
 	verify( disable_preempt_count > 0 );
 
-	enable_interrupts( DEBUG_CTX );
+	enable_interrupts( __cfaabi_dbg_ctx );
 }
 
@@ -381,5 +379,5 @@
 	verify( disable_preempt_count > 0 );
 
-	enable_interrupts( DEBUG_CTX );
+	enable_interrupts( __cfaabi_dbg_ctx );
 }
 
@@ -395,5 +393,5 @@
 	verify( disable_preempt_count > 0 );
 
-	enable_interrupts( DEBUG_CTX );
+	enable_interrupts( __cfaabi_dbg_ctx );
 }
 
@@ -408,5 +406,5 @@
 	verify( disable_preempt_count > 0 );
 
-	enable_interrupts( DEBUG_CTX );
+	enable_interrupts( __cfaabi_dbg_ctx );
 }
 
@@ -423,5 +421,5 @@
 	verify( disable_preempt_count > 0 );
 
-	enable_interrupts( DEBUG_CTX );
+	enable_interrupts( __cfaabi_dbg_ctx );
 }
 
@@ -441,5 +439,5 @@
 // Kernel boot procedures
 void kernel_startup(void) {
-	LIB_DEBUG_PRINT_SAFE("Kernel : Starting\n");
+	__cfaabi_dbg_print_safe("Kernel : Starting\n");
 
 	// Start by initializing the main thread
@@ -450,5 +448,5 @@
 	(*mainThread){ &info };
 
-	LIB_DEBUG_PRINT_SAFE("Kernel : Main thread ready\n");
+	__cfaabi_dbg_print_safe("Kernel : Main thread ready\n");
 
 	// Initialize the main cluster
@@ -456,5 +454,5 @@
 	(*mainCluster){};
 
-	LIB_DEBUG_PRINT_SAFE("Kernel : main cluster ready\n");
+	__cfaabi_dbg_print_safe("Kernel : main cluster ready\n");
 
 	// Initialize the main processor and the main processor ctx
@@ -483,11 +481,11 @@
 
 	// THE SYSTEM IS NOW COMPLETELY RUNNING
-	LIB_DEBUG_PRINT_SAFE("Kernel : Started\n--------------------------------------------------\n\n");
-
-	enable_interrupts( DEBUG_CTX );
+	__cfaabi_dbg_print_safe("Kernel : Started\n--------------------------------------------------\n\n");
+
+	enable_interrupts( __cfaabi_dbg_ctx );
 }
 
 void kernel_shutdown(void) {
-	LIB_DEBUG_PRINT_SAFE("\n--------------------------------------------------\nKernel : Shutting down\n");
+	__cfaabi_dbg_print_safe("\n--------------------------------------------------\nKernel : Shutting down\n");
 
 	disable_interrupts();
@@ -513,5 +511,5 @@
 	^(mainThread){};
 
-	LIB_DEBUG_PRINT_SAFE("Kernel : Shutdown complete\n");
+	__cfaabi_dbg_print_safe("Kernel : Shutdown complete\n");
 }
 
@@ -523,5 +521,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 DEBUG_CTX2 );
+	lock( kernel_abort_lock __cfaabi_dbg_ctx2 );
 
 	// first task to abort ?
@@ -548,21 +546,21 @@
 
 	int len = snprintf( abort_text, abort_text_size, "Error occurred while executing task %.256s (%p)", thrd->self_cor.name, thrd );
-	__lib_debug_write( abort_text, len );
+	__cfaabi_dbg_bits_write( abort_text, len );
 
 	if ( thrd != this_coroutine ) {
 		len = snprintf( abort_text, abort_text_size, " in coroutine %.256s (%p).\n", this_coroutine->name, this_coroutine );
-		__lib_debug_write( abort_text, len );
+		__cfaabi_dbg_bits_write( abort_text, len );
 	}
 	else {
-		__lib_debug_write( ".\n", 2 );
+		__cfaabi_dbg_bits_write( ".\n", 2 );
 	}
 }
 
 extern "C" {
-	void __lib_debug_acquire() {
-		lock( kernel_debug_lock DEBUG_CTX2 );
-	}
-
-	void __lib_debug_release() {
+	void __cfaabi_dbg_bits_acquire() {
+		lock( kernel_debug_lock __cfaabi_dbg_ctx2 );
+	}
+
+	void __cfaabi_dbg_bits_release() {
 		unlock( kernel_debug_lock );
 	}
@@ -582,5 +580,5 @@
 
 void P(semaphore & this) {
-	lock( this.lock DEBUG_CTX2 );
+	lock( this.lock __cfaabi_dbg_ctx2 );
 	this.count -= 1;
 	if ( this.count < 0 ) {
@@ -598,5 +596,5 @@
 void V(semaphore & this) {
 	thread_desc * thrd = NULL;
-	lock( this.lock DEBUG_CTX2 );
+	lock( this.lock __cfaabi_dbg_ctx2 );
 	this.count += 1;
 	if ( this.count <= 0 ) {
Index: src/libcfa/concurrency/kernel_private.h
===================================================================
--- src/libcfa/concurrency/kernel_private.h	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ src/libcfa/concurrency/kernel_private.h	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
@@ -16,6 +16,4 @@
 #pragma once
 
-#include "libhdr.h"
-
 #include "kernel"
 #include "thread"
@@ -30,5 +28,5 @@
 	void disable_interrupts();
 	void enable_interrupts_noPoll();
-	void enable_interrupts( DEBUG_CTX_PARAM );
+	void enable_interrupts( __cfaabi_dbg_ctx_param );
 }
 
@@ -39,5 +37,5 @@
 	disable_interrupts();
 	ScheduleThread( thrd );
-	enable_interrupts( DEBUG_CTX );
+	enable_interrupts( __cfaabi_dbg_ctx );
 }
 thread_desc * nextThread(cluster * this);
Index: src/libcfa/concurrency/monitor.c
===================================================================
--- src/libcfa/concurrency/monitor.c	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ src/libcfa/concurrency/monitor.c	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
@@ -19,5 +19,4 @@
 #include <inttypes.h>
 
-#include "libhdr.h"
 #include "kernel_private.h"
 
@@ -91,8 +90,8 @@
 	static void __enter_monitor_desc( monitor_desc * this, const __monitor_group_t & group ) {
 		// Lock the monitor spinlock
-		DO_LOCK( this->lock DEBUG_CTX2 );
+		DO_LOCK( this->lock __cfaabi_dbg_ctx2 );
 		thread_desc * thrd = this_thread;
 
-		LIB_DEBUG_PRINT_SAFE("Kernel : %10p Entering mon %p (%p)\n", thrd, this, this->owner);
+		__cfaabi_dbg_print_safe("Kernel : %10p Entering mon %p (%p)\n", thrd, this, this->owner);
 
 		if( !this->owner ) {
@@ -100,5 +99,5 @@
 			set_owner( this, thrd );
 
-			LIB_DEBUG_PRINT_SAFE("Kernel :  mon is free \n");
+			__cfaabi_dbg_print_safe("Kernel :  mon is free \n");
 		}
 		else if( this->owner == thrd) {
@@ -106,5 +105,5 @@
 			this->recursion += 1;
 
-			LIB_DEBUG_PRINT_SAFE("Kernel :  mon already owned \n");
+			__cfaabi_dbg_print_safe("Kernel :  mon already owned \n");
 		}
 		else if( is_accepted( this, group) ) {
@@ -115,8 +114,8 @@
 			reset_mask( this );
 
-			LIB_DEBUG_PRINT_SAFE("Kernel :  mon accepts \n");
+			__cfaabi_dbg_print_safe("Kernel :  mon accepts \n");
 		}
 		else {
-			LIB_DEBUG_PRINT_SAFE("Kernel :  blocking \n");
+			__cfaabi_dbg_print_safe("Kernel :  blocking \n");
 
 			// Some one else has the monitor, wait in line for it
@@ -124,5 +123,5 @@
 			BlockInternal( &this->lock );
 
-			LIB_DEBUG_PRINT_SAFE("Kernel : %10p Entered  mon %p\n", thrd, this);
+			__cfaabi_dbg_print_safe("Kernel : %10p Entered  mon %p\n", thrd, this);
 
 			// BlockInternal will unlock spinlock, no need to unlock ourselves
@@ -130,5 +129,5 @@
 		}
 
-		LIB_DEBUG_PRINT_SAFE("Kernel : %10p Entered  mon %p\n", thrd, this);
+		__cfaabi_dbg_print_safe("Kernel : %10p Entered  mon %p\n", thrd, this);
 
 		// Release the lock and leave
@@ -139,12 +138,12 @@
 	static void __enter_monitor_dtor( monitor_desc * this, fptr_t func ) {
 		// Lock the monitor spinlock
-		DO_LOCK( this->lock DEBUG_CTX2 );
+		DO_LOCK( this->lock __cfaabi_dbg_ctx2 );
 		thread_desc * thrd = this_thread;
 
-		LIB_DEBUG_PRINT_SAFE("Kernel : %10p Entering dtor for mon %p (%p)\n", thrd, this, this->owner);
+		__cfaabi_dbg_print_safe("Kernel : %10p Entering dtor for mon %p (%p)\n", thrd, this, this->owner);
 
 
 		if( !this->owner ) {
-			LIB_DEBUG_PRINT_SAFE("Kernel : Destroying free mon %p\n", this);
+			__cfaabi_dbg_print_safe("Kernel : Destroying free mon %p\n", this);
 
 			// No one has the monitor, just take it
@@ -164,5 +163,5 @@
 		__monitor_group_t group = { &this, 1, func };
 		if( is_accepted( this, group) ) {
-			LIB_DEBUG_PRINT_SAFE("Kernel :  mon accepts dtor, block and signal it \n");
+			__cfaabi_dbg_print_safe("Kernel :  mon accepts dtor, block and signal it \n");
 
 			// Wake the thread that is waiting for this
@@ -183,5 +182,5 @@
 		}
 		else {
-			LIB_DEBUG_PRINT_SAFE("Kernel :  blocking \n");
+			__cfaabi_dbg_print_safe("Kernel :  blocking \n");
 
 			wait_ctx( this_thread, 0 )
@@ -196,5 +195,5 @@
 		}
 
-		LIB_DEBUG_PRINT_SAFE("Kernel : Destroying %p\n", this);
+		__cfaabi_dbg_print_safe("Kernel : Destroying %p\n", this);
 
 	}
@@ -203,7 +202,7 @@
 	void __leave_monitor_desc( monitor_desc * this ) {
 		// Lock the monitor spinlock, DO_LOCK to reduce contention
-		DO_LOCK( this->lock DEBUG_CTX2 );
-
-		LIB_DEBUG_PRINT_SAFE("Kernel : %10p Leaving mon %p (%p)\n", this_thread, this, this->owner);
+		DO_LOCK( this->lock __cfaabi_dbg_ctx2 );
+
+		__cfaabi_dbg_print_safe("Kernel : %10p Leaving mon %p (%p)\n", this_thread, this, this->owner);
 
 		verifyf( this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", this_thread, this->owner, this->recursion, this );
@@ -215,5 +214,5 @@
 		// it means we don't need to do anything
 		if( this->recursion != 0) {
-			LIB_DEBUG_PRINT_SAFE("Kernel :  recursion still %d\n", this->recursion);
+			__cfaabi_dbg_print_safe("Kernel :  recursion still %d\n", this->recursion);
 			unlock( this->lock );
 			return;
@@ -232,5 +231,5 @@
 	// Leave single monitor for the last time
 	void __leave_dtor_monitor_desc( monitor_desc * this ) {
-		LIB_DEBUG_DO(
+		__cfaabi_dbg_debug_do(
 			if( this_thread != this->owner ) {
 				abortf("Destroyed monitor %p has inconsistent owner, expected %p got %p.\n", this, this_thread, this->owner);
@@ -249,5 +248,5 @@
 
 		// Lock the monitor now
-		DO_LOCK( this->lock DEBUG_CTX2 );
+		DO_LOCK( this->lock __cfaabi_dbg_ctx2 );
 
 		disable_interrupts();
@@ -308,5 +307,5 @@
 	(this_thread->monitors){m, count, func};
 
-	// LIB_DEBUG_PRINT_SAFE("MGUARD : enter %d\n", count);
+	// __cfaabi_dbg_print_safe("MGUARD : enter %d\n", count);
 
 	// Enter the monitors in order
@@ -314,5 +313,5 @@
 	enter( group );
 
-	// LIB_DEBUG_PRINT_SAFE("MGUARD : entered\n");
+	// __cfaabi_dbg_print_safe("MGUARD : entered\n");
 }
 
@@ -320,10 +319,10 @@
 // Dtor for monitor guard
 void ^?{}( monitor_guard_t & this ) {
-	// LIB_DEBUG_PRINT_SAFE("MGUARD : leaving %d\n", this.count);
+	// __cfaabi_dbg_print_safe("MGUARD : leaving %d\n", this.count);
 
 	// Leave the monitors in order
 	leave( this.m, this.count );
 
-	// LIB_DEBUG_PRINT_SAFE("MGUARD : left\n");
+	// __cfaabi_dbg_print_safe("MGUARD : left\n");
 
 	// Restore thread context
@@ -430,5 +429,5 @@
 
 	//Some more checking in debug
-	LIB_DEBUG_DO(
+	__cfaabi_dbg_debug_do(
 		thread_desc * this_thrd = this_thread;
 		if ( this.monitor_count != this_thrd->monitors.size ) {
@@ -487,5 +486,5 @@
 	set_owner( monitors, count, signallee );
 
-	LIB_DEBUG_PRINT_BUFFER_DECL( "Kernel : signal_block condition %p (s: %p)\n", &this, signallee );
+	__cfaabi_dbg_print_buffer_decl( "Kernel : signal_block condition %p (s: %p)\n", &this, signallee );
 
 	//Everything is ready to go to sleep
@@ -496,5 +495,5 @@
 
 
-	LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel :   signal_block returned\n" );
+	__cfaabi_dbg_print_buffer_local( "Kernel :   signal_block returned\n" );
 
 	//We are back, restore the masks and recursions
@@ -535,9 +534,9 @@
 	__lock_size_t actual_count = aggregate( mon_storage, mask );
 
-	LIB_DEBUG_PRINT_BUFFER_DECL( "Kernel : waitfor %d (s: %d, m: %d)\n", actual_count, mask.size, (__lock_size_t)max);
+	__cfaabi_dbg_print_buffer_decl( "Kernel : waitfor %d (s: %d, m: %d)\n", actual_count, mask.size, (__lock_size_t)max);
 
 	if(actual_count == 0) return;
 
-	LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : waitfor internal proceeding\n");
+	__cfaabi_dbg_print_buffer_local( "Kernel : waitfor internal proceeding\n");
 
 	// Create storage for monitor context
@@ -556,5 +555,5 @@
 			__acceptable_t& accepted = mask[index];
 			if( accepted.is_dtor ) {
-				LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : dtor already there\n");
+				__cfaabi_dbg_print_buffer_local( "Kernel : dtor already there\n");
 				verifyf( accepted.size == 1,  "ERROR: Accepted dtor has more than 1 mutex parameter." );
 
@@ -568,5 +567,5 @@
 			}
 			else {
-				LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : thread present, baton-passing\n");
+				__cfaabi_dbg_print_buffer_local( "Kernel : thread present, baton-passing\n");
 
 				// Create the node specific to this wait operation
@@ -576,11 +575,11 @@
 				monitor_save;
 
-				LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel :  baton of %d monitors : ", count );
+				__cfaabi_dbg_print_buffer_local( "Kernel :  baton of %d monitors : ", count );
 				#ifdef __CFA_DEBUG_PRINT__
 					for( int i = 0; i < count; i++) {
-						LIB_DEBUG_PRINT_BUFFER_LOCAL( "%p %p ", monitors[i], monitors[i]->signal_stack.top );
+						__cfaabi_dbg_print_buffer_local( "%p %p ", monitors[i], monitors[i]->signal_stack.top );
 					}
 				#endif
-				LIB_DEBUG_PRINT_BUFFER_LOCAL( "\n");
+				__cfaabi_dbg_print_buffer_local( "\n");
 
 				// Set the owners to be the next thread
@@ -593,8 +592,8 @@
 				monitor_restore;
 
-				LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : thread present, returned\n");
+				__cfaabi_dbg_print_buffer_local( "Kernel : thread present, returned\n");
 			}
 
-			LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : accepted %d\n", *mask.accepted);
+			__cfaabi_dbg_print_buffer_local( "Kernel : accepted %d\n", *mask.accepted);
 			return;
 		}
@@ -603,9 +602,9 @@
 
 	if( duration == 0 ) {
-		LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : non-blocking, exiting\n");
+		__cfaabi_dbg_print_buffer_local( "Kernel : non-blocking, exiting\n");
 
 		unlock_all( locks, count );
 
-		LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : accepted %d\n", *mask.accepted);
+		__cfaabi_dbg_print_buffer_local( "Kernel : accepted %d\n", *mask.accepted);
 		return;
 	}
@@ -614,5 +613,5 @@
 	verifyf( duration < 0, "Timeout on waitfor statments not supported yet.");
 
-	LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : blocking waitfor\n");
+	__cfaabi_dbg_print_buffer_local( "Kernel : blocking waitfor\n");
 
 	// Create the node specific to this wait operation
@@ -636,7 +635,7 @@
 	monitor_restore;
 
-	LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : exiting\n");
-
-	LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : accepted %d\n", *mask.accepted);
+	__cfaabi_dbg_print_buffer_local( "Kernel : exiting\n");
+
+	__cfaabi_dbg_print_buffer_local( "Kernel : accepted %d\n", *mask.accepted);
 }
 
@@ -645,5 +644,5 @@
 
 static inline void set_owner( monitor_desc * this, thread_desc * owner ) {
-	// LIB_DEBUG_PRINT_SAFE("Kernal :   Setting owner of %p to %p ( was %p)\n", this, owner, this->owner );
+	// __cfaabi_dbg_print_safe("Kernal :   Setting owner of %p to %p ( was %p)\n", this, owner, this->owner );
 
 	//Pass the monitor appropriately
@@ -677,5 +676,5 @@
 static inline thread_desc * next_thread( monitor_desc * this ) {
 	//Check the signaller stack
-	LIB_DEBUG_PRINT_SAFE("Kernel :  mon %p AS-stack top %p\n", this, this->signal_stack.top);
+	__cfaabi_dbg_print_safe("Kernel :  mon %p AS-stack top %p\n", this, this->signal_stack.top);
 	__condition_criterion_t * urgent = pop( this->signal_stack );
 	if( urgent ) {
@@ -729,5 +728,5 @@
 	for( __lock_size_t i = 0; i < count; i++) {
 		(criteria[i]){ monitors[i], waiter };
-		LIB_DEBUG_PRINT_SAFE( "Kernel :  target %p = %p\n", criteria[i].target, &criteria[i] );
+		__cfaabi_dbg_print_safe( "Kernel :  target %p = %p\n", criteria[i].target, &criteria[i] );
 		push( criteria[i].target->signal_stack, &criteria[i] );
 	}
@@ -738,5 +737,5 @@
 static inline void lock_all( __spinlock_t * locks [], __lock_size_t count ) {
 	for( __lock_size_t i = 0; i < count; i++ ) {
-		DO_LOCK( *locks[i] DEBUG_CTX2 );
+		DO_LOCK( *locks[i] __cfaabi_dbg_ctx2 );
 	}
 }
@@ -745,5 +744,5 @@
 	for( __lock_size_t i = 0; i < count; i++ ) {
 		__spinlock_t * l = &source[i]->lock;
-		DO_LOCK( *l DEBUG_CTX2 );
+		DO_LOCK( *l __cfaabi_dbg_ctx2 );
 		if(locks) locks[i] = l;
 	}
@@ -803,8 +802,8 @@
 	for(	int i = 0; i < count; i++ ) {
 
-		// LIB_DEBUG_PRINT_SAFE( "Checking %p for %p\n", &criteria[i], target );
+		// __cfaabi_dbg_print_safe( "Checking %p for %p\n", &criteria[i], target );
 		if( &criteria[i] == target ) {
 			criteria[i].ready = true;
-			// LIB_DEBUG_PRINT_SAFE( "True\n" );
+			// __cfaabi_dbg_print_safe( "True\n" );
 		}
 
@@ -812,5 +811,5 @@
 	}
 
-	LIB_DEBUG_PRINT_SAFE( "Kernel :  Runing %i (%p)\n", ready2run, ready2run ? node->waiting_thread : NULL );
+	__cfaabi_dbg_print_safe( "Kernel :  Runing %i (%p)\n", ready2run, ready2run ? node->waiting_thread : NULL );
 	return ready2run ? node->waiting_thread : NULL;
 }
@@ -819,5 +818,5 @@
 	thread_desc * thrd = this_thread;
 	if( !this.monitors ) {
-		// LIB_DEBUG_PRINT_SAFE("Branding\n");
+		// __cfaabi_dbg_print_safe("Branding\n");
 		assertf( thrd->monitors.data != NULL, "No current monitor to brand condition %p", thrd->monitors.data );
 		this.monitor_count = thrd->monitors.size;
Index: src/libcfa/concurrency/preemption.c
===================================================================
--- src/libcfa/concurrency/preemption.c	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ src/libcfa/concurrency/preemption.c	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
@@ -14,5 +14,4 @@
 //
 
-#include "libhdr.h"
 #include "preemption.h"
 
@@ -148,5 +147,5 @@
 //=============================================================================================
 
-LIB_DEBUG_DO( static thread_local void * last_interrupt = 0; )
+__cfaabi_dbg_debug_do( static thread_local void * last_interrupt = 0; )
 
 extern "C" {
@@ -159,5 +158,5 @@
 	// Enable interrupts by decrementing the counter
 	// If counter reaches 0, execute any pending CtxSwitch
-	void enable_interrupts( DEBUG_CTX_PARAM ) {
+	void enable_interrupts( __cfaabi_dbg_ctx_param ) {
 		processor * proc   = this_processor;      // Cache the processor now since interrupts can start happening after the atomic add
 		thread_desc * thrd = this_thread;         // Cache the thread now since interrupts can start happening after the atomic add
@@ -173,5 +172,5 @@
 
 		// For debugging purposes : keep track of the last person to enable the interrupts
-		LIB_DEBUG_DO( proc->last_enable = caller; )
+		__cfaabi_dbg_debug_do( proc->last_enable = caller; )
 	}
 
@@ -233,5 +232,5 @@
 // Called from kernel_startup
 void kernel_start_preemption() {
-	LIB_DEBUG_PRINT_SAFE("Kernel : Starting preemption\n");
+	__cfaabi_dbg_print_safe("Kernel : Starting preemption\n");
 
 	// Start with preemption disabled until ready
@@ -255,5 +254,5 @@
 // Called from kernel_shutdown
 void kernel_stop_preemption() {
-	LIB_DEBUG_PRINT_SAFE("Kernel : Preemption stopping\n");
+	__cfaabi_dbg_print_safe("Kernel : Preemption stopping\n");
 
 	// Block all signals since we are already shutting down
@@ -271,5 +270,5 @@
 	// Preemption is now fully stopped
 
-	LIB_DEBUG_PRINT_SAFE("Kernel : Preemption stopped\n");
+	__cfaabi_dbg_print_safe("Kernel : Preemption stopped\n");
 }
 
@@ -297,5 +296,5 @@
 // Receives SIGUSR1 signal and causes the current thread to yield
 void sigHandler_ctxSwitch( __CFA_SIGPARMS__ ) {
-	LIB_DEBUG_DO( last_interrupt = (void *)(cxt->uc_mcontext.gregs[CFA_REG_IP]); )
+	__cfaabi_dbg_debug_do( last_interrupt = (void *)(cxt->uc_mcontext.gregs[CFA_REG_IP]); )
 
 	// Check if it is safe to preempt here
@@ -346,5 +345,5 @@
 		assertf(sig == SIGALRM, "Kernel Internal Error, sigwait: Unexpected signal %d (%d : %d)\n", sig, info.si_code, info.si_value.sival_int);
 
-		// LIB_DEBUG_PRINT_SAFE("Kernel : Caught alarm from %d with %d\n", info.si_code, info.si_value.sival_int );
+		// __cfaabi_dbg_print_safe("Kernel : Caught alarm from %d with %d\n", info.si_code, info.si_value.sival_int );
 		// Switch on the code (a.k.a. the sender) to
 		switch( info.si_code )
@@ -354,6 +353,6 @@
 		case SI_TIMER:
 		case SI_KERNEL:
-			// LIB_DEBUG_PRINT_SAFE("Kernel : Preemption thread tick\n");
-			lock( event_kernel->lock DEBUG_CTX2 );
+			// __cfaabi_dbg_print_safe("Kernel : Preemption thread tick\n");
+			lock( event_kernel->lock __cfaabi_dbg_ctx2 );
 			tick_preemption();
 			unlock( event_kernel->lock );
@@ -368,5 +367,5 @@
 
 EXIT:
-	LIB_DEBUG_PRINT_SAFE("Kernel : Preemption thread stopping\n");
+	__cfaabi_dbg_print_safe("Kernel : Preemption thread stopping\n");
 	return NULL;
 }
@@ -380,5 +379,5 @@
 
 	if ( sigaction( sig, &act, NULL ) == -1 ) {
-		LIB_DEBUG_PRINT_BUFFER_DECL(
+		__cfaabi_dbg_print_buffer_decl(
 			" __kernel_sigaction( sig:%d, handler:%p, flags:%d ), problem installing signal handler, error(%d) %s.\n",
 			sig, handler, flags, errno, strerror( errno )
@@ -397,5 +396,5 @@
 
 	if ( sigaction( sig, &act, NULL ) == -1 ) {
-		LIB_DEBUG_PRINT_BUFFER_DECL(
+		__cfaabi_dbg_print_buffer_decl(
 			" __kernel_sigdefault( sig:%d ), problem reseting signal handler, error(%d) %s.\n",
 			sig, errno, strerror( errno )
@@ -409,5 +408,5 @@
 //=============================================================================================
 
-LIB_DEBUG_DO(
+__cfaabi_dbg_debug_do(
 	static void __kernel_backtrace( int start ) {
 		// skip first N stack frames
@@ -476,5 +475,5 @@
 
 // void sigHandler_segv( __CFA_SIGPARMS__ ) {
-// 	LIB_DEBUG_DO(
+// 	__cfaabi_dbg_debug_do(
 // 		#ifdef __USE_STREAM__
 // 		serr 	| "*CFA runtime error* program cfa-cpp terminated with"
@@ -493,5 +492,5 @@
 // void sigHandler_abort( __CFA_SIGPARMS__ ) {
 // 	// skip first 6 stack frames
-// 	LIB_DEBUG_DO( __kernel_backtrace( 6 ); )
+// 	__cfaabi_dbg_debug_do( __kernel_backtrace( 6 ); )
 
 // 	// reset default signal handler
Index: src/libcfa/concurrency/thread.c
===================================================================
--- src/libcfa/concurrency/thread.c	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ src/libcfa/concurrency/thread.c	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
@@ -17,5 +17,4 @@
 
 #include "kernel_private.h"
-#include "libhdr.h"
 
 #define __CFA_INVOKE_PRIVATE__
@@ -72,5 +71,5 @@
 	thrd_c->last = this_coroutine;
 
-	// LIB_DEBUG_PRINT_SAFE("Thread start : %p (t %p, c %p)\n", this, thrd_c, thrd_h);
+	// __cfaabi_dbg_print_safe("Thread start : %p (t %p, c %p)\n", this, thrd_c, thrd_h);
 
 	disable_interrupts();
@@ -82,5 +81,5 @@
 
 	ScheduleThread(thrd_h);
-	enable_interrupts( DEBUG_CTX );
+	enable_interrupts( __cfaabi_dbg_ctx );
 }
 
Index: src/libcfa/exception.c
===================================================================
--- src/libcfa/exception.c	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ src/libcfa/exception.c	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
@@ -23,5 +23,5 @@
 #include <stdio.h>
 #include <unwind.h>
-#include <libhdr/libdebug.h>
+#include <bits/debug.h>
 
 // FIX ME: temporary hack to keep ARM build working
@@ -37,6 +37,6 @@
 
 // Base exception vtable is abstract, you should not have base exceptions.
-struct __cfaehm__base_exception_t_vtable
-		___cfaehm__base_exception_t_vtable_instance = {
+struct __cfaabi_ehm__base_exception_t_vtable
+		___cfaabi_ehm__base_exception_t_vtable_instance = {
 	.parent = NULL,
 	.size = 0,
@@ -49,6 +49,6 @@
 // Temperary global exception context. Does not work with concurency.
 struct exception_context_t {
-    struct __cfaehm__try_resume_node * top_resume;
-    struct __cfaehm__try_resume_node * current_resume;
+    struct __cfaabi_ehm__try_resume_node * top_resume;
+    struct __cfaabi_ehm__try_resume_node * current_resume;
 
     exception * current_exception;
@@ -78,10 +78,10 @@
 // RESUMPTION ================================================================
 
-void __cfaehm__throw_resume(exception * except) {
-
-	LIB_DEBUG_PRINT_SAFE("Throwing resumption exception\n");
-
-	struct __cfaehm__try_resume_node * original_head = shared_stack.current_resume;
-	struct __cfaehm__try_resume_node * current =
+void __cfaabi_ehm__throw_resume(exception * except) {
+
+	__cfaabi_dbg_print_safe("Throwing resumption exception\n");
+
+	struct __cfaabi_ehm__try_resume_node * original_head = shared_stack.current_resume;
+	struct __cfaabi_ehm__try_resume_node * current =
 		(original_head) ? original_head->next : shared_stack.top_resume;
 
@@ -94,9 +94,9 @@
 	}
 
-	LIB_DEBUG_PRINT_SAFE("Unhandled exception\n");
+	__cfaabi_dbg_print_safe("Unhandled exception\n");
 	shared_stack.current_resume = original_head;
 
 	// Fall back to termination:
-	__cfaehm__throw_terminate(except);
+	__cfaabi_ehm__throw_terminate(except);
 	// TODO: Default handler for resumption.
 }
@@ -105,5 +105,5 @@
 // hook has to be added after the node is built but before it is made the top node.
 
-void __cfaehm__try_resume_setup(struct __cfaehm__try_resume_node * node,
+void __cfaabi_ehm__try_resume_setup(struct __cfaabi_ehm__try_resume_node * node,
                         _Bool (*handler)(exception * except)) {
 	node->next = shared_stack.top_resume;
@@ -112,5 +112,5 @@
 }
 
-void __cfaehm__try_resume_cleanup(struct __cfaehm__try_resume_node * node) {
+void __cfaabi_ehm__try_resume_cleanup(struct __cfaabi_ehm__try_resume_node * node) {
 	shared_stack.top_resume = node->next;
 }
@@ -122,18 +122,18 @@
 // May have to move to cfa for constructors and destructors (references).
 
-struct __cfaehm__node {
-	struct __cfaehm__node * next;
+struct __cfaabi_ehm__node {
+	struct __cfaabi_ehm__node * next;
 };
 
 #define NODE_TO_EXCEPT(node) ((exception *)(1 + (node)))
-#define EXCEPT_TO_NODE(except) ((struct __cfaehm__node *)(except) - 1)
+#define EXCEPT_TO_NODE(except) ((struct __cfaabi_ehm__node *)(except) - 1)
 
 // Creates a copy of the indicated exception and sets current_exception to it.
-static void __cfaehm__allocate_exception( exception * except ) {
+static void __cfaabi_ehm__allocate_exception( exception * except ) {
 	struct exception_context_t * context = this_exception_context();
 
 	// Allocate memory for the exception.
-	struct __cfaehm__node * store = malloc(
-		sizeof( struct __cfaehm__node ) + except->virtual_table->size );
+	struct __cfaabi_ehm__node * store = malloc(
+		sizeof( struct __cfaabi_ehm__node ) + except->virtual_table->size );
 
 	if ( ! store ) {
@@ -151,12 +151,12 @@
 
 // Delete the provided exception, unsetting current_exception if relivant.
-static void __cfaehm__delete_exception( exception * except ) {
+static void __cfaabi_ehm__delete_exception( exception * except ) {
 	struct exception_context_t * context = this_exception_context();
 
-	LIB_DEBUG_PRINT_SAFE("Deleting Exception\n");
+	__cfaabi_dbg_print_safe("Deleting Exception\n");
 
 	// Remove the exception from the list.
-	struct __cfaehm__node * to_free = EXCEPT_TO_NODE(except);
-	struct __cfaehm__node * node;
+	struct __cfaabi_ehm__node * to_free = EXCEPT_TO_NODE(except);
+	struct __cfaabi_ehm__node * node;
 
 	if ( context->current_exception == except ) {
@@ -178,6 +178,6 @@
 
 // If this isn't a rethrow (*except==0), delete the provided exception.
-void __cfaehm__cleanup_terminate( void * except ) {
-	if ( *(void**)except ) __cfaehm__delete_exception( *(exception**)except );
+void __cfaabi_ehm__cleanup_terminate( void * except ) {
+	if ( *(void**)except ) __cfaabi_ehm__delete_exception( *(exception**)except );
 }
 
@@ -202,5 +202,5 @@
 
 // The exception that is being thrown must already be stored.
-__attribute__((noreturn)) void __cfaehm__begin_unwind(void) {
+__attribute__((noreturn)) void __cfaabi_ehm__begin_unwind(void) {
 	if ( ! this_exception_context()->current_exception ) {
 		printf("UNWIND ERROR missing exception in begin unwind\n");
@@ -233,15 +233,15 @@
 }
 
-void __cfaehm__throw_terminate( exception * val ) {
-	LIB_DEBUG_PRINT_SAFE("Throwing termination exception\n");
-
-	__cfaehm__allocate_exception( val );
-	__cfaehm__begin_unwind();
-}
-
-void __cfaehm__rethrow_terminate(void) {
-	LIB_DEBUG_PRINT_SAFE("Rethrowing termination exception\n");
-
-	__cfaehm__begin_unwind();
+void __cfaabi_ehm__throw_terminate( exception * val ) {
+	__cfaabi_dbg_print_safe("Throwing termination exception\n");
+
+	__cfaabi_ehm__allocate_exception( val );
+	__cfaabi_ehm__begin_unwind();
+}
+
+void __cfaabi_ehm__rethrow_terminate(void) {
+	__cfaabi_dbg_print_safe("Rethrowing termination exception\n");
+
+	__cfaabi_ehm__begin_unwind();
 }
 
@@ -254,6 +254,6 @@
 {
 
-	//LIB_DEBUG_PRINT_SAFE("CFA: 0x%lx\n", _Unwind_GetCFA(context));
-	LIB_DEBUG_PRINT_SAFE("Personality function (%d, %x, %llu, %p, %p):", version, actions, exceptionClass, unwind_exception, context);
+	//__cfaabi_dbg_print_safe("CFA: 0x%lx\n", _Unwind_GetCFA(context));
+	__cfaabi_dbg_print_safe("Personality function (%d, %x, %llu, %p, %p):", version, actions, exceptionClass, unwind_exception, context);
 
 	// If we've reached the end of the stack then there is nothing much we can do...
@@ -261,8 +261,8 @@
 
 	if (actions & _UA_SEARCH_PHASE) {
-		LIB_DEBUG_PRINT_SAFE(" lookup phase");
+		__cfaabi_dbg_print_safe(" lookup phase");
 	}
 	else if (actions & _UA_CLEANUP_PHASE) {
-		LIB_DEBUG_PRINT_SAFE(" cleanup phase");
+		__cfaabi_dbg_print_safe(" cleanup phase");
 	}
 	// Just in case, probably can't actually happen
@@ -307,5 +307,5 @@
 			void * ep = (void*)lsd_info.Start + callsite_start + callsite_len;
 			void * ip = (void*)instruction_ptr;
-			LIB_DEBUG_PRINT_SAFE("\nfound %p - %p (%p, %p, %p), looking for %p\n", bp, ep, ls, cs, cl, ip);
+			__cfaabi_dbg_print_safe("\nfound %p - %p (%p, %p, %p), looking for %p\n", bp, ep, ls, cs, cl, ip);
 #endif // __CFA_DEBUG_PRINT__
 			continue;
@@ -346,5 +346,5 @@
 
 					// Get a function pointer from the relative offset and call it
-					// _Unwind_Reason_Code (*matcher)() = (_Unwind_Reason_Code (*)())lsd_info.LPStart + imatcher;					
+					// _Unwind_Reason_Code (*matcher)() = (_Unwind_Reason_Code (*)())lsd_info.LPStart + imatcher;
 
 					_Unwind_Reason_Code (*matcher)(exception *) =
@@ -357,7 +357,7 @@
 					// Based on the return value, check if we matched the exception
 					if( ret == _URC_HANDLER_FOUND) {
-						LIB_DEBUG_PRINT_SAFE(" handler found\n");
+						__cfaabi_dbg_print_safe(" handler found\n");
 					} else {
-						LIB_DEBUG_PRINT_SAFE(" no handler\n");
+						__cfaabi_dbg_print_safe(" no handler\n");
 					}
 					return ret;
@@ -365,5 +365,5 @@
 
 				// This is only a cleanup handler, ignore it
-				LIB_DEBUG_PRINT_SAFE(" no action");
+				__cfaabi_dbg_print_safe(" no action");
 			}
 			else if (actions & _UA_CLEANUP_PHASE) {
@@ -385,5 +385,5 @@
 				_Unwind_SetIP( context, ((lsd_info.LPStart) + (callsite_landing_pad)) );
 
-				LIB_DEBUG_PRINT_SAFE(" action\n");
+				__cfaabi_dbg_print_safe(" action\n");
 
 				// Return have some action to run
@@ -393,11 +393,11 @@
 
 		// Nothing to do, move along
-		LIB_DEBUG_PRINT_SAFE(" no landing pad");
+		__cfaabi_dbg_print_safe(" no landing pad");
 	}
 	// No handling found
-	LIB_DEBUG_PRINT_SAFE(" table end reached\n");
+	__cfaabi_dbg_print_safe(" table end reached\n");
 
 	UNWIND:
-	LIB_DEBUG_PRINT_SAFE(" unwind\n");
+	__cfaabi_dbg_print_safe(" unwind\n");
 
 	// Keep unwinding the stack
@@ -408,5 +408,5 @@
 // libcfa but there is one problem left, see the exception table for details
 __attribute__((noinline))
-void __cfaehm__try_terminate(void (*try_block)(),
+void __cfaabi_ehm__try_terminate(void (*try_block)(),
 		void (*catch_block)(int index, exception * except),
 		__attribute__((unused)) int (*match_block)(exception * except)) {
@@ -466,11 +466,11 @@
 	// Body uses language specific data and therefore could be modified arbitrarily
 	".LLSDACSBCFA2:\n"						// BODY start
-	"	.uleb128 .TRYSTART-__cfaehm__try_terminate\n"		// Handled area start  (relative to start of function)
+	"	.uleb128 .TRYSTART-__cfaabi_ehm__try_terminate\n"		// Handled area start  (relative to start of function)
 	"	.uleb128 .TRYEND-.TRYSTART\n"				// Handled area length
-	"	.uleb128 .CATCH-__cfaehm__try_terminate\n"				// Hanlder landing pad adress  (relative to start of function)
+	"	.uleb128 .CATCH-__cfaabi_ehm__try_terminate\n"				// Hanlder landing pad adress  (relative to start of function)
 	"	.uleb128 1\n"						// Action code, gcc seems to use always 0
 	".LLSDACSECFA2:\n"						// BODY end
 	"	.text\n"							// TABLE footer
-	"	.size	__cfaehm__try_terminate, .-__cfaehm__try_terminate\n"
+	"	.size	__cfaabi_ehm__try_terminate, .-__cfaabi_ehm__try_terminate\n"
 	"	.ident	\"GCC: (Ubuntu 6.2.0-3ubuntu11~16.04) 6.2.0 20160901\"\n"
 //	"	.section	.note.GNU-stack,\"x\",@progbits\n"
Index: src/libcfa/exception.h
===================================================================
--- src/libcfa/exception.h	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ src/libcfa/exception.h	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
@@ -21,28 +21,28 @@
 #endif
 
-struct __cfaehm__base_exception_t;
-typedef struct __cfaehm__base_exception_t exception;
-struct __cfaehm__base_exception_t_vtable {
-	const struct __cfaehm__base_exception_t_vtable * parent;
+struct __cfaabi_ehm__base_exception_t;
+typedef struct __cfaabi_ehm__base_exception_t exception;
+struct __cfaabi_ehm__base_exception_t_vtable {
+	const struct __cfaabi_ehm__base_exception_t_vtable * parent;
 	size_t size;
-	void (*copy)(struct __cfaehm__base_exception_t *this,
-	             struct __cfaehm__base_exception_t * other);
-	void (*free)(struct __cfaehm__base_exception_t *this);
-	const char * (*msg)(struct __cfaehm__base_exception_t *this);
+	void (*copy)(struct __cfaabi_ehm__base_exception_t *this,
+	             struct __cfaabi_ehm__base_exception_t * other);
+	void (*free)(struct __cfaabi_ehm__base_exception_t *this);
+	const char * (*msg)(struct __cfaabi_ehm__base_exception_t *this);
 };
-struct __cfaehm__base_exception_t {
-	struct __cfaehm__base_exception_t_vtable const * virtual_table;
+struct __cfaabi_ehm__base_exception_t {
+	struct __cfaabi_ehm__base_exception_t_vtable const * virtual_table;
 };
-extern struct __cfaehm__base_exception_t_vtable
-	___cfaehm__base_exception_t_vtable_instance;
+extern struct __cfaabi_ehm__base_exception_t_vtable
+	___cfaabi_ehm__base_exception_t_vtable_instance;
 
 
 // Used in throw statement translation.
-void __cfaehm__throw_terminate(exception * except) __attribute__((noreturn));
-void __cfaehm__rethrow_terminate() __attribute__((noreturn));
-void __cfaehm__throw_resume(exception * except);
+void __cfaabi_ehm__throw_terminate(exception * except) __attribute__((noreturn));
+void __cfaabi_ehm__rethrow_terminate() __attribute__((noreturn));
+void __cfaabi_ehm__throw_resume(exception * except);
 
 // Function catches termination exceptions.
-void __cfaehm__try_terminate(
+void __cfaabi_ehm__try_terminate(
     void (*try_block)(),
     void (*catch_block)(int index, exception * except),
@@ -50,21 +50,21 @@
 
 // Clean-up the exception in catch blocks.
-void __cfaehm__cleanup_terminate(void * except);
+void __cfaabi_ehm__cleanup_terminate(void * except);
 
 // Data structure creates a list of resume handlers.
-struct __cfaehm__try_resume_node {
-    struct __cfaehm__try_resume_node * next;
+struct __cfaabi_ehm__try_resume_node {
+    struct __cfaabi_ehm__try_resume_node * next;
     _Bool (*handler)(exception * except);
 };
 
 // These act as constructor and destructor for the resume node.
-void __cfaehm__try_resume_setup(
-    struct __cfaehm__try_resume_node * node,
+void __cfaabi_ehm__try_resume_setup(
+    struct __cfaabi_ehm__try_resume_node * node,
     _Bool (*handler)(exception * except));
-void __cfaehm__try_resume_cleanup(
-    struct __cfaehm__try_resume_node * node);
+void __cfaabi_ehm__try_resume_cleanup(
+    struct __cfaabi_ehm__try_resume_node * node);
 
 // Check for a standard way to call fake deconstructors.
-struct __cfaehm__cleanup_hook {};
+struct __cfaabi_ehm__cleanup_hook {};
 
 #ifdef __cforall
Index: src/libcfa/interpose.c
===================================================================
--- src/libcfa/interpose.c	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ src/libcfa/interpose.c	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
@@ -24,6 +24,6 @@
 }
 
-#include "libhdr/libdebug.h"
-#include "libhdr/libtools.h"
+#include "bits/debug.h"
+#include "bits/defs.h"
 #include "startup.h"
 
@@ -69,6 +69,4 @@
 __typeof__( exit ) libc_exit __attribute__(( noreturn ));
 __typeof__( abort ) libc_abort __attribute__(( noreturn ));
-
-// #define INIT_REALRTN( x, ver ) libc_##x = (__typeof__(libc_##x))interpose_symbol( #x, ver )
 
 forall(dtype T)
@@ -127,10 +125,10 @@
 			va_end( args );
 
-			__lib_debug_write( abort_text, len );
-			__lib_debug_write( "\n", 1 );
+			__cfaabi_dbg_bits_write( abort_text, len );
+			__cfaabi_dbg_bits_write( "\n", 1 );
 		}
 
 		len = snprintf( abort_text, abort_text_size, "Cforall Runtime error (UNIX pid:%ld)\n", (long int)getpid() ); // use UNIX pid (versus getPid)
-		__lib_debug_write( abort_text, len );
+		__cfaabi_dbg_bits_write( abort_text, len );
 
 
Index: src/libcfa/libhdr.h
===================================================================
--- src/libcfa/libhdr.h	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ 	(revision )
@@ -1,25 +1,0 @@
-//
-// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
-//
-// The contents of this file are covered under the licence agreement in the
-// file "LICENCE" distributed with Cforall.
-//
-// libhdr.h --
-//
-// Author           : Thierry Delisle
-// Created On       : Mon Nov 28 12:27:26 2016
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jul 22 09:56:32 2017
-// Update Count     : 1
-//
-
-#pragma once
-
-#include "libhdr/libalign.h"
-#include "libhdr/libdebug.h"
-#include "libhdr/libtools.h"
-
-// Local Variables: //
-// mode: c //
-// tab-width: 4 //
-// End: //
Index: src/libcfa/libhdr/libalign.h
===================================================================
--- src/libcfa/libhdr/libalign.h	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ 	(revision )
@@ -1,62 +1,0 @@
-//
-// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
-//
-// The contents of this file are covered under the licence agreement in the
-// file "LICENCE" distributed with Cforall.
-//
-// libdebug.h --
-//
-// Author           : Thierry Delisle
-// Created On       : Mon Nov 28 12:27:26 2016
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Jul 21 23:05:35 2017
-// Update Count     : 2
-//
-// This  library is free  software; you  can redistribute  it and/or  modify it
-// under the terms of the GNU Lesser General Public License as published by the
-// 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.
-//
-
-#pragma once
-
-#include <assert.h>
-#include <stdbool.h>
-
-// Minimum size used to align memory boundaries for memory allocations.
-#define libAlign() (sizeof(double))
-
-// Check for power of 2
-static inline bool libPow2( unsigned long int value ) {
-    // clears all bits below value, rounding value down to the next lower multiple of value
-    return (value & (value - 1ul)) == 0ul;
-} // libPow2
-
-
-// Returns value aligned at the floor of align.
-static inline unsigned long int libFloor( unsigned long int value, unsigned long int align ) {
-    assert( libPow2( align ) );
-    // clears all bits above or equal to align, getting (value % align), the phase of value with regards to align
-    return value & -align;
-} // libFloor
-
-
-// Returns value aligned at the ceiling of align.
-
-static inline unsigned long int libCeiling( unsigned long int value, unsigned long int align ) {
-    assert( libPow2( align ) );
-    // "negate, round down, negate" is the same as round up
-    return -libFloor( -value, align );
-} // uCeiling
-
-// Local Variables: //
-// compile-command: "make install" //
-// End: //
Index: src/libcfa/libhdr/libdebug.c
===================================================================
--- src/libcfa/libhdr/libdebug.c	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ 	(revision )
@@ -1,88 +1,0 @@
-//
-// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
-//
-// The contents of this file are covered under the licence agreement in the
-// file "LICENCE" distributed with Cforall.
-//
-// libdebug.c --
-//
-// Author           : Thierry Delisle
-// Created On       : Thu Mar 30 12:30:01 2017
-// Last Modified By :
-// Last Modified On :
-// Update Count     : 0
-//
-
-extern "C" {
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <errno.h>
-#include <stdarg.h>
-#include <unistd.h>
-}
-
-enum { buffer_size = 512 };
-static char buffer[ buffer_size ];
-
-extern "C" {
-
-	void __lib_debug_write( const char *in_buffer, int len ) {
-		// ensure all data is written
-		for ( int count = 0, retcode; count < len; count += retcode ) {
-			in_buffer += count;
-
-			for ( ;; ) {
-				retcode = write( STDERR_FILENO, in_buffer, len - count );
-
-				// not a timer interrupt ?
-				if ( retcode != -1 || errno != EINTR ) break;
-			}
-
-			if ( retcode == -1 ) _exit( EXIT_FAILURE );
-		}
-	}
-
-	void __lib_debug_acquire() __attribute__((__weak__)) {}
-	void __lib_debug_release() __attribute__((__weak__)) {}
-
-	void __lib_debug_print_safe  ( const char fmt[], ... ) __attribute__(( format (printf, 1, 2) )) {
-		va_list args;
-
-		va_start( args, fmt );
-		__lib_debug_acquire();
-
-		int len = vsnprintf( buffer, buffer_size, fmt, args );
-		__lib_debug_write( buffer, len );
-
-		__lib_debug_release();
-		va_end( args );
-	}
-
-	void __lib_debug_print_nolock( const char fmt[], ... ) __attribute__(( format (printf, 1, 2) )) {
-		va_list args;
-
-		va_start( args, fmt );
-
-		int len = vsnprintf( buffer, buffer_size, fmt, args );
-		__lib_debug_write( buffer, len );
-
-		va_end( args );
-	}
-
-	void __lib_debug_print_vararg( const char fmt[], va_list args ) {
-		int len = vsnprintf( buffer, buffer_size, fmt, args );
-		__lib_debug_write( buffer, len );
-	}
-
-	void __lib_debug_print_buffer( char in_buffer[], int in_buffer_size, const char fmt[], ... ) __attribute__(( format (printf, 3, 4) )) {
-		va_list args;
-
-		va_start( args, fmt );
-
-		int len = vsnprintf( in_buffer, in_buffer_size, fmt, args );
-		__lib_debug_write( in_buffer, len );
-
-		va_end( args );
-	}
-}
Index: src/libcfa/libhdr/libdebug.h
===================================================================
--- src/libcfa/libhdr/libdebug.h	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ 	(revision )
@@ -1,83 +1,0 @@
-//
-// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
-//
-// The contents of this file are covered under the licence agreement in the
-// file "LICENCE" distributed with Cforall.
-//
-// libdebug.h --
-//
-// Author           : Thierry Delisle
-// Created On       : Mon Nov 28 12:27:26 2016
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jul 22 10:02:24 2017
-// Update Count     : 1
-//
-
-#pragma once
-
-#ifdef __CFA_DEBUG__
-	#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
-
-#if !defined(NDEBUG) && (defined(__CFA_DEBUG__) || defined(__CFA_VERIFY__))
-	#define verify(x) assert(x)
-	#define verifyf(x, ...) assertf(x, __VA_ARGS__)
-#else
-	#define verify(x)
-	#define verifyf(x, ...)
-#endif
-
-
-#ifdef __cforall
-extern "C" {
-#endif
-	#include <stdarg.h>
-	#include <stdio.h>
-
-      extern void __lib_debug_write( const char *buffer, int len );
-      extern void __lib_debug_acquire();
-      extern void __lib_debug_release();
-      extern void __lib_debug_print_safe  ( const char fmt[], ... ) __attribute__(( format (printf, 1, 2) ));
-      extern void __lib_debug_print_nolock( const char fmt[], ... ) __attribute__(( format (printf, 1, 2) ));
-      extern void __lib_debug_print_vararg( const char fmt[], va_list arg );
-      extern void __lib_debug_print_buffer( char buffer[], int buffer_size, const char fmt[], ... ) __attribute__(( format (printf, 3, 4) ));
-#ifdef __cforall
-}
-#endif
-
-#ifdef __CFA_DEBUG_PRINT__
-	#define LIB_DEBUG_WRITE( buffer, len )         __lib_debug_write( buffer, len )
-	#define LIB_DEBUG_ACQUIRE()                    __lib_debug_acquire()
-	#define LIB_DEBUG_RELEASE()                    __lib_debug_release()
-	#define LIB_DEBUG_PRINT_SAFE(...)              __lib_debug_print_safe   (__VA_ARGS__)
-	#define LIB_DEBUG_PRINT_NOLOCK(...)            __lib_debug_print_nolock (__VA_ARGS__)
-	#define LIB_DEBUG_PRINT_BUFFER(...)            __lib_debug_print_buffer (__VA_ARGS__)
-	#define LIB_DEBUG_PRINT_BUFFER_DECL(...)       char __dbg_text[256]; int __dbg_len = snprintf( __dbg_text, 256, __VA_ARGS__ ); __lib_debug_write( __dbg_text, __dbg_len );
-	#define LIB_DEBUG_PRINT_BUFFER_LOCAL(...)      __dbg_len = snprintf( __dbg_text, 256, __VA_ARGS__ ); __lib_debug_write( __dbg_text, __dbg_len );
-#else
-	#define LIB_DEBUG_WRITE(...)               ((void)0)
-	#define LIB_DEBUG_ACQUIRE()                ((void)0)
-	#define LIB_DEBUG_RELEASE()                ((void)0)
-	#define LIB_DEBUG_PRINT_SAFE(...)          ((void)0)
-	#define LIB_DEBUG_PRINT_NOLOCK(...)        ((void)0)
-	#define LIB_DEBUG_PRINT_BUFFER(...)        ((void)0)
-	#define LIB_DEBUG_PRINT_BUFFER_DECL(...)   ((void)0)
-	#define LIB_DEBUG_PRINT_BUFFER_LOCAL(...)  ((void)0)
-#endif
-
-// Local Variables: //
-// mode: c //
-// tab-width: 4 //
-// End: //
Index: src/libcfa/libhdr/libtools.h
===================================================================
--- src/libcfa/libhdr/libtools.h	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ 	(revision )
@@ -1,34 +1,0 @@
-//
-// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
-//
-// The contents of this file are covered under the licence agreement in the
-// file "LICENCE" distributed with Cforall.
-//
-// ools.h --
-//
-// Author           : Thierry Delisle
-// Created On       : Mon Nov 28 12:27:26 2016
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jul 22 10:02:10 2017
-// Update Count     : 1
-//
-
-#pragma once
-
-// void abortf( const char *fmt, ... ) {
-//     abort();
-//     // CONTROL NEVER REACHES HERE!
-// } // libAbort
-
-#ifdef __cforall
-extern "C" {
-#endif
-void abortf( const char fmt[], ... ) __attribute__ ((__nothrow__, __leaf__, __noreturn__));
-#ifdef __cforall
-}
-#endif
-
-// Local Variables: //
-// mode: c //
-// tab-width: 4 //
-// End: //
Index: src/libcfa/stdhdr/assert.h
===================================================================
--- src/libcfa/stdhdr/assert.h	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ src/libcfa/stdhdr/assert.h	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
@@ -30,4 +30,12 @@
 #endif
 
+#if !defined(NDEBUG) && (defined(__CFA_DEBUG__) || defined(__CFA_VERIFY__))
+	#define verify(x) assert(x)
+	#define verifyf(x, ...) assertf(x, __VA_ARGS__)
+#else
+	#define verify(x)
+	#define verifyf(x, ...)
+#endif
+
 #ifdef __cforall
 } // extern "C"
Index: src/prelude/builtins.c
===================================================================
--- src/prelude/builtins.c	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ src/prelude/builtins.c	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
@@ -16,5 +16,5 @@
 // exception implementation
 
-typedef unsigned long long __cfaabi_exception_type_t;
+typedef unsigned long long __cfaabi_abi_exception_type_t;
 
 #include "../libcfa/virtual.h"
@@ -80,7 +80,7 @@
 } // ?\?
 
-// FIXME (x \ (unsigned long int)y) relies on X ?\?(T, unsigned long) a function that is neither 
-// defined, nor passed as an assertion parameter. Without user-defined conversions, cannot specify 
-// X as a type that casts to double, yet it doesn't make sense to write functions with that type 
+// FIXME (x \ (unsigned long int)y) relies on X ?\?(T, unsigned long) a function that is neither
+// defined, nor passed as an assertion parameter. Without user-defined conversions, cannot specify
+// X as a type that casts to double, yet it doesn't make sense to write functions with that type
 // signature where X is double.
 
Index: src/tests/except-mac.h
===================================================================
--- src/tests/except-mac.h	(revision 882ad37047443824102ef071eaf49540b434c634)
+++ src/tests/except-mac.h	(revision 3ca540ff8fca8be28ec085a72a11b96bf920dd76)
@@ -7,5 +7,5 @@
 
 // The fully (perhaps overly) qualified name of the base exception type:
-#define BASE_EXCEPT __cfaehm__base_exception_t
+#define BASE_EXCEPT __cfaabi_ehm__base_exception_t
 
 // Get the name of the vtable type and vtable instance for an exception type: