Changeset 9236060 for src/libcfa/exception.c

Timestamp:

Aug 14, 2017, 2:03:39 PM (8 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

74b007ba

Parents:

fd344aa (diff), 54cd58b0 (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 references

File:

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

src/libcfa/exception.c

@@ -10 +10 @@
 // Created On       : Mon Jun 26 15:13:00 2017
 // Last Modified By : Andrew Beach
-// Last Modified On : Tus Jul 11 16:36:00 2017
-// Update Count     : 1
+// Last Modified On : Fri Aug  4 15:20:00 2017
+// Update Count     : 6
 //
+
+#include <stddef.h> // for size_t
 
 #include "exception.h"
@@ -22 +24 @@
 #include <unwind.h>
 
+// FIX ME: temporary hack to keep ARM build working
+#ifndef _URC_FATAL_PHASE1_ERROR
+#define _URC_FATAL_PHASE1_ERROR 2
+#endif // ! _URC_FATAL_PHASE1_ERROR
+#ifndef _URC_FATAL_PHASE2_ERROR
+#define _URC_FATAL_PHASE2_ERROR 2
+#endif // ! _URC_FATAL_PHASE2_ERROR
+
 #include "lsda.h"
 
+
+// Base exception vtable is abstract, you should not have base exceptions.
+struct __cfaehm__base_exception_t_vtable
+                ___cfaehm__base_exception_t_vtable_instance = {
+        .parent = NULL,
+        .size = 0,
+        .copy = NULL,
+        .free = NULL,
+        .msg = NULL
+};
+
+
 // Temperary global exception context. Does not work with concurency.
-struct shared_stack_t {
+struct exception_context_t {
     struct __cfaehm__try_resume_node * top_resume;
     struct __cfaehm__try_resume_node * current_resume;
 
-    exception current_exception;
+    exception * current_exception;
     int current_handler_index;
 } shared_stack = {NULL, NULL, 0, 0};
 
-
-
-// This macro should be the only thing that needs to change across machines.
-// Used in the personality function, way down in termination.
+// Get the current exception context.
+// There can be a single global until multithreading occurs, then each stack
+// needs its own. It will have to be updated to handle that.
+struct exception_context_t * this_exception_context() {
+        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;
+//}
+
+
+// This macro should be the only thing that needs to change across machines.  Used in the personality function, way down
+// in termination.
 // struct _Unwind_Context * -> _Unwind_Reason_Code(*)(exception *)
 #define MATCHER_FROM_CONTEXT(ptr_to_context) \
@@ -47 +80 @@
 
         // DEBUG
-        printf("Throwing resumption exception %d\n", *except);
+        printf("Throwing resumption exception\n");
 
         struct __cfaehm__try_resume_node * original_head = shared_stack.current_resume;
@@ -61 +94 @@
         }
 
-        printf("Unhandled exception %d\n", *except);
+        printf("Unhandled exception\n");
         shared_stack.current_resume = original_head;
 
@@ -69 +102 @@
 }
 
-/* Do we control where exceptions get thrown even with concurency?
- * If not these are not quite thread safe, the cleanup hook has to be added
- * after the node is built but before it is made the top node.
- */
+// Do we control where exceptions get thrown even with concurency?  If not these are not quite thread safe, the cleanup
+// 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,
                         int (*handler)(exception * except)) {
@@ -87 +119 @@
 // TERMINATION ===============================================================
 
-// Requires -fexceptions to work.
-
-// Global which defines the current exception
-// Currently an int just to make matching easier
-//int this_exception; (became shared_stack.current_exception)
+// MEMORY MANAGEMENT (still for integers)
+// May have to move to cfa for constructors and destructors (references).
+
+struct __cfaehm__node {
+        struct __cfaehm__node * next;
+};
+
+#define NODE_TO_EXCEPT(node) ((exception *)(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 * 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 );
+
+        if ( ! store ) {
+                // Failure: cannot allocate exception. Terminate thread.
+                abort(); // <- Although I think it might be the process.
+        }
+
+        // Add the node to the list:
+        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 );
+}
+
+// Delete the provided exception, unsetting current_exception if relivant.
+static void __cfaehm__delete_exception( exception * except ) {
+        struct exception_context_t * context = this_exception_context();
+
+        // DEBUG
+        printf( "Deleting Exception\n");
+
+        // Remove the exception from the list.
+        struct __cfaehm__node * to_free = EXCEPT_TO_NODE(except);
+        struct __cfaehm__node * node;
+
+        if ( context->current_exception == except ) {
+                node = to_free->next;
+                context->current_exception = (node) ? NODE_TO_EXCEPT(node) : 0;
+        } else {
+                node = EXCEPT_TO_NODE(context->current_exception);
+                // It may always be in the first or second position.
+                while( to_free != node->next ) {
+                        node = node->next;
+                }
+                node->next = to_free->next;
+        }
+
+        // Free the old exception node.
+        except->virtual_table->free( except );
+        free( to_free );
+}
+
+// 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 );
+}
+
 
 // We need a piece of storage to raise the exception
@@ -111 +202 @@
 }
 
-void __cfaehm__throw_terminate( exception * val ) {
-        // Store the current exception
-        shared_stack.current_exception = *val;
-
-        // DEBUG
-        printf("Throwing termination exception %d\n", *val);
+// The exception that is being thrown must already be stored.
+__attribute__((noreturn)) void __cfaehm__begin_unwind(void) {
+        if ( ! this_exception_context()->current_exception ) {
+                printf("UNWIND ERROR missing exception in begin unwind\n");
+                abort();
+        }
+
 
         // Call stdlibc to raise the exception
         _Unwind_Reason_Code ret = _Unwind_RaiseException( &this_exception_storage );
 
-        // If we reach here it means something happened
-        // For resumption to work we need to find a way to return back to here
-        // Most of them will probably boil down to setting a global flag and making the phase 1 either stop or fail.
-        // Causing an error on purpose may help avoiding unnecessary work but it might have some weird side effects.
-        // If we just pretend no handler was found that would work but may be expensive for no reason since we will always
-        // search the whole stack
+        // If we reach here it means something happened.  For resumption to work we need to find a way to return back to
+        // here.  Most of them will probably boil down to setting a global flag and making the phase 1 either stop or
+        // fail.  Causing an error on purpose may help avoiding unnecessary work but it might have some weird side
+        // effects.  If we just pretend no handler was found that would work but may be expensive for no reason since we
+        // will always search the whole stack.
 
         if( ret == _URC_END_OF_STACK ) {
-                // No proper handler was found
-                // This can be handled in several way
-                // C++ calls std::terminate
-                // Here we force unwind the stack, basically raising a cancellation
+                // No proper handler was found.  This can be handled in several way.  C++ calls std::terminate Here we
+                // force unwind the stack, basically raising a cancellation.
                 printf("Uncaught exception %p\n", &this_exception_storage);
 
@@ -140 +229 @@
         }
 
-        // We did not simply reach the end of the stack without finding a handler,
-        // Something wen't wrong
+        // We did not simply reach the end of the stack without finding a handler.  Something wen't wrong
         printf("UNWIND ERROR %d after raise exception\n", ret);
         abort();
 }
 
-// Nesting this the other way would probably be faster.
+void __cfaehm__throw_terminate( exception * val ) {
+        // DEBUG
+        printf("Throwing termination exception\n");
+
+        __cfaehm__allocate_exception( val );
+        __cfaehm__begin_unwind();
+}
+
 void __cfaehm__rethrow_terminate(void) {
         // DEBUG
         printf("Rethrowing termination exception\n");
 
-        __cfaehm__throw_terminate(&shared_stack.current_exception);
-}
-
-// This is our personality routine
-// For every stack frame anotated with ".cfi_personality 0x3,__gcfa_personality_v0"
-// This function will be called twice when unwinding
-// Once in the search phased and once in the cleanup phase
+        __cfaehm__begin_unwind();
+}
+
+// This is our personality routine.  For every stack frame anotated with ".cfi_personality 0x3,__gcfa_personality_v0".
+// This function will be called twice when unwinding.  Once in the search phased and once in the cleanup phase.
 _Unwind_Reason_Code __gcfa_personality_v0 (
                 int version, _Unwind_Action actions, unsigned long long exceptionClass,
@@ -263 +356 @@
                                         _Unwind_Reason_Code (*matcher)(exception *) =
                                                 MATCHER_FROM_CONTEXT(context);
-                                        int index = matcher(&shared_stack.current_exception);
+                                        int index = matcher(shared_stack.current_exception);
                                         _Unwind_Reason_Code ret = (0 == index)
                                                 ? _URC_CONTINUE_UNWIND : _URC_HANDLER_FOUND;
@@ -293 +386 @@
                                 // 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 );
+                                _Unwind_SetIP( context, ((lsd_info.LPStart) + (callsite_landing_pad)) );
 
                                 // DEBUG
@@ -317 +410 @@
 }
 
-// Try statements are hoisted out see comments for details
-// With this could probably be unique and simply linked from
-// libcfa but there is one problem left, see the exception table
-// for details
+// Try statements are hoisted out see comments for details.  With this could probably be unique and simply linked from
+// libcfa but there is one problem left, see the exception table for details
 __attribute__((noinline))
 void __cfaehm__try_terminate(void (*try_block)(),
@@ -328 +419 @@
         //! 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 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
         asm volatile (".cfi_personality 0x3,__gcfa_personality_v0");
@@ -340 +429 @@
         asm volatile (".cfi_lsda 0x3, .LLSDACFA2");
 
-        // Label which defines the start of the area for which the handler is setup
+        // Label which defines the start of the area for which the handler is setup.
         asm volatile (".TRYSTART:");
 
@@ -354 +443 @@
         // Exceptionnal path
         CATCH : __attribute__(( unused ));
-        // Label which defines the end of the area for which the handler is setup
+        // 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 will be 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);
-}
-
-// Exception table data we need to generate
-// While this is almost generic, the custom data refers to
-// foo_try_match try match, which is no way generic
-// Some more works need to be done if we want to have a single
-// call to the try routine
+        catch_block( shared_stack.current_handler_index,
+                     shared_stack.current_exception );
+}
+
+// Exception table data we need to generate.  While this is almost generic, the custom data refers to foo_try_match try
+// match, which is no way generic.  Some more works need to be done if we want to have a single call to the try routine.
+
+#if defined( __x86_64__ ) || defined( __i386__ )
 asm (
         //HEADER
@@ -394 +481 @@
 //      "       .section        .note.GNU-stack,\"x\",@progbits\n"
 );
+#endif // __x86_64__ || __i386__