Changeset c13e8dc8 for src/libcfa/exception.c

Timestamp:

Dec 5, 2017, 2:35:03 PM (8 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, arm-eh, ast-experimental, cleanup-dtors, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

f9feab8

Parents:

9c35431 (diff), 65197c2 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' into cleanup-dtors

File:

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

src/libcfa/exception.c

@@ -23 +23 @@
 #include <stdio.h>
 #include <unwind.h>
-#include <libhdr/libdebug.h>
+#include <bits/debug.h>
 
 // FIX ME: temporary hack to keep ARM build working
@@ -37 +37 @@
 
 // Base exception vtable is abstract, you should not have base exceptions.
-struct __cfaehm__base_exception_t_vtable
-                ___cfaehm__base_exception_t_vtable_instance = {
+struct __cfaabi_ehm__base_exception_t_vtable
+                ___cfaabi_ehm__base_exception_t_vtable_instance = {
         .parent = NULL,
         .size = 0,
@@ -49 +49 @@
 // Temperary global exception context. Does not work with concurency.
 struct exception_context_t {
-    struct __cfaehm__try_resume_node * top_resume;
-    struct __cfaehm__try_resume_node * current_resume;
+    struct __cfaabi_ehm__try_resume_node * top_resume;
+    struct __cfaabi_ehm__try_resume_node * current_resume;
 
     exception * current_exception;
@@ -78 +78 @@
 // RESUMPTION ================================================================
 
-void __cfaehm__throw_resume(exception * except) {
-
-        LIB_DEBUG_PRINT_SAFE("Throwing resumption exception\n");
-
-        struct __cfaehm__try_resume_node * original_head = shared_stack.current_resume;
-        struct __cfaehm__try_resume_node * current =
+void __cfaabi_ehm__throw_resume(exception * except) {
+
+        __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 * current =
                 (original_head) ? original_head->next : shared_stack.top_resume;
 
@@ -94 +94 @@
         }
 
-        LIB_DEBUG_PRINT_SAFE("Unhandled exception\n");
+        __cfaabi_dbg_print_safe("Unhandled exception\n");
         shared_stack.current_resume = original_head;
 
         // Fall back to termination:
-        __cfaehm__throw_terminate(except);
+        __cfaabi_ehm__throw_terminate(except);
         // TODO: Default handler for resumption.
 }
@@ -105 +105 @@
 // hook has to be added after the node is built but before it is made the top node.
 
-void __cfaehm__try_resume_setup(struct __cfaehm__try_resume_node * node,
+void __cfaabi_ehm__try_resume_setup(struct __cfaabi_ehm__try_resume_node * node,
                         _Bool (*handler)(exception * except)) {
         node->next = shared_stack.top_resume;
@@ -112 +112 @@
 }
 
-void __cfaehm__try_resume_cleanup(struct __cfaehm__try_resume_node * node) {
+void __cfaabi_ehm__try_resume_cleanup(struct __cfaabi_ehm__try_resume_node * node) {
         shared_stack.top_resume = node->next;
 }
@@ -122 +122 @@
 // May have to move to cfa for constructors and destructors (references).
 
-struct __cfaehm__node {
-        struct __cfaehm__node * next;
+struct __cfaabi_ehm__node {
+        struct __cfaabi_ehm__node * next;
 };
 
 #define NODE_TO_EXCEPT(node) ((exception *)(1 + (node)))
-#define EXCEPT_TO_NODE(except) ((struct __cfaehm__node *)(except) - 1)
+#define EXCEPT_TO_NODE(except) ((struct __cfaabi_ehm__node *)(except) - 1)
 
 // Creates a copy of the indicated exception and sets current_exception to it.
-static void __cfaehm__allocate_exception( exception * except ) {
+static void __cfaabi_ehm__allocate_exception( exception * except ) {
         struct exception_context_t * context = this_exception_context();
 
         // Allocate memory for the exception.
-        struct __cfaehm__node * store = malloc(
-                sizeof( struct __cfaehm__node ) + except->virtual_table->size );
+        struct __cfaabi_ehm__node * store = malloc(
+                sizeof( struct __cfaabi_ehm__node ) + except->virtual_table->size );
 
         if ( ! store ) {
@@ -151 +151 @@
 
 // Delete the provided exception, unsetting current_exception if relivant.
-static void __cfaehm__delete_exception( exception * except ) {
+static void __cfaabi_ehm__delete_exception( exception * except ) {
         struct exception_context_t * context = this_exception_context();
 
-        LIB_DEBUG_PRINT_SAFE("Deleting Exception\n");
+        __cfaabi_dbg_print_safe("Deleting Exception\n");
 
         // Remove the exception from the list.
-        struct __cfaehm__node * to_free = EXCEPT_TO_NODE(except);
-        struct __cfaehm__node * node;
+        struct __cfaabi_ehm__node * to_free = EXCEPT_TO_NODE(except);
+        struct __cfaabi_ehm__node * node;
 
         if ( context->current_exception == except ) {
@@ -178 +178 @@
 
 // If this isn't a rethrow (*except==0), delete the provided exception.
-void __cfaehm__cleanup_terminate( void * except ) {
-        if ( *(void**)except ) __cfaehm__delete_exception( *(exception**)except );
+void __cfaabi_ehm__cleanup_terminate( void * except ) {
+        if ( *(void**)except ) __cfaabi_ehm__delete_exception( *(exception**)except );
 }
 
@@ -202 +202 @@
 
 // The exception that is being thrown must already be stored.
-__attribute__((noreturn)) void __cfaehm__begin_unwind(void) {
+__attribute__((noreturn)) void __cfaabi_ehm__begin_unwind(void) {
         if ( ! this_exception_context()->current_exception ) {
                 printf("UNWIND ERROR missing exception in begin unwind\n");
@@ -233 +233 @@
 }
 
-void __cfaehm__throw_terminate( exception * val ) {
-        LIB_DEBUG_PRINT_SAFE("Throwing termination exception\n");
-
-        __cfaehm__allocate_exception( val );
-        __cfaehm__begin_unwind();
-}
-
-void __cfaehm__rethrow_terminate(void) {
-        LIB_DEBUG_PRINT_SAFE("Rethrowing termination exception\n");
-
-        __cfaehm__begin_unwind();
+void __cfaabi_ehm__throw_terminate( exception * val ) {
+        __cfaabi_dbg_print_safe("Throwing termination exception\n");
+
+        __cfaabi_ehm__allocate_exception( val );
+        __cfaabi_ehm__begin_unwind();
+}
+
+void __cfaabi_ehm__rethrow_terminate(void) {
+        __cfaabi_dbg_print_safe("Rethrowing termination exception\n");
+
+        __cfaabi_ehm__begin_unwind();
 }
 
@@ -254 +254 @@
 {
 
-        //LIB_DEBUG_PRINT_SAFE("CFA: 0x%lx\n", _Unwind_GetCFA(context));
-        LIB_DEBUG_PRINT_SAFE("Personality function (%d, %x, %llu, %p, %p):", version, actions, exceptionClass, unwind_exception, 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);
 
         // If we've reached the end of the stack then there is nothing much we can do...
@@ -261 +261 @@
 
         if (actions & _UA_SEARCH_PHASE) {
-                LIB_DEBUG_PRINT_SAFE(" lookup phase");
+                __cfaabi_dbg_print_safe(" lookup phase");
         }
         else if (actions & _UA_CLEANUP_PHASE) {
-                LIB_DEBUG_PRINT_SAFE(" cleanup phase");
+                __cfaabi_dbg_print_safe(" cleanup phase");
         }
         // Just in case, probably can't actually happen
@@ -307 +307 @@
                         void * ep = (void*)lsd_info.Start + callsite_start + callsite_len;
                         void * ip = (void*)instruction_ptr;
-                        LIB_DEBUG_PRINT_SAFE("\nfound %p - %p (%p, %p, %p), looking for %p\n", bp, ep, ls, cs, cl, ip);
+                        __cfaabi_dbg_print_safe("\nfound %p - %p (%p, %p, %p), looking for %p\n", bp, ep, ls, cs, cl, ip);
 #endif // __CFA_DEBUG_PRINT__
                         continue;
@@ -346 +346 @@
 
                                         // Get a function pointer from the relative offset and call it
-                                        // _Unwind_Reason_Code (*matcher)() = (_Unwind_Reason_Code (*)())lsd_info.LPStart + imatcher;                                   
+                                        // _Unwind_Reason_Code (*matcher)() = (_Unwind_Reason_Code (*)())lsd_info.LPStart + imatcher;
 
                                         _Unwind_Reason_Code (*matcher)(exception *) =
@@ -357 +357 @@
                                         // Based on the return value, check if we matched the exception
                                         if( ret == _URC_HANDLER_FOUND) {
-                                                LIB_DEBUG_PRINT_SAFE(" handler found\n");
+                                                __cfaabi_dbg_print_safe(" handler found\n");
                                         } else {
-                                                LIB_DEBUG_PRINT_SAFE(" no handler\n");
+                                                __cfaabi_dbg_print_safe(" no handler\n");
                                         }
                                         return ret;
@@ -365 +365 @@
 
                                 // This is only a cleanup handler, ignore it
-                                LIB_DEBUG_PRINT_SAFE(" no action");
+                                __cfaabi_dbg_print_safe(" no action");
                         }
                         else if (actions & _UA_CLEANUP_PHASE) {
@@ -385 +385 @@
                                 _Unwind_SetIP( context, ((lsd_info.LPStart) + (callsite_landing_pad)) );
 
-                                LIB_DEBUG_PRINT_SAFE(" action\n");
+                                __cfaabi_dbg_print_safe(" action\n");
 
                                 // Return have some action to run
@@ -393 +393 @@
 
                 // Nothing to do, move along
-                LIB_DEBUG_PRINT_SAFE(" no landing pad");
+                __cfaabi_dbg_print_safe(" no landing pad");
         }
         // No handling found
-        LIB_DEBUG_PRINT_SAFE(" table end reached\n");
+        __cfaabi_dbg_print_safe(" table end reached\n");
 
         UNWIND:
-        LIB_DEBUG_PRINT_SAFE(" unwind\n");
+        __cfaabi_dbg_print_safe(" unwind\n");
 
         // Keep unwinding the stack
@@ -408 +408 @@
 // libcfa but there is one problem left, see the exception table for details
 __attribute__((noinline))
-void __cfaehm__try_terminate(void (*try_block)(),
+void __cfaabi_ehm__try_terminate(void (*try_block)(),
                 void (*catch_block)(int index, exception * except),
                 __attribute__((unused)) int (*match_block)(exception * except)) {
@@ -466 +466 @@
         // Body uses language specific data and therefore could be modified arbitrarily
         ".LLSDACSBCFA2:\n"                                              // BODY start
-        "       .uleb128 .TRYSTART-__cfaehm__try_terminate\n"           // Handled area start  (relative to start of function)
+        "       .uleb128 .TRYSTART-__cfaabi_ehm__try_terminate\n"               // Handled area start  (relative to start of function)
         "       .uleb128 .TRYEND-.TRYSTART\n"                           // Handled area length
-        "       .uleb128 .CATCH-__cfaehm__try_terminate\n"                              // Hanlder landing pad adress  (relative to start of function)
+        "       .uleb128 .CATCH-__cfaabi_ehm__try_terminate\n"                          // Hanlder landing pad adress  (relative to start of function)
         "       .uleb128 1\n"                                           // Action code, gcc seems to use always 0
         ".LLSDACSECFA2:\n"                                              // BODY end
         "       .text\n"                                                        // TABLE footer
-        "       .size   __cfaehm__try_terminate, .-__cfaehm__try_terminate\n"
+        "       .size   __cfaabi_ehm__try_terminate, .-__cfaabi_ehm__try_terminate\n"
         "       .ident  \"GCC: (Ubuntu 6.2.0-3ubuntu11~16.04) 6.2.0 20160901\"\n"
 //      "       .section        .note.GNU-stack,\"x\",@progbits\n"