Changes in / [136f86b:68887f9]

File:

• libcfa/src/exception.c (modified) (15 diffs)

libcfa/src/exception.c

@@ -58 +58 @@
     exception_t * current_exception;
     int current_handler_index;
-} shared_stack = {NULL, NULL, 0, 0};
+} static shared_stack = {NULL, NULL, NULL, 0};
 
 // Get the current exception context.
@@ -66 +66 @@
         return &shared_stack;
 }
-//#define SAVE_EXCEPTION_CONTEXT(to_name)
-//struct exception_context_t * to_name = this_exception_context();
-//exception * this_exception() {
-//    return this_exception_context()->current_exception;
-//}
 
 
@@ -76 +71 @@
 
 void __cfaabi_ehm__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 = shared_stack.current_resume;
+        struct __cfaabi_ehm__try_resume_node * original_head = context->current_resume;
         struct __cfaabi_ehm__try_resume_node * current =
-                (original_head) ? original_head->next : shared_stack.top_resume;
+                (original_head) ? original_head->next : context->top_resume;
 
         for ( ; current ; current = current->next) {
-                shared_stack.current_resume = current;
+                context->current_resume = current;
                 if (current->handler(except)) {
-                        shared_stack.current_resume = original_head;
+                        context->current_resume = original_head;
                         return;
                 }
@@ -92 +88 @@
 
         __cfaabi_dbg_print_safe("Unhandled exception\n");
-        shared_stack.current_resume = original_head;
+        context->current_resume = original_head;
 
         // Fall back to termination:
@@ -105 +101 @@
 void __cfaabi_ehm__try_resume_setup(struct __cfaabi_ehm__try_resume_node * node,
                         _Bool (*handler)(exception_t * except)) {
-        node->next = shared_stack.top_resume;
+        struct exception_context_t * context = this_exception_context();
+        node->next = context->top_resume;
         node->handler = handler;
-        shared_stack.top_resume = node;
+        context->top_resume = node;
 }
 
 void __cfaabi_ehm__try_resume_cleanup(struct __cfaabi_ehm__try_resume_node * node) {
-        shared_stack.top_resume = node->next;
+        struct exception_context_t * context = this_exception_context();
+        context->top_resume = node->next;
 }
 
@@ -164 +162 @@
                 node = EXCEPT_TO_NODE(context->current_exception);
                 // It may always be in the first or second position.
-                while( to_free != node->next ) {
+                while ( to_free != node->next ) {
                         node = node->next;
                 }
@@ -191 +189 @@
                 _Unwind_Exception_Class exceptionClass,
                 struct _Unwind_Exception * unwind_exception,
-                struct _Unwind_Context * context,
-                void * some_param) {
-        if( actions & _UA_END_OF_STACK  ) exit(1);
-        if( actions & _UA_CLEANUP_PHASE ) return _URC_NO_REASON;
+                struct _Unwind_Context * unwind_context,
+                void * stop_param) {
+        if ( actions & _UA_END_OF_STACK  ) exit(1);
+        if ( actions & _UA_CLEANUP_PHASE ) return _URC_NO_REASON;
 
         return _URC_FATAL_PHASE2_ERROR;
@@ -217 +215 @@
         // the whole stack.
 
-        if( ret == _URC_END_OF_STACK ) {
+        if ( ret == _URC_END_OF_STACK ) {
                 // No proper handler was found. This can be handled in many ways, C++ calls std::terminate.
                 // Here we force unwind the stack, basically raising a cancellation.
@@ -251 +249 @@
                 int version, _Unwind_Action actions, unsigned long long exceptionClass,
                 struct _Unwind_Exception* unwind_exception,
-                struct _Unwind_Context* context)
+                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, context);
+                        version, actions, exceptionClass, unwind_exception, unwind_context);
 
         // If we've reached the end of the stack then there is nothing much we can do...
-        if( actions & _UA_END_OF_STACK ) return _URC_END_OF_STACK;
+        if (actions & _UA_END_OF_STACK) return _URC_END_OF_STACK;
 
         if (actions & _UA_SEARCH_PHASE) {
@@ -274 +272 @@
 
         // Get a pointer to the language specific data from which we will read what we need
-        const unsigned char * lsd = (const unsigned char*) _Unwind_GetLanguageSpecificData( context );
-
-        if( !lsd ) {    //Nothing to do, keep unwinding
+        const unsigned char * lsd = _Unwind_GetLanguageSpecificData( unwind_context );
+
+        if ( !lsd ) {   //Nothing to do, keep unwinding
                 printf(" no LSD");
                 goto UNWIND;
@@ -283 +281 @@
         // Get the instuction pointer and a reading pointer into the exception table
         lsda_header_info lsd_info;
-        const unsigned char * cur_ptr = parse_lsda_header(context, lsd, &lsd_info);
-        _Unwind_Ptr instruction_ptr = _Unwind_GetIP( context );
+        const unsigned char * cur_ptr = parse_lsda_header(unwind_context, lsd, &lsd_info);
+        _Unwind_Ptr instruction_ptr = _Unwind_GetIP(unwind_context);
+
+        struct exception_context_t * context = this_exception_context();
 
         // Linearly search the table for stuff to do
-        while( cur_ptr < lsd_info.action_table ) {
+        while ( cur_ptr < lsd_info.action_table ) {
                 _Unwind_Ptr callsite_start;
                 _Unwind_Ptr callsite_len;
@@ -300 +300 @@
 
                 // Have we reach the correct frame info yet?
-                if( lsd_info.Start + callsite_start + callsite_len < instruction_ptr ) {
+                if ( lsd_info.Start + callsite_start + callsite_len < instruction_ptr ) {
 #ifdef __CFA_DEBUG_PRINT__
                         void * ls = (void*)lsd_info.Start;
@@ -315 +315 @@
 
                 // Have we gone too far?
-                if( lsd_info.Start + callsite_start > instruction_ptr ) {
+                if ( lsd_info.Start + callsite_start > instruction_ptr ) {
                         printf(" gone too far");
                         break;
                 }
 
-                // Something to do?
-                if( callsite_landing_pad ) {
-                        // Which phase are we in
-                        if (actions & _UA_SEARCH_PHASE) {
-                                // In search phase, these means we found a potential handler we must check.
-
-                                // We have arbitrarily decided that 0 means nothing to do and 1 means there is
-                                // a potential handler. This doesn't seem to conflict the gcc default behavior.
-                                if (callsite_action != 0) {
-                                        // Now we want to run some code to see if the handler matches
-                                        // This is the tricky part where we want to the power to run arbitrary code
-                                        // However, generating a new exception table entry and try routine every time
-                                        // is way more expansive than we might like
-                                        // The information we have is :
-                                        //  - The GR (Series of registers)
-                                        //    GR1=GP Global Pointer of frame ref by context
-                                        //  - The instruction pointer
-                                        //  - The instruction pointer info (???)
-                                        //  - The CFA (Canonical Frame Address)
-                                        //  - The BSP (Probably the base stack pointer)
-
-
-                                        // The current apprach uses one exception table entry per try block
-                                        _uleb128_t imatcher;
-                                        // Get the relative offset to the {...}?
-                                        cur_ptr = read_uleb128(cur_ptr, &imatcher);
-
-#                                       if defined( __x86_64 )
-                                        _Unwind_Word match_pos = _Unwind_GetCFA(context) + 8;
-#                                       elif defined( __i386 )
-                                        _Unwind_Word match_pos = _Unwind_GetCFA(context) + 24;
-#                                       endif
-                                        int (*matcher)(exception_t *) = *(int(**)(exception_t *))match_pos;
-
-                                        int index = matcher(shared_stack.current_exception);
-                                        _Unwind_Reason_Code ret = (0 == index)
-                                                ? _URC_CONTINUE_UNWIND : _URC_HANDLER_FOUND;
-                                        shared_stack.current_handler_index = index;
-
-                                        // Based on the return value, check if we matched the exception
-                                        if( ret == _URC_HANDLER_FOUND) {
-                                                __cfaabi_dbg_print_safe(" handler found\n");
-                                        } else {
-                                                __cfaabi_dbg_print_safe(" no handler\n");
-                                        }
-                                        return ret;
+                // Check for what we must do:
+                if ( 0 == callsite_landing_pad ) {
+                        // Nothing to do, move along
+                        __cfaabi_dbg_print_safe(" no landing pad");
+                } else if (actions & _UA_SEARCH_PHASE) {
+                        // In search phase, these means we found a potential handler we must check.
+
+                        // We have arbitrarily decided that 0 means nothing to do and 1 means there is
+                        // a potential handler. This doesn't seem to conflict the gcc default behavior.
+                        if (callsite_action != 0) {
+                                // Now we want to run some code to see if the handler matches
+                                // This is the tricky part where we want to the power to run arbitrary code
+                                // However, generating a new exception table entry and try routine every time
+                                // is way more expansive than we might like
+                                // The information we have is :
+                                //  - The GR (Series of registers)
+                                //    GR1=GP Global Pointer of frame ref by context
+                                //  - The instruction pointer
+                                //  - The instruction pointer info (???)
+                                //  - The CFA (Canonical Frame Address)
+                                //  - The BSP (Probably the base stack pointer)
+
+
+                                // The current apprach uses one exception table entry per try block
+                                _uleb128_t imatcher;
+                                // Get the relative offset to the {...}?
+                                cur_ptr = read_uleb128(cur_ptr, &imatcher);
+
+#                               if defined( __x86_64 )
+                                _Unwind_Word match_pos = _Unwind_GetCFA(unwind_context) + 8;
+#                               elif defined( __i386 )
+                                _Unwind_Word match_pos = _Unwind_GetCFA(unwind_context) + 24;
+#                               endif
+                                int (*matcher)(exception_t *) = *(int(**)(exception_t *))match_pos;
+
+                                int index = matcher(context->current_exception);
+                                _Unwind_Reason_Code ret = (0 == index)
+                                        ? _URC_CONTINUE_UNWIND : _URC_HANDLER_FOUND;
+                                context->current_handler_index = index;
+
+                                // Based on the return value, check if we matched the exception
+                                if (ret == _URC_HANDLER_FOUND) {
+                                        __cfaabi_dbg_print_safe(" handler found\n");
+                                } else {
+                                        __cfaabi_dbg_print_safe(" no handler\n");
                                 }
-
-                                // This is only a cleanup handler, ignore it
-                                __cfaabi_dbg_print_safe(" no action");
+                                return ret;
                         }
-                        else if (actions & _UA_CLEANUP_PHASE) {
-
-                                if( (callsite_action != 0) && !(actions & _UA_HANDLER_FRAME) ){
-                                        // If this is a potential exception handler
-                                        // but not the one that matched the exception in the seach phase,
-                                        // just ignore it
-                                        goto UNWIND;
-                                }
-
-                                // We need to run some clean-up or a handler
-                                // These statment do the right thing but I don't know any specifics at all
-                                _Unwind_SetGR( context, __builtin_eh_return_data_regno(0), (_Unwind_Ptr) unwind_exception );
-                                _Unwind_SetGR( context, __builtin_eh_return_data_regno(1), 0 );
-
-                                // I assume this sets the instruction pointer to the adress of the landing pad
-                                // It doesn't actually set it, it only state the value that needs to be set once we return _URC_INSTALL_CONTEXT
-                                _Unwind_SetIP( context, ((lsd_info.LPStart) + (callsite_landing_pad)) );
-
-                                __cfaabi_dbg_print_safe(" action\n");
-
-                                // Return have some action to run
-                                return _URC_INSTALL_CONTEXT;
+
+                        // This is only a cleanup handler, ignore it
+                        __cfaabi_dbg_print_safe(" no action");
+                } else if (actions & _UA_CLEANUP_PHASE) {
+                        // In clean-up phase, no destructors here but this could be the handler.
+
+                        if ( (callsite_action != 0) && !(actions & _UA_HANDLER_FRAME) ){
+                                // If this is a potential exception handler
+                                // but not the one that matched the exception in the seach phase,
+                                // just ignore it
+                                goto UNWIND;
                         }
+
+                        // We need to run some clean-up or a handler
+                        // These statment do the right thing but I don't know any specifics at all
+                        _Unwind_SetGR( unwind_context, __builtin_eh_return_data_regno(0),
+                                (_Unwind_Ptr)unwind_exception );
+                        _Unwind_SetGR( unwind_context, __builtin_eh_return_data_regno(1), 0 );
+
+                        // I assume this sets the instruction pointer to the adress of the landing pad
+                        // It doesn't actually set it, it only state the value that needs to be set once we
+                        // return _URC_INSTALL_CONTEXT
+                        _Unwind_SetIP( unwind_context, ((lsd_info.LPStart) + (callsite_landing_pad)) );
+
+                        __cfaabi_dbg_print_safe(" action\n");
+
+                        // Return have some action to run
+                        return _URC_INSTALL_CONTEXT;
                 }
-
-                // Nothing to do, move along
-                __cfaabi_dbg_print_safe(" no landing pad");
         }
         // No handling found
@@ -421 +420 @@
         //! printf("%p %p %p %p\n", &try_block, &catch_block, &match_block, &xy);
 
-        // Setup statments: These 2 statments won't actually result in any code, they only setup global tables.
-        // However, they clobber gcc cancellation support from gcc.  We can replace the personality routine but
-        // replacing the exception table gcc generates is not really doable, it generates labels based on how the
-        // assembly works.
-
         // Setup the personality routine and exception table.
+        // Unforturnately these clobber gcc cancellation support which means we can't get access to
+        // the attribute cleanup tables at the same time. We would have to inspect the assembly to
+        // create a new set ourselves.
 #ifdef __PIC__
         asm volatile (".cfi_personality 0x9b,CFA.ref.__gcfa_personality_v0");
@@ -451 +448 @@
         // Label which defines the end of the area for which the handler is setup.
         asm volatile (".TRYEND:");
-        // Label which defines the start of the exception landing pad.  Basically what is called when the exception is
-        // caught.  Note, if multiple handlers are given, the multiplexing should be done by the generated code, not the
-        // exception runtime.
+        // Label which defines the start of the exception landing pad. Basically what is called when
+        // the exception is caught. Note, if multiple handlers are given, the multiplexing should be
+        // done by the generated code, not the exception runtime.
         asm volatile (".CATCH:");
 
         // Exception handler
-        catch_block( shared_stack.current_handler_index,
-                     shared_stack.current_exception );
+        // Note: Saving the exception context on the stack breaks termination exceptions.
+        catch_block( this_exception_context()->current_handler_index,
+                     this_exception_context()->current_exception );
 }