Index: libcfa/src/exception.c =================================================================== --- libcfa/src/exception.c (revision aa7a56efa9b7cea9c154230c27e862b7ac06fd36) +++ libcfa/src/exception.c (revision a6853358469a8316171d15bf0ad19b3733c00bbc) @@ -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 aa7a56efa9b7cea9c154230c27e862b7ac06fd36) +++ libcfa/src/exception.h (revision a6853358469a8316171d15bf0ad19b3733c00bbc) @@ -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 Index: src/ControlStruct/ExceptTranslate.cc =================================================================== --- src/ControlStruct/ExceptTranslate.cc (revision aa7a56efa9b7cea9c154230c27e862b7ac06fd36) +++ src/ControlStruct/ExceptTranslate.cc (revision a6853358469a8316171d15bf0ad19b3733c00bbc) @@ -9,7 +9,7 @@ // Author : Andrew Beach // Created On : Wed Jun 14 16:49:00 2017 -// Last Modified By : Peter A. Buhr -// Last Modified On : Fri Dec 13 23:40:15 2019 -// Update Count : 12 +// Last Modified By : Andrew Beach +// Last Modified On : Fri Mar 27 11:58:00 2020 +// Update Count : 13 // @@ -211,5 +211,5 @@ ThrowStmt *throwStmt ) { // __throw_terminate( `throwStmt->get_name()` ); } - return create_given_throw( "__cfaabi_ehm__throw_terminate", throwStmt ); + return create_given_throw( "__cfaehm_throw_terminate", throwStmt ); } @@ -232,5 +232,5 @@ ) ) ); result->push_back( new ExprStmt( - new UntypedExpr( new NameExpr( "__cfaabi_ehm__rethrow_terminate" ) ) + new UntypedExpr( new NameExpr( "__cfaehm_rethrow_terminate" ) ) ) ); delete throwStmt; @@ -241,5 +241,5 @@ ThrowStmt *throwStmt ) { // __throw_resume( `throwStmt->get_name` ); - return create_given_throw( "__cfaabi_ehm__throw_resume", throwStmt ); + return create_given_throw( "__cfaehm_throw_resume", throwStmt ); } @@ -309,5 +309,5 @@ local_except->get_attributes().push_back( new Attribute( "cleanup", - { new NameExpr( "__cfaabi_ehm__cleanup_terminate" ) } + { new NameExpr( "__cfaehm_cleanup_terminate" ) } ) ); @@ -429,8 +429,8 @@ FunctionDecl * terminate_catch, FunctionDecl * terminate_match ) { - // { __cfaabi_ehm__try_terminate(`try`, `catch`, `match`); } + // { __cfaehm_try_terminate(`try`, `catch`, `match`); } UntypedExpr * caller = new UntypedExpr( new NameExpr( - "__cfaabi_ehm__try_terminate" ) ); + "__cfaehm_try_terminate" ) ); std::list& args = caller->get_args(); args.push_back( nameOf( try_wrapper ) ); @@ -486,8 +486,8 @@ // struct __try_resume_node __resume_node - // __attribute__((cleanup( __cfaabi_ehm__try_resume_cleanup ))); + // __attribute__((cleanup( __cfaehm_try_resume_cleanup ))); // ** unwinding of the stack here could cause problems ** // ** however I don't think that can happen currently ** - // __cfaabi_ehm__try_resume_setup( &__resume_node, resume_handler ); + // __cfaehm_try_resume_setup( &__resume_node, resume_handler ); std::list< Attribute * > attributes; @@ -495,5 +495,5 @@ std::list< Expression * > attr_params; attr_params.push_back( new NameExpr( - "__cfaabi_ehm__try_resume_cleanup" ) ); + "__cfaehm_try_resume_cleanup" ) ); attributes.push_back( new Attribute( "cleanup", attr_params ) ); } @@ -514,5 +514,5 @@ UntypedExpr *setup = new UntypedExpr( new NameExpr( - "__cfaabi_ehm__try_resume_setup" ) ); + "__cfaehm_try_resume_setup" ) ); setup->get_args().push_back( new AddressExpr( nameOf( obj ) ) ); setup->get_args().push_back( nameOf( resume_handler ) ); @@ -539,5 +539,5 @@ ObjectDecl * ExceptionMutatorCore::create_finally_hook( FunctionDecl * finally_wrapper ) { - // struct __cfaabi_ehm__cleanup_hook __finally_hook + // struct __cfaehm_cleanup_hook __finally_hook // __attribute__((cleanup( finally_wrapper ))); @@ -593,12 +593,12 @@ // Skip children? return; - } else if ( structDecl->get_name() == "__cfaabi_ehm__base_exception_t" ) { + } else if ( structDecl->get_name() == "__cfaehm_base_exception_t" ) { assert( nullptr == except_decl ); except_decl = structDecl; init_func_types(); - } else if ( structDecl->get_name() == "__cfaabi_ehm__try_resume_node" ) { + } else if ( structDecl->get_name() == "__cfaehm_try_resume_node" ) { assert( nullptr == node_decl ); node_decl = structDecl; - } else if ( structDecl->get_name() == "__cfaabi_ehm__cleanup_hook" ) { + } else if ( structDecl->get_name() == "__cfaehm_cleanup_hook" ) { assert( nullptr == hook_decl ); hook_decl = structDecl; Index: src/ResolvExpr/Resolver.cc =================================================================== --- src/ResolvExpr/Resolver.cc (revision aa7a56efa9b7cea9c154230c27e862b7ac06fd36) +++ src/ResolvExpr/Resolver.cc (revision a6853358469a8316171d15bf0ad19b3733c00bbc) @@ -9,7 +9,7 @@ // Author : Aaron B. Moss // Created On : Sun May 17 12:17:01 2015 -// Last Modified By : Aaron B. Moss -// Last Modified On : Wed May 29 11:00:00 2019 -// Update Count : 241 +// Last Modified By : Andrew Beach +// Last Modified On : Fri Mar 27 11:58:00 2020 +// Update Count : 242 // @@ -560,5 +560,5 @@ // TODO: Replace *exception type with &exception type. if ( throwStmt->get_expr() ) { - const StructDecl * exception_decl = indexer.lookupStruct( "__cfaabi_ehm__base_exception_t" ); + const StructDecl * exception_decl = indexer.lookupStruct( "__cfaehm_base_exception_t" ); assert( exception_decl ); Type * exceptType = new PointerType( noQualifiers, new StructInstType( noQualifiers, const_cast(exception_decl) ) ); @@ -1477,5 +1477,5 @@ if ( throwStmt->expr ) { const ast::StructDecl * exceptionDecl = - symtab.lookupStruct( "__cfaabi_ehm__base_exception_t" ); + symtab.lookupStruct( "__cfaehm_base_exception_t" ); assert( exceptionDecl ); ast::ptr< ast::Type > exceptType = Index: tests/exceptions/except-mac.hfa =================================================================== --- tests/exceptions/except-mac.hfa (revision aa7a56efa9b7cea9c154230c27e862b7ac06fd36) +++ tests/exceptions/except-mac.hfa (revision a6853358469a8316171d15bf0ad19b3733c00bbc) @@ -7,5 +7,5 @@ // The fully (perhaps overly) qualified name of the base exception type: -#define BASE_EXCEPT __cfaabi_ehm__base_exception_t +#define BASE_EXCEPT __cfaehm_base_exception_t // Get the name of the vtable type and vtable instance for an exception type: