Changeset badd22f

Timestamp:

Aug 13, 2020, 9:09:32 PM (4 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

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

Children:

4c925cd, 6553828

Parents:

67bfc50 (diff), 62502cc4 (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 plg.uwaterloo.ca:software/cfa/cfa-cc into master

Files:

• libcfa/src/concurrency/invoke.h (modified) (3 diffs)
• libcfa/src/concurrency/kernel/startup.cfa (modified) (2 diffs)
• libcfa/src/concurrency/ready_queue.cfa (modified) (3 diffs)
• libcfa/src/exception.c (modified) (13 diffs)
• src/AST/Pass.hpp (modified) (1 diff)
• tests/exceptions/.expect/trash.txt (added)
• tests/exceptions/trash.cfa (added)

libcfa/src/concurrency/invoke.h

@@ -26 +26 @@
 #ifndef _INVOKE_H_
 #define _INVOKE_H_
+
+        struct __cfaehm_try_resume_node;
+        struct __cfaehm_base_exception_t;
+        struct exception_context_t {
+                struct __cfaehm_try_resume_node * top_resume;
+                struct __cfaehm_base_exception_t * current_exception;
+        };
 
         struct __stack_context_t {
@@ -51 +58 @@
                 // base of stack
                 void * base;
+
+                // Information for exception handling.
+                struct exception_context_t exception_context;
         };
 
@@ -84 +94 @@
         };
 
-        static inline struct __stack_t * __get_stack( struct $coroutine * cor ) { return (struct __stack_t*)(((uintptr_t)cor->stack.storage) & ((uintptr_t)-2)); }
+        static inline struct __stack_t * __get_stack( struct $coroutine * cor ) {
+                return (struct __stack_t*)(((uintptr_t)cor->stack.storage) & ((uintptr_t)-2));
+        }
 
         // struct which calls the monitor is accepting

libcfa/src/concurrency/kernel/startup.cfa

@@ -516 +516 @@
         ( this.terminated ){ 0 };
         ( this.runner ){};
-        init( this, name, _cltr );
+
+        disable_interrupts();
+                init( this, name, _cltr );
+        enable_interrupts( __cfaabi_dbg_ctx );
 
         __cfadbg_print_safe(runtime_core, "Kernel : Starting core %p\n", &this);
@@ -540 +543 @@
         free( this.stack );
 
-        deinit( this );
+        disable_interrupts();
+                deinit( this );
+        enable_interrupts( __cfaabi_dbg_ctx );
 }
 

libcfa/src/concurrency/ready_queue.cfa

@@ -150 +150 @@
 //  queues or removing them.
 uint_fast32_t ready_mutate_lock( void ) with(*__scheduler_lock) {
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+
         // Step 1 : lock global lock
         // It is needed to avoid processors that register mid Critical-Section
@@ -164 +166 @@
         }
 
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
         return s;
 }
 
 void ready_mutate_unlock( uint_fast32_t last_s ) with(*__scheduler_lock) {
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+
         // Step 1 : release local locks
         // This must be done while the global lock is held to avoid
@@ -182 +187 @@
         /*paranoid*/ assert(true == lock);
         __atomic_store_n(&lock, (bool)false, __ATOMIC_RELEASE);
+
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
 }
 

libcfa/src/exception.c

@@ -10 +10 @@
 // Created On       : Mon Jun 26 15:13:00 2017
 // Last Modified By : Andrew Beach
-// Last Modified On : Thr May 21 12:18:00 2020
-// Update Count     : 20
+// Last Modified On : Wed Aug 12 13:55:00 2020
+// Update Count     : 21
 //
 
@@ -28 +28 @@
 #include <unwind.h>
 #include <bits/debug.hfa>
+#include "concurrency/invoke.h"
 #include "stdhdr/assert.h"
 
@@ -59 +60 @@
 
 // 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};
+static struct exception_context_t shared_stack = {NULL, NULL};
 
 // Get the current exception context.
@@ -122 +118 @@
 
 // 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.
@@ -137 +144 @@
 }
 
-// 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 ) {
@@ -161 +157 @@
         }
 
+        // 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 = 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;
+        store->next = NULL_MAP(EXCEPT_TO_NODE, context->current_exception);
+        context->current_exception = except_store;
 }
 
@@ -185 +181 @@
         if ( context->current_exception == except ) {
                 node = to_free->next;
-                context->current_exception = (node) ? NODE_TO_EXCEPT(node) : 0;
+                context->current_exception = NULL_MAP(NODE_TO_EXCEPT, node);
         } else {
                 node = EXCEPT_TO_NODE(context->current_exception);
@@ -213 +209 @@
         // Verify actions follow the rules we expect.
         verify((actions & _UA_CLEANUP_PHASE) && (actions & _UA_FORCE_UNWIND));
-        verify(!(actions & (_UA_SEARCH_PHASE | _UA_HANDER_FRAME)));
+        verify(!(actions & (_UA_SEARCH_PHASE | _UA_HANDLER_FRAME)));
 
         if ( actions & _UA_END_OF_STACK ) {
@@ -222 +218 @@
 }
 
+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( &this_exception_storage, _Stop_Fn, (void*)0x22 );
+        ret = _Unwind_ForcedUnwind( &cancel_exception_storage, _Stop_Fn, (void*)0x22 );
         printf("UNWIND ERROR %d after force unwind\n", ret);
         abort();
@@ -247 +245 @@
 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
@@ -419 +418 @@
                                 _Unwind_Reason_Code ret = (0 == index)
                                         ? _URC_CONTINUE_UNWIND : _URC_HANDLER_FOUND;
-                                context->current_handler_index = index;
+                                UNWIND_TO_NODE(unwind_exception)->handler_index = index;
 
                                 // Based on the return value, check if we matched the exception
@@ -425 +424 @@
                                         __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");
                                 }
@@ -516 +516 @@
         // Exception handler
         // Note: Saving the exception context on the stack breaks termination exceptions.
-        catch_block( this_exception_context()->current_handler_index,
+        catch_block( EXCEPT_TO_NODE( this_exception_context()->current_exception )->handler_index,
                      this_exception_context()->current_exception );
 }

src/AST/Pass.hpp

@@ -91 +91 @@
         static void run( std::list< ptr<Decl> > & decls, Args &&... args ) {
                 Pass<core_t> visitor( std::forward<Args>( args )... );
+                accept_all( decls, visitor );
+        }
+
+        template< typename... Args >
+        static void run( std::list< ptr<Decl> > & decls ) {
+                Pass<core_t> visitor;
                 accept_all( decls, visitor );
         }