Changes in / [3d560060:dd9b59e]

Location:

src

Files:

• ControlStruct/ExceptTranslate.cc (modified) (10 diffs)
• ResolvExpr/Resolver.cc (modified) (1 diff)
• driver/cfa.cc (modified) (1 diff)
• libcfa/Makefile.am (modified) (2 diffs)
• libcfa/Makefile.in (modified) (16 diffs)
• libcfa/assert.c (modified) (3 diffs)
• libcfa/bits/align.h (deleted)
• libcfa/bits/containers.h (modified) (1 diff)
• libcfa/bits/debug.c (deleted)
• libcfa/bits/debug.h (deleted)
• libcfa/bits/defs.h (modified) (1 diff)
• libcfa/bits/locks.h (modified) (5 diffs)
• libcfa/concurrency/alarm.c (modified) (5 diffs)
• libcfa/concurrency/coroutine.c (modified) (4 diffs)
• libcfa/concurrency/invoke.c (modified) (4 diffs)
• libcfa/concurrency/kernel.c (modified) (27 diffs)
• libcfa/concurrency/kernel_private.h (modified) (3 diffs)
• libcfa/concurrency/monitor.c (modified) (37 diffs)
• libcfa/concurrency/preemption.c (modified) (16 diffs)
• libcfa/concurrency/thread.c (modified) (3 diffs)
• libcfa/exception.c (modified) (22 diffs)
• libcfa/exception.h (modified) (2 diffs)
• libcfa/interpose.c (modified) (3 diffs)
• libcfa/libhdr.h (added)
• libcfa/libhdr/libalign.h (added)
• libcfa/libhdr/libdebug.c (added)
• libcfa/libhdr/libdebug.h (added)
• libcfa/libhdr/libtools.h (added)
• libcfa/stdhdr/assert.h (modified) (1 diff)
• prelude/builtins.c (modified) (2 diffs)
• tests/except-mac.h (modified) (1 diff)

src/ControlStruct/ExceptTranslate.cc

@@ -211 +211 @@
                         ThrowStmt *throwStmt ) {
                 // __throw_terminate( `throwStmt->get_name()` ); }
-                return create_given_throw( "__cfaabi_ehm__throw_terminate", throwStmt );
+                return create_given_throw( "__cfaehm__throw_terminate", throwStmt );
         }
 
@@ -232 +232 @@
                 result->push_back( new ExprStmt(
                         noLabels,
-                        new UntypedExpr( new NameExpr( "__cfaabi_ehm__rethrow_terminate" ) )
+                        new UntypedExpr( new NameExpr( "__cfaehm__rethrow_terminate" ) )
                         ) );
                 delete throwStmt;
@@ -241 +241 @@
                         ThrowStmt *throwStmt ) {
                 // __throw_resume( `throwStmt->get_name` );
-                return create_given_throw( "__cfaabi_ehm__throw_resume", throwStmt );
+                return create_given_throw( "__cfaehm__throw_resume", throwStmt );
         }
 
@@ -309 +309 @@
                         local_except->get_attributes().push_back( new Attribute(
                                 "cleanup",
-                                { new NameExpr( "__cfaabi_ehm__cleanup_terminate" ) }
+                                { new NameExpr( "__cfaehm__cleanup_terminate" ) }
                                 ) );
 
@@ -432 +432 @@
                         FunctionDecl * terminate_catch,
                         FunctionDecl * terminate_match ) {
-                // { __cfaabi_ehm__try_terminate(`try`, `catch`, `match`); }
+                // { __cfaehm__try_terminate(`try`, `catch`, `match`); }
 
                 UntypedExpr * caller = new UntypedExpr( new NameExpr(
-                        "__cfaabi_ehm__try_terminate" ) );
+                        "__cfaehm__try_terminate" ) );
                 std::list<Expression *>& args = caller->get_args();
                 args.push_back( nameOf( try_wrapper ) );
@@ -489 +489 @@
 
                 // struct __try_resume_node __resume_node
-                //      __attribute__((cleanup( __cfaabi_ehm__try_resume_cleanup )));
+                //      __attribute__((cleanup( __cfaehm__try_resume_cleanup )));
                 // ** unwinding of the stack here could cause problems **
                 // ** however I don't think that can happen currently **
-                // __cfaabi_ehm__try_resume_setup( &__resume_node, resume_handler );
+                // __cfaehm__try_resume_setup( &__resume_node, resume_handler );
 
                 std::list< Attribute * > attributes;
@@ -498 +498 @@
                         std::list< Expression * > attr_params;
                         attr_params.push_back( new NameExpr(
-                                "__cfaabi_ehm__try_resume_cleanup" ) );
+                                "__cfaehm__try_resume_cleanup" ) );
                         attributes.push_back( new Attribute( "cleanup", attr_params ) );
                 }
@@ -517 +517 @@
 
                 UntypedExpr *setup = new UntypedExpr( new NameExpr(
-                        "__cfaabi_ehm__try_resume_setup" ) );
+                        "__cfaehm__try_resume_setup" ) );
                 setup->get_args().push_back( new AddressExpr( nameOf( obj ) ) );
                 setup->get_args().push_back( nameOf( resume_handler ) );
@@ -542 +542 @@
         ObjectDecl * ExceptionMutatorCore::create_finally_hook(
                         FunctionDecl * finally_wrapper ) {
-                // struct __cfaabi_ehm__cleanup_hook __finally_hook
+                // struct __cfaehm__cleanup_hook __finally_hook
                 //      __attribute__((cleanup( finally_wrapper )));
 
@@ -596 +596 @@
                         // Skip children?
                         return;
-                } else if ( structDecl->get_name() == "__cfaabi_ehm__base_exception_t" ) {
+                } else if ( structDecl->get_name() == "__cfaehm__base_exception_t" ) {
                         assert( nullptr == except_decl );
                         except_decl = structDecl;
                         init_func_types();
-                } else if ( structDecl->get_name() == "__cfaabi_ehm__try_resume_node" ) {
+                } else if ( structDecl->get_name() == "__cfaehm__try_resume_node" ) {
                         assert( nullptr == node_decl );
                         node_decl = structDecl;
-                } else if ( structDecl->get_name() == "__cfaabi_ehm__cleanup_hook" ) {
+                } else if ( structDecl->get_name() == "__cfaehm__cleanup_hook" ) {
                         assert( nullptr == hook_decl );
                         hook_decl = structDecl;

src/ResolvExpr/Resolver.cc

@@ -369 +369 @@
                 if ( throwStmt->get_expr() ) {
                         StructDecl * exception_decl =
-                                indexer.lookupStruct( "__cfaabi_ehm__base_exception_t" );
+                                indexer.lookupStruct( "__cfaehm__base_exception_t" );
                         assert( exception_decl );
                         Type * exceptType = new PointerType( noQualifiers, new StructInstType( noQualifiers, exception_decl ) );

src/driver/cfa.cc

@@ -275 +275 @@
                 args[nargs] = "-Xlinker";
                 nargs += 1;
-                args[nargs] = "--undefined=__cfaabi_dbg_bits_write";
+                args[nargs] = "--undefined=__lib_debug_write";
                 nargs += 1;
 

src/libcfa/Makefile.am

@@ -55 +55 @@
 
 libobjs = ${headers:=.o}
-libsrc = libcfa-prelude.c interpose.c bits/debug.c ${headers:=.c} \
+libsrc = libcfa-prelude.c interpose.c libhdr/libdebug.c ${headers:=.c} \
          assert.c exception.c virtual.c
 
@@ -100 +100 @@
         math                            \
         gmp                             \
-        bits/align.h            \
         bits/containers.h               \
         bits/defs.h             \
-        bits/debug.h            \
         bits/locks.h            \
-        concurrency/invoke.h
+        concurrency/invoke.h    \
+        libhdr.h                        \
+        libhdr/libalign.h       \
+        libhdr/libdebug.h       \
+        libhdr/libtools.h
 
 CLEANFILES = libcfa-prelude.c

src/libcfa/Makefile.in

@@ -149 +149 @@
 libcfa_d_a_LIBADD =
 am__libcfa_d_a_SOURCES_DIST = libcfa-prelude.c interpose.c \
-        bits/debug.c fstream.c iostream.c iterator.c limits.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 \
@@ -175 +175 @@
 @BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_d_a-preemption.$(OBJEXT)
 am__objects_4 = libcfa_d_a-libcfa-prelude.$(OBJEXT) \
-        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)
+        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)
 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 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
+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
 @BUILD_CONCURRENCY_TRUE@am__objects_5 = concurrency/libcfa_a-coroutine.$(OBJEXT) \
 @BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_a-thread.$(OBJEXT) \
@@ -207 +208 @@
 @BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_a-preemption.$(OBJEXT)
 am__objects_8 = libcfa_a-libcfa-prelude.$(OBJEXT) \
-        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)
+        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)
 am_libcfa_a_OBJECTS = $(am__objects_8)
 libcfa_a_OBJECTS = $(am_libcfa_a_OBJECTS)
@@ -263 +264 @@
         containers/result containers/vector concurrency/coroutine \
         concurrency/thread concurrency/kernel concurrency/monitor \
-        ${shell echo stdhdr/*} math gmp bits/align.h bits/containers.h \
-        bits/defs.h bits/debug.h bits/locks.h concurrency/invoke.h
+        ${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
 HEADERS = $(nobase_cfa_include_HEADERS)
 am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
@@ -422 +424 @@
         containers/vector $(am__append_3)
 libobjs = ${headers:=.o}
-libsrc = libcfa-prelude.c interpose.c bits/debug.c ${headers:=.c} \
+libsrc = libcfa-prelude.c interpose.c libhdr/libdebug.c ${headers:=.c} \
         assert.c exception.c virtual.c $(am__append_4)
 libcfa_a_SOURCES = ${libsrc}
@@ -435 +437 @@
         math                            \
         gmp                             \
-        bits/align.h            \
         bits/containers.h               \
         bits/defs.h             \
-        bits/debug.h            \
         bits/locks.h            \
-        concurrency/invoke.h
+        concurrency/invoke.h    \
+        libhdr.h                        \
+        libhdr/libalign.h       \
+        libhdr/libdebug.h       \
+        libhdr/libtools.h
 
 CLEANFILES = libcfa-prelude.c
@@ -507 +511 @@
 clean-libLIBRARIES:
         -test -z "$(lib_LIBRARIES)" || rm -f $(lib_LIBRARIES)
-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)
+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)
 containers/$(am__dirstamp):
         @$(MKDIR_P) containers
@@ -559 +563 @@
         $(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
-bits/libcfa_a-debug.$(OBJEXT): bits/$(am__dirstamp) \
-        bits/$(DEPDIR)/$(am__dirstamp)
+libhdr/libcfa_a-libdebug.$(OBJEXT): libhdr/$(am__dirstamp) \
+        libhdr/$(DEPDIR)/$(am__dirstamp)
 containers/libcfa_a-maybe.$(OBJEXT): containers/$(am__dirstamp) \
         containers/$(DEPDIR)/$(am__dirstamp)
@@ -592 +596 @@
 mostlyclean-compile:
         -rm -f *.$(OBJEXT)
-        -rm -f bits/*.$(OBJEXT)
         -rm -f concurrency/*.$(OBJEXT)
         -rm -f containers/*.$(OBJEXT)
+        -rm -f libhdr/*.$(OBJEXT)
 
 distclean-compile:
@@ -621 +625 @@
 @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@
@@ -646 +648 @@
 @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:
@@ -700 +704 @@
 @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`
 
-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`
+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`
 
 libcfa_d_a-fstream.o: fstream.c
@@ -994 +998 @@
 @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`
 
-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`
+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`
 
 libcfa_a-fstream.o: fstream.c
@@ -1407 +1411 @@
         -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:
@@ -1422 +1426 @@
 
 distclean: distclean-am
-        -rm -rf ./$(DEPDIR) bits/$(DEPDIR) concurrency/$(DEPDIR) containers/$(DEPDIR)
+        -rm -rf ./$(DEPDIR) concurrency/$(DEPDIR) containers/$(DEPDIR) libhdr/$(DEPDIR)
         -rm -f Makefile
 distclean-am: clean-am distclean-compile distclean-generic \
@@ -1468 +1472 @@
 
 maintainer-clean: maintainer-clean-am
-        -rm -rf ./$(DEPDIR) bits/$(DEPDIR) concurrency/$(DEPDIR) containers/$(DEPDIR)
+        -rm -rf ./$(DEPDIR) concurrency/$(DEPDIR) containers/$(DEPDIR) libhdr/$(DEPDIR)
         -rm -f Makefile
 maintainer-clean-am: distclean-am maintainer-clean-generic \

src/libcfa/assert.c

@@ -17 +17 @@
 #include <stdarg.h>                                                             // varargs
 #include <stdio.h>                                                              // fprintf
-#include "bits/debug.h"
+#include "libhdr/libdebug.h"
 
 extern "C" {
@@ -26 +26 @@
         // called by macro assert in assert.h
         void __assert_fail( const char *assertion, const char *file, unsigned int line, const char *function ) {
-                __cfaabi_dbg_bits_print_safe( CFA_ASSERT_FMT ".\n", __progname, function, line, file );
+                __lib_debug_print_safe( CFA_ASSERT_FMT ".\n", __progname, function, line, file );
                 abort();
         }
@@ -32 +32 @@
         // called by macro assertf
         void __assert_fail_f( const char *assertion, const char *file, unsigned int line, const char *function, const char *fmt, ... ) {
-                __cfaabi_dbg_bits_acquire();
-                __cfaabi_dbg_bits_print_nolock( CFA_ASSERT_FMT ": ", __progname, function, line, file );
+                __lib_debug_acquire();
+                __lib_debug_print_nolock( CFA_ASSERT_FMT ": ", __progname, function, line, file );
 
                 va_list args;
                 va_start( args, fmt );
-                __cfaabi_dbg_bits_print_vararg( fmt, args );
+                __lib_debug_print_vararg( fmt, args );
                 va_end( args );
 
-                __cfaabi_dbg_bits_print_nolock( "\n" );
-                __cfaabi_dbg_bits_release();
+                __lib_debug_print_nolock( "\n" );
+                __lib_debug_release();
                 abort();
         }

src/libcfa/bits/containers.h

@@ -15 +15 @@
 #pragma once
 
-#include "bits/align.h"
 #include "bits/defs.h"
+#include "libhdr.h"
 
 //-----------------------------------------------------------------------------

src/libcfa/bits/defs.h

@@ -32 +32 @@
 #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

src/libcfa/bits/locks.h

@@ -16 +16 @@
 #pragma once
 
-#include "bits/debug.h"
 #include "bits/defs.h"
+
+#include "libhdr.h"
 
 // pause to prevent excess processor bus usage
@@ -64 +65 @@
 
         // Lock the spinlock, return false if already acquired
-        static inline _Bool try_lock  ( __spinlock_t & this __cfaabi_dbg_ctx_param2 ) {
+        static inline _Bool try_lock  ( __spinlock_t & this DEBUG_CTX_PARAM2 ) {
                 _Bool result = __lock_test_and_test_and_set( this.lock );
-                __cfaabi_dbg_debug_do(
+                LIB_DEBUG_DO(
                         if( result ) {
                                 this.prev_name = caller;
@@ -76 +77 @@
 
         // Lock the spinlock, spin if already acquired
-        static inline void lock( __spinlock_t & this __cfaabi_dbg_ctx_param2 ) {
+        static inline void lock( __spinlock_t & this DEBUG_CTX_PARAM2 ) {
                 #ifndef NOEXPBACK
                         enum { SPIN_START = 4, SPIN_END = 64 * 1024, };
@@ -97 +98 @@
                         #endif
                 }
-                __cfaabi_dbg_debug_do(
+                LIB_DEBUG_DO(
                         this.prev_name = caller;
                         this.prev_thrd = this_thread;
@@ -104 +105 @@
 
         // Lock the spinlock, spin if already acquired
-        static inline void lock_yield( __spinlock_t & this __cfaabi_dbg_ctx_param2 ) {
+        static inline void lock_yield( __spinlock_t & this DEBUG_CTX_PARAM2 ) {
                 for ( unsigned int i = 1;; i += 1 ) {
                         if ( __lock_test_and_test_and_set( this.lock ) ) break;
                         yield( i );
                 }
-                __cfaabi_dbg_debug_do(
+                LIB_DEBUG_DO(
                         this.prev_name = caller;
                         this.prev_thrd = this_thread;

src/libcfa/concurrency/alarm.c

@@ -23 +23 @@
 }
 
+#include "libhdr.h"
+
 #include "alarm.h"
 #include "kernel_private.h"
@@ -108 +110 @@
 }
 
-__cfaabi_dbg_debug_do( bool validate( alarm_list_t * this ) {
+LIB_DEBUG_DO( bool validate( alarm_list_t * this ) {
         alarm_node_t ** it = &this->head;
         while( (*it) ) {
@@ -184 +186 @@
 
         disable_interrupts();
-        lock( event_kernel->lock __cfaabi_dbg_ctx2 );
+        lock( event_kernel->lock DEBUG_CTX2 );
         {
                 verify( validate( alarms ) );
@@ -196 +198 @@
         unlock( event_kernel->lock );
         this->set = true;
-        enable_interrupts( __cfaabi_dbg_ctx );
+        enable_interrupts( DEBUG_CTX );
 }
 
 void unregister_self( alarm_node_t * this ) {
         disable_interrupts();
-        lock( event_kernel->lock __cfaabi_dbg_ctx2 );
+        lock( event_kernel->lock DEBUG_CTX2 );
         {
                 verify( validate( &event_kernel->alarms ) );
@@ -207 +209 @@
         }
         unlock( event_kernel->lock );
-        enable_interrupts( __cfaabi_dbg_ctx );
+        enable_interrupts( DEBUG_CTX );
         this->set = false;
 }

src/libcfa/concurrency/coroutine.c

@@ -29 +29 @@
 #define __CFA_INVOKE_PRIVATE__
 #include "invoke.h"
+
 
 //-----------------------------------------------------------------------------
@@ -75 +76 @@
 void ^?{}(coStack_t & this) {
         if ( ! this.userStack && this.storage ) {
-                __cfaabi_dbg_debug_do(
+                LIB_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 ) );
@@ -130 +131 @@
 
                 // assume malloc has 8 byte alignment so add 8 to allow rounding up to 16 byte alignment
-                __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( this->storage = memalign( pageSize, cxtSize + this->size + pageSize ) );
+                LIB_NO_DEBUG_DO( this->storage = malloc( cxtSize + this->size + 8 ) );
 
-                __cfaabi_dbg_debug_do(
+                LIB_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 ) );
@@ -143 +144 @@
                 } // if
 
-                __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
+                LIB_DEBUG_DO( this->limit = (char *)this->storage + pageSize );
+                LIB_NO_DEBUG_DO( this->limit = (char *)libCeiling( (unsigned long)this->storage, 16 ) ); // minimum alignment
 
         } else {

src/libcfa/concurrency/invoke.c

@@ -18 +18 @@
 #include <stdio.h>
 
+#include "libhdr.h"
 #include "invoke.h"
 
@@ -30 +31 @@
 extern void __leave_thread_monitor( struct thread_desc * this );
 extern void disable_interrupts();
-extern void enable_interrupts( __cfaabi_dbg_ctx_param );
+extern void enable_interrupts( DEBUG_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
 ) {
-        struct coroutine_desc* cor = get_coroutine( this );
+      // LIB_DEBUG_PRINTF("Invoke Coroutine : Received %p (main %p, get_c %p)\n", this, main, get_coroutine);
 
-        if(cor->state == Primed) {
-                __suspend_internal();
-        }
+      struct coroutine_desc* cor = get_coroutine( this );
 
-        cor->state = Active;
+      if(cor->state == Primed) {
+            __suspend_internal();
+      }
 
-        main( this );
+      cor->state = Active;
 
-        cor->state = Halted;
+      main( this );
 
-        //Final suspend, should never return
-        __leave_coroutine();
-        abortf("Resumed dead coroutine");
+      cor->state = Halted;
+
+      //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( __cfaabi_dbg_ctx );
+      // Officially start the thread by enabling preemption
+      enable_interrupts( DEBUG_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 *)
 ) {
-        struct coStack_t* stack = &get_coroutine( this )->stack;
+      // 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;
 
 #if defined( __i386__ )
@@ -98 +103 @@
             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
@@ -111 +116 @@
         ((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
 }

src/libcfa/concurrency/kernel.c

@@ -14 +14 @@
 //
 
+#include "libhdr.h"
+
 //C Includes
 #include <stddef.h>
@@ -148 +150 @@
 
         this.runner = &runner;
-        __cfaabi_dbg_print_safe("Kernel : constructing main processor context %p\n", &runner);
+        LIB_DEBUG_PRINT_SAFE("Kernel : constructing main processor context %p\n", &runner);
         runner{ &this };
 }
@@ -154 +156 @@
 void ^?{}(processor & this) {
         if( ! this.do_terminate ) {
-                __cfaabi_dbg_print_safe("Kernel : core %p signaling termination\n", &this);
+                LIB_DEBUG_PRINT_SAFE("Kernel : core %p signaling termination\n", &this);
                 this.do_terminate = true;
                 P( this.terminated );
@@ -179 +181 @@
         processor * this = runner.proc;
 
-        __cfaabi_dbg_print_safe("Kernel : core %p starting\n", this);
+        LIB_DEBUG_PRINT_SAFE("Kernel : core %p starting\n", this);
 
         {
@@ -185 +187 @@
                 preemption_scope scope = { this };
 
-                __cfaabi_dbg_print_safe("Kernel : core %p started\n", this);
+                LIB_DEBUG_PRINT_SAFE("Kernel : core %p started\n", this);
 
                 thread_desc * readyThread = NULL;
@@ -211 +213 @@
                 }
 
-                __cfaabi_dbg_print_safe("Kernel : core %p stopping\n", this);
+                LIB_DEBUG_PRINT_SAFE("Kernel : core %p stopping\n", this);
         }
 
         V( this->terminated );
 
-        __cfaabi_dbg_print_safe("Kernel : core %p terminated\n", this);
+        LIB_DEBUG_PRINT_SAFE("Kernel : core %p terminated\n", this);
 }
 
@@ -290 +292 @@
         processorCtx_t proc_cor_storage = { proc, &info };
 
-        __cfaabi_dbg_print_safe("Coroutine : created stack %p\n", proc_cor_storage.__cor.stack.base);
+        LIB_DEBUG_PRINT_SAFE("Coroutine : created stack %p\n", proc_cor_storage.__cor.stack.base);
 
         //Set global state
@@ -297 +299 @@
 
         //We now have a proper context from which to schedule threads
-        __cfaabi_dbg_print_safe("Kernel : core %p created (%p, %p)\n", proc, proc->runner, &ctx);
+        LIB_DEBUG_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
@@ -308 +310 @@
 
         // Main routine of the core returned, the core is now fully terminated
-        __cfaabi_dbg_print_safe("Kernel : core %p main ended (%p)\n", proc, proc->runner);
+        LIB_DEBUG_PRINT_SAFE("Kernel : core %p main ended (%p)\n", proc, proc->runner);
 
         return NULL;
@@ -314 +316 @@
 
 void start(processor * this) {
-        __cfaabi_dbg_print_safe("Kernel : Starting core %p\n", this);
+        LIB_DEBUG_PRINT_SAFE("Kernel : Starting core %p\n", this);
 
         pthread_create( &this->kernel_thread, NULL, CtxInvokeProcessor, (void*)this );
 
-        __cfaabi_dbg_print_safe("Kernel : core %p started\n", this);
+        LIB_DEBUG_PRINT_SAFE("Kernel : core %p started\n", this);
 }
 
@@ -332 +334 @@
         verifyf( thrd->next == NULL, "Expected null got %p", thrd->next );
 
-        lock(   this_processor->cltr->ready_queue_lock __cfaabi_dbg_ctx2 );
+        lock(   this_processor->cltr->ready_queue_lock DEBUG_CTX2 );
         append( this_processor->cltr->ready_queue, thrd );
         unlock( this_processor->cltr->ready_queue_lock );
@@ -341 +343 @@
 thread_desc * nextThread(cluster * this) {
         verify( disable_preempt_count > 0 );
-        lock( this->ready_queue_lock __cfaabi_dbg_ctx2 );
+        lock( this->ready_queue_lock DEBUG_CTX2 );
         thread_desc * head = pop_head( this->ready_queue );
         unlock( this->ready_queue_lock );
@@ -353 +355 @@
         suspend();
         verify( disable_preempt_count > 0 );
-        enable_interrupts( __cfaabi_dbg_ctx );
+        enable_interrupts( DEBUG_CTX );
 }
 
@@ -365 +367 @@
         verify( disable_preempt_count > 0 );
 
-        enable_interrupts( __cfaabi_dbg_ctx );
+        enable_interrupts( DEBUG_CTX );
 }
 
@@ -379 +381 @@
         verify( disable_preempt_count > 0 );
 
-        enable_interrupts( __cfaabi_dbg_ctx );
+        enable_interrupts( DEBUG_CTX );
 }
 
@@ -393 +395 @@
         verify( disable_preempt_count > 0 );
 
-        enable_interrupts( __cfaabi_dbg_ctx );
+        enable_interrupts( DEBUG_CTX );
 }
 
@@ -406 +408 @@
         verify( disable_preempt_count > 0 );
 
-        enable_interrupts( __cfaabi_dbg_ctx );
+        enable_interrupts( DEBUG_CTX );
 }
 
@@ -421 +423 @@
         verify( disable_preempt_count > 0 );
 
-        enable_interrupts( __cfaabi_dbg_ctx );
+        enable_interrupts( DEBUG_CTX );
 }
 
@@ -439 +441 @@
 // Kernel boot procedures
 void kernel_startup(void) {
-        __cfaabi_dbg_print_safe("Kernel : Starting\n");
+        LIB_DEBUG_PRINT_SAFE("Kernel : Starting\n");
 
         // Start by initializing the main thread
@@ -448 +450 @@
         (*mainThread){ &info };
 
-        __cfaabi_dbg_print_safe("Kernel : Main thread ready\n");
+        LIB_DEBUG_PRINT_SAFE("Kernel : Main thread ready\n");
 
         // Initialize the main cluster
@@ -454 +456 @@
         (*mainCluster){};
 
-        __cfaabi_dbg_print_safe("Kernel : main cluster ready\n");
+        LIB_DEBUG_PRINT_SAFE("Kernel : main cluster ready\n");
 
         // Initialize the main processor and the main processor ctx
@@ -481 +483 @@
 
         // THE SYSTEM IS NOW COMPLETELY RUNNING
-        __cfaabi_dbg_print_safe("Kernel : Started\n--------------------------------------------------\n\n");
-
-        enable_interrupts( __cfaabi_dbg_ctx );
+        LIB_DEBUG_PRINT_SAFE("Kernel : Started\n--------------------------------------------------\n\n");
+
+        enable_interrupts( DEBUG_CTX );
 }
 
 void kernel_shutdown(void) {
-        __cfaabi_dbg_print_safe("\n--------------------------------------------------\nKernel : Shutting down\n");
+        LIB_DEBUG_PRINT_SAFE("\n--------------------------------------------------\nKernel : Shutting down\n");
 
         disable_interrupts();
@@ -511 +513 @@
         ^(mainThread){};
 
-        __cfaabi_dbg_print_safe("Kernel : Shutdown complete\n");
+        LIB_DEBUG_PRINT_SAFE("Kernel : Shutdown complete\n");
 }
 
@@ -521 +523 @@
         // 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 __cfaabi_dbg_ctx2 );
+        lock( kernel_abort_lock DEBUG_CTX2 );
 
         // first task to abort ?
@@ -546 +548 @@
 
         int len = snprintf( abort_text, abort_text_size, "Error occurred while executing task %.256s (%p)", thrd->self_cor.name, thrd );
-        __cfaabi_dbg_bits_write( abort_text, len );
+        __lib_debug_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 );
-                __cfaabi_dbg_bits_write( abort_text, len );
+                __lib_debug_write( abort_text, len );
         }
         else {
-                __cfaabi_dbg_bits_write( ".\n", 2 );
+                __lib_debug_write( ".\n", 2 );
         }
 }
 
 extern "C" {
-        void __cfaabi_dbg_bits_acquire() {
-                lock( kernel_debug_lock __cfaabi_dbg_ctx2 );
-        }
-
-        void __cfaabi_dbg_bits_release() {
+        void __lib_debug_acquire() {
+                lock( kernel_debug_lock DEBUG_CTX2 );
+        }
+
+        void __lib_debug_release() {
                 unlock( kernel_debug_lock );
         }
@@ -580 +582 @@
 
 void P(semaphore & this) {
-        lock( this.lock __cfaabi_dbg_ctx2 );
+        lock( this.lock DEBUG_CTX2 );
         this.count -= 1;
         if ( this.count < 0 ) {
@@ -596 +598 @@
 void V(semaphore & this) {
         thread_desc * thrd = NULL;
-        lock( this.lock __cfaabi_dbg_ctx2 );
+        lock( this.lock DEBUG_CTX2 );
         this.count += 1;
         if ( this.count <= 0 ) {

src/libcfa/concurrency/kernel_private.h

@@ -16 +16 @@
 #pragma once
 
+#include "libhdr.h"
+
 #include "kernel"
 #include "thread"
@@ -28 +30 @@
         void disable_interrupts();
         void enable_interrupts_noPoll();
-        void enable_interrupts( __cfaabi_dbg_ctx_param );
+        void enable_interrupts( DEBUG_CTX_PARAM );
 }
 
@@ -37 +39 @@
         disable_interrupts();
         ScheduleThread( thrd );
-        enable_interrupts( __cfaabi_dbg_ctx );
+        enable_interrupts( DEBUG_CTX );
 }
 thread_desc * nextThread(cluster * this);

src/libcfa/concurrency/monitor.c

@@ -19 +19 @@
 #include <inttypes.h>
 
+#include "libhdr.h"
 #include "kernel_private.h"
 
@@ -90 +91 @@
         static void __enter_monitor_desc( monitor_desc * this, const __monitor_group_t & group ) {
                 // Lock the monitor spinlock
-                DO_LOCK( this->lock __cfaabi_dbg_ctx2 );
+                DO_LOCK( this->lock DEBUG_CTX2 );
                 thread_desc * thrd = this_thread;
 
-                __cfaabi_dbg_print_safe("Kernel : %10p Entering mon %p (%p)\n", thrd, this, this->owner);
+                LIB_DEBUG_PRINT_SAFE("Kernel : %10p Entering mon %p (%p)\n", thrd, this, this->owner);
 
                 if( !this->owner ) {
@@ -99 +100 @@
                         set_owner( this, thrd );
 
-                        __cfaabi_dbg_print_safe("Kernel :  mon is free \n");
+                        LIB_DEBUG_PRINT_SAFE("Kernel :  mon is free \n");
                 }
                 else if( this->owner == thrd) {
@@ -105 +106 @@
                         this->recursion += 1;
 
-                        __cfaabi_dbg_print_safe("Kernel :  mon already owned \n");
+                        LIB_DEBUG_PRINT_SAFE("Kernel :  mon already owned \n");
                 }
                 else if( is_accepted( this, group) ) {
@@ -114 +115 @@
                         reset_mask( this );
 
-                        __cfaabi_dbg_print_safe("Kernel :  mon accepts \n");
+                        LIB_DEBUG_PRINT_SAFE("Kernel :  mon accepts \n");
                 }
                 else {
-                        __cfaabi_dbg_print_safe("Kernel :  blocking \n");
+                        LIB_DEBUG_PRINT_SAFE("Kernel :  blocking \n");
 
                         // Some one else has the monitor, wait in line for it
@@ -123 +124 @@
                         BlockInternal( &this->lock );
 
-                        __cfaabi_dbg_print_safe("Kernel : %10p Entered  mon %p\n", thrd, this);
+                        LIB_DEBUG_PRINT_SAFE("Kernel : %10p Entered  mon %p\n", thrd, this);
 
                         // BlockInternal will unlock spinlock, no need to unlock ourselves
@@ -129 +130 @@
                 }
 
-                __cfaabi_dbg_print_safe("Kernel : %10p Entered  mon %p\n", thrd, this);
+                LIB_DEBUG_PRINT_SAFE("Kernel : %10p Entered  mon %p\n", thrd, this);
 
                 // Release the lock and leave
@@ -138 +139 @@
         static void __enter_monitor_dtor( monitor_desc * this, fptr_t func ) {
                 // Lock the monitor spinlock
-                DO_LOCK( this->lock __cfaabi_dbg_ctx2 );
+                DO_LOCK( this->lock DEBUG_CTX2 );
                 thread_desc * thrd = this_thread;
 
-                __cfaabi_dbg_print_safe("Kernel : %10p Entering dtor for mon %p (%p)\n", thrd, this, this->owner);
+                LIB_DEBUG_PRINT_SAFE("Kernel : %10p Entering dtor for mon %p (%p)\n", thrd, this, this->owner);
 
 
                 if( !this->owner ) {
-                        __cfaabi_dbg_print_safe("Kernel : Destroying free mon %p\n", this);
+                        LIB_DEBUG_PRINT_SAFE("Kernel : Destroying free mon %p\n", this);
 
                         // No one has the monitor, just take it
@@ -163 +164 @@
                 __monitor_group_t group = { &this, 1, func };
                 if( is_accepted( this, group) ) {
-                        __cfaabi_dbg_print_safe("Kernel :  mon accepts dtor, block and signal it \n");
+                        LIB_DEBUG_PRINT_SAFE("Kernel :  mon accepts dtor, block and signal it \n");
 
                         // Wake the thread that is waiting for this
@@ -182 +183 @@
                 }
                 else {
-                        __cfaabi_dbg_print_safe("Kernel :  blocking \n");
+                        LIB_DEBUG_PRINT_SAFE("Kernel :  blocking \n");
 
                         wait_ctx( this_thread, 0 )
@@ -195 +196 @@
                 }
 
-                __cfaabi_dbg_print_safe("Kernel : Destroying %p\n", this);
+                LIB_DEBUG_PRINT_SAFE("Kernel : Destroying %p\n", this);
 
         }
@@ -202 +203 @@
         void __leave_monitor_desc( monitor_desc * this ) {
                 // Lock the monitor spinlock, DO_LOCK to reduce contention
-                DO_LOCK( this->lock __cfaabi_dbg_ctx2 );
-
-                __cfaabi_dbg_print_safe("Kernel : %10p Leaving mon %p (%p)\n", this_thread, this, this->owner);
+                DO_LOCK( this->lock DEBUG_CTX2 );
+
+                LIB_DEBUG_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 );
@@ -214 +215 @@
                 // it means we don't need to do anything
                 if( this->recursion != 0) {
-                        __cfaabi_dbg_print_safe("Kernel :  recursion still %d\n", this->recursion);
+                        LIB_DEBUG_PRINT_SAFE("Kernel :  recursion still %d\n", this->recursion);
                         unlock( this->lock );
                         return;
@@ -231 +232 @@
         // Leave single monitor for the last time
         void __leave_dtor_monitor_desc( monitor_desc * this ) {
-                __cfaabi_dbg_debug_do(
+                LIB_DEBUG_DO(
                         if( this_thread != this->owner ) {
                                 abortf("Destroyed monitor %p has inconsistent owner, expected %p got %p.\n", this, this_thread, this->owner);
@@ -248 +249 @@
 
                 // Lock the monitor now
-                DO_LOCK( this->lock __cfaabi_dbg_ctx2 );
+                DO_LOCK( this->lock DEBUG_CTX2 );
 
                 disable_interrupts();
@@ -307 +308 @@
         (this_thread->monitors){m, count, func};
 
-        // __cfaabi_dbg_print_safe("MGUARD : enter %d\n", count);
+        // LIB_DEBUG_PRINT_SAFE("MGUARD : enter %d\n", count);
 
         // Enter the monitors in order
@@ -313 +314 @@
         enter( group );
 
-        // __cfaabi_dbg_print_safe("MGUARD : entered\n");
+        // LIB_DEBUG_PRINT_SAFE("MGUARD : entered\n");
 }
 
@@ -319 +320 @@
 // Dtor for monitor guard
 void ^?{}( monitor_guard_t & this ) {
-        // __cfaabi_dbg_print_safe("MGUARD : leaving %d\n", this.count);
+        // LIB_DEBUG_PRINT_SAFE("MGUARD : leaving %d\n", this.count);
 
         // Leave the monitors in order
         leave( this.m, this.count );
 
-        // __cfaabi_dbg_print_safe("MGUARD : left\n");
+        // LIB_DEBUG_PRINT_SAFE("MGUARD : left\n");
 
         // Restore thread context
@@ -429 +430 @@
 
         //Some more checking in debug
-        __cfaabi_dbg_debug_do(
+        LIB_DEBUG_DO(
                 thread_desc * this_thrd = this_thread;
                 if ( this.monitor_count != this_thrd->monitors.size ) {
@@ -486 +487 @@
         set_owner( monitors, count, signallee );
 
-        __cfaabi_dbg_print_buffer_decl( "Kernel : signal_block condition %p (s: %p)\n", &this, signallee );
+        LIB_DEBUG_PRINT_BUFFER_DECL( "Kernel : signal_block condition %p (s: %p)\n", &this, signallee );
 
         //Everything is ready to go to sleep
@@ -495 +496 @@
 
 
-        __cfaabi_dbg_print_buffer_local( "Kernel :   signal_block returned\n" );
+        LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel :   signal_block returned\n" );
 
         //We are back, restore the masks and recursions
@@ -534 +535 @@
         __lock_size_t actual_count = aggregate( mon_storage, mask );
 
-        __cfaabi_dbg_print_buffer_decl( "Kernel : waitfor %d (s: %d, m: %d)\n", actual_count, mask.size, (__lock_size_t)max);
+        LIB_DEBUG_PRINT_BUFFER_DECL( "Kernel : waitfor %d (s: %d, m: %d)\n", actual_count, mask.size, (__lock_size_t)max);
 
         if(actual_count == 0) return;
 
-        __cfaabi_dbg_print_buffer_local( "Kernel : waitfor internal proceeding\n");
+        LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : waitfor internal proceeding\n");
 
         // Create storage for monitor context
@@ -555 +556 @@
                         __acceptable_t& accepted = mask[index];
                         if( accepted.is_dtor ) {
-                                __cfaabi_dbg_print_buffer_local( "Kernel : dtor already there\n");
+                                LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : dtor already there\n");
                                 verifyf( accepted.size == 1,  "ERROR: Accepted dtor has more than 1 mutex parameter." );
 
@@ -567 +568 @@
                         }
                         else {
-                                __cfaabi_dbg_print_buffer_local( "Kernel : thread present, baton-passing\n");
+                                LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : thread present, baton-passing\n");
 
                                 // Create the node specific to this wait operation
@@ -575 +576 @@
                                 monitor_save;
 
-                                __cfaabi_dbg_print_buffer_local( "Kernel :  baton of %d monitors : ", count );
+                                LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel :  baton of %d monitors : ", count );
                                 #ifdef __CFA_DEBUG_PRINT__
                                         for( int i = 0; i < count; i++) {
-                                                __cfaabi_dbg_print_buffer_local( "%p %p ", monitors[i], monitors[i]->signal_stack.top );
+                                                LIB_DEBUG_PRINT_BUFFER_LOCAL( "%p %p ", monitors[i], monitors[i]->signal_stack.top );
                                         }
                                 #endif
-                                __cfaabi_dbg_print_buffer_local( "\n");
+                                LIB_DEBUG_PRINT_BUFFER_LOCAL( "\n");
 
                                 // Set the owners to be the next thread
@@ -592 +593 @@
                                 monitor_restore;
 
-                                __cfaabi_dbg_print_buffer_local( "Kernel : thread present, returned\n");
+                                LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : thread present, returned\n");
                         }
 
-                        __cfaabi_dbg_print_buffer_local( "Kernel : accepted %d\n", *mask.accepted);
+                        LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : accepted %d\n", *mask.accepted);
                         return;
                 }
@@ -602 +603 @@
 
         if( duration == 0 ) {
-                __cfaabi_dbg_print_buffer_local( "Kernel : non-blocking, exiting\n");
+                LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : non-blocking, exiting\n");
 
                 unlock_all( locks, count );
 
-                __cfaabi_dbg_print_buffer_local( "Kernel : accepted %d\n", *mask.accepted);
+                LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : accepted %d\n", *mask.accepted);
                 return;
         }
@@ -613 +614 @@
         verifyf( duration < 0, "Timeout on waitfor statments not supported yet.");
 
-        __cfaabi_dbg_print_buffer_local( "Kernel : blocking waitfor\n");
+        LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : blocking waitfor\n");
 
         // Create the node specific to this wait operation
@@ -635 +636 @@
         monitor_restore;
 
-        __cfaabi_dbg_print_buffer_local( "Kernel : exiting\n");
-
-        __cfaabi_dbg_print_buffer_local( "Kernel : accepted %d\n", *mask.accepted);
+        LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : exiting\n");
+
+        LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : accepted %d\n", *mask.accepted);
 }
 
@@ -644 +645 @@
 
 static inline void set_owner( monitor_desc * this, thread_desc * owner ) {
-        // __cfaabi_dbg_print_safe("Kernal :   Setting owner of %p to %p ( was %p)\n", this, owner, this->owner );
+        // LIB_DEBUG_PRINT_SAFE("Kernal :   Setting owner of %p to %p ( was %p)\n", this, owner, this->owner );
 
         //Pass the monitor appropriately
@@ -676 +677 @@
 static inline thread_desc * next_thread( monitor_desc * this ) {
         //Check the signaller stack
-        __cfaabi_dbg_print_safe("Kernel :  mon %p AS-stack top %p\n", this, this->signal_stack.top);
+        LIB_DEBUG_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 ) {
@@ -728 +729 @@
         for( __lock_size_t i = 0; i < count; i++) {
                 (criteria[i]){ monitors[i], waiter };
-                __cfaabi_dbg_print_safe( "Kernel :  target %p = %p\n", criteria[i].target, &criteria[i] );
+                LIB_DEBUG_PRINT_SAFE( "Kernel :  target %p = %p\n", criteria[i].target, &criteria[i] );
                 push( criteria[i].target->signal_stack, &criteria[i] );
         }
@@ -737 +738 @@
 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] __cfaabi_dbg_ctx2 );
+                DO_LOCK( *locks[i] DEBUG_CTX2 );
         }
 }
@@ -744 +745 @@
         for( __lock_size_t i = 0; i < count; i++ ) {
                 __spinlock_t * l = &source[i]->lock;
-                DO_LOCK( *l __cfaabi_dbg_ctx2 );
+                DO_LOCK( *l DEBUG_CTX2 );
                 if(locks) locks[i] = l;
         }
@@ -802 +803 @@
         for(    int i = 0; i < count; i++ ) {
 
-                // __cfaabi_dbg_print_safe( "Checking %p for %p\n", &criteria[i], target );
+                // LIB_DEBUG_PRINT_SAFE( "Checking %p for %p\n", &criteria[i], target );
                 if( &criteria[i] == target ) {
                         criteria[i].ready = true;
-                        // __cfaabi_dbg_print_safe( "True\n" );
+                        // LIB_DEBUG_PRINT_SAFE( "True\n" );
                 }
 
@@ -811 +812 @@
         }
 
-        __cfaabi_dbg_print_safe( "Kernel :  Runing %i (%p)\n", ready2run, ready2run ? node->waiting_thread : NULL );
+        LIB_DEBUG_PRINT_SAFE( "Kernel :  Runing %i (%p)\n", ready2run, ready2run ? node->waiting_thread : NULL );
         return ready2run ? node->waiting_thread : NULL;
 }
@@ -818 +819 @@
         thread_desc * thrd = this_thread;
         if( !this.monitors ) {
-                // __cfaabi_dbg_print_safe("Branding\n");
+                // LIB_DEBUG_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;

src/libcfa/concurrency/preemption.c

@@ -14 +14 @@
 //
 
+#include "libhdr.h"
 #include "preemption.h"
 
@@ -147 +148 @@
 //=============================================================================================
 
-__cfaabi_dbg_debug_do( static thread_local void * last_interrupt = 0; )
+LIB_DEBUG_DO( static thread_local void * last_interrupt = 0; )
 
 extern "C" {
@@ -158 +159 @@
         // Enable interrupts by decrementing the counter
         // If counter reaches 0, execute any pending CtxSwitch
-        void enable_interrupts( __cfaabi_dbg_ctx_param ) {
+        void enable_interrupts( DEBUG_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
@@ -172 +173 @@
 
                 // For debugging purposes : keep track of the last person to enable the interrupts
-                __cfaabi_dbg_debug_do( proc->last_enable = caller; )
+                LIB_DEBUG_DO( proc->last_enable = caller; )
         }
 
@@ -232 +233 @@
 // Called from kernel_startup
 void kernel_start_preemption() {
-        __cfaabi_dbg_print_safe("Kernel : Starting preemption\n");
+        LIB_DEBUG_PRINT_SAFE("Kernel : Starting preemption\n");
 
         // Start with preemption disabled until ready
@@ -254 +255 @@
 // Called from kernel_shutdown
 void kernel_stop_preemption() {
-        __cfaabi_dbg_print_safe("Kernel : Preemption stopping\n");
+        LIB_DEBUG_PRINT_SAFE("Kernel : Preemption stopping\n");
 
         // Block all signals since we are already shutting down
@@ -270 +271 @@
         // Preemption is now fully stopped
 
-        __cfaabi_dbg_print_safe("Kernel : Preemption stopped\n");
+        LIB_DEBUG_PRINT_SAFE("Kernel : Preemption stopped\n");
 }
 
@@ -296 +297 @@
 // Receives SIGUSR1 signal and causes the current thread to yield
 void sigHandler_ctxSwitch( __CFA_SIGPARMS__ ) {
-        __cfaabi_dbg_debug_do( last_interrupt = (void *)(cxt->uc_mcontext.gregs[CFA_REG_IP]); )
+        LIB_DEBUG_DO( last_interrupt = (void *)(cxt->uc_mcontext.gregs[CFA_REG_IP]); )
 
         // Check if it is safe to preempt here
@@ -345 +346 @@
                 assertf(sig == SIGALRM, "Kernel Internal Error, sigwait: Unexpected signal %d (%d : %d)\n", sig, 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 );
+                // LIB_DEBUG_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 )
@@ -353 +354 @@
                 case SI_TIMER:
                 case SI_KERNEL:
-                        // __cfaabi_dbg_print_safe("Kernel : Preemption thread tick\n");
-                        lock( event_kernel->lock __cfaabi_dbg_ctx2 );
+                        // LIB_DEBUG_PRINT_SAFE("Kernel : Preemption thread tick\n");
+                        lock( event_kernel->lock DEBUG_CTX2 );
                         tick_preemption();
                         unlock( event_kernel->lock );
@@ -367 +368 @@
 
 EXIT:
-        __cfaabi_dbg_print_safe("Kernel : Preemption thread stopping\n");
+        LIB_DEBUG_PRINT_SAFE("Kernel : Preemption thread stopping\n");
         return NULL;
 }
@@ -379 +380 @@
 
         if ( sigaction( sig, &act, NULL ) == -1 ) {
-                __cfaabi_dbg_print_buffer_decl(
+                LIB_DEBUG_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 )
@@ -396 +397 @@
 
         if ( sigaction( sig, &act, NULL ) == -1 ) {
-                __cfaabi_dbg_print_buffer_decl(
+                LIB_DEBUG_PRINT_BUFFER_DECL(
                         " __kernel_sigdefault( sig:%d ), problem reseting signal handler, error(%d) %s.\n",
                         sig, errno, strerror( errno )
@@ -408 +409 @@
 //=============================================================================================
 
-__cfaabi_dbg_debug_do(
+LIB_DEBUG_DO(
         static void __kernel_backtrace( int start ) {
                 // skip first N stack frames
@@ -475 +476 @@
 
 // void sigHandler_segv( __CFA_SIGPARMS__ ) {
-//      __cfaabi_dbg_debug_do(
+//      LIB_DEBUG_DO(
 //              #ifdef __USE_STREAM__
 //              serr    | "*CFA runtime error* program cfa-cpp terminated with"
@@ -492 +493 @@
 // void sigHandler_abort( __CFA_SIGPARMS__ ) {
 //      // skip first 6 stack frames
-//      __cfaabi_dbg_debug_do( __kernel_backtrace( 6 ); )
+//      LIB_DEBUG_DO( __kernel_backtrace( 6 ); )
 
 //      // reset default signal handler

src/libcfa/concurrency/thread.c

@@ -17 +17 @@
 
 #include "kernel_private.h"
+#include "libhdr.h"
 
 #define __CFA_INVOKE_PRIVATE__
@@ -71 +72 @@
         thrd_c->last = this_coroutine;
 
-        // __cfaabi_dbg_print_safe("Thread start : %p (t %p, c %p)\n", this, thrd_c, thrd_h);
+        // LIB_DEBUG_PRINT_SAFE("Thread start : %p (t %p, c %p)\n", this, thrd_c, thrd_h);
 
         disable_interrupts();
@@ -81 +82 @@
 
         ScheduleThread(thrd_h);
-        enable_interrupts( __cfaabi_dbg_ctx );
+        enable_interrupts( DEBUG_CTX );
 }
 

src/libcfa/exception.c

@@ -23 +23 @@
 #include <stdio.h>
 #include <unwind.h>
-#include <bits/debug.h>
+#include <libhdr/libdebug.h>
 
 // FIX ME: temporary hack to keep ARM build working
@@ -37 +37 @@
 
 // Base exception vtable is abstract, you should not have base exceptions.
-struct __cfaabi_ehm__base_exception_t_vtable
-                ___cfaabi_ehm__base_exception_t_vtable_instance = {
+struct __cfaehm__base_exception_t_vtable
+                ___cfaehm__base_exception_t_vtable_instance = {
         .parent = NULL,
         .size = 0,
@@ -49 +49 @@
 // Temperary global exception context. Does not work with concurency.
 struct exception_context_t {
-    struct __cfaabi_ehm__try_resume_node * top_resume;
-    struct __cfaabi_ehm__try_resume_node * current_resume;
+    struct __cfaehm__try_resume_node * top_resume;
+    struct __cfaehm__try_resume_node * current_resume;
 
     exception * current_exception;
@@ -78 +78 @@
 // RESUMPTION ================================================================
 
-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 =
+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 =
                 (original_head) ? original_head->next : shared_stack.top_resume;
 
@@ -94 +94 @@
         }
 
-        __cfaabi_dbg_print_safe("Unhandled exception\n");
+        LIB_DEBUG_PRINT_SAFE("Unhandled exception\n");
         shared_stack.current_resume = original_head;
 
         // Fall back to termination:
-        __cfaabi_ehm__throw_terminate(except);
+        __cfaehm__throw_terminate(except);
         // TODO: Default handler for resumption.
 }
@@ -105 +105 @@
 // hook has to be added after the node is built but before it is made the top node.
 
-void __cfaabi_ehm__try_resume_setup(struct __cfaabi_ehm__try_resume_node * node,
+void __cfaehm__try_resume_setup(struct __cfaehm__try_resume_node * node,
                         _Bool (*handler)(exception * except)) {
         node->next = shared_stack.top_resume;
@@ -112 +112 @@
 }
 
-void __cfaabi_ehm__try_resume_cleanup(struct __cfaabi_ehm__try_resume_node * node) {
+void __cfaehm__try_resume_cleanup(struct __cfaehm__try_resume_node * node) {
         shared_stack.top_resume = node->next;
 }
@@ -122 +122 @@
 // May have to move to cfa for constructors and destructors (references).
 
-struct __cfaabi_ehm__node {
-        struct __cfaabi_ehm__node * next;
+struct __cfaehm__node {
+        struct __cfaehm__node * next;
 };
 
 #define NODE_TO_EXCEPT(node) ((exception *)(1 + (node)))
-#define EXCEPT_TO_NODE(except) ((struct __cfaabi_ehm__node *)(except) - 1)
+#define EXCEPT_TO_NODE(except) ((struct __cfaehm__node *)(except) - 1)
 
 // Creates a copy of the indicated exception and sets current_exception to it.
-static void __cfaabi_ehm__allocate_exception( exception * except ) {
+static void __cfaehm__allocate_exception( exception * except ) {
         struct exception_context_t * context = this_exception_context();
 
         // Allocate memory for the exception.
-        struct __cfaabi_ehm__node * store = malloc(
-                sizeof( struct __cfaabi_ehm__node ) + except->virtual_table->size );
+        struct __cfaehm__node * store = malloc(
+                sizeof( struct __cfaehm__node ) + except->virtual_table->size );
 
         if ( ! store ) {
@@ -151 +151 @@
 
 // Delete the provided exception, unsetting current_exception if relivant.
-static void __cfaabi_ehm__delete_exception( exception * except ) {
+static void __cfaehm__delete_exception( exception * except ) {
         struct exception_context_t * context = this_exception_context();
 
-        __cfaabi_dbg_print_safe("Deleting Exception\n");
+        LIB_DEBUG_PRINT_SAFE("Deleting Exception\n");
 
         // Remove the exception from the list.
-        struct __cfaabi_ehm__node * to_free = EXCEPT_TO_NODE(except);
-        struct __cfaabi_ehm__node * node;
+        struct __cfaehm__node * to_free = EXCEPT_TO_NODE(except);
+        struct __cfaehm__node * node;
 
         if ( context->current_exception == except ) {
@@ -178 +178 @@
 
 // If this isn't a rethrow (*except==0), delete the provided exception.
-void __cfaabi_ehm__cleanup_terminate( void * except ) {
-        if ( *(void**)except ) __cfaabi_ehm__delete_exception( *(exception**)except );
+void __cfaehm__cleanup_terminate( void * except ) {
+        if ( *(void**)except ) __cfaehm__delete_exception( *(exception**)except );
 }
 
@@ -202 +202 @@
 
 // The exception that is being thrown must already be stored.
-__attribute__((noreturn)) void __cfaabi_ehm__begin_unwind(void) {
+__attribute__((noreturn)) void __cfaehm__begin_unwind(void) {
         if ( ! this_exception_context()->current_exception ) {
                 printf("UNWIND ERROR missing exception in begin unwind\n");
@@ -233 +233 @@
 }
 
-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();
+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();
 }
 
@@ -254 +254 @@
 {
 
-        //__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);
+        //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);
 
         // If we've reached the end of the stack then there is nothing much we can do...
@@ -261 +261 @@
 
         if (actions & _UA_SEARCH_PHASE) {
-                __cfaabi_dbg_print_safe(" lookup phase");
+                LIB_DEBUG_PRINT_SAFE(" lookup phase");
         }
         else if (actions & _UA_CLEANUP_PHASE) {
-                __cfaabi_dbg_print_safe(" cleanup phase");
+                LIB_DEBUG_PRINT_SAFE(" cleanup phase");
         }
         // Just in case, probably can't actually happen
@@ -307 +307 @@
                         void * ep = (void*)lsd_info.Start + callsite_start + callsite_len;
                         void * ip = (void*)instruction_ptr;
-                        __cfaabi_dbg_print_safe("\nfound %p - %p (%p, %p, %p), looking for %p\n", bp, ep, ls, cs, cl, ip);
+                        LIB_DEBUG_PRINT_SAFE("\nfound %p - %p (%p, %p, %p), looking for %p\n", bp, ep, ls, cs, cl, ip);
 #endif // __CFA_DEBUG_PRINT__
                         continue;
@@ -346 +346 @@
 
                                         // 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 +357 @@
                                         // Based on the return value, check if we matched the exception
                                         if( ret == _URC_HANDLER_FOUND) {
-                                                __cfaabi_dbg_print_safe(" handler found\n");
+                                                LIB_DEBUG_PRINT_SAFE(" handler found\n");
                                         } else {
-                                                __cfaabi_dbg_print_safe(" no handler\n");
+                                                LIB_DEBUG_PRINT_SAFE(" no handler\n");
                                         }
                                         return ret;
@@ -365 +365 @@
 
                                 // This is only a cleanup handler, ignore it
-                                __cfaabi_dbg_print_safe(" no action");
+                                LIB_DEBUG_PRINT_SAFE(" no action");
                         }
                         else if (actions & _UA_CLEANUP_PHASE) {
@@ -385 +385 @@
                                 _Unwind_SetIP( context, ((lsd_info.LPStart) + (callsite_landing_pad)) );
 
-                                __cfaabi_dbg_print_safe(" action\n");
+                                LIB_DEBUG_PRINT_SAFE(" action\n");
 
                                 // Return have some action to run
@@ -393 +393 @@
 
                 // Nothing to do, move along
-                __cfaabi_dbg_print_safe(" no landing pad");
+                LIB_DEBUG_PRINT_SAFE(" no landing pad");
         }
         // No handling found
-        __cfaabi_dbg_print_safe(" table end reached\n");
+        LIB_DEBUG_PRINT_SAFE(" table end reached\n");
 
         UNWIND:
-        __cfaabi_dbg_print_safe(" unwind\n");
+        LIB_DEBUG_PRINT_SAFE(" unwind\n");
 
         // Keep unwinding the stack
@@ -408 +408 @@
 // libcfa but there is one problem left, see the exception table for details
 __attribute__((noinline))
-void __cfaabi_ehm__try_terminate(void (*try_block)(),
+void __cfaehm__try_terminate(void (*try_block)(),
                 void (*catch_block)(int index, exception * except),
                 __attribute__((unused)) int (*match_block)(exception * except)) {
@@ -466 +466 @@
         // Body uses language specific data and therefore could be modified arbitrarily
         ".LLSDACSBCFA2:\n"                                              // BODY start
-        "       .uleb128 .TRYSTART-__cfaabi_ehm__try_terminate\n"               // Handled area start  (relative to start of function)
+        "       .uleb128 .TRYSTART-__cfaehm__try_terminate\n"           // Handled area start  (relative to start of function)
         "       .uleb128 .TRYEND-.TRYSTART\n"                           // Handled area length
-        "       .uleb128 .CATCH-__cfaabi_ehm__try_terminate\n"                          // Hanlder landing pad adress  (relative to start of function)
+        "       .uleb128 .CATCH-__cfaehm__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   __cfaabi_ehm__try_terminate, .-__cfaabi_ehm__try_terminate\n"
+        "       .size   __cfaehm__try_terminate, .-__cfaehm__try_terminate\n"
         "       .ident  \"GCC: (Ubuntu 6.2.0-3ubuntu11~16.04) 6.2.0 20160901\"\n"
 //      "       .section        .note.GNU-stack,\"x\",@progbits\n"

src/libcfa/exception.h

@@ -21 +21 @@
 #endif
 
-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;
+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;
         size_t size;
-        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);
+        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);
 };
-struct __cfaabi_ehm__base_exception_t {
-        struct __cfaabi_ehm__base_exception_t_vtable const * virtual_table;
+struct __cfaehm__base_exception_t {
+        struct __cfaehm__base_exception_t_vtable const * virtual_table;
 };
-extern struct __cfaabi_ehm__base_exception_t_vtable
-        ___cfaabi_ehm__base_exception_t_vtable_instance;
+extern struct __cfaehm__base_exception_t_vtable
+        ___cfaehm__base_exception_t_vtable_instance;
 
 
 // Used in throw statement translation.
-void __cfaabi_ehm__throw_terminate(exception * except) __attribute__((noreturn));
-void __cfaabi_ehm__rethrow_terminate() __attribute__((noreturn));
-void __cfaabi_ehm__throw_resume(exception * except);
+void __cfaehm__throw_terminate(exception * except) __attribute__((noreturn));
+void __cfaehm__rethrow_terminate() __attribute__((noreturn));
+void __cfaehm__throw_resume(exception * except);
 
 // Function catches termination exceptions.
-void __cfaabi_ehm__try_terminate(
+void __cfaehm__try_terminate(
     void (*try_block)(),
     void (*catch_block)(int index, exception * except),
@@ -50 +50 @@
 
 // Clean-up the exception in catch blocks.
-void __cfaabi_ehm__cleanup_terminate(void * except);
+void __cfaehm__cleanup_terminate(void * except);
 
 // Data structure creates a list of resume handlers.
-struct __cfaabi_ehm__try_resume_node {
-    struct __cfaabi_ehm__try_resume_node * next;
+struct __cfaehm__try_resume_node {
+    struct __cfaehm__try_resume_node * next;
     _Bool (*handler)(exception * except);
 };
 
 // These act as constructor and destructor for the resume node.
-void __cfaabi_ehm__try_resume_setup(
-    struct __cfaabi_ehm__try_resume_node * node,
+void __cfaehm__try_resume_setup(
+    struct __cfaehm__try_resume_node * node,
     _Bool (*handler)(exception * except));
-void __cfaabi_ehm__try_resume_cleanup(
-    struct __cfaabi_ehm__try_resume_node * node);
+void __cfaehm__try_resume_cleanup(
+    struct __cfaehm__try_resume_node * node);
 
 // Check for a standard way to call fake deconstructors.
-struct __cfaabi_ehm__cleanup_hook {};
+struct __cfaehm__cleanup_hook {};
 
 #ifdef __cforall

src/libcfa/interpose.c

@@ -24 +24 @@
 }
 
-#include "bits/debug.h"
-#include "bits/defs.h"
+#include "libhdr/libdebug.h"
+#include "libhdr/libtools.h"
 #include "startup.h"
 
@@ -69 +69 @@
 __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)
@@ -125 +127 @@
                         va_end( args );
 
-                        __cfaabi_dbg_bits_write( abort_text, len );
-                        __cfaabi_dbg_bits_write( "\n", 1 );
+                        __lib_debug_write( abort_text, len );
+                        __lib_debug_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)
-                __cfaabi_dbg_bits_write( abort_text, len );
+                __lib_debug_write( abort_text, len );
 
 

src/libcfa/stdhdr/assert.h

@@ -30 +30 @@
 #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"

src/prelude/builtins.c

@@ -16 +16 @@
 // exception implementation
 
-typedef unsigned long long __cfaabi_abi_exception_type_t;
+typedef unsigned long long __cfaabi_exception_type_t;
 
 #include "../libcfa/virtual.h"
@@ -80 +80 @@
 } // ?\?
 
-// 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.
 

src/tests/except-mac.h

@@ -7 +7 @@
 
 // The fully (perhaps overly) qualified name of the base exception type:
-#define BASE_EXCEPT __cfaabi_ehm__base_exception_t
+#define BASE_EXCEPT __cfaehm__base_exception_t
 
 // Get the name of the vtable type and vtable instance for an exception type: