Changeset 79dbb79 for src/libcfa

Timestamp:

Jul 28, 2017, 2:26:29 PM (7 years ago)

Author:

Peter A. Buhr <pabuhr@…>

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:

926341c, ea5023c

Parents:

59310bf (diff), 86d5ba7c (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' of plg2:software/cfa/cfa-cc

Location:

src/libcfa

Files:

• exception.c (modified) (7 diffs)
• exception.h (modified) (4 diffs)

src/libcfa/exception.c

@@ -9 +9 @@
 // Author           : Andrew Beach
 // Created On       : Mon Jun 26 15:13:00 2017
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Jul 26 10:37:51 2017
-// Update Count     : 2
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Jul 28 12:41:00 2017
+// Update Count     : 3
 //
 
@@ -33 +33 @@
 
 // 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};
-
+
+        // Storage to avoid using the heap for exceptions.
+        exception built_in_storage;
+} shared_stack = {NULL, NULL, 0, 0, 0};
+
+// 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;
+//}
 
 
@@ -94 +108 @@
 // 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.
+
+// 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();
+
+        // Try to use the context's store, otherwise use the heap.
+        if ( 0 == context->built_in_storage ) {
+                context->current_exception = &context->built_in_storage;
+        } else {
+                exception * new_copy = malloc( sizeof( exception/*int*/ ) );
+                if ( ! new_copy ) {
+                        // Failure: cannot allocate exception. Terminate thread.
+                        exit(1); // <- thread or program?
+                }
+                context->current_exception = new_copy;
+        }
+
+        // Copy the exception to storage.
+        *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 %d (%s)\n", *except,
+                (&context->built_in_storage == except) ? "builtin" : "dynamic" );
+
+        if ( context->current_exception == except ) {
+                // TODO: This should restore it to the last exception.
+                context->current_exception = NULL;
+        }
+        if ( &context->built_in_storage == except ) {
+                // You can't throw the exception '0'.
+                context->built_in_storage = 0;
+        } else {
+                // Only secondary or too large exceptions are thrown.
+                free( except );
+        }
+}
+
+// If this isn't a rethrow (*except==0), delete the provided exception.
+void __cfaehm__cleanup_terminate( exception ** except ) {
+        if ( *except ) __cfaehm__delete_exception( *except );
+}
+
 
 // We need a piece of storage to raise the exception
@@ -117 +176 @@
 }
 
-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
@@ -148 +208 @@
 }
 
-// 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);
+        __cfaehm__begin_unwind();
 }
 
@@ -263 +330 @@
                                         _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;
@@ -359 +426 @@
         // Exception handler
         catch_block( shared_stack.current_handler_index,
-                    &shared_stack.current_exception );
+                     shared_stack.current_exception );
 }
 

src/libcfa/exception.h

@@ -9 +9 @@
 // Author           : Andrew Beach
 // Created On       : Mon Jun 26 15:11:00 2017
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jul 22 09:57:02 2017
-// Update Count     : 3
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Jul 27 12:42:00 2017
+// Update Count     : 4
 //
 
 #pragma once
 
-// Later to be a special structure type.
-typedef int exception;
 
 #ifdef __CFORALL__
 extern "C" {
 #endif
+
+#if 1
+typedef int exception;
+#else
+struct exception_t;
+struct exception_t_vtable {
+        struct exception_t_vtable const * parent;
+        size_t size;
+        void (*copy)(struct exception_t *this, struct exception_t * other);
+        void (*free)(struct exception_t *this);
+        const char (*msg)(struct exception_t *this);
+};
+struct exception_t {
+        struct exception_vtable const * virtual_table;
+};
+typedef struct exception_t exception;
+#endif
+
 
 // Used in throw statement translation.
@@ -34 +50 @@
     int (*match_block)(exception * except));
 
+// Clean-up the exception in catch blocks.
+void __cfaehm__cleanup_terminate(exception ** except);
+
 // Data structure creates a list of resume handlers.
 struct __cfaehm__try_resume_node {
@@ -40 +59 @@
 };
 
+// These act as constructor and destructor for the resume node.
 void __cfaehm__try_resume_setup(
     struct __cfaehm__try_resume_node * node,
@@ -47 +67 @@
 
 // Check for a standard way to call fake deconstructors.
-struct __cfaehm__cleanup_hook {
-};
+struct __cfaehm__cleanup_hook {};
 
 #ifdef __CFORALL__