Changes in libcfa/src/exception.c [5715d43:67ca73e]

File:

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

libcfa/src/exception.c

@@ -9 +9 @@
 // Author           : Andrew Beach
 // Created On       : Mon Jun 26 15:13:00 2017
-// Last Modified By : Andrew Beach
-// Last Modified On : Wed Aug 12 13:55:00 2020
-// Update Count     : 21
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sat Aug 15 07:17:19 2020
+// Update Count     : 26
 //
 
@@ -21 +21 @@
 // Implementation of the secret header is hardware dependent.
 #if !( defined( __x86_64 ) || defined( __i386 ) )
-#error Exception Handling: No known architecture detected.
+#elif defined( __ARM_ARCH )
+#warning FIX ME: check if anything needed for ARM
+#else
+#warning Exception Handling: No known architecture detected.
 #endif
 
@@ -28 +31 @@
 #include <unwind.h>
 #include <bits/debug.hfa>
-#include "concurrency/invoke.h"
 #include "stdhdr/assert.h"
 
@@ -59 +61 @@
 
 
+// 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};
+
 // Get the current exception context.
 // There can be a single global until multithreading occurs, then each stack
-// needs its own. We get this from libcfathreads (no weak attribute).
-__attribute__((weak)) struct exception_context_t * this_exception_context() {
-        static struct exception_context_t shared_stack = {NULL, NULL};
+// needs its own. It will have to be updated to handle that.
+struct exception_context_t * this_exception_context() {
         return &shared_stack;
 }
@@ -116 +125 @@
 
 // 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.
@@ -142 +140 @@
 }
 
+// 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 ) {
@@ -155 +164 @@
         }
 
-        // 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 = NULL_MAP(EXCEPT_TO_NODE, context->current_exception);
-        context->current_exception = except_store;
+        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;
 }
 
@@ -179 +188 @@
         if ( context->current_exception == except ) {
                 node = to_free->next;
-                context->current_exception = NULL_MAP(NODE_TO_EXCEPT, node);
+                context->current_exception = (node) ? NODE_TO_EXCEPT(node) : 0;
         } else {
                 node = EXCEPT_TO_NODE(context->current_exception);
@@ -207 +216 @@
         // Verify actions follow the rules we expect.
         verify((actions & _UA_CLEANUP_PHASE) && (actions & _UA_FORCE_UNWIND));
-        verify(!(actions & (_UA_SEARCH_PHASE | _UA_HANDLER_FRAME)));
+        verify(!(actions & (_UA_SEARCH_PHASE | _UA_HANDER_FRAME)));
 
         if ( actions & _UA_END_OF_STACK ) {
@@ -216 +225 @@
 }
 
-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( &cancel_exception_storage, _Stop_Fn, (void*)0x22 );
+        ret = _Unwind_ForcedUnwind( &this_exception_storage, _Stop_Fn, (void*)0x22 );
         printf("UNWIND ERROR %d after force unwind\n", ret);
         abort();
@@ -243 +250 @@
 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
@@ -294 +300 @@
         abort();
 }
-
+#if 0
 // This is our personality routine. For every stack frame annotated with
 // ".cfi_personality 0x3,__gcfa_personality_v0" this function will be called twice when unwinding.
@@ -406 +412 @@
                                 cur_ptr = read_uleb128(cur_ptr, &imatcher);
 
+                                _Unwind_Word match_pos =
 #                               if defined( __x86_64 )
-                                _Unwind_Word match_pos = _Unwind_GetCFA(unwind_context) + 8;
+                                    _Unwind_GetCFA(unwind_context) + 8;
 #                               elif defined( __i386 )
-                                _Unwind_Word match_pos = _Unwind_GetCFA(unwind_context) + 24;
+                                    _Unwind_GetCFA(unwind_context) + 24;
+#                               elif defined( __ARM_ARCH )
+#                                   warning FIX ME: check if anything needed for ARM
+                                    42;
 #                               endif
                                 int (*matcher)(exception_t *) = *(int(**)(exception_t *))match_pos;
@@ -416 +426 @@
                                 _Unwind_Reason_Code ret = (0 == index)
                                         ? _URC_CONTINUE_UNWIND : _URC_HANDLER_FOUND;
-                                UNWIND_TO_NODE(unwind_exception)->handler_index = index;
+                                context->current_handler_index = index;
 
                                 // Based on the return value, check if we matched the exception
@@ -422 +432 @@
                                         __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");
                                 }
@@ -514 +523 @@
         // Exception handler
         // Note: Saving the exception context on the stack breaks termination exceptions.
-        catch_block( EXCEPT_TO_NODE( this_exception_context()->current_exception )->handler_index,
+        catch_block( this_exception_context()->current_handler_index,
                      this_exception_context()->current_exception );
 }
@@ -600 +609 @@
 
 #pragma GCC pop_options
+#endif // 0