Changeset 3d560060


Ignore:
Timestamp:
Nov 30, 2017, 3:05:25 PM (4 years ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, deferred_resn, demangler, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, resolv-new, with_gc
Children:
557435e, 5da9d6a
Parents:
dd9b59e (diff), c2b9f21 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:
src
Files:
1 added
3 deleted
23 edited
2 moved

Legend:

Unmodified
Added
Removed
  • src/ControlStruct/ExceptTranslate.cc

    rdd9b59e r3d560060  
    211211                        ThrowStmt *throwStmt ) {
    212212                // __throw_terminate( `throwStmt->get_name()` ); }
    213                 return create_given_throw( "__cfaehm__throw_terminate", throwStmt );
     213                return create_given_throw( "__cfaabi_ehm__throw_terminate", throwStmt );
    214214        }
    215215
     
    232232                result->push_back( new ExprStmt(
    233233                        noLabels,
    234                         new UntypedExpr( new NameExpr( "__cfaehm__rethrow_terminate" ) )
     234                        new UntypedExpr( new NameExpr( "__cfaabi_ehm__rethrow_terminate" ) )
    235235                        ) );
    236236                delete throwStmt;
     
    241241                        ThrowStmt *throwStmt ) {
    242242                // __throw_resume( `throwStmt->get_name` );
    243                 return create_given_throw( "__cfaehm__throw_resume", throwStmt );
     243                return create_given_throw( "__cfaabi_ehm__throw_resume", throwStmt );
    244244        }
    245245
     
    309309                        local_except->get_attributes().push_back( new Attribute(
    310310                                "cleanup",
    311                                 { new NameExpr( "__cfaehm__cleanup_terminate" ) }
     311                                { new NameExpr( "__cfaabi_ehm__cleanup_terminate" ) }
    312312                                ) );
    313313
     
    432432                        FunctionDecl * terminate_catch,
    433433                        FunctionDecl * terminate_match ) {
    434                 // { __cfaehm__try_terminate(`try`, `catch`, `match`); }
     434                // { __cfaabi_ehm__try_terminate(`try`, `catch`, `match`); }
    435435
    436436                UntypedExpr * caller = new UntypedExpr( new NameExpr(
    437                         "__cfaehm__try_terminate" ) );
     437                        "__cfaabi_ehm__try_terminate" ) );
    438438                std::list<Expression *>& args = caller->get_args();
    439439                args.push_back( nameOf( try_wrapper ) );
     
    489489
    490490                // struct __try_resume_node __resume_node
    491                 //      __attribute__((cleanup( __cfaehm__try_resume_cleanup )));
     491                //      __attribute__((cleanup( __cfaabi_ehm__try_resume_cleanup )));
    492492                // ** unwinding of the stack here could cause problems **
    493493                // ** however I don't think that can happen currently **
    494                 // __cfaehm__try_resume_setup( &__resume_node, resume_handler );
     494                // __cfaabi_ehm__try_resume_setup( &__resume_node, resume_handler );
    495495
    496496                std::list< Attribute * > attributes;
     
    498498                        std::list< Expression * > attr_params;
    499499                        attr_params.push_back( new NameExpr(
    500                                 "__cfaehm__try_resume_cleanup" ) );
     500                                "__cfaabi_ehm__try_resume_cleanup" ) );
    501501                        attributes.push_back( new Attribute( "cleanup", attr_params ) );
    502502                }
     
    517517
    518518                UntypedExpr *setup = new UntypedExpr( new NameExpr(
    519                         "__cfaehm__try_resume_setup" ) );
     519                        "__cfaabi_ehm__try_resume_setup" ) );
    520520                setup->get_args().push_back( new AddressExpr( nameOf( obj ) ) );
    521521                setup->get_args().push_back( nameOf( resume_handler ) );
     
    542542        ObjectDecl * ExceptionMutatorCore::create_finally_hook(
    543543                        FunctionDecl * finally_wrapper ) {
    544                 // struct __cfaehm__cleanup_hook __finally_hook
     544                // struct __cfaabi_ehm__cleanup_hook __finally_hook
    545545                //      __attribute__((cleanup( finally_wrapper )));
    546546
     
    596596                        // Skip children?
    597597                        return;
    598                 } else if ( structDecl->get_name() == "__cfaehm__base_exception_t" ) {
     598                } else if ( structDecl->get_name() == "__cfaabi_ehm__base_exception_t" ) {
    599599                        assert( nullptr == except_decl );
    600600                        except_decl = structDecl;
    601601                        init_func_types();
    602                 } else if ( structDecl->get_name() == "__cfaehm__try_resume_node" ) {
     602                } else if ( structDecl->get_name() == "__cfaabi_ehm__try_resume_node" ) {
    603603                        assert( nullptr == node_decl );
    604604                        node_decl = structDecl;
    605                 } else if ( structDecl->get_name() == "__cfaehm__cleanup_hook" ) {
     605                } else if ( structDecl->get_name() == "__cfaabi_ehm__cleanup_hook" ) {
    606606                        assert( nullptr == hook_decl );
    607607                        hook_decl = structDecl;
  • src/ResolvExpr/Resolver.cc

    rdd9b59e r3d560060  
    369369                if ( throwStmt->get_expr() ) {
    370370                        StructDecl * exception_decl =
    371                                 indexer.lookupStruct( "__cfaehm__base_exception_t" );
     371                                indexer.lookupStruct( "__cfaabi_ehm__base_exception_t" );
    372372                        assert( exception_decl );
    373373                        Type * exceptType = new PointerType( noQualifiers, new StructInstType( noQualifiers, exception_decl ) );
  • src/driver/cfa.cc

    rdd9b59e r3d560060  
    275275                args[nargs] = "-Xlinker";
    276276                nargs += 1;
    277                 args[nargs] = "--undefined=__lib_debug_write";
     277                args[nargs] = "--undefined=__cfaabi_dbg_bits_write";
    278278                nargs += 1;
    279279
  • src/libcfa/Makefile.am

    rdd9b59e r3d560060  
    5555
    5656libobjs = ${headers:=.o}
    57 libsrc = libcfa-prelude.c interpose.c libhdr/libdebug.c ${headers:=.c} \
     57libsrc = libcfa-prelude.c interpose.c bits/debug.c ${headers:=.c} \
    5858         assert.c exception.c virtual.c
    5959
     
    100100        math                            \
    101101        gmp                             \
     102        bits/align.h            \
    102103        bits/containers.h               \
    103104        bits/defs.h             \
     105        bits/debug.h            \
    104106        bits/locks.h            \
    105         concurrency/invoke.h    \
    106         libhdr.h                        \
    107         libhdr/libalign.h       \
    108         libhdr/libdebug.h       \
    109         libhdr/libtools.h
     107        concurrency/invoke.h
    110108
    111109CLEANFILES = libcfa-prelude.c
  • src/libcfa/Makefile.in

    rdd9b59e r3d560060  
    149149libcfa_d_a_LIBADD =
    150150am__libcfa_d_a_SOURCES_DIST = libcfa-prelude.c interpose.c \
    151         libhdr/libdebug.c fstream.c iostream.c iterator.c limits.c \
     151        bits/debug.c fstream.c iostream.c iterator.c limits.c \
    152152        rational.c stdlib.c containers/maybe.c containers/pair.c \
    153153        containers/result.c containers/vector.c \
     
    175175@BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_d_a-preemption.$(OBJEXT)
    176176am__objects_4 = libcfa_d_a-libcfa-prelude.$(OBJEXT) \
    177         libcfa_d_a-interpose.$(OBJEXT) \
    178         libhdr/libcfa_d_a-libdebug.$(OBJEXT) $(am__objects_2) \
    179         libcfa_d_a-assert.$(OBJEXT) libcfa_d_a-exception.$(OBJEXT) \
    180         libcfa_d_a-virtual.$(OBJEXT) $(am__objects_3)
     177        libcfa_d_a-interpose.$(OBJEXT) bits/libcfa_d_a-debug.$(OBJEXT) \
     178        $(am__objects_2) libcfa_d_a-assert.$(OBJEXT) \
     179        libcfa_d_a-exception.$(OBJEXT) libcfa_d_a-virtual.$(OBJEXT) \
     180        $(am__objects_3)
    181181am_libcfa_d_a_OBJECTS = $(am__objects_4)
    182182libcfa_d_a_OBJECTS = $(am_libcfa_d_a_OBJECTS)
    183183libcfa_a_AR = $(AR) $(ARFLAGS)
    184184libcfa_a_LIBADD =
    185 am__libcfa_a_SOURCES_DIST = libcfa-prelude.c interpose.c \
    186         libhdr/libdebug.c fstream.c iostream.c iterator.c limits.c \
    187         rational.c stdlib.c containers/maybe.c containers/pair.c \
    188         containers/result.c containers/vector.c \
    189         concurrency/coroutine.c concurrency/thread.c \
    190         concurrency/kernel.c concurrency/monitor.c assert.c \
    191         exception.c virtual.c concurrency/CtxSwitch-@MACHINE_TYPE@.S \
    192         concurrency/alarm.c concurrency/invoke.c \
    193         concurrency/preemption.c
     185am__libcfa_a_SOURCES_DIST = libcfa-prelude.c interpose.c bits/debug.c \
     186        fstream.c iostream.c iterator.c limits.c rational.c stdlib.c \
     187        containers/maybe.c containers/pair.c containers/result.c \
     188        containers/vector.c concurrency/coroutine.c \
     189        concurrency/thread.c concurrency/kernel.c \
     190        concurrency/monitor.c assert.c exception.c virtual.c \
     191        concurrency/CtxSwitch-@MACHINE_TYPE@.S concurrency/alarm.c \
     192        concurrency/invoke.c concurrency/preemption.c
    194193@BUILD_CONCURRENCY_TRUE@am__objects_5 = concurrency/libcfa_a-coroutine.$(OBJEXT) \
    195194@BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_a-thread.$(OBJEXT) \
     
    208207@BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_a-preemption.$(OBJEXT)
    209208am__objects_8 = libcfa_a-libcfa-prelude.$(OBJEXT) \
    210         libcfa_a-interpose.$(OBJEXT) \
    211         libhdr/libcfa_a-libdebug.$(OBJEXT) $(am__objects_6) \
    212         libcfa_a-assert.$(OBJEXT) libcfa_a-exception.$(OBJEXT) \
    213         libcfa_a-virtual.$(OBJEXT) $(am__objects_7)
     209        libcfa_a-interpose.$(OBJEXT) bits/libcfa_a-debug.$(OBJEXT) \
     210        $(am__objects_6) libcfa_a-assert.$(OBJEXT) \
     211        libcfa_a-exception.$(OBJEXT) libcfa_a-virtual.$(OBJEXT) \
     212        $(am__objects_7)
    214213am_libcfa_a_OBJECTS = $(am__objects_8)
    215214libcfa_a_OBJECTS = $(am_libcfa_a_OBJECTS)
     
    264263        containers/result containers/vector concurrency/coroutine \
    265264        concurrency/thread concurrency/kernel concurrency/monitor \
    266         ${shell echo stdhdr/*} math gmp bits/containers.h bits/defs.h \
    267         bits/locks.h concurrency/invoke.h libhdr.h libhdr/libalign.h \
    268         libhdr/libdebug.h libhdr/libtools.h
     265        ${shell echo stdhdr/*} math gmp bits/align.h bits/containers.h \
     266        bits/defs.h bits/debug.h bits/locks.h concurrency/invoke.h
    269267HEADERS = $(nobase_cfa_include_HEADERS)
    270268am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
     
    424422        containers/vector $(am__append_3)
    425423libobjs = ${headers:=.o}
    426 libsrc = libcfa-prelude.c interpose.c libhdr/libdebug.c ${headers:=.c} \
     424libsrc = libcfa-prelude.c interpose.c bits/debug.c ${headers:=.c} \
    427425        assert.c exception.c virtual.c $(am__append_4)
    428426libcfa_a_SOURCES = ${libsrc}
     
    437435        math                            \
    438436        gmp                             \
     437        bits/align.h            \
    439438        bits/containers.h               \
    440439        bits/defs.h             \
     440        bits/debug.h            \
    441441        bits/locks.h            \
    442         concurrency/invoke.h    \
    443         libhdr.h                        \
    444         libhdr/libalign.h       \
    445         libhdr/libdebug.h       \
    446         libhdr/libtools.h
     442        concurrency/invoke.h
    447443
    448444CLEANFILES = libcfa-prelude.c
     
    511507clean-libLIBRARIES:
    512508        -test -z "$(lib_LIBRARIES)" || rm -f $(lib_LIBRARIES)
    513 libhdr/$(am__dirstamp):
    514         @$(MKDIR_P) libhdr
    515         @: > libhdr/$(am__dirstamp)
    516 libhdr/$(DEPDIR)/$(am__dirstamp):
    517         @$(MKDIR_P) libhdr/$(DEPDIR)
    518         @: > libhdr/$(DEPDIR)/$(am__dirstamp)
    519 libhdr/libcfa_d_a-libdebug.$(OBJEXT): libhdr/$(am__dirstamp) \
    520         libhdr/$(DEPDIR)/$(am__dirstamp)
     509bits/$(am__dirstamp):
     510        @$(MKDIR_P) bits
     511        @: > bits/$(am__dirstamp)
     512bits/$(DEPDIR)/$(am__dirstamp):
     513        @$(MKDIR_P) bits/$(DEPDIR)
     514        @: > bits/$(DEPDIR)/$(am__dirstamp)
     515bits/libcfa_d_a-debug.$(OBJEXT): bits/$(am__dirstamp) \
     516        bits/$(DEPDIR)/$(am__dirstamp)
    521517containers/$(am__dirstamp):
    522518        @$(MKDIR_P) containers
     
    563559        $(AM_V_AR)$(libcfa_d_a_AR) libcfa-d.a $(libcfa_d_a_OBJECTS) $(libcfa_d_a_LIBADD)
    564560        $(AM_V_at)$(RANLIB) libcfa-d.a
    565 libhdr/libcfa_a-libdebug.$(OBJEXT): libhdr/$(am__dirstamp) \
    566         libhdr/$(DEPDIR)/$(am__dirstamp)
     561bits/libcfa_a-debug.$(OBJEXT): bits/$(am__dirstamp) \
     562        bits/$(DEPDIR)/$(am__dirstamp)
    567563containers/libcfa_a-maybe.$(OBJEXT): containers/$(am__dirstamp) \
    568564        containers/$(DEPDIR)/$(am__dirstamp)
     
    596592mostlyclean-compile:
    597593        -rm -f *.$(OBJEXT)
     594        -rm -f bits/*.$(OBJEXT)
    598595        -rm -f concurrency/*.$(OBJEXT)
    599596        -rm -f containers/*.$(OBJEXT)
    600         -rm -f libhdr/*.$(OBJEXT)
    601597
    602598distclean-compile:
     
    625621@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_d_a-stdlib.Po@am__quote@
    626622@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_d_a-virtual.Po@am__quote@
     623@AMDEP_TRUE@@am__include@ @am__quote@bits/$(DEPDIR)/libcfa_a-debug.Po@am__quote@
     624@AMDEP_TRUE@@am__include@ @am__quote@bits/$(DEPDIR)/libcfa_d_a-debug.Po@am__quote@
    627625@AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/CtxSwitch-@MACHINE_TYPE@.Po@am__quote@
    628626@AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_a-alarm.Po@am__quote@
     
    648646@AMDEP_TRUE@@am__include@ @am__quote@containers/$(DEPDIR)/libcfa_d_a-result.Po@am__quote@
    649647@AMDEP_TRUE@@am__include@ @am__quote@containers/$(DEPDIR)/libcfa_d_a-vector.Po@am__quote@
    650 @AMDEP_TRUE@@am__include@ @am__quote@libhdr/$(DEPDIR)/libcfa_a-libdebug.Po@am__quote@
    651 @AMDEP_TRUE@@am__include@ @am__quote@libhdr/$(DEPDIR)/libcfa_d_a-libdebug.Po@am__quote@
    652648
    653649.S.o:
     
    704700@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`
    705701
    706 libhdr/libcfa_d_a-libdebug.o: libhdr/libdebug.c
    707 @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
    708 @am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) libhdr/$(DEPDIR)/libcfa_d_a-libdebug.Tpo libhdr/$(DEPDIR)/libcfa_d_a-libdebug.Po
    709 @AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='libhdr/libdebug.c' object='libhdr/libcfa_d_a-libdebug.o' libtool=no @AMDEPBACKSLASH@
    710 @AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
    711 @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
    712 
    713 libhdr/libcfa_d_a-libdebug.obj: libhdr/libdebug.c
    714 @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`
    715 @am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) libhdr/$(DEPDIR)/libcfa_d_a-libdebug.Tpo libhdr/$(DEPDIR)/libcfa_d_a-libdebug.Po
    716 @AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='libhdr/libdebug.c' object='libhdr/libcfa_d_a-libdebug.obj' libtool=no @AMDEPBACKSLASH@
    717 @AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
    718 @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`
     702bits/libcfa_d_a-debug.o: bits/debug.c
     703@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
     704@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) bits/$(DEPDIR)/libcfa_d_a-debug.Tpo bits/$(DEPDIR)/libcfa_d_a-debug.Po
     705@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='bits/debug.c' object='bits/libcfa_d_a-debug.o' libtool=no @AMDEPBACKSLASH@
     706@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
     707@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
     708
     709bits/libcfa_d_a-debug.obj: bits/debug.c
     710@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`
     711@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) bits/$(DEPDIR)/libcfa_d_a-debug.Tpo bits/$(DEPDIR)/libcfa_d_a-debug.Po
     712@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='bits/debug.c' object='bits/libcfa_d_a-debug.obj' libtool=no @AMDEPBACKSLASH@
     713@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
     714@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`
    719715
    720716libcfa_d_a-fstream.o: fstream.c
     
    998994@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`
    999995
    1000 libhdr/libcfa_a-libdebug.o: libhdr/libdebug.c
    1001 @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
    1002 @am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) libhdr/$(DEPDIR)/libcfa_a-libdebug.Tpo libhdr/$(DEPDIR)/libcfa_a-libdebug.Po
    1003 @AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='libhdr/libdebug.c' object='libhdr/libcfa_a-libdebug.o' libtool=no @AMDEPBACKSLASH@
    1004 @AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
    1005 @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
    1006 
    1007 libhdr/libcfa_a-libdebug.obj: libhdr/libdebug.c
    1008 @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`
    1009 @am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) libhdr/$(DEPDIR)/libcfa_a-libdebug.Tpo libhdr/$(DEPDIR)/libcfa_a-libdebug.Po
    1010 @AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='libhdr/libdebug.c' object='libhdr/libcfa_a-libdebug.obj' libtool=no @AMDEPBACKSLASH@
    1011 @AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
    1012 @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`
     996bits/libcfa_a-debug.o: bits/debug.c
     997@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
     998@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) bits/$(DEPDIR)/libcfa_a-debug.Tpo bits/$(DEPDIR)/libcfa_a-debug.Po
     999@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='bits/debug.c' object='bits/libcfa_a-debug.o' libtool=no @AMDEPBACKSLASH@
     1000@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
     1001@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
     1002
     1003bits/libcfa_a-debug.obj: bits/debug.c
     1004@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`
     1005@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) bits/$(DEPDIR)/libcfa_a-debug.Tpo bits/$(DEPDIR)/libcfa_a-debug.Po
     1006@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='bits/debug.c' object='bits/libcfa_a-debug.obj' libtool=no @AMDEPBACKSLASH@
     1007@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
     1008@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`
    10131009
    10141010libcfa_a-fstream.o: fstream.c
     
    14111407        -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
    14121408        -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
     1409        -rm -f bits/$(DEPDIR)/$(am__dirstamp)
     1410        -rm -f bits/$(am__dirstamp)
    14131411        -rm -f concurrency/$(DEPDIR)/$(am__dirstamp)
    14141412        -rm -f concurrency/$(am__dirstamp)
    14151413        -rm -f containers/$(DEPDIR)/$(am__dirstamp)
    14161414        -rm -f containers/$(am__dirstamp)
    1417         -rm -f libhdr/$(DEPDIR)/$(am__dirstamp)
    1418         -rm -f libhdr/$(am__dirstamp)
    14191415
    14201416maintainer-clean-generic:
     
    14261422
    14271423distclean: distclean-am
    1428         -rm -rf ./$(DEPDIR) concurrency/$(DEPDIR) containers/$(DEPDIR) libhdr/$(DEPDIR)
     1424        -rm -rf ./$(DEPDIR) bits/$(DEPDIR) concurrency/$(DEPDIR) containers/$(DEPDIR)
    14291425        -rm -f Makefile
    14301426distclean-am: clean-am distclean-compile distclean-generic \
     
    14721468
    14731469maintainer-clean: maintainer-clean-am
    1474         -rm -rf ./$(DEPDIR) concurrency/$(DEPDIR) containers/$(DEPDIR) libhdr/$(DEPDIR)
     1470        -rm -rf ./$(DEPDIR) bits/$(DEPDIR) concurrency/$(DEPDIR) containers/$(DEPDIR)
    14751471        -rm -f Makefile
    14761472maintainer-clean-am: distclean-am maintainer-clean-generic \
  • src/libcfa/assert.c

    rdd9b59e r3d560060  
    1717#include <stdarg.h>                                                             // varargs
    1818#include <stdio.h>                                                              // fprintf
    19 #include "libhdr/libdebug.h"
     19#include "bits/debug.h"
    2020
    2121extern "C" {
     
    2626        // called by macro assert in assert.h
    2727        void __assert_fail( const char *assertion, const char *file, unsigned int line, const char *function ) {
    28                 __lib_debug_print_safe( CFA_ASSERT_FMT ".\n", __progname, function, line, file );
     28                __cfaabi_dbg_bits_print_safe( CFA_ASSERT_FMT ".\n", __progname, function, line, file );
    2929                abort();
    3030        }
     
    3232        // called by macro assertf
    3333        void __assert_fail_f( const char *assertion, const char *file, unsigned int line, const char *function, const char *fmt, ... ) {
    34                 __lib_debug_acquire();
    35                 __lib_debug_print_nolock( CFA_ASSERT_FMT ": ", __progname, function, line, file );
     34                __cfaabi_dbg_bits_acquire();
     35                __cfaabi_dbg_bits_print_nolock( CFA_ASSERT_FMT ": ", __progname, function, line, file );
    3636
    3737                va_list args;
    3838                va_start( args, fmt );
    39                 __lib_debug_print_vararg( fmt, args );
     39                __cfaabi_dbg_bits_print_vararg( fmt, args );
    4040                va_end( args );
    4141
    42                 __lib_debug_print_nolock( "\n" );
    43                 __lib_debug_release();
     42                __cfaabi_dbg_bits_print_nolock( "\n" );
     43                __cfaabi_dbg_bits_release();
    4444                abort();
    4545        }
  • src/libcfa/bits/align.h

    rdd9b59e r3d560060  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // libdebug.h --
     7// align.h --
    88//
    99// Author           : Thierry Delisle
  • src/libcfa/bits/containers.h

    rdd9b59e r3d560060  
    1515#pragma once
    1616
     17#include "bits/align.h"
    1718#include "bits/defs.h"
    18 #include "libhdr.h"
    1919
    2020//-----------------------------------------------------------------------------
  • src/libcfa/bits/debug.c

    rdd9b59e r3d560060  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // libdebug.c --
     7// debug.c --
    88//
    99// Author           : Thierry Delisle
     
    2828extern "C" {
    2929
    30         void __lib_debug_write( const char *in_buffer, int len ) {
     30        void __cfaabi_dbg_bits_write( const char *in_buffer, int len ) {
    3131                // ensure all data is written
    3232                for ( int count = 0, retcode; count < len; count += retcode ) {
     
    4444        }
    4545
    46         void __lib_debug_acquire() __attribute__((__weak__)) {}
    47         void __lib_debug_release() __attribute__((__weak__)) {}
     46        void __cfaabi_dbg_bits_acquire() __attribute__((__weak__)) {}
     47        void __cfaabi_dbg_bits_release() __attribute__((__weak__)) {}
    4848
    49         void __lib_debug_print_safe  ( const char fmt[], ... ) __attribute__(( format (printf, 1, 2) )) {
     49        void __cfaabi_dbg_bits_print_safe  ( const char fmt[], ... ) __attribute__(( format (printf, 1, 2) )) {
    5050                va_list args;
    5151
    5252                va_start( args, fmt );
    53                 __lib_debug_acquire();
     53                __cfaabi_dbg_bits_acquire();
    5454
    5555                int len = vsnprintf( buffer, buffer_size, fmt, args );
    56                 __lib_debug_write( buffer, len );
     56                __cfaabi_dbg_bits_write( buffer, len );
    5757
    58                 __lib_debug_release();
     58                __cfaabi_dbg_bits_release();
    5959                va_end( args );
    6060        }
    6161
    62         void __lib_debug_print_nolock( const char fmt[], ... ) __attribute__(( format (printf, 1, 2) )) {
     62        void __cfaabi_dbg_bits_print_nolock( const char fmt[], ... ) __attribute__(( format (printf, 1, 2) )) {
    6363                va_list args;
    6464
     
    6666
    6767                int len = vsnprintf( buffer, buffer_size, fmt, args );
    68                 __lib_debug_write( buffer, len );
     68                __cfaabi_dbg_bits_write( buffer, len );
    6969
    7070                va_end( args );
    7171        }
    7272
    73         void __lib_debug_print_vararg( const char fmt[], va_list args ) {
     73        void __cfaabi_dbg_bits_print_vararg( const char fmt[], va_list args ) {
    7474                int len = vsnprintf( buffer, buffer_size, fmt, args );
    75                 __lib_debug_write( buffer, len );
     75                __cfaabi_dbg_bits_write( buffer, len );
    7676        }
    7777
    78         void __lib_debug_print_buffer( char in_buffer[], int in_buffer_size, const char fmt[], ... ) __attribute__(( format (printf, 3, 4) )) {
     78        void __cfaabi_dbg_bits_print_buffer( char in_buffer[], int in_buffer_size, const char fmt[], ... ) __attribute__(( format (printf, 3, 4) )) {
    7979                va_list args;
    8080
     
    8282
    8383                int len = vsnprintf( in_buffer, in_buffer_size, fmt, args );
    84                 __lib_debug_write( in_buffer, len );
     84                __cfaabi_dbg_bits_write( in_buffer, len );
    8585
    8686                va_end( args );
  • src/libcfa/bits/defs.h

    rdd9b59e r3d560060  
    3232#define __cfa_anonymous_object __cfa_anonymous_object
    3333#endif
     34
     35#ifdef __cforall
     36extern "C" {
     37#endif
     38void abortf( const char fmt[], ... ) __attribute__ ((__nothrow__, __leaf__, __noreturn__));
     39#ifdef __cforall
     40}
     41#endif
  • src/libcfa/bits/locks.h

    rdd9b59e r3d560060  
    1616#pragma once
    1717
     18#include "bits/debug.h"
    1819#include "bits/defs.h"
    19 
    20 #include "libhdr.h"
    2120
    2221// pause to prevent excess processor bus usage
     
    6564
    6665        // Lock the spinlock, return false if already acquired
    67         static inline _Bool try_lock  ( __spinlock_t & this DEBUG_CTX_PARAM2 ) {
     66        static inline _Bool try_lock  ( __spinlock_t & this __cfaabi_dbg_ctx_param2 ) {
    6867                _Bool result = __lock_test_and_test_and_set( this.lock );
    69                 LIB_DEBUG_DO(
     68                __cfaabi_dbg_debug_do(
    7069                        if( result ) {
    7170                                this.prev_name = caller;
     
    7776
    7877        // Lock the spinlock, spin if already acquired
    79         static inline void lock( __spinlock_t & this DEBUG_CTX_PARAM2 ) {
     78        static inline void lock( __spinlock_t & this __cfaabi_dbg_ctx_param2 ) {
    8079                #ifndef NOEXPBACK
    8180                        enum { SPIN_START = 4, SPIN_END = 64 * 1024, };
     
    9897                        #endif
    9998                }
    100                 LIB_DEBUG_DO(
     99                __cfaabi_dbg_debug_do(
    101100                        this.prev_name = caller;
    102101                        this.prev_thrd = this_thread;
     
    105104
    106105        // Lock the spinlock, spin if already acquired
    107         static inline void lock_yield( __spinlock_t & this DEBUG_CTX_PARAM2 ) {
     106        static inline void lock_yield( __spinlock_t & this __cfaabi_dbg_ctx_param2 ) {
    108107                for ( unsigned int i = 1;; i += 1 ) {
    109108                        if ( __lock_test_and_test_and_set( this.lock ) ) break;
    110109                        yield( i );
    111110                }
    112                 LIB_DEBUG_DO(
     111                __cfaabi_dbg_debug_do(
    113112                        this.prev_name = caller;
    114113                        this.prev_thrd = this_thread;
  • src/libcfa/concurrency/alarm.c

    rdd9b59e r3d560060  
    2323}
    2424
    25 #include "libhdr.h"
    26 
    2725#include "alarm.h"
    2826#include "kernel_private.h"
     
    110108}
    111109
    112 LIB_DEBUG_DO( bool validate( alarm_list_t * this ) {
     110__cfaabi_dbg_debug_do( bool validate( alarm_list_t * this ) {
    113111        alarm_node_t ** it = &this->head;
    114112        while( (*it) ) {
     
    186184
    187185        disable_interrupts();
    188         lock( event_kernel->lock DEBUG_CTX2 );
     186        lock( event_kernel->lock __cfaabi_dbg_ctx2 );
    189187        {
    190188                verify( validate( alarms ) );
     
    198196        unlock( event_kernel->lock );
    199197        this->set = true;
    200         enable_interrupts( DEBUG_CTX );
     198        enable_interrupts( __cfaabi_dbg_ctx );
    201199}
    202200
    203201void unregister_self( alarm_node_t * this ) {
    204202        disable_interrupts();
    205         lock( event_kernel->lock DEBUG_CTX2 );
     203        lock( event_kernel->lock __cfaabi_dbg_ctx2 );
    206204        {
    207205                verify( validate( &event_kernel->alarms ) );
     
    209207        }
    210208        unlock( event_kernel->lock );
    211         enable_interrupts( DEBUG_CTX );
     209        enable_interrupts( __cfaabi_dbg_ctx );
    212210        this->set = false;
    213211}
  • src/libcfa/concurrency/coroutine.c

    rdd9b59e r3d560060  
    2929#define __CFA_INVOKE_PRIVATE__
    3030#include "invoke.h"
    31 
    3231
    3332//-----------------------------------------------------------------------------
     
    7675void ^?{}(coStack_t & this) {
    7776        if ( ! this.userStack && this.storage ) {
    78                 LIB_DEBUG_DO(
     77                __cfaabi_dbg_debug_do(
    7978                        if ( mprotect( this.storage, pageSize, PROT_READ | PROT_WRITE ) == -1 ) {
    8079                                abortf( "(coStack_t *)%p.^?{}() : internal error, mprotect failure, error(%d) %s.", &this, errno, strerror( errno ) );
     
    131130
    132131                // assume malloc has 8 byte alignment so add 8 to allow rounding up to 16 byte alignment
    133                 LIB_DEBUG_DO( this->storage = memalign( pageSize, cxtSize + this->size + pageSize ) );
    134                 LIB_NO_DEBUG_DO( this->storage = malloc( cxtSize + this->size + 8 ) );
     132                __cfaabi_dbg_debug_do( this->storage = memalign( pageSize, cxtSize + this->size + pageSize ) );
     133                __cfaabi_dbg_no_debug_do( this->storage = malloc( cxtSize + this->size + 8 ) );
    135134
    136                 LIB_DEBUG_DO(
     135                __cfaabi_dbg_debug_do(
    137136                        if ( mprotect( this->storage, pageSize, PROT_NONE ) == -1 ) {
    138137                                abortf( "(uMachContext &)%p.createContext() : internal error, mprotect failure, error(%d) %s.", this, (int)errno, strerror( (int)errno ) );
     
    144143                } // if
    145144
    146                 LIB_DEBUG_DO( this->limit = (char *)this->storage + pageSize );
    147                 LIB_NO_DEBUG_DO( this->limit = (char *)libCeiling( (unsigned long)this->storage, 16 ) ); // minimum alignment
     145                __cfaabi_dbg_debug_do( this->limit = (char *)this->storage + pageSize );
     146                __cfaabi_dbg_no_debug_do( this->limit = (char *)libCeiling( (unsigned long)this->storage, 16 ) ); // minimum alignment
    148147
    149148        } else {
  • src/libcfa/concurrency/invoke.c

    rdd9b59e r3d560060  
    1818#include <stdio.h>
    1919
    20 #include "libhdr.h"
    2120#include "invoke.h"
    2221
     
    3130extern void __leave_thread_monitor( struct thread_desc * this );
    3231extern void disable_interrupts();
    33 extern void enable_interrupts( DEBUG_CTX_PARAM );
     32extern void enable_interrupts( __cfaabi_dbg_ctx_param );
    3433
    3534void CtxInvokeCoroutine(
    36       void (*main)(void *),
    37       struct coroutine_desc *(*get_coroutine)(void *),
    38       void *this
     35        void (*main)(void *),
     36        struct coroutine_desc *(*get_coroutine)(void *),
     37        void *this
    3938) {
    40       // LIB_DEBUG_PRINTF("Invoke Coroutine : Received %p (main %p, get_c %p)\n", this, main, get_coroutine);
     39        struct coroutine_desc* cor = get_coroutine( this );
    4140
    42       struct coroutine_desc* cor = get_coroutine( this );
     41        if(cor->state == Primed) {
     42                __suspend_internal();
     43        }
    4344
    44       if(cor->state == Primed) {
    45             __suspend_internal();
    46       }
     45        cor->state = Active;
    4746
    48       cor->state = Active;
     47        main( this );
    4948
    50       main( this );
     49        cor->state = Halted;
    5150
    52       cor->state = Halted;
    53 
    54       //Final suspend, should never return
    55       __leave_coroutine();
    56       abortf("Resumed dead coroutine");
     51        //Final suspend, should never return
     52        __leave_coroutine();
     53        abortf("Resumed dead coroutine");
    5754}
    5855
    5956void CtxInvokeThread(
    60       void (*dtor)(void *),
    61       void (*main)(void *),
    62       struct thread_desc *(*get_thread)(void *),
    63       void *this
     57        void (*dtor)(void *),
     58        void (*main)(void *),
     59        struct thread_desc *(*get_thread)(void *),
     60        void *this
    6461) {
    65       // First suspend, once the thread arrives here,
    66       // the function pointer to main can be invalidated without risk
    67       __suspend_internal();
     62        // First suspend, once the thread arrives here,
     63        // the function pointer to main can be invalidated without risk
     64        __suspend_internal();
    6865
    69       // Fetch the thread handle from the user defined thread structure
    70       struct thread_desc* thrd = get_thread( this );
     66        // Fetch the thread handle from the user defined thread structure
     67        struct thread_desc* thrd = get_thread( this );
    7168
    72       // Officially start the thread by enabling preemption
    73       enable_interrupts( DEBUG_CTX );
     69        // Officially start the thread by enabling preemption
     70        enable_interrupts( __cfaabi_dbg_ctx );
    7471
    75       // Call the main of the thread
    76       main( this );
     72        // Call the main of the thread
     73        main( this );
    7774
    78       // To exit a thread we must :
    79       // 1 - Mark it as halted
    80       // 2 - Leave its monitor
    81       // 3 - Disable the interupts
    82       // 4 - Final suspend
    83       // The order of these 4 operations is very important
    84       //Final suspend, should never return
    85       __leave_thread_monitor( thrd );
    86       abortf("Resumed dead thread");
     75        // To exit a thread we must :
     76        // 1 - Mark it as halted
     77        // 2 - Leave its monitor
     78        // 3 - Disable the interupts
     79        // 4 - Final suspend
     80        // The order of these 4 operations is very important
     81        //Final suspend, should never return
     82        __leave_thread_monitor( thrd );
     83        abortf("Resumed dead thread");
    8784}
    8885
    8986
    9087void CtxStart(
    91       void (*main)(void *),
    92       struct coroutine_desc *(*get_coroutine)(void *),
    93       void *this,
    94       void (*invoke)(void *)
     88        void (*main)(void *),
     89        struct coroutine_desc *(*get_coroutine)(void *),
     90        void *this,
     91        void (*invoke)(void *)
    9592) {
    96       // LIB_DEBUG_PRINTF("StartCoroutine : Passing in %p (main %p) to invoke (%p) from start (%p)\n", this, main, invoke, CtxStart);
    97 
    98       struct coStack_t* stack = &get_coroutine( this )->stack;
     93        struct coStack_t* stack = &get_coroutine( this )->stack;
    9994
    10095#if defined( __i386__ )
     
    10398            void *fixedRegisters[3];                    // fixed registers ebx, edi, esi (popped on 1st uSwitch, values unimportant)
    10499            uint32_t mxcr;                        // SSE Status and Control bits (control bits are preserved across function calls)
    105           uint16_t fcw;                         // X97 FPU control word (preserved across function calls)
     100            uint16_t fcw;                         // X97 FPU control word (preserved across function calls)
    106101            void *rturn;                          // where to go on return from uSwitch
    107102            void *dummyReturn;                          // fake return compiler would have pushed on call to uInvoke
     
    116111        ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->argument[0] = this;     // argument to invoke
    117112        ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->rturn = invoke;
    118       ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->mxcr = 0x1F80; //Vol. 2A 3-520
    119       ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->fcw = 0x037F;  //Vol. 1 8-7
     113        ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->mxcr = 0x1F80; //Vol. 2A 3-520
     114        ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->fcw = 0x037F;  //Vol. 1 8-7
    120115
    121116#elif defined( __x86_64__ )
    122117
    123       struct FakeStack {
    124             void *fixedRegisters[5];            // fixed registers rbx, r12, r13, r14, r15
    125             uint32_t mxcr;                      // SSE Status and Control bits (control bits are preserved across function calls)
    126             uint16_t fcw;                       // X97 FPU control word (preserved across function calls)
    127             void *rturn;                        // where to go on return from uSwitch
    128             void *dummyReturn;                  // NULL return address to provide proper alignment
    129       };
     118        struct FakeStack {
     119                void *fixedRegisters[5];            // fixed registers rbx, r12, r13, r14, r15
     120                uint32_t mxcr;                      // SSE Status and Control bits (control bits are preserved across function calls)
     121                uint16_t fcw;                       // X97 FPU control word (preserved across function calls)
     122                void *rturn;                        // where to go on return from uSwitch
     123                void *dummyReturn;                  // NULL return address to provide proper alignment
     124        };
    130125
    131       ((struct machine_context_t *)stack->context)->SP = (char *)stack->base - sizeof( struct FakeStack );
    132       ((struct machine_context_t *)stack->context)->FP = NULL;          // terminate stack with NULL fp
     126        ((struct machine_context_t *)stack->context)->SP = (char *)stack->base - sizeof( struct FakeStack );
     127        ((struct machine_context_t *)stack->context)->FP = NULL;                // terminate stack with NULL fp
    133128
    134       ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->dummyReturn = NULL;
    135       ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->rturn = CtxInvokeStub;
    136       ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->fixedRegisters[0] = this;
    137       ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->fixedRegisters[1] = invoke;
    138       ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->mxcr = 0x1F80; //Vol. 2A 3-520
    139       ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->fcw = 0x037F;  //Vol. 1 8-7
     129        ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->dummyReturn = NULL;
     130        ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->rturn = CtxInvokeStub;
     131        ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->fixedRegisters[0] = this;
     132        ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->fixedRegisters[1] = invoke;
     133        ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->mxcr = 0x1F80; //Vol. 2A 3-520
     134        ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->fcw = 0x037F;  //Vol. 1 8-7
    140135#else
    141       #error Only __i386__ and __x86_64__ is supported for threads in cfa
     136        #error Only __i386__ and __x86_64__ is supported for threads in cfa
    142137#endif
    143138}
  • src/libcfa/concurrency/kernel.c

    rdd9b59e r3d560060  
    1414//
    1515
    16 #include "libhdr.h"
    17 
    1816//C Includes
    1917#include <stddef.h>
     
    150148
    151149        this.runner = &runner;
    152         LIB_DEBUG_PRINT_SAFE("Kernel : constructing main processor context %p\n", &runner);
     150        __cfaabi_dbg_print_safe("Kernel : constructing main processor context %p\n", &runner);
    153151        runner{ &this };
    154152}
     
    156154void ^?{}(processor & this) {
    157155        if( ! this.do_terminate ) {
    158                 LIB_DEBUG_PRINT_SAFE("Kernel : core %p signaling termination\n", &this);
     156                __cfaabi_dbg_print_safe("Kernel : core %p signaling termination\n", &this);
    159157                this.do_terminate = true;
    160158                P( this.terminated );
     
    181179        processor * this = runner.proc;
    182180
    183         LIB_DEBUG_PRINT_SAFE("Kernel : core %p starting\n", this);
     181        __cfaabi_dbg_print_safe("Kernel : core %p starting\n", this);
    184182
    185183        {
     
    187185                preemption_scope scope = { this };
    188186
    189                 LIB_DEBUG_PRINT_SAFE("Kernel : core %p started\n", this);
     187                __cfaabi_dbg_print_safe("Kernel : core %p started\n", this);
    190188
    191189                thread_desc * readyThread = NULL;
     
    213211                }
    214212
    215                 LIB_DEBUG_PRINT_SAFE("Kernel : core %p stopping\n", this);
     213                __cfaabi_dbg_print_safe("Kernel : core %p stopping\n", this);
    216214        }
    217215
    218216        V( this->terminated );
    219217
    220         LIB_DEBUG_PRINT_SAFE("Kernel : core %p terminated\n", this);
     218        __cfaabi_dbg_print_safe("Kernel : core %p terminated\n", this);
    221219}
    222220
     
    292290        processorCtx_t proc_cor_storage = { proc, &info };
    293291
    294         LIB_DEBUG_PRINT_SAFE("Coroutine : created stack %p\n", proc_cor_storage.__cor.stack.base);
     292        __cfaabi_dbg_print_safe("Coroutine : created stack %p\n", proc_cor_storage.__cor.stack.base);
    295293
    296294        //Set global state
     
    299297
    300298        //We now have a proper context from which to schedule threads
    301         LIB_DEBUG_PRINT_SAFE("Kernel : core %p created (%p, %p)\n", proc, proc->runner, &ctx);
     299        __cfaabi_dbg_print_safe("Kernel : core %p created (%p, %p)\n", proc, proc->runner, &ctx);
    302300
    303301        // SKULLDUGGERY: Since the coroutine doesn't have its own stack, we can't
     
    310308
    311309        // Main routine of the core returned, the core is now fully terminated
    312         LIB_DEBUG_PRINT_SAFE("Kernel : core %p main ended (%p)\n", proc, proc->runner);
     310        __cfaabi_dbg_print_safe("Kernel : core %p main ended (%p)\n", proc, proc->runner);
    313311
    314312        return NULL;
     
    316314
    317315void start(processor * this) {
    318         LIB_DEBUG_PRINT_SAFE("Kernel : Starting core %p\n", this);
     316        __cfaabi_dbg_print_safe("Kernel : Starting core %p\n", this);
    319317
    320318        pthread_create( &this->kernel_thread, NULL, CtxInvokeProcessor, (void*)this );
    321319
    322         LIB_DEBUG_PRINT_SAFE("Kernel : core %p started\n", this);
     320        __cfaabi_dbg_print_safe("Kernel : core %p started\n", this);
    323321}
    324322
     
    334332        verifyf( thrd->next == NULL, "Expected null got %p", thrd->next );
    335333
    336         lock(   this_processor->cltr->ready_queue_lock DEBUG_CTX2 );
     334        lock(   this_processor->cltr->ready_queue_lock __cfaabi_dbg_ctx2 );
    337335        append( this_processor->cltr->ready_queue, thrd );
    338336        unlock( this_processor->cltr->ready_queue_lock );
     
    343341thread_desc * nextThread(cluster * this) {
    344342        verify( disable_preempt_count > 0 );
    345         lock( this->ready_queue_lock DEBUG_CTX2 );
     343        lock( this->ready_queue_lock __cfaabi_dbg_ctx2 );
    346344        thread_desc * head = pop_head( this->ready_queue );
    347345        unlock( this->ready_queue_lock );
     
    355353        suspend();
    356354        verify( disable_preempt_count > 0 );
    357         enable_interrupts( DEBUG_CTX );
     355        enable_interrupts( __cfaabi_dbg_ctx );
    358356}
    359357
     
    367365        verify( disable_preempt_count > 0 );
    368366
    369         enable_interrupts( DEBUG_CTX );
     367        enable_interrupts( __cfaabi_dbg_ctx );
    370368}
    371369
     
    381379        verify( disable_preempt_count > 0 );
    382380
    383         enable_interrupts( DEBUG_CTX );
     381        enable_interrupts( __cfaabi_dbg_ctx );
    384382}
    385383
     
    395393        verify( disable_preempt_count > 0 );
    396394
    397         enable_interrupts( DEBUG_CTX );
     395        enable_interrupts( __cfaabi_dbg_ctx );
    398396}
    399397
     
    408406        verify( disable_preempt_count > 0 );
    409407
    410         enable_interrupts( DEBUG_CTX );
     408        enable_interrupts( __cfaabi_dbg_ctx );
    411409}
    412410
     
    423421        verify( disable_preempt_count > 0 );
    424422
    425         enable_interrupts( DEBUG_CTX );
     423        enable_interrupts( __cfaabi_dbg_ctx );
    426424}
    427425
     
    441439// Kernel boot procedures
    442440void kernel_startup(void) {
    443         LIB_DEBUG_PRINT_SAFE("Kernel : Starting\n");
     441        __cfaabi_dbg_print_safe("Kernel : Starting\n");
    444442
    445443        // Start by initializing the main thread
     
    450448        (*mainThread){ &info };
    451449
    452         LIB_DEBUG_PRINT_SAFE("Kernel : Main thread ready\n");
     450        __cfaabi_dbg_print_safe("Kernel : Main thread ready\n");
    453451
    454452        // Initialize the main cluster
     
    456454        (*mainCluster){};
    457455
    458         LIB_DEBUG_PRINT_SAFE("Kernel : main cluster ready\n");
     456        __cfaabi_dbg_print_safe("Kernel : main cluster ready\n");
    459457
    460458        // Initialize the main processor and the main processor ctx
     
    483481
    484482        // THE SYSTEM IS NOW COMPLETELY RUNNING
    485         LIB_DEBUG_PRINT_SAFE("Kernel : Started\n--------------------------------------------------\n\n");
    486 
    487         enable_interrupts( DEBUG_CTX );
     483        __cfaabi_dbg_print_safe("Kernel : Started\n--------------------------------------------------\n\n");
     484
     485        enable_interrupts( __cfaabi_dbg_ctx );
    488486}
    489487
    490488void kernel_shutdown(void) {
    491         LIB_DEBUG_PRINT_SAFE("\n--------------------------------------------------\nKernel : Shutting down\n");
     489        __cfaabi_dbg_print_safe("\n--------------------------------------------------\nKernel : Shutting down\n");
    492490
    493491        disable_interrupts();
     
    513511        ^(mainThread){};
    514512
    515         LIB_DEBUG_PRINT_SAFE("Kernel : Shutdown complete\n");
     513        __cfaabi_dbg_print_safe("Kernel : Shutdown complete\n");
    516514}
    517515
     
    523521        // abort cannot be recursively entered by the same or different processors because all signal handlers return when
    524522        // the globalAbort flag is true.
    525         lock( kernel_abort_lock DEBUG_CTX2 );
     523        lock( kernel_abort_lock __cfaabi_dbg_ctx2 );
    526524
    527525        // first task to abort ?
     
    548546
    549547        int len = snprintf( abort_text, abort_text_size, "Error occurred while executing task %.256s (%p)", thrd->self_cor.name, thrd );
    550         __lib_debug_write( abort_text, len );
     548        __cfaabi_dbg_bits_write( abort_text, len );
    551549
    552550        if ( thrd != this_coroutine ) {
    553551                len = snprintf( abort_text, abort_text_size, " in coroutine %.256s (%p).\n", this_coroutine->name, this_coroutine );
    554                 __lib_debug_write( abort_text, len );
     552                __cfaabi_dbg_bits_write( abort_text, len );
    555553        }
    556554        else {
    557                 __lib_debug_write( ".\n", 2 );
     555                __cfaabi_dbg_bits_write( ".\n", 2 );
    558556        }
    559557}
    560558
    561559extern "C" {
    562         void __lib_debug_acquire() {
    563                 lock( kernel_debug_lock DEBUG_CTX2 );
    564         }
    565 
    566         void __lib_debug_release() {
     560        void __cfaabi_dbg_bits_acquire() {
     561                lock( kernel_debug_lock __cfaabi_dbg_ctx2 );
     562        }
     563
     564        void __cfaabi_dbg_bits_release() {
    567565                unlock( kernel_debug_lock );
    568566        }
     
    582580
    583581void P(semaphore & this) {
    584         lock( this.lock DEBUG_CTX2 );
     582        lock( this.lock __cfaabi_dbg_ctx2 );
    585583        this.count -= 1;
    586584        if ( this.count < 0 ) {
     
    598596void V(semaphore & this) {
    599597        thread_desc * thrd = NULL;
    600         lock( this.lock DEBUG_CTX2 );
     598        lock( this.lock __cfaabi_dbg_ctx2 );
    601599        this.count += 1;
    602600        if ( this.count <= 0 ) {
  • src/libcfa/concurrency/kernel_private.h

    rdd9b59e r3d560060  
    1616#pragma once
    1717
    18 #include "libhdr.h"
    19 
    2018#include "kernel"
    2119#include "thread"
     
    3028        void disable_interrupts();
    3129        void enable_interrupts_noPoll();
    32         void enable_interrupts( DEBUG_CTX_PARAM );
     30        void enable_interrupts( __cfaabi_dbg_ctx_param );
    3331}
    3432
     
    3937        disable_interrupts();
    4038        ScheduleThread( thrd );
    41         enable_interrupts( DEBUG_CTX );
     39        enable_interrupts( __cfaabi_dbg_ctx );
    4240}
    4341thread_desc * nextThread(cluster * this);
  • src/libcfa/concurrency/monitor.c

    rdd9b59e r3d560060  
    1919#include <inttypes.h>
    2020
    21 #include "libhdr.h"
    2221#include "kernel_private.h"
    2322
     
    9190        static void __enter_monitor_desc( monitor_desc * this, const __monitor_group_t & group ) {
    9291                // Lock the monitor spinlock
    93                 DO_LOCK( this->lock DEBUG_CTX2 );
     92                DO_LOCK( this->lock __cfaabi_dbg_ctx2 );
    9493                thread_desc * thrd = this_thread;
    9594
    96                 LIB_DEBUG_PRINT_SAFE("Kernel : %10p Entering mon %p (%p)\n", thrd, this, this->owner);
     95                __cfaabi_dbg_print_safe("Kernel : %10p Entering mon %p (%p)\n", thrd, this, this->owner);
    9796
    9897                if( !this->owner ) {
     
    10099                        set_owner( this, thrd );
    101100
    102                         LIB_DEBUG_PRINT_SAFE("Kernel :  mon is free \n");
     101                        __cfaabi_dbg_print_safe("Kernel :  mon is free \n");
    103102                }
    104103                else if( this->owner == thrd) {
     
    106105                        this->recursion += 1;
    107106
    108                         LIB_DEBUG_PRINT_SAFE("Kernel :  mon already owned \n");
     107                        __cfaabi_dbg_print_safe("Kernel :  mon already owned \n");
    109108                }
    110109                else if( is_accepted( this, group) ) {
     
    115114                        reset_mask( this );
    116115
    117                         LIB_DEBUG_PRINT_SAFE("Kernel :  mon accepts \n");
     116                        __cfaabi_dbg_print_safe("Kernel :  mon accepts \n");
    118117                }
    119118                else {
    120                         LIB_DEBUG_PRINT_SAFE("Kernel :  blocking \n");
     119                        __cfaabi_dbg_print_safe("Kernel :  blocking \n");
    121120
    122121                        // Some one else has the monitor, wait in line for it
     
    124123                        BlockInternal( &this->lock );
    125124
    126                         LIB_DEBUG_PRINT_SAFE("Kernel : %10p Entered  mon %p\n", thrd, this);
     125                        __cfaabi_dbg_print_safe("Kernel : %10p Entered  mon %p\n", thrd, this);
    127126
    128127                        // BlockInternal will unlock spinlock, no need to unlock ourselves
     
    130129                }
    131130
    132                 LIB_DEBUG_PRINT_SAFE("Kernel : %10p Entered  mon %p\n", thrd, this);
     131                __cfaabi_dbg_print_safe("Kernel : %10p Entered  mon %p\n", thrd, this);
    133132
    134133                // Release the lock and leave
     
    139138        static void __enter_monitor_dtor( monitor_desc * this, fptr_t func ) {
    140139                // Lock the monitor spinlock
    141                 DO_LOCK( this->lock DEBUG_CTX2 );
     140                DO_LOCK( this->lock __cfaabi_dbg_ctx2 );
    142141                thread_desc * thrd = this_thread;
    143142
    144                 LIB_DEBUG_PRINT_SAFE("Kernel : %10p Entering dtor for mon %p (%p)\n", thrd, this, this->owner);
     143                __cfaabi_dbg_print_safe("Kernel : %10p Entering dtor for mon %p (%p)\n", thrd, this, this->owner);
    145144
    146145
    147146                if( !this->owner ) {
    148                         LIB_DEBUG_PRINT_SAFE("Kernel : Destroying free mon %p\n", this);
     147                        __cfaabi_dbg_print_safe("Kernel : Destroying free mon %p\n", this);
    149148
    150149                        // No one has the monitor, just take it
     
    164163                __monitor_group_t group = { &this, 1, func };
    165164                if( is_accepted( this, group) ) {
    166                         LIB_DEBUG_PRINT_SAFE("Kernel :  mon accepts dtor, block and signal it \n");
     165                        __cfaabi_dbg_print_safe("Kernel :  mon accepts dtor, block and signal it \n");
    167166
    168167                        // Wake the thread that is waiting for this
     
    183182                }
    184183                else {
    185                         LIB_DEBUG_PRINT_SAFE("Kernel :  blocking \n");
     184                        __cfaabi_dbg_print_safe("Kernel :  blocking \n");
    186185
    187186                        wait_ctx( this_thread, 0 )
     
    196195                }
    197196
    198                 LIB_DEBUG_PRINT_SAFE("Kernel : Destroying %p\n", this);
     197                __cfaabi_dbg_print_safe("Kernel : Destroying %p\n", this);
    199198
    200199        }
     
    203202        void __leave_monitor_desc( monitor_desc * this ) {
    204203                // Lock the monitor spinlock, DO_LOCK to reduce contention
    205                 DO_LOCK( this->lock DEBUG_CTX2 );
    206 
    207                 LIB_DEBUG_PRINT_SAFE("Kernel : %10p Leaving mon %p (%p)\n", this_thread, this, this->owner);
     204                DO_LOCK( this->lock __cfaabi_dbg_ctx2 );
     205
     206                __cfaabi_dbg_print_safe("Kernel : %10p Leaving mon %p (%p)\n", this_thread, this, this->owner);
    208207
    209208                verifyf( this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", this_thread, this->owner, this->recursion, this );
     
    215214                // it means we don't need to do anything
    216215                if( this->recursion != 0) {
    217                         LIB_DEBUG_PRINT_SAFE("Kernel :  recursion still %d\n", this->recursion);
     216                        __cfaabi_dbg_print_safe("Kernel :  recursion still %d\n", this->recursion);
    218217                        unlock( this->lock );
    219218                        return;
     
    232231        // Leave single monitor for the last time
    233232        void __leave_dtor_monitor_desc( monitor_desc * this ) {
    234                 LIB_DEBUG_DO(
     233                __cfaabi_dbg_debug_do(
    235234                        if( this_thread != this->owner ) {
    236235                                abortf("Destroyed monitor %p has inconsistent owner, expected %p got %p.\n", this, this_thread, this->owner);
     
    249248
    250249                // Lock the monitor now
    251                 DO_LOCK( this->lock DEBUG_CTX2 );
     250                DO_LOCK( this->lock __cfaabi_dbg_ctx2 );
    252251
    253252                disable_interrupts();
     
    308307        (this_thread->monitors){m, count, func};
    309308
    310         // LIB_DEBUG_PRINT_SAFE("MGUARD : enter %d\n", count);
     309        // __cfaabi_dbg_print_safe("MGUARD : enter %d\n", count);
    311310
    312311        // Enter the monitors in order
     
    314313        enter( group );
    315314
    316         // LIB_DEBUG_PRINT_SAFE("MGUARD : entered\n");
     315        // __cfaabi_dbg_print_safe("MGUARD : entered\n");
    317316}
    318317
     
    320319// Dtor for monitor guard
    321320void ^?{}( monitor_guard_t & this ) {
    322         // LIB_DEBUG_PRINT_SAFE("MGUARD : leaving %d\n", this.count);
     321        // __cfaabi_dbg_print_safe("MGUARD : leaving %d\n", this.count);
    323322
    324323        // Leave the monitors in order
    325324        leave( this.m, this.count );
    326325
    327         // LIB_DEBUG_PRINT_SAFE("MGUARD : left\n");
     326        // __cfaabi_dbg_print_safe("MGUARD : left\n");
    328327
    329328        // Restore thread context
     
    430429
    431430        //Some more checking in debug
    432         LIB_DEBUG_DO(
     431        __cfaabi_dbg_debug_do(
    433432                thread_desc * this_thrd = this_thread;
    434433                if ( this.monitor_count != this_thrd->monitors.size ) {
     
    487486        set_owner( monitors, count, signallee );
    488487
    489         LIB_DEBUG_PRINT_BUFFER_DECL( "Kernel : signal_block condition %p (s: %p)\n", &this, signallee );
     488        __cfaabi_dbg_print_buffer_decl( "Kernel : signal_block condition %p (s: %p)\n", &this, signallee );
    490489
    491490        //Everything is ready to go to sleep
     
    496495
    497496
    498         LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel :   signal_block returned\n" );
     497        __cfaabi_dbg_print_buffer_local( "Kernel :   signal_block returned\n" );
    499498
    500499        //We are back, restore the masks and recursions
     
    535534        __lock_size_t actual_count = aggregate( mon_storage, mask );
    536535
    537         LIB_DEBUG_PRINT_BUFFER_DECL( "Kernel : waitfor %d (s: %d, m: %d)\n", actual_count, mask.size, (__lock_size_t)max);
     536        __cfaabi_dbg_print_buffer_decl( "Kernel : waitfor %d (s: %d, m: %d)\n", actual_count, mask.size, (__lock_size_t)max);
    538537
    539538        if(actual_count == 0) return;
    540539
    541         LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : waitfor internal proceeding\n");
     540        __cfaabi_dbg_print_buffer_local( "Kernel : waitfor internal proceeding\n");
    542541
    543542        // Create storage for monitor context
     
    556555                        __acceptable_t& accepted = mask[index];
    557556                        if( accepted.is_dtor ) {
    558                                 LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : dtor already there\n");
     557                                __cfaabi_dbg_print_buffer_local( "Kernel : dtor already there\n");
    559558                                verifyf( accepted.size == 1,  "ERROR: Accepted dtor has more than 1 mutex parameter." );
    560559
     
    568567                        }
    569568                        else {
    570                                 LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : thread present, baton-passing\n");
     569                                __cfaabi_dbg_print_buffer_local( "Kernel : thread present, baton-passing\n");
    571570
    572571                                // Create the node specific to this wait operation
     
    576575                                monitor_save;
    577576
    578                                 LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel :  baton of %d monitors : ", count );
     577                                __cfaabi_dbg_print_buffer_local( "Kernel :  baton of %d monitors : ", count );
    579578                                #ifdef __CFA_DEBUG_PRINT__
    580579                                        for( int i = 0; i < count; i++) {
    581                                                 LIB_DEBUG_PRINT_BUFFER_LOCAL( "%p %p ", monitors[i], monitors[i]->signal_stack.top );
     580                                                __cfaabi_dbg_print_buffer_local( "%p %p ", monitors[i], monitors[i]->signal_stack.top );
    582581                                        }
    583582                                #endif
    584                                 LIB_DEBUG_PRINT_BUFFER_LOCAL( "\n");
     583                                __cfaabi_dbg_print_buffer_local( "\n");
    585584
    586585                                // Set the owners to be the next thread
     
    593592                                monitor_restore;
    594593
    595                                 LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : thread present, returned\n");
     594                                __cfaabi_dbg_print_buffer_local( "Kernel : thread present, returned\n");
    596595                        }
    597596
    598                         LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : accepted %d\n", *mask.accepted);
     597                        __cfaabi_dbg_print_buffer_local( "Kernel : accepted %d\n", *mask.accepted);
    599598                        return;
    600599                }
     
    603602
    604603        if( duration == 0 ) {
    605                 LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : non-blocking, exiting\n");
     604                __cfaabi_dbg_print_buffer_local( "Kernel : non-blocking, exiting\n");
    606605
    607606                unlock_all( locks, count );
    608607
    609                 LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : accepted %d\n", *mask.accepted);
     608                __cfaabi_dbg_print_buffer_local( "Kernel : accepted %d\n", *mask.accepted);
    610609                return;
    611610        }
     
    614613        verifyf( duration < 0, "Timeout on waitfor statments not supported yet.");
    615614
    616         LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : blocking waitfor\n");
     615        __cfaabi_dbg_print_buffer_local( "Kernel : blocking waitfor\n");
    617616
    618617        // Create the node specific to this wait operation
     
    636635        monitor_restore;
    637636
    638         LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : exiting\n");
    639 
    640         LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : accepted %d\n", *mask.accepted);
     637        __cfaabi_dbg_print_buffer_local( "Kernel : exiting\n");
     638
     639        __cfaabi_dbg_print_buffer_local( "Kernel : accepted %d\n", *mask.accepted);
    641640}
    642641
     
    645644
    646645static inline void set_owner( monitor_desc * this, thread_desc * owner ) {
    647         // LIB_DEBUG_PRINT_SAFE("Kernal :   Setting owner of %p to %p ( was %p)\n", this, owner, this->owner );
     646        // __cfaabi_dbg_print_safe("Kernal :   Setting owner of %p to %p ( was %p)\n", this, owner, this->owner );
    648647
    649648        //Pass the monitor appropriately
     
    677676static inline thread_desc * next_thread( monitor_desc * this ) {
    678677        //Check the signaller stack
    679         LIB_DEBUG_PRINT_SAFE("Kernel :  mon %p AS-stack top %p\n", this, this->signal_stack.top);
     678        __cfaabi_dbg_print_safe("Kernel :  mon %p AS-stack top %p\n", this, this->signal_stack.top);
    680679        __condition_criterion_t * urgent = pop( this->signal_stack );
    681680        if( urgent ) {
     
    729728        for( __lock_size_t i = 0; i < count; i++) {
    730729                (criteria[i]){ monitors[i], waiter };
    731                 LIB_DEBUG_PRINT_SAFE( "Kernel :  target %p = %p\n", criteria[i].target, &criteria[i] );
     730                __cfaabi_dbg_print_safe( "Kernel :  target %p = %p\n", criteria[i].target, &criteria[i] );
    732731                push( criteria[i].target->signal_stack, &criteria[i] );
    733732        }
     
    738737static inline void lock_all( __spinlock_t * locks [], __lock_size_t count ) {
    739738        for( __lock_size_t i = 0; i < count; i++ ) {
    740                 DO_LOCK( *locks[i] DEBUG_CTX2 );
     739                DO_LOCK( *locks[i] __cfaabi_dbg_ctx2 );
    741740        }
    742741}
     
    745744        for( __lock_size_t i = 0; i < count; i++ ) {
    746745                __spinlock_t * l = &source[i]->lock;
    747                 DO_LOCK( *l DEBUG_CTX2 );
     746                DO_LOCK( *l __cfaabi_dbg_ctx2 );
    748747                if(locks) locks[i] = l;
    749748        }
     
    803802        for(    int i = 0; i < count; i++ ) {
    804803
    805                 // LIB_DEBUG_PRINT_SAFE( "Checking %p for %p\n", &criteria[i], target );
     804                // __cfaabi_dbg_print_safe( "Checking %p for %p\n", &criteria[i], target );
    806805                if( &criteria[i] == target ) {
    807806                        criteria[i].ready = true;
    808                         // LIB_DEBUG_PRINT_SAFE( "True\n" );
     807                        // __cfaabi_dbg_print_safe( "True\n" );
    809808                }
    810809
     
    812811        }
    813812
    814         LIB_DEBUG_PRINT_SAFE( "Kernel :  Runing %i (%p)\n", ready2run, ready2run ? node->waiting_thread : NULL );
     813        __cfaabi_dbg_print_safe( "Kernel :  Runing %i (%p)\n", ready2run, ready2run ? node->waiting_thread : NULL );
    815814        return ready2run ? node->waiting_thread : NULL;
    816815}
     
    819818        thread_desc * thrd = this_thread;
    820819        if( !this.monitors ) {
    821                 // LIB_DEBUG_PRINT_SAFE("Branding\n");
     820                // __cfaabi_dbg_print_safe("Branding\n");
    822821                assertf( thrd->monitors.data != NULL, "No current monitor to brand condition %p", thrd->monitors.data );
    823822                this.monitor_count = thrd->monitors.size;
  • src/libcfa/concurrency/preemption.c

    rdd9b59e r3d560060  
    1414//
    1515
    16 #include "libhdr.h"
    1716#include "preemption.h"
    1817
     
    148147//=============================================================================================
    149148
    150 LIB_DEBUG_DO( static thread_local void * last_interrupt = 0; )
     149__cfaabi_dbg_debug_do( static thread_local void * last_interrupt = 0; )
    151150
    152151extern "C" {
     
    159158        // Enable interrupts by decrementing the counter
    160159        // If counter reaches 0, execute any pending CtxSwitch
    161         void enable_interrupts( DEBUG_CTX_PARAM ) {
     160        void enable_interrupts( __cfaabi_dbg_ctx_param ) {
    162161                processor * proc   = this_processor;      // Cache the processor now since interrupts can start happening after the atomic add
    163162                thread_desc * thrd = this_thread;         // Cache the thread now since interrupts can start happening after the atomic add
     
    173172
    174173                // For debugging purposes : keep track of the last person to enable the interrupts
    175                 LIB_DEBUG_DO( proc->last_enable = caller; )
     174                __cfaabi_dbg_debug_do( proc->last_enable = caller; )
    176175        }
    177176
     
    233232// Called from kernel_startup
    234233void kernel_start_preemption() {
    235         LIB_DEBUG_PRINT_SAFE("Kernel : Starting preemption\n");
     234        __cfaabi_dbg_print_safe("Kernel : Starting preemption\n");
    236235
    237236        // Start with preemption disabled until ready
     
    255254// Called from kernel_shutdown
    256255void kernel_stop_preemption() {
    257         LIB_DEBUG_PRINT_SAFE("Kernel : Preemption stopping\n");
     256        __cfaabi_dbg_print_safe("Kernel : Preemption stopping\n");
    258257
    259258        // Block all signals since we are already shutting down
     
    271270        // Preemption is now fully stopped
    272271
    273         LIB_DEBUG_PRINT_SAFE("Kernel : Preemption stopped\n");
     272        __cfaabi_dbg_print_safe("Kernel : Preemption stopped\n");
    274273}
    275274
     
    297296// Receives SIGUSR1 signal and causes the current thread to yield
    298297void sigHandler_ctxSwitch( __CFA_SIGPARMS__ ) {
    299         LIB_DEBUG_DO( last_interrupt = (void *)(cxt->uc_mcontext.gregs[CFA_REG_IP]); )
     298        __cfaabi_dbg_debug_do( last_interrupt = (void *)(cxt->uc_mcontext.gregs[CFA_REG_IP]); )
    300299
    301300        // Check if it is safe to preempt here
     
    346345                assertf(sig == SIGALRM, "Kernel Internal Error, sigwait: Unexpected signal %d (%d : %d)\n", sig, info.si_code, info.si_value.sival_int);
    347346
    348                 // LIB_DEBUG_PRINT_SAFE("Kernel : Caught alarm from %d with %d\n", info.si_code, info.si_value.sival_int );
     347                // __cfaabi_dbg_print_safe("Kernel : Caught alarm from %d with %d\n", info.si_code, info.si_value.sival_int );
    349348                // Switch on the code (a.k.a. the sender) to
    350349                switch( info.si_code )
     
    354353                case SI_TIMER:
    355354                case SI_KERNEL:
    356                         // LIB_DEBUG_PRINT_SAFE("Kernel : Preemption thread tick\n");
    357                         lock( event_kernel->lock DEBUG_CTX2 );
     355                        // __cfaabi_dbg_print_safe("Kernel : Preemption thread tick\n");
     356                        lock( event_kernel->lock __cfaabi_dbg_ctx2 );
    358357                        tick_preemption();
    359358                        unlock( event_kernel->lock );
     
    368367
    369368EXIT:
    370         LIB_DEBUG_PRINT_SAFE("Kernel : Preemption thread stopping\n");
     369        __cfaabi_dbg_print_safe("Kernel : Preemption thread stopping\n");
    371370        return NULL;
    372371}
     
    380379
    381380        if ( sigaction( sig, &act, NULL ) == -1 ) {
    382                 LIB_DEBUG_PRINT_BUFFER_DECL(
     381                __cfaabi_dbg_print_buffer_decl(
    383382                        " __kernel_sigaction( sig:%d, handler:%p, flags:%d ), problem installing signal handler, error(%d) %s.\n",
    384383                        sig, handler, flags, errno, strerror( errno )
     
    397396
    398397        if ( sigaction( sig, &act, NULL ) == -1 ) {
    399                 LIB_DEBUG_PRINT_BUFFER_DECL(
     398                __cfaabi_dbg_print_buffer_decl(
    400399                        " __kernel_sigdefault( sig:%d ), problem reseting signal handler, error(%d) %s.\n",
    401400                        sig, errno, strerror( errno )
     
    409408//=============================================================================================
    410409
    411 LIB_DEBUG_DO(
     410__cfaabi_dbg_debug_do(
    412411        static void __kernel_backtrace( int start ) {
    413412                // skip first N stack frames
     
    476475
    477476// void sigHandler_segv( __CFA_SIGPARMS__ ) {
    478 //      LIB_DEBUG_DO(
     477//      __cfaabi_dbg_debug_do(
    479478//              #ifdef __USE_STREAM__
    480479//              serr    | "*CFA runtime error* program cfa-cpp terminated with"
     
    493492// void sigHandler_abort( __CFA_SIGPARMS__ ) {
    494493//      // skip first 6 stack frames
    495 //      LIB_DEBUG_DO( __kernel_backtrace( 6 ); )
     494//      __cfaabi_dbg_debug_do( __kernel_backtrace( 6 ); )
    496495
    497496//      // reset default signal handler
  • src/libcfa/concurrency/thread.c

    rdd9b59e r3d560060  
    1717
    1818#include "kernel_private.h"
    19 #include "libhdr.h"
    2019
    2120#define __CFA_INVOKE_PRIVATE__
     
    7271        thrd_c->last = this_coroutine;
    7372
    74         // LIB_DEBUG_PRINT_SAFE("Thread start : %p (t %p, c %p)\n", this, thrd_c, thrd_h);
     73        // __cfaabi_dbg_print_safe("Thread start : %p (t %p, c %p)\n", this, thrd_c, thrd_h);
    7574
    7675        disable_interrupts();
     
    8281
    8382        ScheduleThread(thrd_h);
    84         enable_interrupts( DEBUG_CTX );
     83        enable_interrupts( __cfaabi_dbg_ctx );
    8584}
    8685
  • src/libcfa/exception.c

    rdd9b59e r3d560060  
    2323#include <stdio.h>
    2424#include <unwind.h>
    25 #include <libhdr/libdebug.h>
     25#include <bits/debug.h>
    2626
    2727// FIX ME: temporary hack to keep ARM build working
     
    3737
    3838// Base exception vtable is abstract, you should not have base exceptions.
    39 struct __cfaehm__base_exception_t_vtable
    40                 ___cfaehm__base_exception_t_vtable_instance = {
     39struct __cfaabi_ehm__base_exception_t_vtable
     40                ___cfaabi_ehm__base_exception_t_vtable_instance = {
    4141        .parent = NULL,
    4242        .size = 0,
     
    4949// Temperary global exception context. Does not work with concurency.
    5050struct exception_context_t {
    51     struct __cfaehm__try_resume_node * top_resume;
    52     struct __cfaehm__try_resume_node * current_resume;
     51    struct __cfaabi_ehm__try_resume_node * top_resume;
     52    struct __cfaabi_ehm__try_resume_node * current_resume;
    5353
    5454    exception * current_exception;
     
    7878// RESUMPTION ================================================================
    7979
    80 void __cfaehm__throw_resume(exception * except) {
    81 
    82         LIB_DEBUG_PRINT_SAFE("Throwing resumption exception\n");
    83 
    84         struct __cfaehm__try_resume_node * original_head = shared_stack.current_resume;
    85         struct __cfaehm__try_resume_node * current =
     80void __cfaabi_ehm__throw_resume(exception * except) {
     81
     82        __cfaabi_dbg_print_safe("Throwing resumption exception\n");
     83
     84        struct __cfaabi_ehm__try_resume_node * original_head = shared_stack.current_resume;
     85        struct __cfaabi_ehm__try_resume_node * current =
    8686                (original_head) ? original_head->next : shared_stack.top_resume;
    8787
     
    9494        }
    9595
    96         LIB_DEBUG_PRINT_SAFE("Unhandled exception\n");
     96        __cfaabi_dbg_print_safe("Unhandled exception\n");
    9797        shared_stack.current_resume = original_head;
    9898
    9999        // Fall back to termination:
    100         __cfaehm__throw_terminate(except);
     100        __cfaabi_ehm__throw_terminate(except);
    101101        // TODO: Default handler for resumption.
    102102}
     
    105105// hook has to be added after the node is built but before it is made the top node.
    106106
    107 void __cfaehm__try_resume_setup(struct __cfaehm__try_resume_node * node,
     107void __cfaabi_ehm__try_resume_setup(struct __cfaabi_ehm__try_resume_node * node,
    108108                        _Bool (*handler)(exception * except)) {
    109109        node->next = shared_stack.top_resume;
     
    112112}
    113113
    114 void __cfaehm__try_resume_cleanup(struct __cfaehm__try_resume_node * node) {
     114void __cfaabi_ehm__try_resume_cleanup(struct __cfaabi_ehm__try_resume_node * node) {
    115115        shared_stack.top_resume = node->next;
    116116}
     
    122122// May have to move to cfa for constructors and destructors (references).
    123123
    124 struct __cfaehm__node {
    125         struct __cfaehm__node * next;
     124struct __cfaabi_ehm__node {
     125        struct __cfaabi_ehm__node * next;
    126126};
    127127
    128128#define NODE_TO_EXCEPT(node) ((exception *)(1 + (node)))
    129 #define EXCEPT_TO_NODE(except) ((struct __cfaehm__node *)(except) - 1)
     129#define EXCEPT_TO_NODE(except) ((struct __cfaabi_ehm__node *)(except) - 1)
    130130
    131131// Creates a copy of the indicated exception and sets current_exception to it.
    132 static void __cfaehm__allocate_exception( exception * except ) {
     132static void __cfaabi_ehm__allocate_exception( exception * except ) {
    133133        struct exception_context_t * context = this_exception_context();
    134134
    135135        // Allocate memory for the exception.
    136         struct __cfaehm__node * store = malloc(
    137                 sizeof( struct __cfaehm__node ) + except->virtual_table->size );
     136        struct __cfaabi_ehm__node * store = malloc(
     137                sizeof( struct __cfaabi_ehm__node ) + except->virtual_table->size );
    138138
    139139        if ( ! store ) {
     
    151151
    152152// Delete the provided exception, unsetting current_exception if relivant.
    153 static void __cfaehm__delete_exception( exception * except ) {
     153static void __cfaabi_ehm__delete_exception( exception * except ) {
    154154        struct exception_context_t * context = this_exception_context();
    155155
    156         LIB_DEBUG_PRINT_SAFE("Deleting Exception\n");
     156        __cfaabi_dbg_print_safe("Deleting Exception\n");
    157157
    158158        // Remove the exception from the list.
    159         struct __cfaehm__node * to_free = EXCEPT_TO_NODE(except);
    160         struct __cfaehm__node * node;
     159        struct __cfaabi_ehm__node * to_free = EXCEPT_TO_NODE(except);
     160        struct __cfaabi_ehm__node * node;
    161161
    162162        if ( context->current_exception == except ) {
     
    178178
    179179// If this isn't a rethrow (*except==0), delete the provided exception.
    180 void __cfaehm__cleanup_terminate( void * except ) {
    181         if ( *(void**)except ) __cfaehm__delete_exception( *(exception**)except );
     180void __cfaabi_ehm__cleanup_terminate( void * except ) {
     181        if ( *(void**)except ) __cfaabi_ehm__delete_exception( *(exception**)except );
    182182}
    183183
     
    202202
    203203// The exception that is being thrown must already be stored.
    204 __attribute__((noreturn)) void __cfaehm__begin_unwind(void) {
     204__attribute__((noreturn)) void __cfaabi_ehm__begin_unwind(void) {
    205205        if ( ! this_exception_context()->current_exception ) {
    206206                printf("UNWIND ERROR missing exception in begin unwind\n");
     
    233233}
    234234
    235 void __cfaehm__throw_terminate( exception * val ) {
    236         LIB_DEBUG_PRINT_SAFE("Throwing termination exception\n");
    237 
    238         __cfaehm__allocate_exception( val );
    239         __cfaehm__begin_unwind();
    240 }
    241 
    242 void __cfaehm__rethrow_terminate(void) {
    243         LIB_DEBUG_PRINT_SAFE("Rethrowing termination exception\n");
    244 
    245         __cfaehm__begin_unwind();
     235void __cfaabi_ehm__throw_terminate( exception * val ) {
     236        __cfaabi_dbg_print_safe("Throwing termination exception\n");
     237
     238        __cfaabi_ehm__allocate_exception( val );
     239        __cfaabi_ehm__begin_unwind();
     240}
     241
     242void __cfaabi_ehm__rethrow_terminate(void) {
     243        __cfaabi_dbg_print_safe("Rethrowing termination exception\n");
     244
     245        __cfaabi_ehm__begin_unwind();
    246246}
    247247
     
    254254{
    255255
    256         //LIB_DEBUG_PRINT_SAFE("CFA: 0x%lx\n", _Unwind_GetCFA(context));
    257         LIB_DEBUG_PRINT_SAFE("Personality function (%d, %x, %llu, %p, %p):", version, actions, exceptionClass, unwind_exception, context);
     256        //__cfaabi_dbg_print_safe("CFA: 0x%lx\n", _Unwind_GetCFA(context));
     257        __cfaabi_dbg_print_safe("Personality function (%d, %x, %llu, %p, %p):", version, actions, exceptionClass, unwind_exception, context);
    258258
    259259        // If we've reached the end of the stack then there is nothing much we can do...
     
    261261
    262262        if (actions & _UA_SEARCH_PHASE) {
    263                 LIB_DEBUG_PRINT_SAFE(" lookup phase");
     263                __cfaabi_dbg_print_safe(" lookup phase");
    264264        }
    265265        else if (actions & _UA_CLEANUP_PHASE) {
    266                 LIB_DEBUG_PRINT_SAFE(" cleanup phase");
     266                __cfaabi_dbg_print_safe(" cleanup phase");
    267267        }
    268268        // Just in case, probably can't actually happen
     
    307307                        void * ep = (void*)lsd_info.Start + callsite_start + callsite_len;
    308308                        void * ip = (void*)instruction_ptr;
    309                         LIB_DEBUG_PRINT_SAFE("\nfound %p - %p (%p, %p, %p), looking for %p\n", bp, ep, ls, cs, cl, ip);
     309                        __cfaabi_dbg_print_safe("\nfound %p - %p (%p, %p, %p), looking for %p\n", bp, ep, ls, cs, cl, ip);
    310310#endif // __CFA_DEBUG_PRINT__
    311311                        continue;
     
    346346
    347347                                        // Get a function pointer from the relative offset and call it
    348                                         // _Unwind_Reason_Code (*matcher)() = (_Unwind_Reason_Code (*)())lsd_info.LPStart + imatcher;                                   
     348                                        // _Unwind_Reason_Code (*matcher)() = (_Unwind_Reason_Code (*)())lsd_info.LPStart + imatcher;
    349349
    350350                                        _Unwind_Reason_Code (*matcher)(exception *) =
     
    357357                                        // Based on the return value, check if we matched the exception
    358358                                        if( ret == _URC_HANDLER_FOUND) {
    359                                                 LIB_DEBUG_PRINT_SAFE(" handler found\n");
     359                                                __cfaabi_dbg_print_safe(" handler found\n");
    360360                                        } else {
    361                                                 LIB_DEBUG_PRINT_SAFE(" no handler\n");
     361                                                __cfaabi_dbg_print_safe(" no handler\n");
    362362                                        }
    363363                                        return ret;
     
    365365
    366366                                // This is only a cleanup handler, ignore it
    367                                 LIB_DEBUG_PRINT_SAFE(" no action");
     367                                __cfaabi_dbg_print_safe(" no action");
    368368                        }
    369369                        else if (actions & _UA_CLEANUP_PHASE) {
     
    385385                                _Unwind_SetIP( context, ((lsd_info.LPStart) + (callsite_landing_pad)) );
    386386
    387                                 LIB_DEBUG_PRINT_SAFE(" action\n");
     387                                __cfaabi_dbg_print_safe(" action\n");
    388388
    389389                                // Return have some action to run
     
    393393
    394394                // Nothing to do, move along
    395                 LIB_DEBUG_PRINT_SAFE(" no landing pad");
     395                __cfaabi_dbg_print_safe(" no landing pad");
    396396        }
    397397        // No handling found
    398         LIB_DEBUG_PRINT_SAFE(" table end reached\n");
     398        __cfaabi_dbg_print_safe(" table end reached\n");
    399399
    400400        UNWIND:
    401         LIB_DEBUG_PRINT_SAFE(" unwind\n");
     401        __cfaabi_dbg_print_safe(" unwind\n");
    402402
    403403        // Keep unwinding the stack
     
    408408// libcfa but there is one problem left, see the exception table for details
    409409__attribute__((noinline))
    410 void __cfaehm__try_terminate(void (*try_block)(),
     410void __cfaabi_ehm__try_terminate(void (*try_block)(),
    411411                void (*catch_block)(int index, exception * except),
    412412                __attribute__((unused)) int (*match_block)(exception * except)) {
     
    466466        // Body uses language specific data and therefore could be modified arbitrarily
    467467        ".LLSDACSBCFA2:\n"                                              // BODY start
    468         "       .uleb128 .TRYSTART-__cfaehm__try_terminate\n"           // Handled area start  (relative to start of function)
     468        "       .uleb128 .TRYSTART-__cfaabi_ehm__try_terminate\n"               // Handled area start  (relative to start of function)
    469469        "       .uleb128 .TRYEND-.TRYSTART\n"                           // Handled area length
    470         "       .uleb128 .CATCH-__cfaehm__try_terminate\n"                              // Hanlder landing pad adress  (relative to start of function)
     470        "       .uleb128 .CATCH-__cfaabi_ehm__try_terminate\n"                          // Hanlder landing pad adress  (relative to start of function)
    471471        "       .uleb128 1\n"                                           // Action code, gcc seems to use always 0
    472472        ".LLSDACSECFA2:\n"                                              // BODY end
    473473        "       .text\n"                                                        // TABLE footer
    474         "       .size   __cfaehm__try_terminate, .-__cfaehm__try_terminate\n"
     474        "       .size   __cfaabi_ehm__try_terminate, .-__cfaabi_ehm__try_terminate\n"
    475475        "       .ident  \"GCC: (Ubuntu 6.2.0-3ubuntu11~16.04) 6.2.0 20160901\"\n"
    476476//      "       .section        .note.GNU-stack,\"x\",@progbits\n"
  • src/libcfa/exception.h

    rdd9b59e r3d560060  
    2121#endif
    2222
    23 struct __cfaehm__base_exception_t;
    24 typedef struct __cfaehm__base_exception_t exception;
    25 struct __cfaehm__base_exception_t_vtable {
    26         const struct __cfaehm__base_exception_t_vtable * parent;
     23struct __cfaabi_ehm__base_exception_t;
     24typedef struct __cfaabi_ehm__base_exception_t exception;
     25struct __cfaabi_ehm__base_exception_t_vtable {
     26        const struct __cfaabi_ehm__base_exception_t_vtable * parent;
    2727        size_t size;
    28         void (*copy)(struct __cfaehm__base_exception_t *this,
    29                      struct __cfaehm__base_exception_t * other);
    30         void (*free)(struct __cfaehm__base_exception_t *this);
    31         const char * (*msg)(struct __cfaehm__base_exception_t *this);
     28        void (*copy)(struct __cfaabi_ehm__base_exception_t *this,
     29                     struct __cfaabi_ehm__base_exception_t * other);
     30        void (*free)(struct __cfaabi_ehm__base_exception_t *this);
     31        const char * (*msg)(struct __cfaabi_ehm__base_exception_t *this);
    3232};
    33 struct __cfaehm__base_exception_t {
    34         struct __cfaehm__base_exception_t_vtable const * virtual_table;
     33struct __cfaabi_ehm__base_exception_t {
     34        struct __cfaabi_ehm__base_exception_t_vtable const * virtual_table;
    3535};
    36 extern struct __cfaehm__base_exception_t_vtable
    37         ___cfaehm__base_exception_t_vtable_instance;
     36extern struct __cfaabi_ehm__base_exception_t_vtable
     37        ___cfaabi_ehm__base_exception_t_vtable_instance;
    3838
    3939
    4040// Used in throw statement translation.
    41 void __cfaehm__throw_terminate(exception * except) __attribute__((noreturn));
    42 void __cfaehm__rethrow_terminate() __attribute__((noreturn));
    43 void __cfaehm__throw_resume(exception * except);
     41void __cfaabi_ehm__throw_terminate(exception * except) __attribute__((noreturn));
     42void __cfaabi_ehm__rethrow_terminate() __attribute__((noreturn));
     43void __cfaabi_ehm__throw_resume(exception * except);
    4444
    4545// Function catches termination exceptions.
    46 void __cfaehm__try_terminate(
     46void __cfaabi_ehm__try_terminate(
    4747    void (*try_block)(),
    4848    void (*catch_block)(int index, exception * except),
     
    5050
    5151// Clean-up the exception in catch blocks.
    52 void __cfaehm__cleanup_terminate(void * except);
     52void __cfaabi_ehm__cleanup_terminate(void * except);
    5353
    5454// Data structure creates a list of resume handlers.
    55 struct __cfaehm__try_resume_node {
    56     struct __cfaehm__try_resume_node * next;
     55struct __cfaabi_ehm__try_resume_node {
     56    struct __cfaabi_ehm__try_resume_node * next;
    5757    _Bool (*handler)(exception * except);
    5858};
    5959
    6060// These act as constructor and destructor for the resume node.
    61 void __cfaehm__try_resume_setup(
    62     struct __cfaehm__try_resume_node * node,
     61void __cfaabi_ehm__try_resume_setup(
     62    struct __cfaabi_ehm__try_resume_node * node,
    6363    _Bool (*handler)(exception * except));
    64 void __cfaehm__try_resume_cleanup(
    65     struct __cfaehm__try_resume_node * node);
     64void __cfaabi_ehm__try_resume_cleanup(
     65    struct __cfaabi_ehm__try_resume_node * node);
    6666
    6767// Check for a standard way to call fake deconstructors.
    68 struct __cfaehm__cleanup_hook {};
     68struct __cfaabi_ehm__cleanup_hook {};
    6969
    7070#ifdef __cforall
  • src/libcfa/interpose.c

    rdd9b59e r3d560060  
    2424}
    2525
    26 #include "libhdr/libdebug.h"
    27 #include "libhdr/libtools.h"
     26#include "bits/debug.h"
     27#include "bits/defs.h"
    2828#include "startup.h"
    2929
     
    6969__typeof__( exit ) libc_exit __attribute__(( noreturn ));
    7070__typeof__( abort ) libc_abort __attribute__(( noreturn ));
    71 
    72 // #define INIT_REALRTN( x, ver ) libc_##x = (__typeof__(libc_##x))interpose_symbol( #x, ver )
    7371
    7472forall(dtype T)
     
    127125                        va_end( args );
    128126
    129                         __lib_debug_write( abort_text, len );
    130                         __lib_debug_write( "\n", 1 );
     127                        __cfaabi_dbg_bits_write( abort_text, len );
     128                        __cfaabi_dbg_bits_write( "\n", 1 );
    131129                }
    132130
    133131                len = snprintf( abort_text, abort_text_size, "Cforall Runtime error (UNIX pid:%ld)\n", (long int)getpid() ); // use UNIX pid (versus getPid)
    134                 __lib_debug_write( abort_text, len );
     132                __cfaabi_dbg_bits_write( abort_text, len );
    135133
    136134
  • src/libcfa/stdhdr/assert.h

    rdd9b59e r3d560060  
    3030#endif
    3131
     32#if !defined(NDEBUG) && (defined(__CFA_DEBUG__) || defined(__CFA_VERIFY__))
     33        #define verify(x) assert(x)
     34        #define verifyf(x, ...) assertf(x, __VA_ARGS__)
     35#else
     36        #define verify(x)
     37        #define verifyf(x, ...)
     38#endif
     39
    3240#ifdef __cforall
    3341} // extern "C"
  • src/prelude/builtins.c

    rdd9b59e r3d560060  
    1616// exception implementation
    1717
    18 typedef unsigned long long __cfaabi_exception_type_t;
     18typedef unsigned long long __cfaabi_abi_exception_type_t;
    1919
    2020#include "../libcfa/virtual.h"
     
    8080} // ?\?
    8181
    82 // FIXME (x \ (unsigned long int)y) relies on X ?\?(T, unsigned long) a function that is neither 
    83 // defined, nor passed as an assertion parameter. Without user-defined conversions, cannot specify 
    84 // X as a type that casts to double, yet it doesn't make sense to write functions with that type 
     82// FIXME (x \ (unsigned long int)y) relies on X ?\?(T, unsigned long) a function that is neither
     83// defined, nor passed as an assertion parameter. Without user-defined conversions, cannot specify
     84// X as a type that casts to double, yet it doesn't make sense to write functions with that type
    8585// signature where X is double.
    8686
  • src/tests/except-mac.h

    rdd9b59e r3d560060  
    77
    88// The fully (perhaps overly) qualified name of the base exception type:
    9 #define BASE_EXCEPT __cfaehm__base_exception_t
     9#define BASE_EXCEPT __cfaabi_ehm__base_exception_t
    1010
    1111// Get the name of the vtable type and vtable instance for an exception type:
Note: See TracChangeset for help on using the changeset viewer.