Index: src/libcfa/assert.c =================================================================== --- src/libcfa/assert.c (revision f5478c89f22dfaa80c81adb28a7eba9eb97eb1a7) +++ src/libcfa/assert.c (revision 36982fc1f527597d650797d8db4fa9d288e819d9) @@ -26,5 +26,5 @@ // called by macro assert in assert.h void __assert_fail( const char *assertion, const char *file, unsigned int line, const char *function ) { - __lib_debug_print_safe( CFA_ASSERT_FMT ".\n", __progname, function, line, file ); + __cfaabi_dbg_bits_print_safe( CFA_ASSERT_FMT ".\n", __progname, function, line, file ); abort(); } @@ -32,14 +32,14 @@ // called by macro assertf void __assert_fail_f( const char *assertion, const char *file, unsigned int line, const char *function, const char *fmt, ... ) { - __lib_debug_acquire(); - __lib_debug_print_nolock( CFA_ASSERT_FMT ": ", __progname, function, line, file ); + __cfaabi_dbg_bits_acquire(); + __cfaabi_dbg_bits_print_nolock( CFA_ASSERT_FMT ": ", __progname, function, line, file ); va_list args; va_start( args, fmt ); - __lib_debug_print_vararg( fmt, args ); + __cfaabi_dbg_bits_print_vararg( fmt, args ); va_end( args ); - __lib_debug_print_nolock( "\n" ); - __lib_debug_release(); + __cfaabi_dbg_bits_print_nolock( "\n" ); + __cfaabi_dbg_bits_release(); abort(); } Index: src/libcfa/bits/locks.h =================================================================== --- src/libcfa/bits/locks.h (revision f5478c89f22dfaa80c81adb28a7eba9eb97eb1a7) +++ src/libcfa/bits/locks.h (revision 36982fc1f527597d650797d8db4fa9d288e819d9) @@ -65,7 +65,7 @@ // Lock the spinlock, return false if already acquired - static inline _Bool try_lock ( __spinlock_t & this DEBUG_CTX_PARAM2 ) { + static inline _Bool try_lock ( __spinlock_t & this __cfaabi_dbg_ctx_param2 ) { _Bool result = __lock_test_and_test_and_set( this.lock ); - LIB_DEBUG_DO( + __cfaabi_dbg_debug_do( if( result ) { this.prev_name = caller; @@ -77,5 +77,5 @@ // Lock the spinlock, spin if already acquired - static inline void lock( __spinlock_t & this DEBUG_CTX_PARAM2 ) { + static inline void lock( __spinlock_t & this __cfaabi_dbg_ctx_param2 ) { #ifndef NOEXPBACK enum { SPIN_START = 4, SPIN_END = 64 * 1024, }; @@ -98,5 +98,5 @@ #endif } - LIB_DEBUG_DO( + __cfaabi_dbg_debug_do( this.prev_name = caller; this.prev_thrd = this_thread; @@ -105,10 +105,10 @@ // Lock the spinlock, spin if already acquired - static inline void lock_yield( __spinlock_t & this DEBUG_CTX_PARAM2 ) { + static inline void lock_yield( __spinlock_t & this __cfaabi_dbg_ctx_param2 ) { for ( unsigned int i = 1;; i += 1 ) { if ( __lock_test_and_test_and_set( this.lock ) ) break; yield( i ); } - LIB_DEBUG_DO( + __cfaabi_dbg_debug_do( this.prev_name = caller; this.prev_thrd = this_thread; Index: src/libcfa/concurrency/alarm.c =================================================================== --- src/libcfa/concurrency/alarm.c (revision f5478c89f22dfaa80c81adb28a7eba9eb97eb1a7) +++ src/libcfa/concurrency/alarm.c (revision 36982fc1f527597d650797d8db4fa9d288e819d9) @@ -110,5 +110,5 @@ } -LIB_DEBUG_DO( bool validate( alarm_list_t * this ) { +__cfaabi_dbg_debug_do( bool validate( alarm_list_t * this ) { alarm_node_t ** it = &this->head; while( (*it) ) { @@ -186,5 +186,5 @@ disable_interrupts(); - lock( event_kernel->lock DEBUG_CTX2 ); + lock( event_kernel->lock __cfaabi_dbg_ctx2 ); { verify( validate( alarms ) ); @@ -198,10 +198,10 @@ unlock( event_kernel->lock ); this->set = true; - enable_interrupts( DEBUG_CTX ); + enable_interrupts( __cfaabi_dbg_ctx ); } void unregister_self( alarm_node_t * this ) { disable_interrupts(); - lock( event_kernel->lock DEBUG_CTX2 ); + lock( event_kernel->lock __cfaabi_dbg_ctx2 ); { verify( validate( &event_kernel->alarms ) ); @@ -209,5 +209,5 @@ } unlock( event_kernel->lock ); - enable_interrupts( DEBUG_CTX ); + enable_interrupts( __cfaabi_dbg_ctx ); this->set = false; } Index: src/libcfa/concurrency/coroutine.c =================================================================== --- src/libcfa/concurrency/coroutine.c (revision f5478c89f22dfaa80c81adb28a7eba9eb97eb1a7) +++ src/libcfa/concurrency/coroutine.c (revision 36982fc1f527597d650797d8db4fa9d288e819d9) @@ -76,5 +76,5 @@ void ^?{}(coStack_t & this) { if ( ! this.userStack && this.storage ) { - LIB_DEBUG_DO( + __cfaabi_dbg_debug_do( if ( mprotect( this.storage, pageSize, PROT_READ | PROT_WRITE ) == -1 ) { abortf( "(coStack_t *)%p.^?{}() : internal error, mprotect failure, error(%d) %s.", &this, errno, strerror( errno ) ); @@ -131,8 +131,8 @@ // assume malloc has 8 byte alignment so add 8 to allow rounding up to 16 byte alignment - LIB_DEBUG_DO( this->storage = memalign( pageSize, cxtSize + this->size + pageSize ) ); - LIB_NO_DEBUG_DO( this->storage = malloc( cxtSize + this->size + 8 ) ); + __cfaabi_dbg_debug_do( this->storage = memalign( pageSize, cxtSize + this->size + pageSize ) ); + __cfaabi_dbg_no_debug_do( this->storage = malloc( cxtSize + this->size + 8 ) ); - LIB_DEBUG_DO( + __cfaabi_dbg_debug_do( if ( mprotect( this->storage, pageSize, PROT_NONE ) == -1 ) { abortf( "(uMachContext &)%p.createContext() : internal error, mprotect failure, error(%d) %s.", this, (int)errno, strerror( (int)errno ) ); @@ -144,6 +144,6 @@ } // if - LIB_DEBUG_DO( this->limit = (char *)this->storage + pageSize ); - LIB_NO_DEBUG_DO( this->limit = (char *)libCeiling( (unsigned long)this->storage, 16 ) ); // minimum alignment + __cfaabi_dbg_debug_do( this->limit = (char *)this->storage + pageSize ); + __cfaabi_dbg_no_debug_do( this->limit = (char *)libCeiling( (unsigned long)this->storage, 16 ) ); // minimum alignment } else { Index: src/libcfa/concurrency/invoke.c =================================================================== --- src/libcfa/concurrency/invoke.c (revision f5478c89f22dfaa80c81adb28a7eba9eb97eb1a7) +++ src/libcfa/concurrency/invoke.c (revision 36982fc1f527597d650797d8db4fa9d288e819d9) @@ -31,70 +31,66 @@ extern void __leave_thread_monitor( struct thread_desc * this ); extern void disable_interrupts(); -extern void enable_interrupts( DEBUG_CTX_PARAM ); +extern void enable_interrupts( __cfaabi_dbg_ctx_param ); void CtxInvokeCoroutine( - void (*main)(void *), - struct coroutine_desc *(*get_coroutine)(void *), - void *this + void (*main)(void *), + struct coroutine_desc *(*get_coroutine)(void *), + void *this ) { - // LIB_DEBUG_PRINTF("Invoke Coroutine : Received %p (main %p, get_c %p)\n", this, main, get_coroutine); + struct coroutine_desc* cor = get_coroutine( this ); - struct coroutine_desc* cor = get_coroutine( this ); + if(cor->state == Primed) { + __suspend_internal(); + } - if(cor->state == Primed) { - __suspend_internal(); - } + cor->state = Active; - cor->state = Active; + main( this ); - main( this ); + cor->state = Halted; - cor->state = Halted; - - //Final suspend, should never return - __leave_coroutine(); - abortf("Resumed dead coroutine"); + //Final suspend, should never return + __leave_coroutine(); + abortf("Resumed dead coroutine"); } void CtxInvokeThread( - void (*dtor)(void *), - void (*main)(void *), - struct thread_desc *(*get_thread)(void *), - void *this + void (*dtor)(void *), + void (*main)(void *), + struct thread_desc *(*get_thread)(void *), + void *this ) { - // First suspend, once the thread arrives here, - // the function pointer to main can be invalidated without risk - __suspend_internal(); + // First suspend, once the thread arrives here, + // the function pointer to main can be invalidated without risk + __suspend_internal(); - // Fetch the thread handle from the user defined thread structure - struct thread_desc* thrd = get_thread( this ); + // Fetch the thread handle from the user defined thread structure + struct thread_desc* thrd = get_thread( this ); - // Officially start the thread by enabling preemption - enable_interrupts( DEBUG_CTX ); + // Officially start the thread by enabling preemption + enable_interrupts( __cfaabi_dbg_ctx ); - // Call the main of the thread - main( this ); + // Call the main of the thread + main( this ); - // To exit a thread we must : - // 1 - Mark it as halted - // 2 - Leave its monitor - // 3 - Disable the interupts - // 4 - Final suspend - // The order of these 4 operations is very important - //Final suspend, should never return - __leave_thread_monitor( thrd ); - abortf("Resumed dead thread"); + // To exit a thread we must : + // 1 - Mark it as halted + // 2 - Leave its monitor + // 3 - Disable the interupts + // 4 - Final suspend + // The order of these 4 operations is very important + //Final suspend, should never return + __leave_thread_monitor( thrd ); + abortf("Resumed dead thread"); } void CtxStart( - void (*main)(void *), - struct coroutine_desc *(*get_coroutine)(void *), - void *this, - void (*invoke)(void *) + void (*main)(void *), + struct coroutine_desc *(*get_coroutine)(void *), + void *this, + void (*invoke)(void *) ) { - // LIB_DEBUG_PRINTF("StartCoroutine : Passing in %p (main %p) to invoke (%p) from start (%p)\n", this, main, invoke, CtxStart); - - struct coStack_t* stack = &get_coroutine( this )->stack; + struct coStack_t* stack = &get_coroutine( this )->stack; #if defined( __i386__ ) @@ -103,5 +99,5 @@ void *fixedRegisters[3]; // fixed registers ebx, edi, esi (popped on 1st uSwitch, values unimportant) uint32_t mxcr; // SSE Status and Control bits (control bits are preserved across function calls) - uint16_t fcw; // X97 FPU control word (preserved across function calls) + uint16_t fcw; // X97 FPU control word (preserved across function calls) void *rturn; // where to go on return from uSwitch void *dummyReturn; // fake return compiler would have pushed on call to uInvoke @@ -116,28 +112,28 @@ ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->argument[0] = this; // argument to invoke ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->rturn = invoke; - ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->mxcr = 0x1F80; //Vol. 2A 3-520 - ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->fcw = 0x037F; //Vol. 1 8-7 + ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->mxcr = 0x1F80; //Vol. 2A 3-520 + ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->fcw = 0x037F; //Vol. 1 8-7 #elif defined( __x86_64__ ) - struct FakeStack { - void *fixedRegisters[5]; // fixed registers rbx, r12, r13, r14, r15 - uint32_t mxcr; // SSE Status and Control bits (control bits are preserved across function calls) - uint16_t fcw; // X97 FPU control word (preserved across function calls) - void *rturn; // where to go on return from uSwitch - void *dummyReturn; // NULL return address to provide proper alignment - }; + struct FakeStack { + void *fixedRegisters[5]; // fixed registers rbx, r12, r13, r14, r15 + uint32_t mxcr; // SSE Status and Control bits (control bits are preserved across function calls) + uint16_t fcw; // X97 FPU control word (preserved across function calls) + void *rturn; // where to go on return from uSwitch + void *dummyReturn; // NULL return address to provide proper alignment + }; - ((struct machine_context_t *)stack->context)->SP = (char *)stack->base - sizeof( struct FakeStack ); - ((struct machine_context_t *)stack->context)->FP = NULL; // terminate stack with NULL fp + ((struct machine_context_t *)stack->context)->SP = (char *)stack->base - sizeof( struct FakeStack ); + ((struct machine_context_t *)stack->context)->FP = NULL; // terminate stack with NULL fp - ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->dummyReturn = NULL; - ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->rturn = CtxInvokeStub; - ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->fixedRegisters[0] = this; - ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->fixedRegisters[1] = invoke; - ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->mxcr = 0x1F80; //Vol. 2A 3-520 - ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->fcw = 0x037F; //Vol. 1 8-7 + ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->dummyReturn = NULL; + ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->rturn = CtxInvokeStub; + ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->fixedRegisters[0] = this; + ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->fixedRegisters[1] = invoke; + ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->mxcr = 0x1F80; //Vol. 2A 3-520 + ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->fcw = 0x037F; //Vol. 1 8-7 #else - #error Only __i386__ and __x86_64__ is supported for threads in cfa + #error Only __i386__ and __x86_64__ is supported for threads in cfa #endif } Index: src/libcfa/concurrency/kernel.c =================================================================== --- src/libcfa/concurrency/kernel.c (revision f5478c89f22dfaa80c81adb28a7eba9eb97eb1a7) +++ src/libcfa/concurrency/kernel.c (revision 36982fc1f527597d650797d8db4fa9d288e819d9) @@ -150,5 +150,5 @@ this.runner = &runner; - LIB_DEBUG_PRINT_SAFE("Kernel : constructing main processor context %p\n", &runner); + __cfaabi_dbg_print_safe("Kernel : constructing main processor context %p\n", &runner); runner{ &this }; } @@ -156,5 +156,5 @@ void ^?{}(processor & this) { if( ! this.do_terminate ) { - LIB_DEBUG_PRINT_SAFE("Kernel : core %p signaling termination\n", &this); + __cfaabi_dbg_print_safe("Kernel : core %p signaling termination\n", &this); this.do_terminate = true; P( this.terminated ); @@ -181,5 +181,5 @@ processor * this = runner.proc; - LIB_DEBUG_PRINT_SAFE("Kernel : core %p starting\n", this); + __cfaabi_dbg_print_safe("Kernel : core %p starting\n", this); { @@ -187,5 +187,5 @@ preemption_scope scope = { this }; - LIB_DEBUG_PRINT_SAFE("Kernel : core %p started\n", this); + __cfaabi_dbg_print_safe("Kernel : core %p started\n", this); thread_desc * readyThread = NULL; @@ -213,10 +213,10 @@ } - LIB_DEBUG_PRINT_SAFE("Kernel : core %p stopping\n", this); + __cfaabi_dbg_print_safe("Kernel : core %p stopping\n", this); } V( this->terminated ); - LIB_DEBUG_PRINT_SAFE("Kernel : core %p terminated\n", this); + __cfaabi_dbg_print_safe("Kernel : core %p terminated\n", this); } @@ -292,5 +292,5 @@ processorCtx_t proc_cor_storage = { proc, &info }; - LIB_DEBUG_PRINT_SAFE("Coroutine : created stack %p\n", proc_cor_storage.__cor.stack.base); + __cfaabi_dbg_print_safe("Coroutine : created stack %p\n", proc_cor_storage.__cor.stack.base); //Set global state @@ -299,5 +299,5 @@ //We now have a proper context from which to schedule threads - LIB_DEBUG_PRINT_SAFE("Kernel : core %p created (%p, %p)\n", proc, proc->runner, &ctx); + __cfaabi_dbg_print_safe("Kernel : core %p created (%p, %p)\n", proc, proc->runner, &ctx); // SKULLDUGGERY: Since the coroutine doesn't have its own stack, we can't @@ -310,5 +310,5 @@ // Main routine of the core returned, the core is now fully terminated - LIB_DEBUG_PRINT_SAFE("Kernel : core %p main ended (%p)\n", proc, proc->runner); + __cfaabi_dbg_print_safe("Kernel : core %p main ended (%p)\n", proc, proc->runner); return NULL; @@ -316,9 +316,9 @@ void start(processor * this) { - LIB_DEBUG_PRINT_SAFE("Kernel : Starting core %p\n", this); + __cfaabi_dbg_print_safe("Kernel : Starting core %p\n", this); pthread_create( &this->kernel_thread, NULL, CtxInvokeProcessor, (void*)this ); - LIB_DEBUG_PRINT_SAFE("Kernel : core %p started\n", this); + __cfaabi_dbg_print_safe("Kernel : core %p started\n", this); } @@ -334,5 +334,5 @@ verifyf( thrd->next == NULL, "Expected null got %p", thrd->next ); - lock( this_processor->cltr->ready_queue_lock DEBUG_CTX2 ); + lock( this_processor->cltr->ready_queue_lock __cfaabi_dbg_ctx2 ); append( this_processor->cltr->ready_queue, thrd ); unlock( this_processor->cltr->ready_queue_lock ); @@ -343,5 +343,5 @@ thread_desc * nextThread(cluster * this) { verify( disable_preempt_count > 0 ); - lock( this->ready_queue_lock DEBUG_CTX2 ); + lock( this->ready_queue_lock __cfaabi_dbg_ctx2 ); thread_desc * head = pop_head( this->ready_queue ); unlock( this->ready_queue_lock ); @@ -355,5 +355,5 @@ suspend(); verify( disable_preempt_count > 0 ); - enable_interrupts( DEBUG_CTX ); + enable_interrupts( __cfaabi_dbg_ctx ); } @@ -367,5 +367,5 @@ verify( disable_preempt_count > 0 ); - enable_interrupts( DEBUG_CTX ); + enable_interrupts( __cfaabi_dbg_ctx ); } @@ -381,5 +381,5 @@ verify( disable_preempt_count > 0 ); - enable_interrupts( DEBUG_CTX ); + enable_interrupts( __cfaabi_dbg_ctx ); } @@ -395,5 +395,5 @@ verify( disable_preempt_count > 0 ); - enable_interrupts( DEBUG_CTX ); + enable_interrupts( __cfaabi_dbg_ctx ); } @@ -408,5 +408,5 @@ verify( disable_preempt_count > 0 ); - enable_interrupts( DEBUG_CTX ); + enable_interrupts( __cfaabi_dbg_ctx ); } @@ -423,5 +423,5 @@ verify( disable_preempt_count > 0 ); - enable_interrupts( DEBUG_CTX ); + enable_interrupts( __cfaabi_dbg_ctx ); } @@ -441,5 +441,5 @@ // Kernel boot procedures void kernel_startup(void) { - LIB_DEBUG_PRINT_SAFE("Kernel : Starting\n"); + __cfaabi_dbg_print_safe("Kernel : Starting\n"); // Start by initializing the main thread @@ -450,5 +450,5 @@ (*mainThread){ &info }; - LIB_DEBUG_PRINT_SAFE("Kernel : Main thread ready\n"); + __cfaabi_dbg_print_safe("Kernel : Main thread ready\n"); // Initialize the main cluster @@ -456,5 +456,5 @@ (*mainCluster){}; - LIB_DEBUG_PRINT_SAFE("Kernel : main cluster ready\n"); + __cfaabi_dbg_print_safe("Kernel : main cluster ready\n"); // Initialize the main processor and the main processor ctx @@ -483,11 +483,11 @@ // THE SYSTEM IS NOW COMPLETELY RUNNING - LIB_DEBUG_PRINT_SAFE("Kernel : Started\n--------------------------------------------------\n\n"); - - enable_interrupts( DEBUG_CTX ); + __cfaabi_dbg_print_safe("Kernel : Started\n--------------------------------------------------\n\n"); + + enable_interrupts( __cfaabi_dbg_ctx ); } void kernel_shutdown(void) { - LIB_DEBUG_PRINT_SAFE("\n--------------------------------------------------\nKernel : Shutting down\n"); + __cfaabi_dbg_print_safe("\n--------------------------------------------------\nKernel : Shutting down\n"); disable_interrupts(); @@ -513,5 +513,5 @@ ^(mainThread){}; - LIB_DEBUG_PRINT_SAFE("Kernel : Shutdown complete\n"); + __cfaabi_dbg_print_safe("Kernel : Shutdown complete\n"); } @@ -523,5 +523,5 @@ // abort cannot be recursively entered by the same or different processors because all signal handlers return when // the globalAbort flag is true. - lock( kernel_abort_lock DEBUG_CTX2 ); + lock( kernel_abort_lock __cfaabi_dbg_ctx2 ); // first task to abort ? @@ -548,21 +548,21 @@ int len = snprintf( abort_text, abort_text_size, "Error occurred while executing task %.256s (%p)", thrd->self_cor.name, thrd ); - __lib_debug_write( abort_text, len ); + __cfaabi_dbg_bits_write( abort_text, len ); if ( thrd != this_coroutine ) { len = snprintf( abort_text, abort_text_size, " in coroutine %.256s (%p).\n", this_coroutine->name, this_coroutine ); - __lib_debug_write( abort_text, len ); + __cfaabi_dbg_bits_write( abort_text, len ); } else { - __lib_debug_write( ".\n", 2 ); + __cfaabi_dbg_bits_write( ".\n", 2 ); } } extern "C" { - void __lib_debug_acquire() { - lock( kernel_debug_lock DEBUG_CTX2 ); - } - - void __lib_debug_release() { + void __cfaabi_dbg_bits_acquire() { + lock( kernel_debug_lock __cfaabi_dbg_ctx2 ); + } + + void __cfaabi_dbg_bits_release() { unlock( kernel_debug_lock ); } @@ -582,5 +582,5 @@ void P(semaphore & this) { - lock( this.lock DEBUG_CTX2 ); + lock( this.lock __cfaabi_dbg_ctx2 ); this.count -= 1; if ( this.count < 0 ) { @@ -598,5 +598,5 @@ void V(semaphore & this) { thread_desc * thrd = NULL; - lock( this.lock DEBUG_CTX2 ); + lock( this.lock __cfaabi_dbg_ctx2 ); this.count += 1; if ( this.count <= 0 ) { Index: src/libcfa/concurrency/kernel_private.h =================================================================== --- src/libcfa/concurrency/kernel_private.h (revision f5478c89f22dfaa80c81adb28a7eba9eb97eb1a7) +++ src/libcfa/concurrency/kernel_private.h (revision 36982fc1f527597d650797d8db4fa9d288e819d9) @@ -30,5 +30,5 @@ void disable_interrupts(); void enable_interrupts_noPoll(); - void enable_interrupts( DEBUG_CTX_PARAM ); + void enable_interrupts( __cfaabi_dbg_ctx_param ); } @@ -39,5 +39,5 @@ disable_interrupts(); ScheduleThread( thrd ); - enable_interrupts( DEBUG_CTX ); + enable_interrupts( __cfaabi_dbg_ctx ); } thread_desc * nextThread(cluster * this); Index: src/libcfa/concurrency/monitor.c =================================================================== --- src/libcfa/concurrency/monitor.c (revision f5478c89f22dfaa80c81adb28a7eba9eb97eb1a7) +++ src/libcfa/concurrency/monitor.c (revision 36982fc1f527597d650797d8db4fa9d288e819d9) @@ -91,8 +91,8 @@ static void __enter_monitor_desc( monitor_desc * this, const __monitor_group_t & group ) { // Lock the monitor spinlock - DO_LOCK( this->lock DEBUG_CTX2 ); + DO_LOCK( this->lock __cfaabi_dbg_ctx2 ); thread_desc * thrd = this_thread; - LIB_DEBUG_PRINT_SAFE("Kernel : %10p Entering mon %p (%p)\n", thrd, this, this->owner); + __cfaabi_dbg_print_safe("Kernel : %10p Entering mon %p (%p)\n", thrd, this, this->owner); if( !this->owner ) { @@ -100,5 +100,5 @@ set_owner( this, thrd ); - LIB_DEBUG_PRINT_SAFE("Kernel : mon is free \n"); + __cfaabi_dbg_print_safe("Kernel : mon is free \n"); } else if( this->owner == thrd) { @@ -106,5 +106,5 @@ this->recursion += 1; - LIB_DEBUG_PRINT_SAFE("Kernel : mon already owned \n"); + __cfaabi_dbg_print_safe("Kernel : mon already owned \n"); } else if( is_accepted( this, group) ) { @@ -115,8 +115,8 @@ reset_mask( this ); - LIB_DEBUG_PRINT_SAFE("Kernel : mon accepts \n"); + __cfaabi_dbg_print_safe("Kernel : mon accepts \n"); } else { - LIB_DEBUG_PRINT_SAFE("Kernel : blocking \n"); + __cfaabi_dbg_print_safe("Kernel : blocking \n"); // Some one else has the monitor, wait in line for it @@ -124,5 +124,5 @@ BlockInternal( &this->lock ); - LIB_DEBUG_PRINT_SAFE("Kernel : %10p Entered mon %p\n", thrd, this); + __cfaabi_dbg_print_safe("Kernel : %10p Entered mon %p\n", thrd, this); // BlockInternal will unlock spinlock, no need to unlock ourselves @@ -130,5 +130,5 @@ } - LIB_DEBUG_PRINT_SAFE("Kernel : %10p Entered mon %p\n", thrd, this); + __cfaabi_dbg_print_safe("Kernel : %10p Entered mon %p\n", thrd, this); // Release the lock and leave @@ -139,12 +139,12 @@ static void __enter_monitor_dtor( monitor_desc * this, fptr_t func ) { // Lock the monitor spinlock - DO_LOCK( this->lock DEBUG_CTX2 ); + DO_LOCK( this->lock __cfaabi_dbg_ctx2 ); thread_desc * thrd = this_thread; - LIB_DEBUG_PRINT_SAFE("Kernel : %10p Entering dtor for mon %p (%p)\n", thrd, this, this->owner); + __cfaabi_dbg_print_safe("Kernel : %10p Entering dtor for mon %p (%p)\n", thrd, this, this->owner); if( !this->owner ) { - LIB_DEBUG_PRINT_SAFE("Kernel : Destroying free mon %p\n", this); + __cfaabi_dbg_print_safe("Kernel : Destroying free mon %p\n", this); // No one has the monitor, just take it @@ -164,5 +164,5 @@ __monitor_group_t group = { &this, 1, func }; if( is_accepted( this, group) ) { - LIB_DEBUG_PRINT_SAFE("Kernel : mon accepts dtor, block and signal it \n"); + __cfaabi_dbg_print_safe("Kernel : mon accepts dtor, block and signal it \n"); // Wake the thread that is waiting for this @@ -183,5 +183,5 @@ } else { - LIB_DEBUG_PRINT_SAFE("Kernel : blocking \n"); + __cfaabi_dbg_print_safe("Kernel : blocking \n"); wait_ctx( this_thread, 0 ) @@ -196,5 +196,5 @@ } - LIB_DEBUG_PRINT_SAFE("Kernel : Destroying %p\n", this); + __cfaabi_dbg_print_safe("Kernel : Destroying %p\n", this); } @@ -203,7 +203,7 @@ void __leave_monitor_desc( monitor_desc * this ) { // Lock the monitor spinlock, DO_LOCK to reduce contention - DO_LOCK( this->lock DEBUG_CTX2 ); - - LIB_DEBUG_PRINT_SAFE("Kernel : %10p Leaving mon %p (%p)\n", this_thread, this, this->owner); + DO_LOCK( this->lock __cfaabi_dbg_ctx2 ); + + __cfaabi_dbg_print_safe("Kernel : %10p Leaving mon %p (%p)\n", this_thread, this, this->owner); verifyf( this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", this_thread, this->owner, this->recursion, this ); @@ -215,5 +215,5 @@ // it means we don't need to do anything if( this->recursion != 0) { - LIB_DEBUG_PRINT_SAFE("Kernel : recursion still %d\n", this->recursion); + __cfaabi_dbg_print_safe("Kernel : recursion still %d\n", this->recursion); unlock( this->lock ); return; @@ -232,5 +232,5 @@ // Leave single monitor for the last time void __leave_dtor_monitor_desc( monitor_desc * this ) { - LIB_DEBUG_DO( + __cfaabi_dbg_debug_do( if( this_thread != this->owner ) { abortf("Destroyed monitor %p has inconsistent owner, expected %p got %p.\n", this, this_thread, this->owner); @@ -249,5 +249,5 @@ // Lock the monitor now - DO_LOCK( this->lock DEBUG_CTX2 ); + DO_LOCK( this->lock __cfaabi_dbg_ctx2 ); disable_interrupts(); @@ -308,5 +308,5 @@ (this_thread->monitors){m, count, func}; - // LIB_DEBUG_PRINT_SAFE("MGUARD : enter %d\n", count); + // __cfaabi_dbg_print_safe("MGUARD : enter %d\n", count); // Enter the monitors in order @@ -314,5 +314,5 @@ enter( group ); - // LIB_DEBUG_PRINT_SAFE("MGUARD : entered\n"); + // __cfaabi_dbg_print_safe("MGUARD : entered\n"); } @@ -320,10 +320,10 @@ // Dtor for monitor guard void ^?{}( monitor_guard_t & this ) { - // LIB_DEBUG_PRINT_SAFE("MGUARD : leaving %d\n", this.count); + // __cfaabi_dbg_print_safe("MGUARD : leaving %d\n", this.count); // Leave the monitors in order leave( this.m, this.count ); - // LIB_DEBUG_PRINT_SAFE("MGUARD : left\n"); + // __cfaabi_dbg_print_safe("MGUARD : left\n"); // Restore thread context @@ -430,5 +430,5 @@ //Some more checking in debug - LIB_DEBUG_DO( + __cfaabi_dbg_debug_do( thread_desc * this_thrd = this_thread; if ( this.monitor_count != this_thrd->monitors.size ) { @@ -487,5 +487,5 @@ set_owner( monitors, count, signallee ); - LIB_DEBUG_PRINT_BUFFER_DECL( "Kernel : signal_block condition %p (s: %p)\n", &this, signallee ); + __cfaabi_dbg_print_buffer_decl( "Kernel : signal_block condition %p (s: %p)\n", &this, signallee ); //Everything is ready to go to sleep @@ -496,5 +496,5 @@ - LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : signal_block returned\n" ); + __cfaabi_dbg_print_buffer_local( "Kernel : signal_block returned\n" ); //We are back, restore the masks and recursions @@ -535,9 +535,9 @@ __lock_size_t actual_count = aggregate( mon_storage, mask ); - LIB_DEBUG_PRINT_BUFFER_DECL( "Kernel : waitfor %d (s: %d, m: %d)\n", actual_count, mask.size, (__lock_size_t)max); + __cfaabi_dbg_print_buffer_decl( "Kernel : waitfor %d (s: %d, m: %d)\n", actual_count, mask.size, (__lock_size_t)max); if(actual_count == 0) return; - LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : waitfor internal proceeding\n"); + __cfaabi_dbg_print_buffer_local( "Kernel : waitfor internal proceeding\n"); // Create storage for monitor context @@ -556,5 +556,5 @@ __acceptable_t& accepted = mask[index]; if( accepted.is_dtor ) { - LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : dtor already there\n"); + __cfaabi_dbg_print_buffer_local( "Kernel : dtor already there\n"); verifyf( accepted.size == 1, "ERROR: Accepted dtor has more than 1 mutex parameter." ); @@ -568,5 +568,5 @@ } else { - LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : thread present, baton-passing\n"); + __cfaabi_dbg_print_buffer_local( "Kernel : thread present, baton-passing\n"); // Create the node specific to this wait operation @@ -576,11 +576,11 @@ monitor_save; - LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : baton of %d monitors : ", count ); + __cfaabi_dbg_print_buffer_local( "Kernel : baton of %d monitors : ", count ); #ifdef __CFA_DEBUG_PRINT__ for( int i = 0; i < count; i++) { - LIB_DEBUG_PRINT_BUFFER_LOCAL( "%p %p ", monitors[i], monitors[i]->signal_stack.top ); + __cfaabi_dbg_print_buffer_local( "%p %p ", monitors[i], monitors[i]->signal_stack.top ); } #endif - LIB_DEBUG_PRINT_BUFFER_LOCAL( "\n"); + __cfaabi_dbg_print_buffer_local( "\n"); // Set the owners to be the next thread @@ -593,8 +593,8 @@ monitor_restore; - LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : thread present, returned\n"); + __cfaabi_dbg_print_buffer_local( "Kernel : thread present, returned\n"); } - LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : accepted %d\n", *mask.accepted); + __cfaabi_dbg_print_buffer_local( "Kernel : accepted %d\n", *mask.accepted); return; } @@ -603,9 +603,9 @@ if( duration == 0 ) { - LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : non-blocking, exiting\n"); + __cfaabi_dbg_print_buffer_local( "Kernel : non-blocking, exiting\n"); unlock_all( locks, count ); - LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : accepted %d\n", *mask.accepted); + __cfaabi_dbg_print_buffer_local( "Kernel : accepted %d\n", *mask.accepted); return; } @@ -614,5 +614,5 @@ verifyf( duration < 0, "Timeout on waitfor statments not supported yet."); - LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : blocking waitfor\n"); + __cfaabi_dbg_print_buffer_local( "Kernel : blocking waitfor\n"); // Create the node specific to this wait operation @@ -636,7 +636,7 @@ monitor_restore; - LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : exiting\n"); - - LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : accepted %d\n", *mask.accepted); + __cfaabi_dbg_print_buffer_local( "Kernel : exiting\n"); + + __cfaabi_dbg_print_buffer_local( "Kernel : accepted %d\n", *mask.accepted); } @@ -645,5 +645,5 @@ static inline void set_owner( monitor_desc * this, thread_desc * owner ) { - // LIB_DEBUG_PRINT_SAFE("Kernal : Setting owner of %p to %p ( was %p)\n", this, owner, this->owner ); + // __cfaabi_dbg_print_safe("Kernal : Setting owner of %p to %p ( was %p)\n", this, owner, this->owner ); //Pass the monitor appropriately @@ -677,5 +677,5 @@ static inline thread_desc * next_thread( monitor_desc * this ) { //Check the signaller stack - LIB_DEBUG_PRINT_SAFE("Kernel : mon %p AS-stack top %p\n", this, this->signal_stack.top); + __cfaabi_dbg_print_safe("Kernel : mon %p AS-stack top %p\n", this, this->signal_stack.top); __condition_criterion_t * urgent = pop( this->signal_stack ); if( urgent ) { @@ -729,5 +729,5 @@ for( __lock_size_t i = 0; i < count; i++) { (criteria[i]){ monitors[i], waiter }; - LIB_DEBUG_PRINT_SAFE( "Kernel : target %p = %p\n", criteria[i].target, &criteria[i] ); + __cfaabi_dbg_print_safe( "Kernel : target %p = %p\n", criteria[i].target, &criteria[i] ); push( criteria[i].target->signal_stack, &criteria[i] ); } @@ -738,5 +738,5 @@ static inline void lock_all( __spinlock_t * locks [], __lock_size_t count ) { for( __lock_size_t i = 0; i < count; i++ ) { - DO_LOCK( *locks[i] DEBUG_CTX2 ); + DO_LOCK( *locks[i] __cfaabi_dbg_ctx2 ); } } @@ -745,5 +745,5 @@ for( __lock_size_t i = 0; i < count; i++ ) { __spinlock_t * l = &source[i]->lock; - DO_LOCK( *l DEBUG_CTX2 ); + DO_LOCK( *l __cfaabi_dbg_ctx2 ); if(locks) locks[i] = l; } @@ -803,8 +803,8 @@ for( int i = 0; i < count; i++ ) { - // LIB_DEBUG_PRINT_SAFE( "Checking %p for %p\n", &criteria[i], target ); + // __cfaabi_dbg_print_safe( "Checking %p for %p\n", &criteria[i], target ); if( &criteria[i] == target ) { criteria[i].ready = true; - // LIB_DEBUG_PRINT_SAFE( "True\n" ); + // __cfaabi_dbg_print_safe( "True\n" ); } @@ -812,5 +812,5 @@ } - LIB_DEBUG_PRINT_SAFE( "Kernel : Runing %i (%p)\n", ready2run, ready2run ? node->waiting_thread : NULL ); + __cfaabi_dbg_print_safe( "Kernel : Runing %i (%p)\n", ready2run, ready2run ? node->waiting_thread : NULL ); return ready2run ? node->waiting_thread : NULL; } @@ -819,5 +819,5 @@ thread_desc * thrd = this_thread; if( !this.monitors ) { - // LIB_DEBUG_PRINT_SAFE("Branding\n"); + // __cfaabi_dbg_print_safe("Branding\n"); assertf( thrd->monitors.data != NULL, "No current monitor to brand condition %p", thrd->monitors.data ); this.monitor_count = thrd->monitors.size; Index: src/libcfa/concurrency/preemption.c =================================================================== --- src/libcfa/concurrency/preemption.c (revision f5478c89f22dfaa80c81adb28a7eba9eb97eb1a7) +++ src/libcfa/concurrency/preemption.c (revision 36982fc1f527597d650797d8db4fa9d288e819d9) @@ -148,5 +148,5 @@ //============================================================================================= -LIB_DEBUG_DO( static thread_local void * last_interrupt = 0; ) +__cfaabi_dbg_debug_do( static thread_local void * last_interrupt = 0; ) extern "C" { @@ -159,5 +159,5 @@ // Enable interrupts by decrementing the counter // If counter reaches 0, execute any pending CtxSwitch - void enable_interrupts( DEBUG_CTX_PARAM ) { + void enable_interrupts( __cfaabi_dbg_ctx_param ) { processor * proc = this_processor; // Cache the processor now since interrupts can start happening after the atomic add thread_desc * thrd = this_thread; // Cache the thread now since interrupts can start happening after the atomic add @@ -173,5 +173,5 @@ // For debugging purposes : keep track of the last person to enable the interrupts - LIB_DEBUG_DO( proc->last_enable = caller; ) + __cfaabi_dbg_debug_do( proc->last_enable = caller; ) } @@ -233,5 +233,5 @@ // Called from kernel_startup void kernel_start_preemption() { - LIB_DEBUG_PRINT_SAFE("Kernel : Starting preemption\n"); + __cfaabi_dbg_print_safe("Kernel : Starting preemption\n"); // Start with preemption disabled until ready @@ -255,5 +255,5 @@ // Called from kernel_shutdown void kernel_stop_preemption() { - LIB_DEBUG_PRINT_SAFE("Kernel : Preemption stopping\n"); + __cfaabi_dbg_print_safe("Kernel : Preemption stopping\n"); // Block all signals since we are already shutting down @@ -271,5 +271,5 @@ // Preemption is now fully stopped - LIB_DEBUG_PRINT_SAFE("Kernel : Preemption stopped\n"); + __cfaabi_dbg_print_safe("Kernel : Preemption stopped\n"); } @@ -297,5 +297,5 @@ // Receives SIGUSR1 signal and causes the current thread to yield void sigHandler_ctxSwitch( __CFA_SIGPARMS__ ) { - LIB_DEBUG_DO( last_interrupt = (void *)(cxt->uc_mcontext.gregs[CFA_REG_IP]); ) + __cfaabi_dbg_debug_do( last_interrupt = (void *)(cxt->uc_mcontext.gregs[CFA_REG_IP]); ) // Check if it is safe to preempt here @@ -346,5 +346,5 @@ assertf(sig == SIGALRM, "Kernel Internal Error, sigwait: Unexpected signal %d (%d : %d)\n", sig, info.si_code, info.si_value.sival_int); - // LIB_DEBUG_PRINT_SAFE("Kernel : Caught alarm from %d with %d\n", info.si_code, info.si_value.sival_int ); + // __cfaabi_dbg_print_safe("Kernel : Caught alarm from %d with %d\n", info.si_code, info.si_value.sival_int ); // Switch on the code (a.k.a. the sender) to switch( info.si_code ) @@ -354,6 +354,6 @@ case SI_TIMER: case SI_KERNEL: - // LIB_DEBUG_PRINT_SAFE("Kernel : Preemption thread tick\n"); - lock( event_kernel->lock DEBUG_CTX2 ); + // __cfaabi_dbg_print_safe("Kernel : Preemption thread tick\n"); + lock( event_kernel->lock __cfaabi_dbg_ctx2 ); tick_preemption(); unlock( event_kernel->lock ); @@ -368,5 +368,5 @@ EXIT: - LIB_DEBUG_PRINT_SAFE("Kernel : Preemption thread stopping\n"); + __cfaabi_dbg_print_safe("Kernel : Preemption thread stopping\n"); return NULL; } @@ -380,5 +380,5 @@ if ( sigaction( sig, &act, NULL ) == -1 ) { - LIB_DEBUG_PRINT_BUFFER_DECL( + __cfaabi_dbg_print_buffer_decl( " __kernel_sigaction( sig:%d, handler:%p, flags:%d ), problem installing signal handler, error(%d) %s.\n", sig, handler, flags, errno, strerror( errno ) @@ -397,5 +397,5 @@ if ( sigaction( sig, &act, NULL ) == -1 ) { - LIB_DEBUG_PRINT_BUFFER_DECL( + __cfaabi_dbg_print_buffer_decl( " __kernel_sigdefault( sig:%d ), problem reseting signal handler, error(%d) %s.\n", sig, errno, strerror( errno ) @@ -409,5 +409,5 @@ //============================================================================================= -LIB_DEBUG_DO( +__cfaabi_dbg_debug_do( static void __kernel_backtrace( int start ) { // skip first N stack frames @@ -476,5 +476,5 @@ // void sigHandler_segv( __CFA_SIGPARMS__ ) { -// LIB_DEBUG_DO( +// __cfaabi_dbg_debug_do( // #ifdef __USE_STREAM__ // serr | "*CFA runtime error* program cfa-cpp terminated with" @@ -493,5 +493,5 @@ // void sigHandler_abort( __CFA_SIGPARMS__ ) { // // skip first 6 stack frames -// LIB_DEBUG_DO( __kernel_backtrace( 6 ); ) +// __cfaabi_dbg_debug_do( __kernel_backtrace( 6 ); ) // // reset default signal handler Index: src/libcfa/concurrency/thread.c =================================================================== --- src/libcfa/concurrency/thread.c (revision f5478c89f22dfaa80c81adb28a7eba9eb97eb1a7) +++ src/libcfa/concurrency/thread.c (revision 36982fc1f527597d650797d8db4fa9d288e819d9) @@ -72,5 +72,5 @@ thrd_c->last = this_coroutine; - // LIB_DEBUG_PRINT_SAFE("Thread start : %p (t %p, c %p)\n", this, thrd_c, thrd_h); + // __cfaabi_dbg_print_safe("Thread start : %p (t %p, c %p)\n", this, thrd_c, thrd_h); disable_interrupts(); @@ -82,5 +82,5 @@ ScheduleThread(thrd_h); - enable_interrupts( DEBUG_CTX ); + enable_interrupts( __cfaabi_dbg_ctx ); } Index: src/libcfa/exception.c =================================================================== --- src/libcfa/exception.c (revision f5478c89f22dfaa80c81adb28a7eba9eb97eb1a7) +++ src/libcfa/exception.c (revision 36982fc1f527597d650797d8db4fa9d288e819d9) @@ -37,6 +37,6 @@ // Base exception vtable is abstract, you should not have base exceptions. -struct __cfaehm__base_exception_t_vtable - ___cfaehm__base_exception_t_vtable_instance = { +struct __cfaabi_ehm__base_exception_t_vtable + ___cfaabi_ehm__base_exception_t_vtable_instance = { .parent = NULL, .size = 0, @@ -49,6 +49,6 @@ // Temperary global exception context. Does not work with concurency. struct exception_context_t { - struct __cfaehm__try_resume_node * top_resume; - struct __cfaehm__try_resume_node * current_resume; + struct __cfaabi_ehm__try_resume_node * top_resume; + struct __cfaabi_ehm__try_resume_node * current_resume; exception * current_exception; @@ -78,10 +78,10 @@ // RESUMPTION ================================================================ -void __cfaehm__throw_resume(exception * except) { - - LIB_DEBUG_PRINT_SAFE("Throwing resumption exception\n"); - - struct __cfaehm__try_resume_node * original_head = shared_stack.current_resume; - struct __cfaehm__try_resume_node * current = +void __cfaabi_ehm__throw_resume(exception * except) { + + __cfaabi_dbg_print_safe("Throwing resumption exception\n"); + + struct __cfaabi_ehm__try_resume_node * original_head = shared_stack.current_resume; + struct __cfaabi_ehm__try_resume_node * current = (original_head) ? original_head->next : shared_stack.top_resume; @@ -94,9 +94,9 @@ } - LIB_DEBUG_PRINT_SAFE("Unhandled exception\n"); + __cfaabi_dbg_print_safe("Unhandled exception\n"); shared_stack.current_resume = original_head; // Fall back to termination: - __cfaehm__throw_terminate(except); + __cfaabi_ehm__throw_terminate(except); // TODO: Default handler for resumption. } @@ -105,5 +105,5 @@ // hook has to be added after the node is built but before it is made the top node. -void __cfaehm__try_resume_setup(struct __cfaehm__try_resume_node * node, +void __cfaabi_ehm__try_resume_setup(struct __cfaabi_ehm__try_resume_node * node, _Bool (*handler)(exception * except)) { node->next = shared_stack.top_resume; @@ -112,5 +112,5 @@ } -void __cfaehm__try_resume_cleanup(struct __cfaehm__try_resume_node * node) { +void __cfaabi_ehm__try_resume_cleanup(struct __cfaabi_ehm__try_resume_node * node) { shared_stack.top_resume = node->next; } @@ -122,18 +122,18 @@ // May have to move to cfa for constructors and destructors (references). -struct __cfaehm__node { - struct __cfaehm__node * next; +struct __cfaabi_ehm__node { + struct __cfaabi_ehm__node * next; }; #define NODE_TO_EXCEPT(node) ((exception *)(1 + (node))) -#define EXCEPT_TO_NODE(except) ((struct __cfaehm__node *)(except) - 1) +#define EXCEPT_TO_NODE(except) ((struct __cfaabi_ehm__node *)(except) - 1) // Creates a copy of the indicated exception and sets current_exception to it. -static void __cfaehm__allocate_exception( exception * except ) { +static void __cfaabi_ehm__allocate_exception( exception * except ) { struct exception_context_t * context = this_exception_context(); // Allocate memory for the exception. - struct __cfaehm__node * store = malloc( - sizeof( struct __cfaehm__node ) + except->virtual_table->size ); + struct __cfaabi_ehm__node * store = malloc( + sizeof( struct __cfaabi_ehm__node ) + except->virtual_table->size ); if ( ! store ) { @@ -151,12 +151,12 @@ // Delete the provided exception, unsetting current_exception if relivant. -static void __cfaehm__delete_exception( exception * except ) { +static void __cfaabi_ehm__delete_exception( exception * except ) { struct exception_context_t * context = this_exception_context(); - LIB_DEBUG_PRINT_SAFE("Deleting Exception\n"); + __cfaabi_dbg_print_safe("Deleting Exception\n"); // Remove the exception from the list. - struct __cfaehm__node * to_free = EXCEPT_TO_NODE(except); - struct __cfaehm__node * node; + struct __cfaabi_ehm__node * to_free = EXCEPT_TO_NODE(except); + struct __cfaabi_ehm__node * node; if ( context->current_exception == except ) { @@ -178,6 +178,6 @@ // If this isn't a rethrow (*except==0), delete the provided exception. -void __cfaehm__cleanup_terminate( void * except ) { - if ( *(void**)except ) __cfaehm__delete_exception( *(exception**)except ); +void __cfaabi_ehm__cleanup_terminate( void * except ) { + if ( *(void**)except ) __cfaabi_ehm__delete_exception( *(exception**)except ); } @@ -202,5 +202,5 @@ // The exception that is being thrown must already be stored. -__attribute__((noreturn)) void __cfaehm__begin_unwind(void) { +__attribute__((noreturn)) void __cfaabi_ehm__begin_unwind(void) { if ( ! this_exception_context()->current_exception ) { printf("UNWIND ERROR missing exception in begin unwind\n"); @@ -233,15 +233,15 @@ } -void __cfaehm__throw_terminate( exception * val ) { - LIB_DEBUG_PRINT_SAFE("Throwing termination exception\n"); - - __cfaehm__allocate_exception( val ); - __cfaehm__begin_unwind(); -} - -void __cfaehm__rethrow_terminate(void) { - LIB_DEBUG_PRINT_SAFE("Rethrowing termination exception\n"); - - __cfaehm__begin_unwind(); +void __cfaabi_ehm__throw_terminate( exception * val ) { + __cfaabi_dbg_print_safe("Throwing termination exception\n"); + + __cfaabi_ehm__allocate_exception( val ); + __cfaabi_ehm__begin_unwind(); +} + +void __cfaabi_ehm__rethrow_terminate(void) { + __cfaabi_dbg_print_safe("Rethrowing termination exception\n"); + + __cfaabi_ehm__begin_unwind(); } @@ -254,6 +254,6 @@ { - //LIB_DEBUG_PRINT_SAFE("CFA: 0x%lx\n", _Unwind_GetCFA(context)); - LIB_DEBUG_PRINT_SAFE("Personality function (%d, %x, %llu, %p, %p):", version, actions, exceptionClass, unwind_exception, context); + //__cfaabi_dbg_print_safe("CFA: 0x%lx\n", _Unwind_GetCFA(context)); + __cfaabi_dbg_print_safe("Personality function (%d, %x, %llu, %p, %p):", version, actions, exceptionClass, unwind_exception, context); // If we've reached the end of the stack then there is nothing much we can do... @@ -261,8 +261,8 @@ if (actions & _UA_SEARCH_PHASE) { - LIB_DEBUG_PRINT_SAFE(" lookup phase"); + __cfaabi_dbg_print_safe(" lookup phase"); } else if (actions & _UA_CLEANUP_PHASE) { - LIB_DEBUG_PRINT_SAFE(" cleanup phase"); + __cfaabi_dbg_print_safe(" cleanup phase"); } // Just in case, probably can't actually happen @@ -307,5 +307,5 @@ void * ep = (void*)lsd_info.Start + callsite_start + callsite_len; void * ip = (void*)instruction_ptr; - LIB_DEBUG_PRINT_SAFE("\nfound %p - %p (%p, %p, %p), looking for %p\n", bp, ep, ls, cs, cl, ip); + __cfaabi_dbg_print_safe("\nfound %p - %p (%p, %p, %p), looking for %p\n", bp, ep, ls, cs, cl, ip); #endif // __CFA_DEBUG_PRINT__ continue; @@ -346,5 +346,5 @@ // Get a function pointer from the relative offset and call it - // _Unwind_Reason_Code (*matcher)() = (_Unwind_Reason_Code (*)())lsd_info.LPStart + imatcher; + // _Unwind_Reason_Code (*matcher)() = (_Unwind_Reason_Code (*)())lsd_info.LPStart + imatcher; _Unwind_Reason_Code (*matcher)(exception *) = @@ -357,7 +357,7 @@ // Based on the return value, check if we matched the exception if( ret == _URC_HANDLER_FOUND) { - LIB_DEBUG_PRINT_SAFE(" handler found\n"); + __cfaabi_dbg_print_safe(" handler found\n"); } else { - LIB_DEBUG_PRINT_SAFE(" no handler\n"); + __cfaabi_dbg_print_safe(" no handler\n"); } return ret; @@ -365,5 +365,5 @@ // This is only a cleanup handler, ignore it - LIB_DEBUG_PRINT_SAFE(" no action"); + __cfaabi_dbg_print_safe(" no action"); } else if (actions & _UA_CLEANUP_PHASE) { @@ -385,5 +385,5 @@ _Unwind_SetIP( context, ((lsd_info.LPStart) + (callsite_landing_pad)) ); - LIB_DEBUG_PRINT_SAFE(" action\n"); + __cfaabi_dbg_print_safe(" action\n"); // Return have some action to run @@ -393,11 +393,11 @@ // Nothing to do, move along - LIB_DEBUG_PRINT_SAFE(" no landing pad"); + __cfaabi_dbg_print_safe(" no landing pad"); } // No handling found - LIB_DEBUG_PRINT_SAFE(" table end reached\n"); + __cfaabi_dbg_print_safe(" table end reached\n"); UNWIND: - LIB_DEBUG_PRINT_SAFE(" unwind\n"); + __cfaabi_dbg_print_safe(" unwind\n"); // Keep unwinding the stack @@ -408,5 +408,5 @@ // libcfa but there is one problem left, see the exception table for details __attribute__((noinline)) -void __cfaehm__try_terminate(void (*try_block)(), +void __cfaabi_ehm__try_terminate(void (*try_block)(), void (*catch_block)(int index, exception * except), __attribute__((unused)) int (*match_block)(exception * except)) { @@ -466,11 +466,11 @@ // Body uses language specific data and therefore could be modified arbitrarily ".LLSDACSBCFA2:\n" // BODY start - " .uleb128 .TRYSTART-__cfaehm__try_terminate\n" // Handled area start (relative to start of function) + " .uleb128 .TRYSTART-__cfaabi_ehm__try_terminate\n" // Handled area start (relative to start of function) " .uleb128 .TRYEND-.TRYSTART\n" // Handled area length - " .uleb128 .CATCH-__cfaehm__try_terminate\n" // Hanlder landing pad adress (relative to start of function) + " .uleb128 .CATCH-__cfaabi_ehm__try_terminate\n" // Hanlder landing pad adress (relative to start of function) " .uleb128 1\n" // Action code, gcc seems to use always 0 ".LLSDACSECFA2:\n" // BODY end " .text\n" // TABLE footer - " .size __cfaehm__try_terminate, .-__cfaehm__try_terminate\n" + " .size __cfaabi_ehm__try_terminate, .-__cfaabi_ehm__try_terminate\n" " .ident \"GCC: (Ubuntu 6.2.0-3ubuntu11~16.04) 6.2.0 20160901\"\n" // " .section .note.GNU-stack,\"x\",@progbits\n" Index: src/libcfa/exception.h =================================================================== --- src/libcfa/exception.h (revision f5478c89f22dfaa80c81adb28a7eba9eb97eb1a7) +++ src/libcfa/exception.h (revision 36982fc1f527597d650797d8db4fa9d288e819d9) @@ -21,28 +21,28 @@ #endif -struct __cfaehm__base_exception_t; -typedef struct __cfaehm__base_exception_t exception; -struct __cfaehm__base_exception_t_vtable { - const struct __cfaehm__base_exception_t_vtable * parent; +struct __cfaabi_ehm__base_exception_t; +typedef struct __cfaabi_ehm__base_exception_t exception; +struct __cfaabi_ehm__base_exception_t_vtable { + const struct __cfaabi_ehm__base_exception_t_vtable * parent; size_t size; - void (*copy)(struct __cfaehm__base_exception_t *this, - struct __cfaehm__base_exception_t * other); - void (*free)(struct __cfaehm__base_exception_t *this); - const char * (*msg)(struct __cfaehm__base_exception_t *this); + void (*copy)(struct __cfaabi_ehm__base_exception_t *this, + struct __cfaabi_ehm__base_exception_t * other); + void (*free)(struct __cfaabi_ehm__base_exception_t *this); + const char * (*msg)(struct __cfaabi_ehm__base_exception_t *this); }; -struct __cfaehm__base_exception_t { - struct __cfaehm__base_exception_t_vtable const * virtual_table; +struct __cfaabi_ehm__base_exception_t { + struct __cfaabi_ehm__base_exception_t_vtable const * virtual_table; }; -extern struct __cfaehm__base_exception_t_vtable - ___cfaehm__base_exception_t_vtable_instance; +extern struct __cfaabi_ehm__base_exception_t_vtable + ___cfaabi_ehm__base_exception_t_vtable_instance; // Used in throw statement translation. -void __cfaehm__throw_terminate(exception * except) __attribute__((noreturn)); -void __cfaehm__rethrow_terminate() __attribute__((noreturn)); -void __cfaehm__throw_resume(exception * except); +void __cfaabi_ehm__throw_terminate(exception * except) __attribute__((noreturn)); +void __cfaabi_ehm__rethrow_terminate() __attribute__((noreturn)); +void __cfaabi_ehm__throw_resume(exception * except); // Function catches termination exceptions. -void __cfaehm__try_terminate( +void __cfaabi_ehm__try_terminate( void (*try_block)(), void (*catch_block)(int index, exception * except), @@ -50,21 +50,21 @@ // Clean-up the exception in catch blocks. -void __cfaehm__cleanup_terminate(void * except); +void __cfaabi_ehm__cleanup_terminate(void * except); // Data structure creates a list of resume handlers. -struct __cfaehm__try_resume_node { - struct __cfaehm__try_resume_node * next; +struct __cfaabi_ehm__try_resume_node { + struct __cfaabi_ehm__try_resume_node * next; _Bool (*handler)(exception * except); }; // These act as constructor and destructor for the resume node. -void __cfaehm__try_resume_setup( - struct __cfaehm__try_resume_node * node, +void __cfaabi_ehm__try_resume_setup( + struct __cfaabi_ehm__try_resume_node * node, _Bool (*handler)(exception * except)); -void __cfaehm__try_resume_cleanup( - struct __cfaehm__try_resume_node * node); +void __cfaabi_ehm__try_resume_cleanup( + struct __cfaabi_ehm__try_resume_node * node); // Check for a standard way to call fake deconstructors. -struct __cfaehm__cleanup_hook {}; +struct __cfaabi_ehm__cleanup_hook {}; #ifdef __cforall Index: src/libcfa/interpose.c =================================================================== --- src/libcfa/interpose.c (revision f5478c89f22dfaa80c81adb28a7eba9eb97eb1a7) +++ src/libcfa/interpose.c (revision 36982fc1f527597d650797d8db4fa9d288e819d9) @@ -127,10 +127,10 @@ va_end( args ); - __lib_debug_write( abort_text, len ); - __lib_debug_write( "\n", 1 ); + __cfaabi_dbg_bits_write( abort_text, len ); + __cfaabi_dbg_bits_write( "\n", 1 ); } len = snprintf( abort_text, abort_text_size, "Cforall Runtime error (UNIX pid:%ld)\n", (long int)getpid() ); // use UNIX pid (versus getPid) - __lib_debug_write( abort_text, len ); + __cfaabi_dbg_bits_write( abort_text, len ); Index: src/libcfa/libhdr/libdebug.c =================================================================== --- src/libcfa/libhdr/libdebug.c (revision f5478c89f22dfaa80c81adb28a7eba9eb97eb1a7) +++ src/libcfa/libhdr/libdebug.c (revision 36982fc1f527597d650797d8db4fa9d288e819d9) @@ -28,5 +28,5 @@ extern "C" { - void __lib_debug_write( const char *in_buffer, int len ) { + void __cfaabi_dbg_bits_write( const char *in_buffer, int len ) { // ensure all data is written for ( int count = 0, retcode; count < len; count += retcode ) { @@ -44,21 +44,21 @@ } - void __lib_debug_acquire() __attribute__((__weak__)) {} - void __lib_debug_release() __attribute__((__weak__)) {} + void __cfaabi_dbg_bits_acquire() __attribute__((__weak__)) {} + void __cfaabi_dbg_bits_release() __attribute__((__weak__)) {} - void __lib_debug_print_safe ( const char fmt[], ... ) __attribute__(( format (printf, 1, 2) )) { + void __cfaabi_dbg_bits_print_safe ( const char fmt[], ... ) __attribute__(( format (printf, 1, 2) )) { va_list args; va_start( args, fmt ); - __lib_debug_acquire(); + __cfaabi_dbg_bits_acquire(); int len = vsnprintf( buffer, buffer_size, fmt, args ); - __lib_debug_write( buffer, len ); + __cfaabi_dbg_bits_write( buffer, len ); - __lib_debug_release(); + __cfaabi_dbg_bits_release(); va_end( args ); } - void __lib_debug_print_nolock( const char fmt[], ... ) __attribute__(( format (printf, 1, 2) )) { + void __cfaabi_dbg_bits_print_nolock( const char fmt[], ... ) __attribute__(( format (printf, 1, 2) )) { va_list args; @@ -66,15 +66,15 @@ int len = vsnprintf( buffer, buffer_size, fmt, args ); - __lib_debug_write( buffer, len ); + __cfaabi_dbg_bits_write( buffer, len ); va_end( args ); } - void __lib_debug_print_vararg( const char fmt[], va_list args ) { + void __cfaabi_dbg_bits_print_vararg( const char fmt[], va_list args ) { int len = vsnprintf( buffer, buffer_size, fmt, args ); - __lib_debug_write( buffer, len ); + __cfaabi_dbg_bits_write( buffer, len ); } - void __lib_debug_print_buffer( char in_buffer[], int in_buffer_size, const char fmt[], ... ) __attribute__(( format (printf, 3, 4) )) { + void __cfaabi_dbg_bits_print_buffer( char in_buffer[], int in_buffer_size, const char fmt[], ... ) __attribute__(( format (printf, 3, 4) )) { va_list args; @@ -82,5 +82,5 @@ int len = vsnprintf( in_buffer, in_buffer_size, fmt, args ); - __lib_debug_write( in_buffer, len ); + __cfaabi_dbg_bits_write( in_buffer, len ); va_end( args ); Index: src/libcfa/libhdr/libdebug.h =================================================================== --- src/libcfa/libhdr/libdebug.h (revision f5478c89f22dfaa80c81adb28a7eba9eb97eb1a7) +++ src/libcfa/libhdr/libdebug.h (revision 36982fc1f527597d650797d8db4fa9d288e819d9) @@ -17,27 +17,23 @@ #ifdef __CFA_DEBUG__ - #define LIB_DEBUG_DO(...) __VA_ARGS__ - #define LIB_NO_DEBUG_DO(...) - #define DEBUG_CTX __PRETTY_FUNCTION__ - #define DEBUG_CTX2 , __PRETTY_FUNCTION__ - #define DEBUG_CTX_PARAM const char * caller - #define DEBUG_CTX_PARAM2 , const char * caller + #define __cfaabi_dbg_debug_do(...) __VA_ARGS__ + #define __cfaabi_dbg_no_debug_do(...) + #define __cfaabi_dbg_ctx __PRETTY_FUNCTION__ + #define __cfaabi_dbg_ctx2 , __PRETTY_FUNCTION__ + #define __cfaabi_dbg_ctx_param const char * caller + #define __cfaabi_dbg_ctx_param2 , const char * caller #else - #define LIB_DEBUG_DO(...) - #define LIB_NO_DEBUG_DO(...) __VA_ARGS__ - #define DEBUG_CTX - #define DEBUG_CTX2 - #define DEBUG_CTX_PARAM - #define DEBUG_CTX_PARAM2 + #define __cfaabi_dbg_debug_do(...) + #define __cfaabi_dbg_no_debug_do(...) __VA_ARGS__ + #define __cfaabi_dbg_ctx + #define __cfaabi_dbg_ctx2 + #define __cfaabi_dbg_ctx_param + #define __cfaabi_dbg_ctx_param2 #endif -#if !defined(NDEBUG) && (defined(__CFA_DEBUG__) || defined(__CFA_VERIFY__)) - #define verify(x) assert(x) - #define verifyf(x, ...) assertf(x, __VA_ARGS__) -#else - #define verify(x) - #define verifyf(x, ...) -#endif - +__cfaabi::ehm +__cfaabi::dbg +__cfaabi::rt +__cfaabi::mem #ifdef __cforall @@ -47,11 +43,11 @@ #include - extern void __lib_debug_write( const char *buffer, int len ); - extern void __lib_debug_acquire(); - extern void __lib_debug_release(); - extern void __lib_debug_print_safe ( const char fmt[], ... ) __attribute__(( format (printf, 1, 2) )); - extern void __lib_debug_print_nolock( const char fmt[], ... ) __attribute__(( format (printf, 1, 2) )); - extern void __lib_debug_print_vararg( const char fmt[], va_list arg ); - extern void __lib_debug_print_buffer( char buffer[], int buffer_size, const char fmt[], ... ) __attribute__(( format (printf, 3, 4) )); + extern void __cfaabi_dbg_bits_write( const char *buffer, int len ); + extern void __cfaabi_dbg_bits_acquire(); + extern void __cfaabi_dbg_bits_release(); + extern void __cfaabi_dbg_bits_print_safe ( const char fmt[], ... ) __attribute__(( format (printf, 1, 2) )); + extern void __cfaabi_dbg_bits_print_nolock( const char fmt[], ... ) __attribute__(( format (printf, 1, 2) )); + extern void __cfaabi_dbg_bits_print_vararg( const char fmt[], va_list arg ); + extern void __cfaabi_dbg_bits_print_buffer( char buffer[], int buffer_size, const char fmt[], ... ) __attribute__(( format (printf, 3, 4) )); #ifdef __cforall } @@ -59,21 +55,21 @@ #ifdef __CFA_DEBUG_PRINT__ - #define LIB_DEBUG_WRITE( buffer, len ) __lib_debug_write( buffer, len ) - #define LIB_DEBUG_ACQUIRE() __lib_debug_acquire() - #define LIB_DEBUG_RELEASE() __lib_debug_release() - #define LIB_DEBUG_PRINT_SAFE(...) __lib_debug_print_safe (__VA_ARGS__) - #define LIB_DEBUG_PRINT_NOLOCK(...) __lib_debug_print_nolock (__VA_ARGS__) - #define LIB_DEBUG_PRINT_BUFFER(...) __lib_debug_print_buffer (__VA_ARGS__) - #define LIB_DEBUG_PRINT_BUFFER_DECL(...) char __dbg_text[256]; int __dbg_len = snprintf( __dbg_text, 256, __VA_ARGS__ ); __lib_debug_write( __dbg_text, __dbg_len ); - #define LIB_DEBUG_PRINT_BUFFER_LOCAL(...) __dbg_len = snprintf( __dbg_text, 256, __VA_ARGS__ ); __lib_debug_write( __dbg_text, __dbg_len ); + #define __cfaabi_dbg_write( buffer, len ) __cfaabi_dbg_bits_write( buffer, len ) + #define __cfaabi_dbg_acquire() __cfaabi_dbg_bits_acquire() + #define __cfaabi_dbg_release() __cfaabi_dbg_bits_release() + #define __cfaabi_dbg_print_safe(...) __cfaabi_dbg_bits_print_safe (__VA_ARGS__) + #define __cfaabi_dbg_print_nolock(...) __cfaabi_dbg_bits_print_nolock (__VA_ARGS__) + #define __cfaabi_dbg_print_buffer(...) __cfaabi_dbg_bits_print_buffer (__VA_ARGS__) + #define __cfaabi_dbg_print_buffer_decl(...) char __dbg_text[256]; int __dbg_len = snprintf( __dbg_text, 256, __VA_ARGS__ ); __cfaabi_dbg_bits_write( __dbg_text, __dbg_len ); + #define __cfaabi_dbg_print_buffer_local(...) __dbg_len = snprintf( __dbg_text, 256, __VA_ARGS__ ); __cfaabi_dbg_bits_write( __dbg_text, __dbg_len ); #else - #define LIB_DEBUG_WRITE(...) ((void)0) - #define LIB_DEBUG_ACQUIRE() ((void)0) - #define LIB_DEBUG_RELEASE() ((void)0) - #define LIB_DEBUG_PRINT_SAFE(...) ((void)0) - #define LIB_DEBUG_PRINT_NOLOCK(...) ((void)0) - #define LIB_DEBUG_PRINT_BUFFER(...) ((void)0) - #define LIB_DEBUG_PRINT_BUFFER_DECL(...) ((void)0) - #define LIB_DEBUG_PRINT_BUFFER_LOCAL(...) ((void)0) + #define __cfaabi_dbg_write(...) ((void)0) + #define __cfaabi_dbg_acquire() ((void)0) + #define __cfaabi_dbg_release() ((void)0) + #define __cfaabi_dbg_print_safe(...) ((void)0) + #define __cfaabi_dbg_print_nolock(...) ((void)0) + #define __cfaabi_dbg_print_buffer(...) ((void)0) + #define __cfaabi_dbg_print_buffer_decl(...) ((void)0) + #define __cfaabi_dbg_print_buffer_local(...) ((void)0) #endif Index: src/libcfa/stdhdr/assert.h =================================================================== --- src/libcfa/stdhdr/assert.h (revision f5478c89f22dfaa80c81adb28a7eba9eb97eb1a7) +++ src/libcfa/stdhdr/assert.h (revision 36982fc1f527597d650797d8db4fa9d288e819d9) @@ -30,4 +30,12 @@ #endif +#if !defined(NDEBUG) && (defined(__CFA_DEBUG__) || defined(__CFA_VERIFY__)) + #define verify(x) assert(x) + #define verifyf(x, ...) assertf(x, __VA_ARGS__) +#else + #define verify(x) + #define verifyf(x, ...) +#endif + #ifdef __cforall } // extern "C"