Index: libcfa/src/concurrency/invoke.h =================================================================== --- libcfa/src/concurrency/invoke.h (revision 67bfc50b1e9eeee360c34e3c2c3dd4fca93f06ad) +++ libcfa/src/concurrency/invoke.h (revision badd22fed4b3a215a3ee5543fcf2ab6273d57984) @@ -26,4 +26,11 @@ #ifndef _INVOKE_H_ #define _INVOKE_H_ + + struct __cfaehm_try_resume_node; + struct __cfaehm_base_exception_t; + struct exception_context_t { + struct __cfaehm_try_resume_node * top_resume; + struct __cfaehm_base_exception_t * current_exception; + }; struct __stack_context_t { @@ -51,4 +58,7 @@ // base of stack void * base; + + // Information for exception handling. + struct exception_context_t exception_context; }; @@ -84,5 +94,7 @@ }; - static inline struct __stack_t * __get_stack( struct $coroutine * cor ) { return (struct __stack_t*)(((uintptr_t)cor->stack.storage) & ((uintptr_t)-2)); } + static inline struct __stack_t * __get_stack( struct $coroutine * cor ) { + return (struct __stack_t*)(((uintptr_t)cor->stack.storage) & ((uintptr_t)-2)); + } // struct which calls the monitor is accepting Index: libcfa/src/concurrency/kernel/startup.cfa =================================================================== --- libcfa/src/concurrency/kernel/startup.cfa (revision 67bfc50b1e9eeee360c34e3c2c3dd4fca93f06ad) +++ libcfa/src/concurrency/kernel/startup.cfa (revision badd22fed4b3a215a3ee5543fcf2ab6273d57984) @@ -516,5 +516,8 @@ ( this.terminated ){ 0 }; ( this.runner ){}; - init( this, name, _cltr ); + + disable_interrupts(); + init( this, name, _cltr ); + enable_interrupts( __cfaabi_dbg_ctx ); __cfadbg_print_safe(runtime_core, "Kernel : Starting core %p\n", &this); @@ -540,5 +543,7 @@ free( this.stack ); - deinit( this ); + disable_interrupts(); + deinit( this ); + enable_interrupts( __cfaabi_dbg_ctx ); } Index: libcfa/src/concurrency/ready_queue.cfa =================================================================== --- libcfa/src/concurrency/ready_queue.cfa (revision 67bfc50b1e9eeee360c34e3c2c3dd4fca93f06ad) +++ libcfa/src/concurrency/ready_queue.cfa (revision badd22fed4b3a215a3ee5543fcf2ab6273d57984) @@ -150,4 +150,6 @@ // queues or removing them. uint_fast32_t ready_mutate_lock( void ) with(*__scheduler_lock) { + /* paranoid */ verify( ! kernelTLS.preemption_state.enabled ); + // Step 1 : lock global lock // It is needed to avoid processors that register mid Critical-Section @@ -164,8 +166,11 @@ } + /* paranoid */ verify( ! kernelTLS.preemption_state.enabled ); return s; } void ready_mutate_unlock( uint_fast32_t last_s ) with(*__scheduler_lock) { + /* paranoid */ verify( ! kernelTLS.preemption_state.enabled ); + // Step 1 : release local locks // This must be done while the global lock is held to avoid @@ -182,4 +187,6 @@ /*paranoid*/ assert(true == lock); __atomic_store_n(&lock, (bool)false, __ATOMIC_RELEASE); + + /* paranoid */ verify( ! kernelTLS.preemption_state.enabled ); } Index: libcfa/src/exception.c =================================================================== --- libcfa/src/exception.c (revision 67bfc50b1e9eeee360c34e3c2c3dd4fca93f06ad) +++ libcfa/src/exception.c (revision badd22fed4b3a215a3ee5543fcf2ab6273d57984) @@ -10,6 +10,6 @@ // Created On : Mon Jun 26 15:13:00 2017 // Last Modified By : Andrew Beach -// Last Modified On : Thr May 21 12:18:00 2020 -// Update Count : 20 +// Last Modified On : Wed Aug 12 13:55:00 2020 +// Update Count : 21 // @@ -28,4 +28,5 @@ #include #include +#include "concurrency/invoke.h" #include "stdhdr/assert.h" @@ -59,10 +60,5 @@ // Temperary global exception context. Does not work with concurency. -struct exception_context_t { - struct __cfaehm_try_resume_node * top_resume; - - exception_t * current_exception; - int current_handler_index; -} static shared_stack = {NULL, NULL, 0}; +static struct exception_context_t shared_stack = {NULL, NULL}; // Get the current exception context. @@ -122,4 +118,15 @@ // MEMORY MANAGEMENT ========================================================= + +struct __cfaehm_node { + struct _Unwind_Exception unwind_exception; + struct __cfaehm_node * next; + int handler_index; +}; + +#define NODE_TO_EXCEPT(node) ((exception_t *)(1 + (node))) +#define EXCEPT_TO_NODE(except) ((struct __cfaehm_node *)(except) - 1) +#define UNWIND_TO_NODE(unwind) ((struct __cfaehm_node *)(unwind)) +#define NULL_MAP(map, ptr) ((ptr) ? (map(ptr)) : NULL) // How to clean up an exception in various situations. @@ -137,15 +144,4 @@ } -// We need a piece of storage to raise the exception, for now its a single -// piece. -static struct _Unwind_Exception this_exception_storage; - -struct __cfaehm_node { - struct __cfaehm_node * next; -}; - -#define NODE_TO_EXCEPT(node) ((exception_t *)(1 + (node))) -#define EXCEPT_TO_NODE(except) ((struct __cfaehm_node *)(except) - 1) - // Creates a copy of the indicated exception and sets current_exception to it. static void __cfaehm_allocate_exception( exception_t * except ) { @@ -161,14 +157,14 @@ } + // Initialize the node: + exception_t * except_store = NODE_TO_EXCEPT(store); + store->unwind_exception.exception_class = __cfaehm_exception_class; + store->unwind_exception.exception_cleanup = __cfaehm_exception_cleanup; + store->handler_index = 0; + except->virtual_table->copy( except_store, except ); + // Add the node to the list: - store->next = EXCEPT_TO_NODE(context->current_exception); - context->current_exception = NODE_TO_EXCEPT(store); - - // Copy the exception to storage. - except->virtual_table->copy( context->current_exception, except ); - - // Set up the exception storage. - this_exception_storage.exception_class = __cfaehm_exception_class; - this_exception_storage.exception_cleanup = __cfaehm_exception_cleanup; + store->next = NULL_MAP(EXCEPT_TO_NODE, context->current_exception); + context->current_exception = except_store; } @@ -185,5 +181,5 @@ if ( context->current_exception == except ) { node = to_free->next; - context->current_exception = (node) ? NODE_TO_EXCEPT(node) : 0; + context->current_exception = NULL_MAP(NODE_TO_EXCEPT, node); } else { node = EXCEPT_TO_NODE(context->current_exception); @@ -213,5 +209,5 @@ // Verify actions follow the rules we expect. verify((actions & _UA_CLEANUP_PHASE) && (actions & _UA_FORCE_UNWIND)); - verify(!(actions & (_UA_SEARCH_PHASE | _UA_HANDER_FRAME))); + verify(!(actions & (_UA_SEARCH_PHASE | _UA_HANDLER_FRAME))); if ( actions & _UA_END_OF_STACK ) { @@ -222,9 +218,11 @@ } +static struct _Unwind_Exception cancel_exception_storage; + // Cancel the current stack, prefroming approprate clean-up and messaging. void __cfaehm_cancel_stack( exception_t * exception ) { // TODO: Detect current stack and pick a particular stop-function. _Unwind_Reason_Code ret; - ret = _Unwind_ForcedUnwind( &this_exception_storage, _Stop_Fn, (void*)0x22 ); + ret = _Unwind_ForcedUnwind( &cancel_exception_storage, _Stop_Fn, (void*)0x22 ); printf("UNWIND ERROR %d after force unwind\n", ret); abort(); @@ -247,9 +245,10 @@ static void __cfaehm_begin_unwind(void(*defaultHandler)(exception_t *)) { struct exception_context_t * context = this_exception_context(); - struct _Unwind_Exception * storage = &this_exception_storage; if ( NULL == context->current_exception ) { printf("UNWIND ERROR missing exception in begin unwind\n"); abort(); } + struct _Unwind_Exception * storage = + &EXCEPT_TO_NODE(context->current_exception)->unwind_exception; // Call stdlibc to raise the exception @@ -419,5 +418,5 @@ _Unwind_Reason_Code ret = (0 == index) ? _URC_CONTINUE_UNWIND : _URC_HANDLER_FOUND; - context->current_handler_index = index; + UNWIND_TO_NODE(unwind_exception)->handler_index = index; // Based on the return value, check if we matched the exception @@ -425,4 +424,5 @@ __cfadbg_print_safe(exception, " handler found\n"); } else { + // TODO: Continue the search if there is more in the table. __cfadbg_print_safe(exception, " no handler\n"); } @@ -516,5 +516,5 @@ // Exception handler // Note: Saving the exception context on the stack breaks termination exceptions. - catch_block( this_exception_context()->current_handler_index, + catch_block( EXCEPT_TO_NODE( this_exception_context()->current_exception )->handler_index, this_exception_context()->current_exception ); } Index: src/AST/Pass.hpp =================================================================== --- src/AST/Pass.hpp (revision 67bfc50b1e9eeee360c34e3c2c3dd4fca93f06ad) +++ src/AST/Pass.hpp (revision badd22fed4b3a215a3ee5543fcf2ab6273d57984) @@ -91,4 +91,10 @@ static void run( std::list< ptr > & decls, Args &&... args ) { Pass visitor( std::forward( args )... ); + accept_all( decls, visitor ); + } + + template< typename... Args > + static void run( std::list< ptr > & decls ) { + Pass visitor; accept_all( decls, visitor ); } Index: tests/exceptions/.expect/trash.txt =================================================================== --- tests/exceptions/.expect/trash.txt (revision badd22fed4b3a215a3ee5543fcf2ab6273d57984) +++ tests/exceptions/.expect/trash.txt (revision badd22fed4b3a215a3ee5543fcf2ab6273d57984) @@ -0,0 +1,2 @@ +inner yang +outer yin Index: tests/exceptions/trash.cfa =================================================================== --- tests/exceptions/trash.cfa (revision badd22fed4b3a215a3ee5543fcf2ab6273d57984) +++ tests/exceptions/trash.cfa (revision badd22fed4b3a215a3ee5543fcf2ab6273d57984) @@ -0,0 +1,27 @@ +// Make sure throw-catch during unwind does not trash internal data. + +#include +#include + +TRIVIAL_EXCEPTION(yin); +TRIVIAL_EXCEPTION(yang); + +int main(int argc, char * argv[]) { + try { + try { + throw (yin){}; + } finally { + try { + throw (yang){}; + } catch (yin *) { + printf("inner yin\n"); + } catch (yang *) { + printf("inner yang\n"); + } + } + } catch (yin *) { + printf("outer yin\n"); + } catch (yang *) { + printf("outer yang\n"); + } +}