Changes in / [389528b0:35bae526]
- Location:
- src
- Files:
-
- 2 added
- 2 deleted
- 22 edited
Legend:
- Unmodified
- Added
- Removed
-
src/ControlStruct/ExceptTranslate.cc
r389528b0 r35bae526 211 211 ThrowStmt *throwStmt ) { 212 212 // __throw_terminate( `throwStmt->get_name()` ); } 213 return create_given_throw( "__cfa ehm__throw_terminate", throwStmt );213 return create_given_throw( "__cfaabi_ehm__throw_terminate", throwStmt ); 214 214 } 215 215 … … 232 232 result->push_back( new ExprStmt( 233 233 noLabels, 234 new UntypedExpr( new NameExpr( "__cfa ehm__rethrow_terminate" ) )234 new UntypedExpr( new NameExpr( "__cfaabi_ehm__rethrow_terminate" ) ) 235 235 ) ); 236 236 delete throwStmt; … … 241 241 ThrowStmt *throwStmt ) { 242 242 // __throw_resume( `throwStmt->get_name` ); 243 return create_given_throw( "__cfa ehm__throw_resume", throwStmt );243 return create_given_throw( "__cfaabi_ehm__throw_resume", throwStmt ); 244 244 } 245 245 … … 309 309 local_except->get_attributes().push_back( new Attribute( 310 310 "cleanup", 311 { new NameExpr( "__cfa ehm__cleanup_terminate" ) }311 { new NameExpr( "__cfaabi_ehm__cleanup_terminate" ) } 312 312 ) ); 313 313 … … 432 432 FunctionDecl * terminate_catch, 433 433 FunctionDecl * terminate_match ) { 434 // { __cfa ehm__try_terminate(`try`, `catch`, `match`); }434 // { __cfaabi_ehm__try_terminate(`try`, `catch`, `match`); } 435 435 436 436 UntypedExpr * caller = new UntypedExpr( new NameExpr( 437 "__cfa ehm__try_terminate" ) );437 "__cfaabi_ehm__try_terminate" ) ); 438 438 std::list<Expression *>& args = caller->get_args(); 439 439 args.push_back( nameOf( try_wrapper ) ); … … 489 489 490 490 // struct __try_resume_node __resume_node 491 // __attribute__((cleanup( __cfa ehm__try_resume_cleanup )));491 // __attribute__((cleanup( __cfaabi_ehm__try_resume_cleanup ))); 492 492 // ** unwinding of the stack here could cause problems ** 493 493 // ** however I don't think that can happen currently ** 494 // __cfa ehm__try_resume_setup( &__resume_node, resume_handler );494 // __cfaabi_ehm__try_resume_setup( &__resume_node, resume_handler ); 495 495 496 496 std::list< Attribute * > attributes; … … 498 498 std::list< Expression * > attr_params; 499 499 attr_params.push_back( new NameExpr( 500 "__cfa ehm__try_resume_cleanup" ) );500 "__cfaabi_ehm__try_resume_cleanup" ) ); 501 501 attributes.push_back( new Attribute( "cleanup", attr_params ) ); 502 502 } … … 517 517 518 518 UntypedExpr *setup = new UntypedExpr( new NameExpr( 519 "__cfa ehm__try_resume_setup" ) );519 "__cfaabi_ehm__try_resume_setup" ) ); 520 520 setup->get_args().push_back( new AddressExpr( nameOf( obj ) ) ); 521 521 setup->get_args().push_back( nameOf( resume_handler ) ); … … 542 542 ObjectDecl * ExceptionMutatorCore::create_finally_hook( 543 543 FunctionDecl * finally_wrapper ) { 544 // struct __cfa ehm__cleanup_hook __finally_hook544 // struct __cfaabi_ehm__cleanup_hook __finally_hook 545 545 // __attribute__((cleanup( finally_wrapper ))); 546 546 … … 596 596 // Skip children? 597 597 return; 598 } else if ( structDecl->get_name() == "__cfa ehm__base_exception_t" ) {598 } else if ( structDecl->get_name() == "__cfaabi_ehm__base_exception_t" ) { 599 599 assert( nullptr == except_decl ); 600 600 except_decl = structDecl; 601 601 init_func_types(); 602 } else if ( structDecl->get_name() == "__cfa ehm__try_resume_node" ) {602 } else if ( structDecl->get_name() == "__cfaabi_ehm__try_resume_node" ) { 603 603 assert( nullptr == node_decl ); 604 604 node_decl = structDecl; 605 } else if ( structDecl->get_name() == "__cfa ehm__cleanup_hook" ) {605 } else if ( structDecl->get_name() == "__cfaabi_ehm__cleanup_hook" ) { 606 606 assert( nullptr == hook_decl ); 607 607 hook_decl = structDecl; -
src/ResolvExpr/Resolver.cc
r389528b0 r35bae526 369 369 if ( throwStmt->get_expr() ) { 370 370 StructDecl * exception_decl = 371 indexer.lookupStruct( "__cfa ehm__base_exception_t" );371 indexer.lookupStruct( "__cfaabi_ehm__base_exception_t" ); 372 372 assert( exception_decl ); 373 373 Type * exceptType = new PointerType( noQualifiers, new StructInstType( noQualifiers, exception_decl ) ); -
src/driver/cfa.cc
r389528b0 r35bae526 275 275 args[nargs] = "-Xlinker"; 276 276 nargs += 1; 277 args[nargs] = "--undefined=__ lib_debug_write";277 args[nargs] = "--undefined=__cfaabi_dbg_bits_write"; 278 278 nargs += 1; 279 279 -
src/libcfa/Makefile.am
r389528b0 r35bae526 55 55 56 56 libobjs = ${headers:=.o} 57 libsrc = libcfa-prelude.c interpose.c libhdr/libdebug.c ${headers:=.c} \57 libsrc = libcfa-prelude.c interpose.c bits/debug.c ${headers:=.c} \ 58 58 assert.c exception.c virtual.c 59 59 … … 102 102 bits/containers.h \ 103 103 bits/defs.h \ 104 bits/debug.h \ 104 105 bits/locks.h \ 105 106 concurrency/invoke.h \ 106 107 libhdr.h \ 107 108 libhdr/libalign.h \ 108 libhdr/libdebug.h \109 109 libhdr/libtools.h 110 110 -
src/libcfa/Makefile.in
r389528b0 r35bae526 149 149 libcfa_d_a_LIBADD = 150 150 am__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 \ 152 152 rational.c stdlib.c containers/maybe.c containers/pair.c \ 153 153 containers/result.c containers/vector.c \ … … 175 175 @BUILD_CONCURRENCY_TRUE@ concurrency/libcfa_d_a-preemption.$(OBJEXT) 176 176 am__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) 181 181 am_libcfa_d_a_OBJECTS = $(am__objects_4) 182 182 libcfa_d_a_OBJECTS = $(am_libcfa_d_a_OBJECTS) 183 183 libcfa_a_AR = $(AR) $(ARFLAGS) 184 184 libcfa_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 185 am__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 194 193 @BUILD_CONCURRENCY_TRUE@am__objects_5 = concurrency/libcfa_a-coroutine.$(OBJEXT) \ 195 194 @BUILD_CONCURRENCY_TRUE@ concurrency/libcfa_a-thread.$(OBJEXT) \ … … 208 207 @BUILD_CONCURRENCY_TRUE@ concurrency/libcfa_a-preemption.$(OBJEXT) 209 208 am__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) 214 213 am_libcfa_a_OBJECTS = $(am__objects_8) 215 214 libcfa_a_OBJECTS = $(am_libcfa_a_OBJECTS) … … 265 264 concurrency/thread concurrency/kernel concurrency/monitor \ 266 265 ${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/lib debug.h libhdr/libtools.h266 bits/debug.h bits/locks.h concurrency/invoke.h libhdr.h \ 267 libhdr/libalign.h libhdr/libtools.h 269 268 HEADERS = $(nobase_cfa_include_HEADERS) 270 269 am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP) … … 424 423 containers/vector $(am__append_3) 425 424 libobjs = ${headers:=.o} 426 libsrc = libcfa-prelude.c interpose.c libhdr/libdebug.c ${headers:=.c} \425 libsrc = libcfa-prelude.c interpose.c bits/debug.c ${headers:=.c} \ 427 426 assert.c exception.c virtual.c $(am__append_4) 428 427 libcfa_a_SOURCES = ${libsrc} … … 439 438 bits/containers.h \ 440 439 bits/defs.h \ 440 bits/debug.h \ 441 441 bits/locks.h \ 442 442 concurrency/invoke.h \ 443 443 libhdr.h \ 444 444 libhdr/libalign.h \ 445 libhdr/libdebug.h \446 445 libhdr/libtools.h 447 446 … … 511 510 clean-libLIBRARIES: 512 511 -test -z "$(lib_LIBRARIES)" || rm -f $(lib_LIBRARIES) 513 libhdr/$(am__dirstamp):514 @$(MKDIR_P) libhdr515 @: > 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)512 bits/$(am__dirstamp): 513 @$(MKDIR_P) bits 514 @: > bits/$(am__dirstamp) 515 bits/$(DEPDIR)/$(am__dirstamp): 516 @$(MKDIR_P) bits/$(DEPDIR) 517 @: > bits/$(DEPDIR)/$(am__dirstamp) 518 bits/libcfa_d_a-debug.$(OBJEXT): bits/$(am__dirstamp) \ 519 bits/$(DEPDIR)/$(am__dirstamp) 521 520 containers/$(am__dirstamp): 522 521 @$(MKDIR_P) containers … … 563 562 $(AM_V_AR)$(libcfa_d_a_AR) libcfa-d.a $(libcfa_d_a_OBJECTS) $(libcfa_d_a_LIBADD) 564 563 $(AM_V_at)$(RANLIB) libcfa-d.a 565 libhdr/libcfa_a-libdebug.$(OBJEXT): libhdr/$(am__dirstamp) \566 libhdr/$(DEPDIR)/$(am__dirstamp)564 bits/libcfa_a-debug.$(OBJEXT): bits/$(am__dirstamp) \ 565 bits/$(DEPDIR)/$(am__dirstamp) 567 566 containers/libcfa_a-maybe.$(OBJEXT): containers/$(am__dirstamp) \ 568 567 containers/$(DEPDIR)/$(am__dirstamp) … … 596 595 mostlyclean-compile: 597 596 -rm -f *.$(OBJEXT) 597 -rm -f bits/*.$(OBJEXT) 598 598 -rm -f concurrency/*.$(OBJEXT) 599 599 -rm -f containers/*.$(OBJEXT) 600 -rm -f libhdr/*.$(OBJEXT)601 600 602 601 distclean-compile: … … 625 624 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_d_a-stdlib.Po@am__quote@ 626 625 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_d_a-virtual.Po@am__quote@ 626 @AMDEP_TRUE@@am__include@ @am__quote@bits/$(DEPDIR)/libcfa_a-debug.Po@am__quote@ 627 @AMDEP_TRUE@@am__include@ @am__quote@bits/$(DEPDIR)/libcfa_d_a-debug.Po@am__quote@ 627 628 @AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/CtxSwitch-@MACHINE_TYPE@.Po@am__quote@ 628 629 @AMDEP_TRUE@@am__include@ @am__quote@concurrency/$(DEPDIR)/libcfa_a-alarm.Po@am__quote@ … … 648 649 @AMDEP_TRUE@@am__include@ @am__quote@containers/$(DEPDIR)/libcfa_d_a-result.Po@am__quote@ 649 650 @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@652 651 653 652 .S.o: … … 704 703 @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` 705 704 706 libhdr/libcfa_d_a-libdebug.o: libhdr/libdebug.c707 @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.c708 @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) libhdr/$(DEPDIR)/libcfa_d_a-libdebug.Tpo libhdr/$(DEPDIR)/libcfa_d_a-libdebug.Po709 @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.c712 713 libhdr/libcfa_d_a-libdebug.obj: libhdr/libdebug.c714 @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.Po716 @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`705 bits/libcfa_d_a-debug.o: bits/debug.c 706 @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 707 @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) bits/$(DEPDIR)/libcfa_d_a-debug.Tpo bits/$(DEPDIR)/libcfa_d_a-debug.Po 708 @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='bits/debug.c' object='bits/libcfa_d_a-debug.o' libtool=no @AMDEPBACKSLASH@ 709 @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ 710 @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 711 712 bits/libcfa_d_a-debug.obj: bits/debug.c 713 @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` 714 @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) bits/$(DEPDIR)/libcfa_d_a-debug.Tpo bits/$(DEPDIR)/libcfa_d_a-debug.Po 715 @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='bits/debug.c' object='bits/libcfa_d_a-debug.obj' libtool=no @AMDEPBACKSLASH@ 716 @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ 717 @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` 719 718 720 719 libcfa_d_a-fstream.o: fstream.c … … 998 997 @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` 999 998 1000 libhdr/libcfa_a-libdebug.o: libhdr/libdebug.c1001 @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.c1002 @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) libhdr/$(DEPDIR)/libcfa_a-libdebug.Tpo libhdr/$(DEPDIR)/libcfa_a-libdebug.Po1003 @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.c1006 1007 libhdr/libcfa_a-libdebug.obj: libhdr/libdebug.c1008 @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.Po1010 @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`999 bits/libcfa_a-debug.o: bits/debug.c 1000 @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 1001 @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) bits/$(DEPDIR)/libcfa_a-debug.Tpo bits/$(DEPDIR)/libcfa_a-debug.Po 1002 @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='bits/debug.c' object='bits/libcfa_a-debug.o' libtool=no @AMDEPBACKSLASH@ 1003 @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ 1004 @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 1005 1006 bits/libcfa_a-debug.obj: bits/debug.c 1007 @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` 1008 @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) bits/$(DEPDIR)/libcfa_a-debug.Tpo bits/$(DEPDIR)/libcfa_a-debug.Po 1009 @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='bits/debug.c' object='bits/libcfa_a-debug.obj' libtool=no @AMDEPBACKSLASH@ 1010 @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ 1011 @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` 1013 1012 1014 1013 libcfa_a-fstream.o: fstream.c … … 1411 1410 -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) 1412 1411 -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) 1412 -rm -f bits/$(DEPDIR)/$(am__dirstamp) 1413 -rm -f bits/$(am__dirstamp) 1413 1414 -rm -f concurrency/$(DEPDIR)/$(am__dirstamp) 1414 1415 -rm -f concurrency/$(am__dirstamp) 1415 1416 -rm -f containers/$(DEPDIR)/$(am__dirstamp) 1416 1417 -rm -f containers/$(am__dirstamp) 1417 -rm -f libhdr/$(DEPDIR)/$(am__dirstamp)1418 -rm -f libhdr/$(am__dirstamp)1419 1418 1420 1419 maintainer-clean-generic: … … 1426 1425 1427 1426 distclean: distclean-am 1428 -rm -rf ./$(DEPDIR) concurrency/$(DEPDIR) containers/$(DEPDIR) libhdr/$(DEPDIR)1427 -rm -rf ./$(DEPDIR) bits/$(DEPDIR) concurrency/$(DEPDIR) containers/$(DEPDIR) 1429 1428 -rm -f Makefile 1430 1429 distclean-am: clean-am distclean-compile distclean-generic \ … … 1472 1471 1473 1472 maintainer-clean: maintainer-clean-am 1474 -rm -rf ./$(DEPDIR) concurrency/$(DEPDIR) containers/$(DEPDIR) libhdr/$(DEPDIR)1473 -rm -rf ./$(DEPDIR) bits/$(DEPDIR) concurrency/$(DEPDIR) containers/$(DEPDIR) 1475 1474 -rm -f Makefile 1476 1475 maintainer-clean-am: distclean-am maintainer-clean-generic \ -
src/libcfa/assert.c
r389528b0 r35bae526 17 17 #include <stdarg.h> // varargs 18 18 #include <stdio.h> // fprintf 19 #include " libhdr/libdebug.h"19 #include "bits/debug.h" 20 20 21 21 extern "C" { … … 26 26 // called by macro assert in assert.h 27 27 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 ); 29 29 abort(); 30 30 } … … 32 32 // called by macro assertf 33 33 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 ); 36 36 37 37 va_list args; 38 38 va_start( args, fmt ); 39 __ lib_debug_print_vararg( fmt, args );39 __cfaabi_dbg_bits_print_vararg( fmt, args ); 40 40 va_end( args ); 41 41 42 __ lib_debug_print_nolock( "\n" );43 __ lib_debug_release();42 __cfaabi_dbg_bits_print_nolock( "\n" ); 43 __cfaabi_dbg_bits_release(); 44 44 abort(); 45 45 } -
src/libcfa/bits/locks.h
r389528b0 r35bae526 16 16 #pragma once 17 17 18 #include "bits/debug.h" 18 19 #include "bits/defs.h" 19 20 … … 65 66 66 67 // Lock the spinlock, return false if already acquired 67 static inline _Bool try_lock ( __spinlock_t & this DEBUG_CTX_PARAM2 ) {68 static inline _Bool try_lock ( __spinlock_t & this __cfaabi_dbg_ctx_param2 ) { 68 69 _Bool result = __lock_test_and_test_and_set( this.lock ); 69 LIB_DEBUG_DO(70 __cfaabi_dbg_debug_do( 70 71 if( result ) { 71 72 this.prev_name = caller; … … 77 78 78 79 // Lock the spinlock, spin if already acquired 79 static inline void lock( __spinlock_t & this DEBUG_CTX_PARAM2 ) {80 static inline void lock( __spinlock_t & this __cfaabi_dbg_ctx_param2 ) { 80 81 #ifndef NOEXPBACK 81 82 enum { SPIN_START = 4, SPIN_END = 64 * 1024, }; … … 98 99 #endif 99 100 } 100 LIB_DEBUG_DO(101 __cfaabi_dbg_debug_do( 101 102 this.prev_name = caller; 102 103 this.prev_thrd = this_thread; … … 105 106 106 107 // Lock the spinlock, spin if already acquired 107 static inline void lock_yield( __spinlock_t & this DEBUG_CTX_PARAM2 ) {108 static inline void lock_yield( __spinlock_t & this __cfaabi_dbg_ctx_param2 ) { 108 109 for ( unsigned int i = 1;; i += 1 ) { 109 110 if ( __lock_test_and_test_and_set( this.lock ) ) break; 110 111 yield( i ); 111 112 } 112 LIB_DEBUG_DO(113 __cfaabi_dbg_debug_do( 113 114 this.prev_name = caller; 114 115 this.prev_thrd = this_thread; -
src/libcfa/concurrency/alarm.c
r389528b0 r35bae526 110 110 } 111 111 112 LIB_DEBUG_DO( bool validate( alarm_list_t * this ) {112 __cfaabi_dbg_debug_do( bool validate( alarm_list_t * this ) { 113 113 alarm_node_t ** it = &this->head; 114 114 while( (*it) ) { … … 186 186 187 187 disable_interrupts(); 188 lock( event_kernel->lock DEBUG_CTX2 );188 lock( event_kernel->lock __cfaabi_dbg_ctx2 ); 189 189 { 190 190 verify( validate( alarms ) ); … … 198 198 unlock( event_kernel->lock ); 199 199 this->set = true; 200 enable_interrupts( DEBUG_CTX);200 enable_interrupts( __cfaabi_dbg_ctx ); 201 201 } 202 202 203 203 void unregister_self( alarm_node_t * this ) { 204 204 disable_interrupts(); 205 lock( event_kernel->lock DEBUG_CTX2 );205 lock( event_kernel->lock __cfaabi_dbg_ctx2 ); 206 206 { 207 207 verify( validate( &event_kernel->alarms ) ); … … 209 209 } 210 210 unlock( event_kernel->lock ); 211 enable_interrupts( DEBUG_CTX);211 enable_interrupts( __cfaabi_dbg_ctx ); 212 212 this->set = false; 213 213 } -
src/libcfa/concurrency/coroutine.c
r389528b0 r35bae526 76 76 void ^?{}(coStack_t & this) { 77 77 if ( ! this.userStack && this.storage ) { 78 LIB_DEBUG_DO(78 __cfaabi_dbg_debug_do( 79 79 if ( mprotect( this.storage, pageSize, PROT_READ | PROT_WRITE ) == -1 ) { 80 80 abortf( "(coStack_t *)%p.^?{}() : internal error, mprotect failure, error(%d) %s.", &this, errno, strerror( errno ) ); … … 131 131 132 132 // 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 ) );133 __cfaabi_dbg_debug_do( this->storage = memalign( pageSize, cxtSize + this->size + pageSize ) ); 134 __cfaabi_dbg_no_debug_do( this->storage = malloc( cxtSize + this->size + 8 ) ); 135 135 136 LIB_DEBUG_DO(136 __cfaabi_dbg_debug_do( 137 137 if ( mprotect( this->storage, pageSize, PROT_NONE ) == -1 ) { 138 138 abortf( "(uMachContext &)%p.createContext() : internal error, mprotect failure, error(%d) %s.", this, (int)errno, strerror( (int)errno ) ); … … 144 144 } // if 145 145 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 alignment146 __cfaabi_dbg_debug_do( this->limit = (char *)this->storage + pageSize ); 147 __cfaabi_dbg_no_debug_do( this->limit = (char *)libCeiling( (unsigned long)this->storage, 16 ) ); // minimum alignment 148 148 149 149 } else { -
src/libcfa/concurrency/invoke.c
r389528b0 r35bae526 31 31 extern void __leave_thread_monitor( struct thread_desc * this ); 32 32 extern void disable_interrupts(); 33 extern void enable_interrupts( DEBUG_CTX_PARAM);33 extern void enable_interrupts( __cfaabi_dbg_ctx_param ); 34 34 35 35 void CtxInvokeCoroutine( 36 37 38 36 void (*main)(void *), 37 struct coroutine_desc *(*get_coroutine)(void *), 38 void *this 39 39 ) { 40 // LIB_DEBUG_PRINTF("Invoke Coroutine : Received %p (main %p, get_c %p)\n", this, main, get_coroutine);40 struct coroutine_desc* cor = get_coroutine( this ); 41 41 42 struct coroutine_desc* cor = get_coroutine( this ); 42 if(cor->state == Primed) { 43 __suspend_internal(); 44 } 43 45 44 if(cor->state == Primed) { 45 __suspend_internal(); 46 } 46 cor->state = Active; 47 47 48 cor->state = Active;48 main( this ); 49 49 50 main( this );50 cor->state = Halted; 51 51 52 cor->state = Halted; 53 54 //Final suspend, should never return 55 __leave_coroutine(); 56 abortf("Resumed dead coroutine"); 52 //Final suspend, should never return 53 __leave_coroutine(); 54 abortf("Resumed dead coroutine"); 57 55 } 58 56 59 57 void CtxInvokeThread( 60 61 62 63 58 void (*dtor)(void *), 59 void (*main)(void *), 60 struct thread_desc *(*get_thread)(void *), 61 void *this 64 62 ) { 65 66 67 63 // First suspend, once the thread arrives here, 64 // the function pointer to main can be invalidated without risk 65 __suspend_internal(); 68 66 69 70 67 // Fetch the thread handle from the user defined thread structure 68 struct thread_desc* thrd = get_thread( this ); 71 69 72 73 enable_interrupts( DEBUG_CTX);70 // Officially start the thread by enabling preemption 71 enable_interrupts( __cfaabi_dbg_ctx ); 74 72 75 76 73 // Call the main of the thread 74 main( this ); 77 75 78 79 80 81 82 83 84 85 86 76 // To exit a thread we must : 77 // 1 - Mark it as halted 78 // 2 - Leave its monitor 79 // 3 - Disable the interupts 80 // 4 - Final suspend 81 // The order of these 4 operations is very important 82 //Final suspend, should never return 83 __leave_thread_monitor( thrd ); 84 abortf("Resumed dead thread"); 87 85 } 88 86 89 87 90 88 void CtxStart( 91 92 93 94 89 void (*main)(void *), 90 struct coroutine_desc *(*get_coroutine)(void *), 91 void *this, 92 void (*invoke)(void *) 95 93 ) { 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; 94 struct coStack_t* stack = &get_coroutine( this )->stack; 99 95 100 96 #if defined( __i386__ ) … … 103 99 void *fixedRegisters[3]; // fixed registers ebx, edi, esi (popped on 1st uSwitch, values unimportant) 104 100 uint32_t mxcr; // SSE Status and Control bits (control bits are preserved across function calls) 105 101 uint16_t fcw; // X97 FPU control word (preserved across function calls) 106 102 void *rturn; // where to go on return from uSwitch 107 103 void *dummyReturn; // fake return compiler would have pushed on call to uInvoke … … 116 112 ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->argument[0] = this; // argument to invoke 117 113 ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->rturn = invoke; 118 119 114 ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->mxcr = 0x1F80; //Vol. 2A 3-520 115 ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->fcw = 0x037F; //Vol. 1 8-7 120 116 121 117 #elif defined( __x86_64__ ) 122 118 123 124 125 126 127 128 129 119 struct FakeStack { 120 void *fixedRegisters[5]; // fixed registers rbx, r12, r13, r14, r15 121 uint32_t mxcr; // SSE Status and Control bits (control bits are preserved across function calls) 122 uint16_t fcw; // X97 FPU control word (preserved across function calls) 123 void *rturn; // where to go on return from uSwitch 124 void *dummyReturn; // NULL return address to provide proper alignment 125 }; 130 126 131 132 127 ((struct machine_context_t *)stack->context)->SP = (char *)stack->base - sizeof( struct FakeStack ); 128 ((struct machine_context_t *)stack->context)->FP = NULL; // terminate stack with NULL fp 133 129 134 135 136 137 138 139 130 ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->dummyReturn = NULL; 131 ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->rturn = CtxInvokeStub; 132 ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->fixedRegisters[0] = this; 133 ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->fixedRegisters[1] = invoke; 134 ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->mxcr = 0x1F80; //Vol. 2A 3-520 135 ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->fcw = 0x037F; //Vol. 1 8-7 140 136 #else 141 137 #error Only __i386__ and __x86_64__ is supported for threads in cfa 142 138 #endif 143 139 } -
src/libcfa/concurrency/kernel.c
r389528b0 r35bae526 150 150 151 151 this.runner = &runner; 152 LIB_DEBUG_PRINT_SAFE("Kernel : constructing main processor context %p\n", &runner);152 __cfaabi_dbg_print_safe("Kernel : constructing main processor context %p\n", &runner); 153 153 runner{ &this }; 154 154 } … … 156 156 void ^?{}(processor & this) { 157 157 if( ! this.do_terminate ) { 158 LIB_DEBUG_PRINT_SAFE("Kernel : core %p signaling termination\n", &this);158 __cfaabi_dbg_print_safe("Kernel : core %p signaling termination\n", &this); 159 159 this.do_terminate = true; 160 160 P( this.terminated ); … … 181 181 processor * this = runner.proc; 182 182 183 LIB_DEBUG_PRINT_SAFE("Kernel : core %p starting\n", this);183 __cfaabi_dbg_print_safe("Kernel : core %p starting\n", this); 184 184 185 185 { … … 187 187 preemption_scope scope = { this }; 188 188 189 LIB_DEBUG_PRINT_SAFE("Kernel : core %p started\n", this);189 __cfaabi_dbg_print_safe("Kernel : core %p started\n", this); 190 190 191 191 thread_desc * readyThread = NULL; … … 213 213 } 214 214 215 LIB_DEBUG_PRINT_SAFE("Kernel : core %p stopping\n", this);215 __cfaabi_dbg_print_safe("Kernel : core %p stopping\n", this); 216 216 } 217 217 218 218 V( this->terminated ); 219 219 220 LIB_DEBUG_PRINT_SAFE("Kernel : core %p terminated\n", this);220 __cfaabi_dbg_print_safe("Kernel : core %p terminated\n", this); 221 221 } 222 222 … … 292 292 processorCtx_t proc_cor_storage = { proc, &info }; 293 293 294 LIB_DEBUG_PRINT_SAFE("Coroutine : created stack %p\n", proc_cor_storage.__cor.stack.base);294 __cfaabi_dbg_print_safe("Coroutine : created stack %p\n", proc_cor_storage.__cor.stack.base); 295 295 296 296 //Set global state … … 299 299 300 300 //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);301 __cfaabi_dbg_print_safe("Kernel : core %p created (%p, %p)\n", proc, proc->runner, &ctx); 302 302 303 303 // SKULLDUGGERY: Since the coroutine doesn't have its own stack, we can't … … 310 310 311 311 // 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);312 __cfaabi_dbg_print_safe("Kernel : core %p main ended (%p)\n", proc, proc->runner); 313 313 314 314 return NULL; … … 316 316 317 317 void start(processor * this) { 318 LIB_DEBUG_PRINT_SAFE("Kernel : Starting core %p\n", this);318 __cfaabi_dbg_print_safe("Kernel : Starting core %p\n", this); 319 319 320 320 pthread_create( &this->kernel_thread, NULL, CtxInvokeProcessor, (void*)this ); 321 321 322 LIB_DEBUG_PRINT_SAFE("Kernel : core %p started\n", this);322 __cfaabi_dbg_print_safe("Kernel : core %p started\n", this); 323 323 } 324 324 … … 334 334 verifyf( thrd->next == NULL, "Expected null got %p", thrd->next ); 335 335 336 lock( this_processor->cltr->ready_queue_lock DEBUG_CTX2 );336 lock( this_processor->cltr->ready_queue_lock __cfaabi_dbg_ctx2 ); 337 337 append( this_processor->cltr->ready_queue, thrd ); 338 338 unlock( this_processor->cltr->ready_queue_lock ); … … 343 343 thread_desc * nextThread(cluster * this) { 344 344 verify( disable_preempt_count > 0 ); 345 lock( this->ready_queue_lock DEBUG_CTX2 );345 lock( this->ready_queue_lock __cfaabi_dbg_ctx2 ); 346 346 thread_desc * head = pop_head( this->ready_queue ); 347 347 unlock( this->ready_queue_lock ); … … 355 355 suspend(); 356 356 verify( disable_preempt_count > 0 ); 357 enable_interrupts( DEBUG_CTX);357 enable_interrupts( __cfaabi_dbg_ctx ); 358 358 } 359 359 … … 367 367 verify( disable_preempt_count > 0 ); 368 368 369 enable_interrupts( DEBUG_CTX);369 enable_interrupts( __cfaabi_dbg_ctx ); 370 370 } 371 371 … … 381 381 verify( disable_preempt_count > 0 ); 382 382 383 enable_interrupts( DEBUG_CTX);383 enable_interrupts( __cfaabi_dbg_ctx ); 384 384 } 385 385 … … 395 395 verify( disable_preempt_count > 0 ); 396 396 397 enable_interrupts( DEBUG_CTX);397 enable_interrupts( __cfaabi_dbg_ctx ); 398 398 } 399 399 … … 408 408 verify( disable_preempt_count > 0 ); 409 409 410 enable_interrupts( DEBUG_CTX);410 enable_interrupts( __cfaabi_dbg_ctx ); 411 411 } 412 412 … … 423 423 verify( disable_preempt_count > 0 ); 424 424 425 enable_interrupts( DEBUG_CTX);425 enable_interrupts( __cfaabi_dbg_ctx ); 426 426 } 427 427 … … 441 441 // Kernel boot procedures 442 442 void kernel_startup(void) { 443 LIB_DEBUG_PRINT_SAFE("Kernel : Starting\n");443 __cfaabi_dbg_print_safe("Kernel : Starting\n"); 444 444 445 445 // Start by initializing the main thread … … 450 450 (*mainThread){ &info }; 451 451 452 LIB_DEBUG_PRINT_SAFE("Kernel : Main thread ready\n");452 __cfaabi_dbg_print_safe("Kernel : Main thread ready\n"); 453 453 454 454 // Initialize the main cluster … … 456 456 (*mainCluster){}; 457 457 458 LIB_DEBUG_PRINT_SAFE("Kernel : main cluster ready\n");458 __cfaabi_dbg_print_safe("Kernel : main cluster ready\n"); 459 459 460 460 // Initialize the main processor and the main processor ctx … … 483 483 484 484 // THE SYSTEM IS NOW COMPLETELY RUNNING 485 LIB_DEBUG_PRINT_SAFE("Kernel : Started\n--------------------------------------------------\n\n");486 487 enable_interrupts( DEBUG_CTX);485 __cfaabi_dbg_print_safe("Kernel : Started\n--------------------------------------------------\n\n"); 486 487 enable_interrupts( __cfaabi_dbg_ctx ); 488 488 } 489 489 490 490 void kernel_shutdown(void) { 491 LIB_DEBUG_PRINT_SAFE("\n--------------------------------------------------\nKernel : Shutting down\n");491 __cfaabi_dbg_print_safe("\n--------------------------------------------------\nKernel : Shutting down\n"); 492 492 493 493 disable_interrupts(); … … 513 513 ^(mainThread){}; 514 514 515 LIB_DEBUG_PRINT_SAFE("Kernel : Shutdown complete\n");515 __cfaabi_dbg_print_safe("Kernel : Shutdown complete\n"); 516 516 } 517 517 … … 523 523 // abort cannot be recursively entered by the same or different processors because all signal handlers return when 524 524 // the globalAbort flag is true. 525 lock( kernel_abort_lock DEBUG_CTX2 );525 lock( kernel_abort_lock __cfaabi_dbg_ctx2 ); 526 526 527 527 // first task to abort ? … … 548 548 549 549 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 );550 __cfaabi_dbg_bits_write( abort_text, len ); 551 551 552 552 if ( thrd != this_coroutine ) { 553 553 len = snprintf( abort_text, abort_text_size, " in coroutine %.256s (%p).\n", this_coroutine->name, this_coroutine ); 554 __ lib_debug_write( abort_text, len );554 __cfaabi_dbg_bits_write( abort_text, len ); 555 555 } 556 556 else { 557 __ lib_debug_write( ".\n", 2 );557 __cfaabi_dbg_bits_write( ".\n", 2 ); 558 558 } 559 559 } 560 560 561 561 extern "C" { 562 void __ lib_debug_acquire() {563 lock( kernel_debug_lock DEBUG_CTX2 );564 } 565 566 void __ lib_debug_release() {562 void __cfaabi_dbg_bits_acquire() { 563 lock( kernel_debug_lock __cfaabi_dbg_ctx2 ); 564 } 565 566 void __cfaabi_dbg_bits_release() { 567 567 unlock( kernel_debug_lock ); 568 568 } … … 582 582 583 583 void P(semaphore & this) { 584 lock( this.lock DEBUG_CTX2 );584 lock( this.lock __cfaabi_dbg_ctx2 ); 585 585 this.count -= 1; 586 586 if ( this.count < 0 ) { … … 598 598 void V(semaphore & this) { 599 599 thread_desc * thrd = NULL; 600 lock( this.lock DEBUG_CTX2 );600 lock( this.lock __cfaabi_dbg_ctx2 ); 601 601 this.count += 1; 602 602 if ( this.count <= 0 ) { -
src/libcfa/concurrency/kernel_private.h
r389528b0 r35bae526 30 30 void disable_interrupts(); 31 31 void enable_interrupts_noPoll(); 32 void enable_interrupts( DEBUG_CTX_PARAM);32 void enable_interrupts( __cfaabi_dbg_ctx_param ); 33 33 } 34 34 … … 39 39 disable_interrupts(); 40 40 ScheduleThread( thrd ); 41 enable_interrupts( DEBUG_CTX);41 enable_interrupts( __cfaabi_dbg_ctx ); 42 42 } 43 43 thread_desc * nextThread(cluster * this); -
src/libcfa/concurrency/monitor.c
r389528b0 r35bae526 91 91 static void __enter_monitor_desc( monitor_desc * this, const __monitor_group_t & group ) { 92 92 // Lock the monitor spinlock 93 DO_LOCK( this->lock DEBUG_CTX2 );93 DO_LOCK( this->lock __cfaabi_dbg_ctx2 ); 94 94 thread_desc * thrd = this_thread; 95 95 96 LIB_DEBUG_PRINT_SAFE("Kernel : %10p Entering mon %p (%p)\n", thrd, this, this->owner);96 __cfaabi_dbg_print_safe("Kernel : %10p Entering mon %p (%p)\n", thrd, this, this->owner); 97 97 98 98 if( !this->owner ) { … … 100 100 set_owner( this, thrd ); 101 101 102 LIB_DEBUG_PRINT_SAFE("Kernel : mon is free \n");102 __cfaabi_dbg_print_safe("Kernel : mon is free \n"); 103 103 } 104 104 else if( this->owner == thrd) { … … 106 106 this->recursion += 1; 107 107 108 LIB_DEBUG_PRINT_SAFE("Kernel : mon already owned \n");108 __cfaabi_dbg_print_safe("Kernel : mon already owned \n"); 109 109 } 110 110 else if( is_accepted( this, group) ) { … … 115 115 reset_mask( this ); 116 116 117 LIB_DEBUG_PRINT_SAFE("Kernel : mon accepts \n");117 __cfaabi_dbg_print_safe("Kernel : mon accepts \n"); 118 118 } 119 119 else { 120 LIB_DEBUG_PRINT_SAFE("Kernel : blocking \n");120 __cfaabi_dbg_print_safe("Kernel : blocking \n"); 121 121 122 122 // Some one else has the monitor, wait in line for it … … 124 124 BlockInternal( &this->lock ); 125 125 126 LIB_DEBUG_PRINT_SAFE("Kernel : %10p Entered mon %p\n", thrd, this);126 __cfaabi_dbg_print_safe("Kernel : %10p Entered mon %p\n", thrd, this); 127 127 128 128 // BlockInternal will unlock spinlock, no need to unlock ourselves … … 130 130 } 131 131 132 LIB_DEBUG_PRINT_SAFE("Kernel : %10p Entered mon %p\n", thrd, this);132 __cfaabi_dbg_print_safe("Kernel : %10p Entered mon %p\n", thrd, this); 133 133 134 134 // Release the lock and leave … … 139 139 static void __enter_monitor_dtor( monitor_desc * this, fptr_t func ) { 140 140 // Lock the monitor spinlock 141 DO_LOCK( this->lock DEBUG_CTX2 );141 DO_LOCK( this->lock __cfaabi_dbg_ctx2 ); 142 142 thread_desc * thrd = this_thread; 143 143 144 LIB_DEBUG_PRINT_SAFE("Kernel : %10p Entering dtor for mon %p (%p)\n", thrd, this, this->owner);144 __cfaabi_dbg_print_safe("Kernel : %10p Entering dtor for mon %p (%p)\n", thrd, this, this->owner); 145 145 146 146 147 147 if( !this->owner ) { 148 LIB_DEBUG_PRINT_SAFE("Kernel : Destroying free mon %p\n", this);148 __cfaabi_dbg_print_safe("Kernel : Destroying free mon %p\n", this); 149 149 150 150 // No one has the monitor, just take it … … 164 164 __monitor_group_t group = { &this, 1, func }; 165 165 if( is_accepted( this, group) ) { 166 LIB_DEBUG_PRINT_SAFE("Kernel : mon accepts dtor, block and signal it \n");166 __cfaabi_dbg_print_safe("Kernel : mon accepts dtor, block and signal it \n"); 167 167 168 168 // Wake the thread that is waiting for this … … 183 183 } 184 184 else { 185 LIB_DEBUG_PRINT_SAFE("Kernel : blocking \n");185 __cfaabi_dbg_print_safe("Kernel : blocking \n"); 186 186 187 187 wait_ctx( this_thread, 0 ) … … 196 196 } 197 197 198 LIB_DEBUG_PRINT_SAFE("Kernel : Destroying %p\n", this);198 __cfaabi_dbg_print_safe("Kernel : Destroying %p\n", this); 199 199 200 200 } … … 203 203 void __leave_monitor_desc( monitor_desc * this ) { 204 204 // 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);205 DO_LOCK( this->lock __cfaabi_dbg_ctx2 ); 206 207 __cfaabi_dbg_print_safe("Kernel : %10p Leaving mon %p (%p)\n", this_thread, this, this->owner); 208 208 209 209 verifyf( this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", this_thread, this->owner, this->recursion, this ); … … 215 215 // it means we don't need to do anything 216 216 if( this->recursion != 0) { 217 LIB_DEBUG_PRINT_SAFE("Kernel : recursion still %d\n", this->recursion);217 __cfaabi_dbg_print_safe("Kernel : recursion still %d\n", this->recursion); 218 218 unlock( this->lock ); 219 219 return; … … 232 232 // Leave single monitor for the last time 233 233 void __leave_dtor_monitor_desc( monitor_desc * this ) { 234 LIB_DEBUG_DO(234 __cfaabi_dbg_debug_do( 235 235 if( this_thread != this->owner ) { 236 236 abortf("Destroyed monitor %p has inconsistent owner, expected %p got %p.\n", this, this_thread, this->owner); … … 249 249 250 250 // Lock the monitor now 251 DO_LOCK( this->lock DEBUG_CTX2 );251 DO_LOCK( this->lock __cfaabi_dbg_ctx2 ); 252 252 253 253 disable_interrupts(); … … 308 308 (this_thread->monitors){m, count, func}; 309 309 310 // LIB_DEBUG_PRINT_SAFE("MGUARD : enter %d\n", count);310 // __cfaabi_dbg_print_safe("MGUARD : enter %d\n", count); 311 311 312 312 // Enter the monitors in order … … 314 314 enter( group ); 315 315 316 // LIB_DEBUG_PRINT_SAFE("MGUARD : entered\n");316 // __cfaabi_dbg_print_safe("MGUARD : entered\n"); 317 317 } 318 318 … … 320 320 // Dtor for monitor guard 321 321 void ^?{}( monitor_guard_t & this ) { 322 // LIB_DEBUG_PRINT_SAFE("MGUARD : leaving %d\n", this.count);322 // __cfaabi_dbg_print_safe("MGUARD : leaving %d\n", this.count); 323 323 324 324 // Leave the monitors in order 325 325 leave( this.m, this.count ); 326 326 327 // LIB_DEBUG_PRINT_SAFE("MGUARD : left\n");327 // __cfaabi_dbg_print_safe("MGUARD : left\n"); 328 328 329 329 // Restore thread context … … 430 430 431 431 //Some more checking in debug 432 LIB_DEBUG_DO(432 __cfaabi_dbg_debug_do( 433 433 thread_desc * this_thrd = this_thread; 434 434 if ( this.monitor_count != this_thrd->monitors.size ) { … … 487 487 set_owner( monitors, count, signallee ); 488 488 489 LIB_DEBUG_PRINT_BUFFER_DECL( "Kernel : signal_block condition %p (s: %p)\n", &this, signallee );489 __cfaabi_dbg_print_buffer_decl( "Kernel : signal_block condition %p (s: %p)\n", &this, signallee ); 490 490 491 491 //Everything is ready to go to sleep … … 496 496 497 497 498 LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : signal_block returned\n" );498 __cfaabi_dbg_print_buffer_local( "Kernel : signal_block returned\n" ); 499 499 500 500 //We are back, restore the masks and recursions … … 535 535 __lock_size_t actual_count = aggregate( mon_storage, mask ); 536 536 537 LIB_DEBUG_PRINT_BUFFER_DECL( "Kernel : waitfor %d (s: %d, m: %d)\n", actual_count, mask.size, (__lock_size_t)max);537 __cfaabi_dbg_print_buffer_decl( "Kernel : waitfor %d (s: %d, m: %d)\n", actual_count, mask.size, (__lock_size_t)max); 538 538 539 539 if(actual_count == 0) return; 540 540 541 LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : waitfor internal proceeding\n");541 __cfaabi_dbg_print_buffer_local( "Kernel : waitfor internal proceeding\n"); 542 542 543 543 // Create storage for monitor context … … 556 556 __acceptable_t& accepted = mask[index]; 557 557 if( accepted.is_dtor ) { 558 LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : dtor already there\n");558 __cfaabi_dbg_print_buffer_local( "Kernel : dtor already there\n"); 559 559 verifyf( accepted.size == 1, "ERROR: Accepted dtor has more than 1 mutex parameter." ); 560 560 … … 568 568 } 569 569 else { 570 LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : thread present, baton-passing\n");570 __cfaabi_dbg_print_buffer_local( "Kernel : thread present, baton-passing\n"); 571 571 572 572 // Create the node specific to this wait operation … … 576 576 monitor_save; 577 577 578 LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : baton of %d monitors : ", count );578 __cfaabi_dbg_print_buffer_local( "Kernel : baton of %d monitors : ", count ); 579 579 #ifdef __CFA_DEBUG_PRINT__ 580 580 for( int i = 0; i < count; i++) { 581 LIB_DEBUG_PRINT_BUFFER_LOCAL( "%p %p ", monitors[i], monitors[i]->signal_stack.top );581 __cfaabi_dbg_print_buffer_local( "%p %p ", monitors[i], monitors[i]->signal_stack.top ); 582 582 } 583 583 #endif 584 LIB_DEBUG_PRINT_BUFFER_LOCAL( "\n");584 __cfaabi_dbg_print_buffer_local( "\n"); 585 585 586 586 // Set the owners to be the next thread … … 593 593 monitor_restore; 594 594 595 LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : thread present, returned\n");595 __cfaabi_dbg_print_buffer_local( "Kernel : thread present, returned\n"); 596 596 } 597 597 598 LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : accepted %d\n", *mask.accepted);598 __cfaabi_dbg_print_buffer_local( "Kernel : accepted %d\n", *mask.accepted); 599 599 return; 600 600 } … … 603 603 604 604 if( duration == 0 ) { 605 LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : non-blocking, exiting\n");605 __cfaabi_dbg_print_buffer_local( "Kernel : non-blocking, exiting\n"); 606 606 607 607 unlock_all( locks, count ); 608 608 609 LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : accepted %d\n", *mask.accepted);609 __cfaabi_dbg_print_buffer_local( "Kernel : accepted %d\n", *mask.accepted); 610 610 return; 611 611 } … … 614 614 verifyf( duration < 0, "Timeout on waitfor statments not supported yet."); 615 615 616 LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : blocking waitfor\n");616 __cfaabi_dbg_print_buffer_local( "Kernel : blocking waitfor\n"); 617 617 618 618 // Create the node specific to this wait operation … … 636 636 monitor_restore; 637 637 638 LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : exiting\n");639 640 LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : accepted %d\n", *mask.accepted);638 __cfaabi_dbg_print_buffer_local( "Kernel : exiting\n"); 639 640 __cfaabi_dbg_print_buffer_local( "Kernel : accepted %d\n", *mask.accepted); 641 641 } 642 642 … … 645 645 646 646 static 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 );647 // __cfaabi_dbg_print_safe("Kernal : Setting owner of %p to %p ( was %p)\n", this, owner, this->owner ); 648 648 649 649 //Pass the monitor appropriately … … 677 677 static inline thread_desc * next_thread( monitor_desc * this ) { 678 678 //Check the signaller stack 679 LIB_DEBUG_PRINT_SAFE("Kernel : mon %p AS-stack top %p\n", this, this->signal_stack.top);679 __cfaabi_dbg_print_safe("Kernel : mon %p AS-stack top %p\n", this, this->signal_stack.top); 680 680 __condition_criterion_t * urgent = pop( this->signal_stack ); 681 681 if( urgent ) { … … 729 729 for( __lock_size_t i = 0; i < count; i++) { 730 730 (criteria[i]){ monitors[i], waiter }; 731 LIB_DEBUG_PRINT_SAFE( "Kernel : target %p = %p\n", criteria[i].target, &criteria[i] );731 __cfaabi_dbg_print_safe( "Kernel : target %p = %p\n", criteria[i].target, &criteria[i] ); 732 732 push( criteria[i].target->signal_stack, &criteria[i] ); 733 733 } … … 738 738 static inline void lock_all( __spinlock_t * locks [], __lock_size_t count ) { 739 739 for( __lock_size_t i = 0; i < count; i++ ) { 740 DO_LOCK( *locks[i] DEBUG_CTX2 );740 DO_LOCK( *locks[i] __cfaabi_dbg_ctx2 ); 741 741 } 742 742 } … … 745 745 for( __lock_size_t i = 0; i < count; i++ ) { 746 746 __spinlock_t * l = &source[i]->lock; 747 DO_LOCK( *l DEBUG_CTX2 );747 DO_LOCK( *l __cfaabi_dbg_ctx2 ); 748 748 if(locks) locks[i] = l; 749 749 } … … 803 803 for( int i = 0; i < count; i++ ) { 804 804 805 // LIB_DEBUG_PRINT_SAFE( "Checking %p for %p\n", &criteria[i], target );805 // __cfaabi_dbg_print_safe( "Checking %p for %p\n", &criteria[i], target ); 806 806 if( &criteria[i] == target ) { 807 807 criteria[i].ready = true; 808 // LIB_DEBUG_PRINT_SAFE( "True\n" );808 // __cfaabi_dbg_print_safe( "True\n" ); 809 809 } 810 810 … … 812 812 } 813 813 814 LIB_DEBUG_PRINT_SAFE( "Kernel : Runing %i (%p)\n", ready2run, ready2run ? node->waiting_thread : NULL );814 __cfaabi_dbg_print_safe( "Kernel : Runing %i (%p)\n", ready2run, ready2run ? node->waiting_thread : NULL ); 815 815 return ready2run ? node->waiting_thread : NULL; 816 816 } … … 819 819 thread_desc * thrd = this_thread; 820 820 if( !this.monitors ) { 821 // LIB_DEBUG_PRINT_SAFE("Branding\n");821 // __cfaabi_dbg_print_safe("Branding\n"); 822 822 assertf( thrd->monitors.data != NULL, "No current monitor to brand condition %p", thrd->monitors.data ); 823 823 this.monitor_count = thrd->monitors.size; -
src/libcfa/concurrency/preemption.c
r389528b0 r35bae526 148 148 //============================================================================================= 149 149 150 LIB_DEBUG_DO( static thread_local void * last_interrupt = 0; )150 __cfaabi_dbg_debug_do( static thread_local void * last_interrupt = 0; ) 151 151 152 152 extern "C" { … … 159 159 // Enable interrupts by decrementing the counter 160 160 // If counter reaches 0, execute any pending CtxSwitch 161 void enable_interrupts( DEBUG_CTX_PARAM) {161 void enable_interrupts( __cfaabi_dbg_ctx_param ) { 162 162 processor * proc = this_processor; // Cache the processor now since interrupts can start happening after the atomic add 163 163 thread_desc * thrd = this_thread; // Cache the thread now since interrupts can start happening after the atomic add … … 173 173 174 174 // For debugging purposes : keep track of the last person to enable the interrupts 175 LIB_DEBUG_DO( proc->last_enable = caller; )175 __cfaabi_dbg_debug_do( proc->last_enable = caller; ) 176 176 } 177 177 … … 233 233 // Called from kernel_startup 234 234 void kernel_start_preemption() { 235 LIB_DEBUG_PRINT_SAFE("Kernel : Starting preemption\n");235 __cfaabi_dbg_print_safe("Kernel : Starting preemption\n"); 236 236 237 237 // Start with preemption disabled until ready … … 255 255 // Called from kernel_shutdown 256 256 void kernel_stop_preemption() { 257 LIB_DEBUG_PRINT_SAFE("Kernel : Preemption stopping\n");257 __cfaabi_dbg_print_safe("Kernel : Preemption stopping\n"); 258 258 259 259 // Block all signals since we are already shutting down … … 271 271 // Preemption is now fully stopped 272 272 273 LIB_DEBUG_PRINT_SAFE("Kernel : Preemption stopped\n");273 __cfaabi_dbg_print_safe("Kernel : Preemption stopped\n"); 274 274 } 275 275 … … 297 297 // Receives SIGUSR1 signal and causes the current thread to yield 298 298 void sigHandler_ctxSwitch( __CFA_SIGPARMS__ ) { 299 LIB_DEBUG_DO( last_interrupt = (void *)(cxt->uc_mcontext.gregs[CFA_REG_IP]); )299 __cfaabi_dbg_debug_do( last_interrupt = (void *)(cxt->uc_mcontext.gregs[CFA_REG_IP]); ) 300 300 301 301 // Check if it is safe to preempt here … … 346 346 assertf(sig == SIGALRM, "Kernel Internal Error, sigwait: Unexpected signal %d (%d : %d)\n", sig, info.si_code, info.si_value.sival_int); 347 347 348 // LIB_DEBUG_PRINT_SAFE("Kernel : Caught alarm from %d with %d\n", info.si_code, info.si_value.sival_int );348 // __cfaabi_dbg_print_safe("Kernel : Caught alarm from %d with %d\n", info.si_code, info.si_value.sival_int ); 349 349 // Switch on the code (a.k.a. the sender) to 350 350 switch( info.si_code ) … … 354 354 case SI_TIMER: 355 355 case SI_KERNEL: 356 // LIB_DEBUG_PRINT_SAFE("Kernel : Preemption thread tick\n");357 lock( event_kernel->lock DEBUG_CTX2 );356 // __cfaabi_dbg_print_safe("Kernel : Preemption thread tick\n"); 357 lock( event_kernel->lock __cfaabi_dbg_ctx2 ); 358 358 tick_preemption(); 359 359 unlock( event_kernel->lock ); … … 368 368 369 369 EXIT: 370 LIB_DEBUG_PRINT_SAFE("Kernel : Preemption thread stopping\n");370 __cfaabi_dbg_print_safe("Kernel : Preemption thread stopping\n"); 371 371 return NULL; 372 372 } … … 380 380 381 381 if ( sigaction( sig, &act, NULL ) == -1 ) { 382 LIB_DEBUG_PRINT_BUFFER_DECL(382 __cfaabi_dbg_print_buffer_decl( 383 383 " __kernel_sigaction( sig:%d, handler:%p, flags:%d ), problem installing signal handler, error(%d) %s.\n", 384 384 sig, handler, flags, errno, strerror( errno ) … … 397 397 398 398 if ( sigaction( sig, &act, NULL ) == -1 ) { 399 LIB_DEBUG_PRINT_BUFFER_DECL(399 __cfaabi_dbg_print_buffer_decl( 400 400 " __kernel_sigdefault( sig:%d ), problem reseting signal handler, error(%d) %s.\n", 401 401 sig, errno, strerror( errno ) … … 409 409 //============================================================================================= 410 410 411 LIB_DEBUG_DO(411 __cfaabi_dbg_debug_do( 412 412 static void __kernel_backtrace( int start ) { 413 413 // skip first N stack frames … … 476 476 477 477 // void sigHandler_segv( __CFA_SIGPARMS__ ) { 478 // LIB_DEBUG_DO(478 // __cfaabi_dbg_debug_do( 479 479 // #ifdef __USE_STREAM__ 480 480 // serr | "*CFA runtime error* program cfa-cpp terminated with" … … 493 493 // void sigHandler_abort( __CFA_SIGPARMS__ ) { 494 494 // // skip first 6 stack frames 495 // LIB_DEBUG_DO( __kernel_backtrace( 6 ); )495 // __cfaabi_dbg_debug_do( __kernel_backtrace( 6 ); ) 496 496 497 497 // // reset default signal handler -
src/libcfa/concurrency/thread.c
r389528b0 r35bae526 72 72 thrd_c->last = this_coroutine; 73 73 74 // LIB_DEBUG_PRINT_SAFE("Thread start : %p (t %p, c %p)\n", this, thrd_c, thrd_h);74 // __cfaabi_dbg_print_safe("Thread start : %p (t %p, c %p)\n", this, thrd_c, thrd_h); 75 75 76 76 disable_interrupts(); … … 82 82 83 83 ScheduleThread(thrd_h); 84 enable_interrupts( DEBUG_CTX);84 enable_interrupts( __cfaabi_dbg_ctx ); 85 85 } 86 86 -
src/libcfa/exception.c
r389528b0 r35bae526 23 23 #include <stdio.h> 24 24 #include <unwind.h> 25 #include < libhdr/libdebug.h>25 #include <bits/debug.h> 26 26 27 27 // FIX ME: temporary hack to keep ARM build working … … 37 37 38 38 // Base exception vtable is abstract, you should not have base exceptions. 39 struct __cfa ehm__base_exception_t_vtable40 ___cfa ehm__base_exception_t_vtable_instance = {39 struct __cfaabi_ehm__base_exception_t_vtable 40 ___cfaabi_ehm__base_exception_t_vtable_instance = { 41 41 .parent = NULL, 42 42 .size = 0, … … 49 49 // Temperary global exception context. Does not work with concurency. 50 50 struct exception_context_t { 51 struct __cfa ehm__try_resume_node * top_resume;52 struct __cfa ehm__try_resume_node * current_resume;51 struct __cfaabi_ehm__try_resume_node * top_resume; 52 struct __cfaabi_ehm__try_resume_node * current_resume; 53 53 54 54 exception * current_exception; … … 78 78 // RESUMPTION ================================================================ 79 79 80 void __cfa ehm__throw_resume(exception * except) {81 82 LIB_DEBUG_PRINT_SAFE("Throwing resumption exception\n");83 84 struct __cfa ehm__try_resume_node * original_head = shared_stack.current_resume;85 struct __cfa ehm__try_resume_node * current =80 void __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 = 86 86 (original_head) ? original_head->next : shared_stack.top_resume; 87 87 … … 94 94 } 95 95 96 LIB_DEBUG_PRINT_SAFE("Unhandled exception\n");96 __cfaabi_dbg_print_safe("Unhandled exception\n"); 97 97 shared_stack.current_resume = original_head; 98 98 99 99 // Fall back to termination: 100 __cfa ehm__throw_terminate(except);100 __cfaabi_ehm__throw_terminate(except); 101 101 // TODO: Default handler for resumption. 102 102 } … … 105 105 // hook has to be added after the node is built but before it is made the top node. 106 106 107 void __cfa ehm__try_resume_setup(struct __cfaehm__try_resume_node * node,107 void __cfaabi_ehm__try_resume_setup(struct __cfaabi_ehm__try_resume_node * node, 108 108 _Bool (*handler)(exception * except)) { 109 109 node->next = shared_stack.top_resume; … … 112 112 } 113 113 114 void __cfa ehm__try_resume_cleanup(struct __cfaehm__try_resume_node * node) {114 void __cfaabi_ehm__try_resume_cleanup(struct __cfaabi_ehm__try_resume_node * node) { 115 115 shared_stack.top_resume = node->next; 116 116 } … … 122 122 // May have to move to cfa for constructors and destructors (references). 123 123 124 struct __cfa ehm__node {125 struct __cfa ehm__node * next;124 struct __cfaabi_ehm__node { 125 struct __cfaabi_ehm__node * next; 126 126 }; 127 127 128 128 #define NODE_TO_EXCEPT(node) ((exception *)(1 + (node))) 129 #define EXCEPT_TO_NODE(except) ((struct __cfa ehm__node *)(except) - 1)129 #define EXCEPT_TO_NODE(except) ((struct __cfaabi_ehm__node *)(except) - 1) 130 130 131 131 // Creates a copy of the indicated exception and sets current_exception to it. 132 static void __cfa ehm__allocate_exception( exception * except ) {132 static void __cfaabi_ehm__allocate_exception( exception * except ) { 133 133 struct exception_context_t * context = this_exception_context(); 134 134 135 135 // Allocate memory for the exception. 136 struct __cfa ehm__node * store = malloc(137 sizeof( struct __cfa ehm__node ) + except->virtual_table->size );136 struct __cfaabi_ehm__node * store = malloc( 137 sizeof( struct __cfaabi_ehm__node ) + except->virtual_table->size ); 138 138 139 139 if ( ! store ) { … … 151 151 152 152 // Delete the provided exception, unsetting current_exception if relivant. 153 static void __cfa ehm__delete_exception( exception * except ) {153 static void __cfaabi_ehm__delete_exception( exception * except ) { 154 154 struct exception_context_t * context = this_exception_context(); 155 155 156 LIB_DEBUG_PRINT_SAFE("Deleting Exception\n");156 __cfaabi_dbg_print_safe("Deleting Exception\n"); 157 157 158 158 // Remove the exception from the list. 159 struct __cfa ehm__node * to_free = EXCEPT_TO_NODE(except);160 struct __cfa ehm__node * node;159 struct __cfaabi_ehm__node * to_free = EXCEPT_TO_NODE(except); 160 struct __cfaabi_ehm__node * node; 161 161 162 162 if ( context->current_exception == except ) { … … 178 178 179 179 // If this isn't a rethrow (*except==0), delete the provided exception. 180 void __cfa ehm__cleanup_terminate( void * except ) {181 if ( *(void**)except ) __cfa ehm__delete_exception( *(exception**)except );180 void __cfaabi_ehm__cleanup_terminate( void * except ) { 181 if ( *(void**)except ) __cfaabi_ehm__delete_exception( *(exception**)except ); 182 182 } 183 183 … … 202 202 203 203 // The exception that is being thrown must already be stored. 204 __attribute__((noreturn)) void __cfa ehm__begin_unwind(void) {204 __attribute__((noreturn)) void __cfaabi_ehm__begin_unwind(void) { 205 205 if ( ! this_exception_context()->current_exception ) { 206 206 printf("UNWIND ERROR missing exception in begin unwind\n"); … … 233 233 } 234 234 235 void __cfa ehm__throw_terminate( exception * val ) {236 LIB_DEBUG_PRINT_SAFE("Throwing termination exception\n");237 238 __cfa ehm__allocate_exception( val );239 __cfa ehm__begin_unwind();240 } 241 242 void __cfa ehm__rethrow_terminate(void) {243 LIB_DEBUG_PRINT_SAFE("Rethrowing termination exception\n");244 245 __cfa ehm__begin_unwind();235 void __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 242 void __cfaabi_ehm__rethrow_terminate(void) { 243 __cfaabi_dbg_print_safe("Rethrowing termination exception\n"); 244 245 __cfaabi_ehm__begin_unwind(); 246 246 } 247 247 … … 254 254 { 255 255 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); 258 258 259 259 // If we've reached the end of the stack then there is nothing much we can do... … … 261 261 262 262 if (actions & _UA_SEARCH_PHASE) { 263 LIB_DEBUG_PRINT_SAFE(" lookup phase");263 __cfaabi_dbg_print_safe(" lookup phase"); 264 264 } 265 265 else if (actions & _UA_CLEANUP_PHASE) { 266 LIB_DEBUG_PRINT_SAFE(" cleanup phase");266 __cfaabi_dbg_print_safe(" cleanup phase"); 267 267 } 268 268 // Just in case, probably can't actually happen … … 307 307 void * ep = (void*)lsd_info.Start + callsite_start + callsite_len; 308 308 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); 310 310 #endif // __CFA_DEBUG_PRINT__ 311 311 continue; … … 346 346 347 347 // 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; 349 349 350 350 _Unwind_Reason_Code (*matcher)(exception *) = … … 357 357 // Based on the return value, check if we matched the exception 358 358 if( ret == _URC_HANDLER_FOUND) { 359 LIB_DEBUG_PRINT_SAFE(" handler found\n");359 __cfaabi_dbg_print_safe(" handler found\n"); 360 360 } else { 361 LIB_DEBUG_PRINT_SAFE(" no handler\n");361 __cfaabi_dbg_print_safe(" no handler\n"); 362 362 } 363 363 return ret; … … 365 365 366 366 // This is only a cleanup handler, ignore it 367 LIB_DEBUG_PRINT_SAFE(" no action");367 __cfaabi_dbg_print_safe(" no action"); 368 368 } 369 369 else if (actions & _UA_CLEANUP_PHASE) { … … 385 385 _Unwind_SetIP( context, ((lsd_info.LPStart) + (callsite_landing_pad)) ); 386 386 387 LIB_DEBUG_PRINT_SAFE(" action\n");387 __cfaabi_dbg_print_safe(" action\n"); 388 388 389 389 // Return have some action to run … … 393 393 394 394 // Nothing to do, move along 395 LIB_DEBUG_PRINT_SAFE(" no landing pad");395 __cfaabi_dbg_print_safe(" no landing pad"); 396 396 } 397 397 // No handling found 398 LIB_DEBUG_PRINT_SAFE(" table end reached\n");398 __cfaabi_dbg_print_safe(" table end reached\n"); 399 399 400 400 UNWIND: 401 LIB_DEBUG_PRINT_SAFE(" unwind\n");401 __cfaabi_dbg_print_safe(" unwind\n"); 402 402 403 403 // Keep unwinding the stack … … 408 408 // libcfa but there is one problem left, see the exception table for details 409 409 __attribute__((noinline)) 410 void __cfa ehm__try_terminate(void (*try_block)(),410 void __cfaabi_ehm__try_terminate(void (*try_block)(), 411 411 void (*catch_block)(int index, exception * except), 412 412 __attribute__((unused)) int (*match_block)(exception * except)) { … … 466 466 // Body uses language specific data and therefore could be modified arbitrarily 467 467 ".LLSDACSBCFA2:\n" // BODY start 468 " .uleb128 .TRYSTART-__cfa ehm__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) 469 469 " .uleb128 .TRYEND-.TRYSTART\n" // Handled area length 470 " .uleb128 .CATCH-__cfa ehm__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) 471 471 " .uleb128 1\n" // Action code, gcc seems to use always 0 472 472 ".LLSDACSECFA2:\n" // BODY end 473 473 " .text\n" // TABLE footer 474 " .size __cfa ehm__try_terminate, .-__cfaehm__try_terminate\n"474 " .size __cfaabi_ehm__try_terminate, .-__cfaabi_ehm__try_terminate\n" 475 475 " .ident \"GCC: (Ubuntu 6.2.0-3ubuntu11~16.04) 6.2.0 20160901\"\n" 476 476 // " .section .note.GNU-stack,\"x\",@progbits\n" -
src/libcfa/exception.h
r389528b0 r35bae526 21 21 #endif 22 22 23 struct __cfa ehm__base_exception_t;24 typedef struct __cfa ehm__base_exception_t exception;25 struct __cfa ehm__base_exception_t_vtable {26 const struct __cfa ehm__base_exception_t_vtable * parent;23 struct __cfaabi_ehm__base_exception_t; 24 typedef struct __cfaabi_ehm__base_exception_t exception; 25 struct __cfaabi_ehm__base_exception_t_vtable { 26 const struct __cfaabi_ehm__base_exception_t_vtable * parent; 27 27 size_t size; 28 void (*copy)(struct __cfa ehm__base_exception_t *this,29 struct __cfa ehm__base_exception_t * other);30 void (*free)(struct __cfa ehm__base_exception_t *this);31 const char * (*msg)(struct __cfa ehm__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); 32 32 }; 33 struct __cfa ehm__base_exception_t {34 struct __cfa ehm__base_exception_t_vtable const * virtual_table;33 struct __cfaabi_ehm__base_exception_t { 34 struct __cfaabi_ehm__base_exception_t_vtable const * virtual_table; 35 35 }; 36 extern struct __cfa ehm__base_exception_t_vtable37 ___cfa ehm__base_exception_t_vtable_instance;36 extern struct __cfaabi_ehm__base_exception_t_vtable 37 ___cfaabi_ehm__base_exception_t_vtable_instance; 38 38 39 39 40 40 // Used in throw statement translation. 41 void __cfa ehm__throw_terminate(exception * except) __attribute__((noreturn));42 void __cfa ehm__rethrow_terminate() __attribute__((noreturn));43 void __cfa ehm__throw_resume(exception * except);41 void __cfaabi_ehm__throw_terminate(exception * except) __attribute__((noreturn)); 42 void __cfaabi_ehm__rethrow_terminate() __attribute__((noreturn)); 43 void __cfaabi_ehm__throw_resume(exception * except); 44 44 45 45 // Function catches termination exceptions. 46 void __cfa ehm__try_terminate(46 void __cfaabi_ehm__try_terminate( 47 47 void (*try_block)(), 48 48 void (*catch_block)(int index, exception * except), … … 50 50 51 51 // Clean-up the exception in catch blocks. 52 void __cfa ehm__cleanup_terminate(void * except);52 void __cfaabi_ehm__cleanup_terminate(void * except); 53 53 54 54 // Data structure creates a list of resume handlers. 55 struct __cfa ehm__try_resume_node {56 struct __cfa ehm__try_resume_node * next;55 struct __cfaabi_ehm__try_resume_node { 56 struct __cfaabi_ehm__try_resume_node * next; 57 57 _Bool (*handler)(exception * except); 58 58 }; 59 59 60 60 // These act as constructor and destructor for the resume node. 61 void __cfa ehm__try_resume_setup(62 struct __cfa ehm__try_resume_node * node,61 void __cfaabi_ehm__try_resume_setup( 62 struct __cfaabi_ehm__try_resume_node * node, 63 63 _Bool (*handler)(exception * except)); 64 void __cfa ehm__try_resume_cleanup(65 struct __cfa ehm__try_resume_node * node);64 void __cfaabi_ehm__try_resume_cleanup( 65 struct __cfaabi_ehm__try_resume_node * node); 66 66 67 67 // Check for a standard way to call fake deconstructors. 68 struct __cfa ehm__cleanup_hook {};68 struct __cfaabi_ehm__cleanup_hook {}; 69 69 70 70 #ifdef __cforall -
src/libcfa/interpose.c
r389528b0 r35bae526 24 24 } 25 25 26 #include " libhdr/libdebug.h"26 #include "bits/debug.h" 27 27 #include "libhdr/libtools.h" 28 28 #include "startup.h" … … 69 69 __typeof__( exit ) libc_exit __attribute__(( noreturn )); 70 70 __typeof__( abort ) libc_abort __attribute__(( noreturn )); 71 72 // #define INIT_REALRTN( x, ver ) libc_##x = (__typeof__(libc_##x))interpose_symbol( #x, ver )73 71 74 72 forall(dtype T) … … 127 125 va_end( args ); 128 126 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 ); 131 129 } 132 130 133 131 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 ); 135 133 136 134 -
src/libcfa/libhdr.h
r389528b0 r35bae526 17 17 18 18 #include "libhdr/libalign.h" 19 #include "libhdr/libdebug.h"20 19 #include "libhdr/libtools.h" 21 20 -
src/libcfa/stdhdr/assert.h
r389528b0 r35bae526 30 30 #endif 31 31 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 32 40 #ifdef __cforall 33 41 } // extern "C" -
src/prelude/builtins.c
r389528b0 r35bae526 16 16 // exception implementation 17 17 18 typedef unsigned long long __cfaabi_ exception_type_t;18 typedef unsigned long long __cfaabi_abi_exception_type_t; 19 19 20 20 #include "../libcfa/virtual.h" … … 80 80 } // ?\? 81 81 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 85 85 // signature where X is double. 86 86 -
src/tests/except-mac.h
r389528b0 r35bae526 7 7 8 8 // The fully (perhaps overly) qualified name of the base exception type: 9 #define BASE_EXCEPT __cfa ehm__base_exception_t9 #define BASE_EXCEPT __cfaabi_ehm__base_exception_t 10 10 11 11 // Get the name of the vtable type and vtable instance for an exception type:
Note: See TracChangeset
for help on using the changeset viewer.