Index: libcfa/src/exception.c =================================================================== --- libcfa/src/exception.c (revision 92e7631c742d91efe39fcc19647764af9d15f167) +++ libcfa/src/exception.c (revision 309012709e091dfaf06aaeec56491e73a68b71a1) @@ -9,7 +9,7 @@ // Author : Andrew Beach // Created On : Mon Jun 26 15:13:00 2017 -// Last Modified By : Peter A. Buhr -// Last Modified On : Thu Feb 22 18:17:34 2018 -// Update Count : 11 +// Last Modified By : Andrew Beach +// Last Modified On : Fri Mar 27 10:19:00 2020 +// Update Count : 12 // @@ -41,6 +41,6 @@ // Base exception vtable is abstract, you should not have base exceptions. -struct __cfaabi_ehm__base_exception_t_vtable - ___cfaabi_ehm__base_exception_t_vtable_instance = { +struct __cfaehm_base_exception_t_vtable + ___cfaehm_base_exception_t_vtable_instance = { .parent = NULL, .size = 0, @@ -53,6 +53,6 @@ // Temperary global exception context. Does not work with concurency. struct exception_context_t { - struct __cfaabi_ehm__try_resume_node * top_resume; - struct __cfaabi_ehm__try_resume_node * current_resume; + struct __cfaehm_try_resume_node * top_resume; + struct __cfaehm_try_resume_node * current_resume; exception_t * current_exception; @@ -70,11 +70,11 @@ // RESUMPTION ================================================================ -void __cfaabi_ehm__throw_resume(exception_t * except) { +void __cfaehm_throw_resume(exception_t * except) { struct exception_context_t * context = this_exception_context(); __cfaabi_dbg_print_safe("Throwing resumption exception\n"); - struct __cfaabi_ehm__try_resume_node * original_head = context->current_resume; - struct __cfaabi_ehm__try_resume_node * current = + struct __cfaehm_try_resume_node * original_head = context->current_resume; + struct __cfaehm_try_resume_node * current = (original_head) ? original_head->next : context->top_resume; @@ -91,5 +91,5 @@ // Fall back to termination: - __cfaabi_ehm__throw_terminate(except); + __cfaehm_throw_terminate(except); // TODO: Default handler for resumption. } @@ -99,5 +99,5 @@ // be added after the node is built but before it is made the top node. -void __cfaabi_ehm__try_resume_setup(struct __cfaabi_ehm__try_resume_node * node, +void __cfaehm_try_resume_setup(struct __cfaehm_try_resume_node * node, _Bool (*handler)(exception_t * except)) { struct exception_context_t * context = this_exception_context(); @@ -107,5 +107,5 @@ } -void __cfaabi_ehm__try_resume_cleanup(struct __cfaabi_ehm__try_resume_node * node) { +void __cfaehm_try_resume_cleanup(struct __cfaehm_try_resume_node * node) { struct exception_context_t * context = this_exception_context(); context->top_resume = node->next; @@ -118,18 +118,18 @@ // May have to move to cfa for constructors and destructors (references). -struct __cfaabi_ehm__node { - struct __cfaabi_ehm__node * next; +struct __cfaehm_node { + struct __cfaehm_node * next; }; #define NODE_TO_EXCEPT(node) ((exception_t *)(1 + (node))) -#define EXCEPT_TO_NODE(except) ((struct __cfaabi_ehm__node *)(except) - 1) +#define EXCEPT_TO_NODE(except) ((struct __cfaehm_node *)(except) - 1) // Creates a copy of the indicated exception and sets current_exception to it. -static void __cfaabi_ehm__allocate_exception( exception_t * except ) { +static void __cfaehm_allocate_exception( exception_t * except ) { struct exception_context_t * context = this_exception_context(); // Allocate memory for the exception. - struct __cfaabi_ehm__node * store = malloc( - sizeof( struct __cfaabi_ehm__node ) + except->virtual_table->size ); + struct __cfaehm_node * store = malloc( + sizeof( struct __cfaehm_node ) + except->virtual_table->size ); if ( ! store ) { @@ -147,5 +147,5 @@ // Delete the provided exception, unsetting current_exception if relivant. -static void __cfaabi_ehm__delete_exception( exception_t * except ) { +static void __cfaehm_delete_exception( exception_t * except ) { struct exception_context_t * context = this_exception_context(); @@ -153,6 +153,6 @@ // Remove the exception from the list. - struct __cfaabi_ehm__node * to_free = EXCEPT_TO_NODE(except); - struct __cfaabi_ehm__node * node; + struct __cfaehm_node * to_free = EXCEPT_TO_NODE(except); + struct __cfaehm_node * node; if ( context->current_exception == except ) { @@ -174,6 +174,6 @@ // If this isn't a rethrow (*except==0), delete the provided exception. -void __cfaabi_ehm__cleanup_terminate( void * except ) { - if ( *(void**)except ) __cfaabi_ehm__delete_exception( *(exception_t **)except ); +void __cfaehm_cleanup_terminate( void * except ) { + if ( *(void**)except ) __cfaehm_delete_exception( *(exception_t **)except ); } @@ -187,5 +187,5 @@ int version, _Unwind_Action actions, - _Unwind_Exception_Class exceptionClass, + _Unwind_Exception_Class exception_class, struct _Unwind_Exception * unwind_exception, struct _Unwind_Context * unwind_context, @@ -198,5 +198,5 @@ // The exception that is being thrown must already be stored. -__attribute__((noreturn)) void __cfaabi_ehm__begin_unwind(void) { +static __attribute__((noreturn)) void __cfaehm_begin_unwind(void) { if ( ! this_exception_context()->current_exception ) { printf("UNWIND ERROR missing exception in begin unwind\n"); @@ -230,15 +230,15 @@ } -void __cfaabi_ehm__throw_terminate( exception_t * val ) { +void __cfaehm_throw_terminate( exception_t * val ) { __cfaabi_dbg_print_safe("Throwing termination exception\n"); - __cfaabi_ehm__allocate_exception( val ); - __cfaabi_ehm__begin_unwind(); -} - -void __cfaabi_ehm__rethrow_terminate(void) { + __cfaehm_allocate_exception( val ); + __cfaehm_begin_unwind(); +} + +void __cfaehm_rethrow_terminate(void) { __cfaabi_dbg_print_safe("Rethrowing termination exception\n"); - __cfaabi_ehm__begin_unwind(); + __cfaehm_begin_unwind(); } @@ -246,13 +246,15 @@ // ".cfi_personality 0x3,__gcfa_personality_v0" this function will be called twice when unwinding. // Once in the search phase and once in the cleanup phase. -_Unwind_Reason_Code __gcfa_personality_v0 ( - int version, _Unwind_Action actions, unsigned long long exceptionClass, - struct _Unwind_Exception* unwind_exception, - struct _Unwind_Context* unwind_context) +_Unwind_Reason_Code __gcfa_personality_v0( + int version, + _Unwind_Action actions, + unsigned long long exception_class, + struct _Unwind_Exception * unwind_exception, + struct _Unwind_Context * unwind_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, unwind_context); + version, actions, exception_class, unwind_exception, unwind_context); // If we've reached the end of the stack then there is nothing much we can do... @@ -342,5 +344,4 @@ // - The BSP (Probably the base stack pointer) - // The current apprach uses one exception table entry per try block _uleb128_t imatcher; @@ -414,5 +415,5 @@ // and simply linked from libcfa but there is one problem left, see the exception table for details __attribute__((noinline)) -void __cfaabi_ehm__try_terminate(void (*try_block)(), +void __cfaehm_try_terminate(void (*try_block)(), void (*catch_block)(int index, exception_t * except), __attribute__((unused)) int (*match_block)(exception_t * except)) { @@ -480,12 +481,12 @@ // handler landing pad offset and 1 (action code, gcc seems to use 0). ".LLSDACSBCFA2:\n" - " .uleb128 .TRYSTART-__cfaabi_ehm__try_terminate\n" + " .uleb128 .TRYSTART-__cfaehm_try_terminate\n" " .uleb128 .TRYEND-.TRYSTART\n" - " .uleb128 .CATCH-__cfaabi_ehm__try_terminate\n" + " .uleb128 .CATCH-__cfaehm_try_terminate\n" " .uleb128 1\n" ".LLSDACSECFA2:\n" // TABLE FOOTER " .text\n" - " .size __cfaabi_ehm__try_terminate, .-__cfaabi_ehm__try_terminate\n" + " .size __cfaehm_try_terminate, .-__cfaehm_try_terminate\n" ); @@ -524,9 +525,9 @@ ".LLSDACSBCFA2:\n" // Handled area start (relative to start of function) - " .uleb128 .TRYSTART-__cfaabi_ehm__try_terminate\n" + " .uleb128 .TRYSTART-__cfaehm_try_terminate\n" // Handled area length " .uleb128 .TRYEND-.TRYSTART\n" // Handler landing pad address (relative to start of function) - " .uleb128 .CATCH-__cfaabi_ehm__try_terminate\n" + " .uleb128 .CATCH-__cfaehm_try_terminate\n" // Action code, gcc seems to always use 0. " .uleb128 1\n" @@ -534,5 +535,5 @@ ".LLSDACSECFA2:\n" " .text\n" - " .size __cfaabi_ehm__try_terminate, .-__cfaabi_ehm__try_terminate\n" + " .size __cfaehm_try_terminate, .-__cfaehm_try_terminate\n" " .ident \"GCC: (Ubuntu 6.2.0-3ubuntu11~16.04) 6.2.0 20160901\"\n" " .section .note.GNU-stack,\"x\",@progbits\n" Index: libcfa/src/exception.h =================================================================== --- libcfa/src/exception.h (revision 92e7631c742d91efe39fcc19647764af9d15f167) +++ libcfa/src/exception.h (revision 309012709e091dfaf06aaeec56491e73a68b71a1) @@ -9,7 +9,7 @@ // Author : Andrew Beach // Created On : Mon Jun 26 15:11:00 2017 -// Last Modified By : Peter A. Buhr -// Last Modified On : Thu Feb 22 18:11:15 2018 -// Update Count : 8 +// Last Modified By : Andrew Beach +// Last Modified On : Fri Mar 27 10:16:00 2020 +// Update Count : 9 // @@ -21,28 +21,28 @@ #endif -struct __cfaabi_ehm__base_exception_t; -typedef struct __cfaabi_ehm__base_exception_t exception_t; -struct __cfaabi_ehm__base_exception_t_vtable { - const struct __cfaabi_ehm__base_exception_t_vtable * parent; +struct __cfaehm_base_exception_t; +typedef struct __cfaehm_base_exception_t exception_t; +struct __cfaehm_base_exception_t_vtable { + const struct __cfaehm_base_exception_t_vtable * parent; size_t size; - void (*copy)(struct __cfaabi_ehm__base_exception_t *this, - struct __cfaabi_ehm__base_exception_t * other); - void (*free)(struct __cfaabi_ehm__base_exception_t *this); - const char * (*msg)(struct __cfaabi_ehm__base_exception_t *this); + void (*copy)(struct __cfaehm_base_exception_t *this, + struct __cfaehm_base_exception_t * other); + void (*free)(struct __cfaehm_base_exception_t *this); + const char * (*msg)(struct __cfaehm_base_exception_t *this); }; -struct __cfaabi_ehm__base_exception_t { - struct __cfaabi_ehm__base_exception_t_vtable const * virtual_table; +struct __cfaehm_base_exception_t { + struct __cfaehm_base_exception_t_vtable const * virtual_table; }; -extern struct __cfaabi_ehm__base_exception_t_vtable - ___cfaabi_ehm__base_exception_t_vtable_instance; +extern struct __cfaehm_base_exception_t_vtable + ___cfaehm_base_exception_t_vtable_instance; // Used in throw statement translation. -void __cfaabi_ehm__throw_terminate(exception_t * except) __attribute__((noreturn)); -void __cfaabi_ehm__rethrow_terminate() __attribute__((noreturn)); -void __cfaabi_ehm__throw_resume(exception_t * except); +void __cfaehm_throw_terminate(exception_t * except) __attribute__((noreturn)); +void __cfaehm_rethrow_terminate() __attribute__((noreturn)); +void __cfaehm_throw_resume(exception_t * except); // Function catches termination exceptions. -void __cfaabi_ehm__try_terminate( +void __cfaehm_try_terminate( void (*try_block)(), void (*catch_block)(int index, exception_t * except), @@ -50,21 +50,21 @@ // Clean-up the exception in catch blocks. -void __cfaabi_ehm__cleanup_terminate(void * except); +void __cfaehm_cleanup_terminate(void * except); // Data structure creates a list of resume handlers. -struct __cfaabi_ehm__try_resume_node { - struct __cfaabi_ehm__try_resume_node * next; +struct __cfaehm_try_resume_node { + struct __cfaehm_try_resume_node * next; _Bool (*handler)(exception_t * except); }; // These act as constructor and destructor for the resume node. -void __cfaabi_ehm__try_resume_setup( - struct __cfaabi_ehm__try_resume_node * node, +void __cfaehm_try_resume_setup( + struct __cfaehm_try_resume_node * node, _Bool (*handler)(exception_t * except)); -void __cfaabi_ehm__try_resume_cleanup( - struct __cfaabi_ehm__try_resume_node * node); +void __cfaehm_try_resume_cleanup( + struct __cfaehm_try_resume_node * node); // Check for a standard way to call fake deconstructors. -struct __cfaabi_ehm__cleanup_hook {}; +struct __cfaehm_cleanup_hook {}; #ifdef __cforall