Changeset 0e4df2e

Timestamp:

May 22, 2020, 11:49:29 AM (5 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

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

Children:

95cb63b

Parents:

2802824 (diff), 99fea48 (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 relaxed_ready

Files:

• driver/cfa.cc (modified) (3 diffs)
• libcfa/src/Makefile.am (modified) (2 diffs)
• libcfa/src/Makefile.in (modified) (2 diffs)
• libcfa/src/concurrency/io.cfa (modified) (18 diffs)
• libcfa/src/concurrency/kernel.cfa (modified) (1 diff)
• libcfa/src/containers/list.hfa (modified) (1 diff)
• libcfa/src/containers/stackLockFree.hfa (added)
• libcfa/src/exception.c (modified) (8 diffs)
• libcfa/src/exception.h (modified) (3 diffs)
• libcfa/src/exception.hfa (modified) (3 diffs)
• libcfa/src/executor.cfa (modified) (6 diffs)
• libcfa/src/heap.cfa (modified) (24 diffs)
• libcfa/src/stdlib.hfa (modified) (8 diffs)
• src/ControlStruct/ExceptTranslate.cc (modified) (19 diffs)
• src/ControlStruct/ExceptTranslate.h (modified) (2 diffs)
• src/main.cc (modified) (3 diffs)
• tests/errors/.expect/completeType.txt (modified) (1 diff)
• tests/exceptions/.expect/defaults.txt (added)
• tests/exceptions/conditional.cfa (modified) (2 diffs)
• tests/exceptions/data-except.cfa (modified) (2 diffs)
• tests/exceptions/defaults.cfa (added)
• tests/exceptions/finally.cfa (modified) (2 diffs)
• tests/exceptions/interact.cfa (modified) (10 diffs)
• tests/exceptions/resume.cfa (modified) (8 diffs)
• tests/exceptions/terminate.cfa (modified) (8 diffs)
• tests/list/.expect/dlist-insert-remove.txt (modified) (1 diff)
• tests/list/dlist-insert-remove.cfa (modified) (2 diffs)

driver/cfa.cc

@@ -10 +10 @@
 // Created On       : Tue Aug 20 13:44:49 2002
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Jan 31 16:48:03 2020
-// Update Count     : 421
+// Last Modified On : Mon May 18 13:26:26 2020
+// Update Count     : 424
 //
 
@@ -301 +301 @@
         } // for
 
-        #ifdef __x86_64__
-        args[nargs++] = "-mcx16";                                                       // allow double-wide CAA
-        #endif // __x86_64__
-
         #ifdef __DEBUG_H__
         cerr << "args:";
@@ -419 +415 @@
                 args[nargs++] = "-lcfa";
                 args[nargs++] = "-Wl,--pop-state";
+                #ifdef __x86_64__
+                args[nargs++] = "-mcx16";                                               // allow double-wide CAS
+                args[nargs++] = "-latomic";
+                #endif // __x86_64__
                 args[nargs++] = "-pthread";
                 args[nargs++] = "-ldl";

libcfa/src/Makefile.am

@@ -11 +11 @@
 ## Created On       : Sun May 31 08:54:01 2015
 ## Last Modified By : Peter A. Buhr
-## Last Modified On : Mon Mar 16 18:07:59 2020
-## Update Count     : 242
+## Last Modified On : Sun May 17 21:10:26 2020
+## Update Count     : 243
 ###############################################################################
 
@@ -39 +39 @@
 #----------------------------------------------------------------------------------------------------------------
 if BUILDLIB
-headers_nosrc = bitmanip.hfa math.hfa gmp.hfa time_t.hfa bits/align.hfa bits/containers.hfa bits/defs.hfa bits/debug.hfa bits/locks.hfa containers/list.hfa
+headers_nosrc = bitmanip.hfa math.hfa gmp.hfa time_t.hfa clock.hfa \
+                bits/align.hfa bits/containers.hfa bits/defs.hfa bits/debug.hfa bits/locks.hfa containers/list.hfa
 headers = fstream.hfa iostream.hfa iterator.hfa limits.hfa rational.hfa time.hfa stdlib.hfa common.hfa \
-          containers/maybe.hfa containers/pair.hfa containers/result.hfa containers/vector.hfa
+                containers/maybe.hfa containers/pair.hfa containers/result.hfa containers/stackLockFree.hfa containers/vector.hfa
 
 libsrc = startup.cfa interpose.cfa bits/debug.cfa assert.cfa exception.c virtual.c heap.cfa ${headers:.hfa=.cfa}

libcfa/src/Makefile.in

@@ -241 +241 @@
         containers/maybe.hfa containers/pair.hfa containers/result.hfa \
         containers/vector.hfa bitmanip.hfa math.hfa gmp.hfa time_t.hfa \
-        bits/align.hfa bits/containers.hfa bits/defs.hfa \
+        clock.hfa bits/align.hfa bits/containers.hfa bits/defs.hfa \
         bits/debug.hfa bits/locks.hfa containers/list.hfa \
         concurrency/coroutine.hfa concurrency/thread.hfa \
@@ -465 +465 @@
 
 #----------------------------------------------------------------------------------------------------------------
-@BUILDLIB_TRUE@headers_nosrc = bitmanip.hfa math.hfa gmp.hfa time_t.hfa bits/align.hfa bits/containers.hfa bits/defs.hfa bits/debug.hfa bits/locks.hfa containers/list.hfa
+@BUILDLIB_TRUE@headers_nosrc = bitmanip.hfa math.hfa gmp.hfa time_t.hfa clock.hfa \
+@BUILDLIB_TRUE@         bits/align.hfa bits/containers.hfa bits/defs.hfa bits/debug.hfa bits/locks.hfa containers/list.hfa
+
 @BUILDLIB_FALSE@headers = 
 @BUILDLIB_TRUE@headers = fstream.hfa iostream.hfa iterator.hfa limits.hfa rational.hfa time.hfa stdlib.hfa common.hfa \
-@BUILDLIB_TRUE@   containers/maybe.hfa containers/pair.hfa containers/result.hfa containers/vector.hfa
+@BUILDLIB_TRUE@         containers/maybe.hfa containers/pair.hfa containers/result.hfa containers/vector.hfa
 
 @BUILDLIB_FALSE@libsrc = 

libcfa/src/concurrency/io.cfa

@@ -124 +124 @@
 
                 // Like head/tail but not seen by the kernel
-                volatile uint32_t alloc;
                 volatile uint32_t * ready;
                 uint32_t ready_cnt;
@@ -141 +140 @@
                         struct {
                                 struct {
-                                        volatile unsigned long long int val;
+                                        volatile unsigned long long int rdy;
+                                        volatile unsigned long long int csm;
+                                        volatile unsigned long long int avl;
                                         volatile unsigned long long int cnt;
-                                        volatile unsigned long long int block;
                                 } submit_avg;
                                 struct {
@@ -150 +150 @@
                                         volatile unsigned long long int block;
                                 } look_avg;
+                                struct {
+                                        volatile unsigned long long int val;
+                                        volatile unsigned long long int cnt;
+                                        volatile unsigned long long int block;
+                                } alloc_avg;
                         } stats;
                 #endif
@@ -279 +284 @@
                 sq.dropped = (         uint32_t *)(((intptr_t)sq.ring_ptr) + params.sq_off.dropped);
                 sq.array   = (         uint32_t *)(((intptr_t)sq.ring_ptr) + params.sq_off.array);
-                sq.alloc = *sq.tail;
+
+                {
+                        const uint32_t num = *sq.num;
+                        for( i; num ) {
+                                sq.sqes[i].user_data = 0ul64;
+                        }
+                }
 
                 if( io_flags & CFA_CLUSTER_IO_POLLER_THREAD_SUBMITS ) {
@@ -322 +333 @@
                 // Initialize statistics
                 #if !defined(__CFA_NO_STATISTICS__)
-                        this.io->submit_q.stats.submit_avg.val   = 0;
-                        this.io->submit_q.stats.submit_avg.cnt   = 0;
-                        this.io->submit_q.stats.submit_avg.block = 0;
+                        this.io->submit_q.stats.submit_avg.rdy = 0;
+                        this.io->submit_q.stats.submit_avg.csm = 0;
+                        this.io->submit_q.stats.submit_avg.avl = 0;
+                        this.io->submit_q.stats.submit_avg.cnt = 0;
                         this.io->submit_q.stats.look_avg.val   = 0;
                         this.io->submit_q.stats.look_avg.cnt   = 0;
                         this.io->submit_q.stats.look_avg.block = 0;
+                        this.io->submit_q.stats.alloc_avg.val   = 0;
+                        this.io->submit_q.stats.alloc_avg.cnt   = 0;
+                        this.io->submit_q.stats.alloc_avg.block = 0;
                         this.io->completion_q.stats.completed_avg.val = 0;
                         this.io->completion_q.stats.completed_avg.slow_cnt = 0;
@@ -384 +399 @@
                                         this.ready_queue.head = 1p;
                                         thrd.next = 0p;
+                                        __cfaabi_dbg_debug_do( thrd.unpark_stale = true );
 
                                         // Fixup the thread state
@@ -426 +442 @@
                         if(this.print_stats) {
                                 with(this.io->submit_q.stats, this.io->completion_q.stats) {
+                                        double avgrdy = ((double)submit_avg.rdy) / submit_avg.cnt;
+                                        double avgcsm = ((double)submit_avg.csm) / submit_avg.cnt;
+                                        double avgavl = ((double)submit_avg.avl) / submit_avg.cnt;
+
                                         double lavgv = 0;
                                         double lavgb = 0;
@@ -433 +453 @@
                                         }
 
+                                        double aavgv = 0;
+                                        double aavgb = 0;
+                                        if(alloc_avg.cnt != 0) {
+                                                aavgv = ((double)alloc_avg.val  ) / alloc_avg.cnt;
+                                                aavgb = ((double)alloc_avg.block) / alloc_avg.cnt;
+                                        }
+
                                         __cfaabi_bits_print_safe( STDOUT_FILENO,
                                                 "----- I/O uRing Stats -----\n"
                                                 "- total submit calls     : %'15llu\n"
-                                                "- avg submit             : %'18.2lf\n"
-                                                "- pre-submit block %%     : %'18.2lf\n"
+                                                "- avg ready entries      : %'18.2lf\n"
+                                                "- avg submitted entries  : %'18.2lf\n"
+                                                "- avg available entries  : %'18.2lf\n"
                                                 "- total ready search     : %'15llu\n"
                                                 "- avg ready search len   : %'18.2lf\n"
                                                 "- avg ready search block : %'18.2lf\n"
+                                                "- total alloc search     : %'15llu\n"
+                                                "- avg alloc search len   : %'18.2lf\n"
+                                                "- avg alloc search block : %'18.2lf\n"
                                                 "- total wait calls       : %'15llu   (%'llu slow, %'llu fast)\n"
                                                 "- avg completion/wait    : %'18.2lf\n",
                                                 submit_avg.cnt,
-                                                ((double)submit_avg.val) / submit_avg.cnt,
-                                                (100.0 * submit_avg.block) / submit_avg.cnt,
+                                                avgrdy,
+                                                avgcsm,
+                                                avgavl,
                                                 look_avg.cnt,
                                                 lavgv,
                                                 lavgb,
+                                                alloc_avg.cnt,
+                                                aavgv,
+                                                aavgb,
                                                 completed_avg.slow_cnt + completed_avg.fast_cnt,
                                                 completed_avg.slow_cnt,  completed_avg.fast_cnt,
@@ -494 +529 @@
 
                         // If the poller thread also submits, then we need to aggregate the submissions which are ready
-                        uint32_t * tail = ring.submit_q.tail;
+                        uint32_t tail = *ring.submit_q.tail;
                         const uint32_t mask = *ring.submit_q.mask;
 
@@ -506 +541 @@
 
                                 // If we got a real submission, append it to the list
-                                ring.submit_q.array[ ((*tail) + to_submit) & mask ] = idx & mask;
+                                ring.submit_q.array[ (tail + to_submit) & mask ] = idx & mask;
                                 to_submit++;
                         }
 
                         // Increment the tail based on how many we are ready to submit
-                        __atomic_fetch_add(tail, to_submit, __ATOMIC_SEQ_CST);
-
-                        // update statistics
-                        #if !defined(__CFA_NO_STATISTICS__)
-                                ring.submit_q.stats.submit_avg.val += to_submit;
-                                ring.submit_q.stats.submit_avg.cnt += 1;
-                        #endif
-                }
-
+                        __atomic_fetch_add(ring.submit_q.tail, to_submit, __ATOMIC_SEQ_CST);
+                }
+
+                const uint32_t smask = *ring.submit_q.mask;
+                uint32_t shead = *ring.submit_q.head;
                 int ret = syscall( __NR_io_uring_enter, ring.fd, to_submit, waitcnt, IORING_ENTER_GETEVENTS, mask, _NSIG / 8);
                 if( ret < 0 ) {
@@ -531 +562 @@
                 }
 
+                verify( (shead + ret) == *ring.submit_q.head );
+
+                // Release the consumed SQEs
+                for( i; ret ) {
+                        uint32_t idx = ring.submit_q.array[ (i + shead) & smask ];
+                        ring.submit_q.sqes[ idx ].user_data = 0;
+                }
+
+                uint32_t avail = 0;
+                uint32_t sqe_num = *ring.submit_q.num;
+                for(i; sqe_num) {
+                        if( ring.submit_q.sqes[ i ].user_data == 0 ) avail++;
+                }
+
+                // update statistics
+                #if !defined(__CFA_NO_STATISTICS__)
+                        ring.submit_q.stats.submit_avg.rdy += to_submit;
+                        ring.submit_q.stats.submit_avg.csm += ret;
+                        ring.submit_q.stats.submit_avg.avl += avail;
+                        ring.submit_q.stats.submit_avg.cnt += 1;
+                #endif
+
                 // Drain the queue
                 unsigned head = *ring.completion_q.head;
-                unsigned tail = __atomic_load_n(ring.completion_q.tail, __ATOMIC_ACQUIRE);
+                unsigned tail = *ring.completion_q.tail;
+                const uint32_t mask = *ring.completion_q.mask;
+
+                // Memory barrier
+                __atomic_thread_fence( __ATOMIC_SEQ_CST );
 
                 // Nothing was new return 0
@@ -542 +599 @@
                 uint32_t count = tail - head;
                 for(i; count) {
-                        unsigned idx = (head + i) & (*ring.completion_q.mask);
+                        unsigned idx = (head + i) & mask;
                         struct io_uring_cqe & cqe = ring.completion_q.cqes[idx];
 
@@ -556 +613 @@
 
                 // Allow new submissions to happen
-                V(ring.submit, count);
+                // V(ring.submit, count);
 
                 // Mark to the kernel that the cqe has been seen
                 // Ensure that the kernel only sees the new value of the head index after the CQEs have been read.
+                __atomic_thread_fence( __ATOMIC_SEQ_CST );
                 __atomic_fetch_add( ring.completion_q.head, count, __ATOMIC_RELAXED );
 
@@ -710 +768 @@
 //
 
-        static inline [* struct io_uring_sqe, uint32_t] __submit_alloc( struct __io_data & ring ) {
-                // Wait for a spot to be available
-                __attribute__((unused)) bool blocked = P(ring.submit);
-                #if !defined(__CFA_NO_STATISTICS__)
-                        __atomic_fetch_add( &ring.submit_q.stats.submit_avg.block, blocked ? 1ul64 : 0ul64, __ATOMIC_RELAXED );
-                #endif
-
-                // Allocate the sqe
-                uint32_t idx = __atomic_fetch_add(&ring.submit_q.alloc, 1ul32, __ATOMIC_SEQ_CST);
-
-                // Mask the idx now to allow make everything easier to check
-                idx &= *ring.submit_q.mask;
-
-                // Return the sqe
-                return [&ring.submit_q.sqes[ idx ], idx];
+        static inline [* struct io_uring_sqe, uint32_t] __submit_alloc( struct __io_data & ring, uint64_t data ) {
+                verify( data != 0 );
+
+                // Prepare the data we need
+                __attribute((unused)) int len   = 0;
+                __attribute((unused)) int block = 0;
+                uint32_t cnt = *ring.submit_q.num;
+                uint32_t mask = *ring.submit_q.mask;
+                uint32_t off = __tls_rand();
+
+                // Loop around looking for an available spot
+                LOOKING: for() {
+                        // Look through the list starting at some offset
+                        for(i; cnt) {
+                                uint64_t expected = 0;
+                                uint32_t idx = (i + off) & mask;
+                                struct io_uring_sqe * sqe = &ring.submit_q.sqes[idx];
+                                volatile uint64_t * udata = &sqe->user_data;
+
+                                if( *udata == expected &&
+                                        __atomic_compare_exchange_n( udata, &expected, data, true, __ATOMIC_SEQ_CST, __ATOMIC_RELAXED ) )
+                                {
+                                        // update statistics
+                                        #if !defined(__CFA_NO_STATISTICS__)
+                                                __atomic_fetch_add( &ring.submit_q.stats.alloc_avg.val,   len,   __ATOMIC_RELAXED );
+                                                __atomic_fetch_add( &ring.submit_q.stats.alloc_avg.block, block, __ATOMIC_RELAXED );
+                                                __atomic_fetch_add( &ring.submit_q.stats.alloc_avg.cnt,   1,     __ATOMIC_RELAXED );
+                                        #endif
+
+                                        // Success return the data
+                                        return [sqe, idx];
+                                }
+                                verify(expected != data);
+
+                                len ++;
+                        }
+
+                        block++;
+                        yield();
+                }
         }
 
@@ -742 +825 @@
                         __attribute((unused)) int len   = 0;
                         __attribute((unused)) int block = 0;
-                        uint32_t expected = -1ul32;
                         uint32_t ready_mask = ring.submit_q.ready_cnt - 1;
                         uint32_t off = __tls_rand();
@@ -748 +830 @@
                                 for(i; ring.submit_q.ready_cnt) {
                                         uint32_t ii = (i + off) & ready_mask;
+                                        uint32_t expected = -1ul32;
                                         if( __atomic_compare_exchange_n( &ring.submit_q.ready[ii], &expected, idx, true, __ATOMIC_SEQ_CST, __ATOMIC_RELAXED ) ) {
                                                 break LOOKING;
                                         }
+                                        verify(expected != idx);
 
                                         len ++;
@@ -792 +876 @@
                         // update statistics
                         #if !defined(__CFA_NO_STATISTICS__)
-                                ring.submit_q.stats.submit_avg.val += 1;
+                                ring.submit_q.stats.submit_avg.csm += 1;
                                 ring.submit_q.stats.submit_avg.cnt += 1;
                         #endif
@@ -831 +915 @@
 
         #define __submit_prelude \
-                struct __io_data & ring = *active_cluster()->io; \
+                io_user_data data = { 0, active_thread() }; \
+                struct __io_data & ring = *data.thrd->curr_cluster->io; \
                 struct io_uring_sqe * sqe; \
                 uint32_t idx; \
-                [sqe, idx] = __submit_alloc( ring );
+                [sqe, idx] = __submit_alloc( ring, (uint64_t)&data );
 
         #define __submit_wait \
-                io_user_data data = { 0, active_thread() }; \
                 /*__cfaabi_bits_print_safe( STDERR_FILENO, "Preparing user data %p for %p\n", &data, data.thrd );*/ \
-                sqe->user_data = (uint64_t)&data; \
+                verify( sqe->user_data == (uint64_t)&data ); \
                 __submit( ring, idx ); \
                 park( __cfaabi_dbg_ctx ); \

libcfa/src/concurrency/kernel.cfa

@@ -648 +648 @@
 
         // record activity
+        __cfaabi_dbg_debug_do( char * old_caller = thrd->unpark_caller; )
         __cfaabi_dbg_record_thrd( *thrd, false, caller );
 

libcfa/src/containers/list.hfa

@@ -301 +301 @@
                 $prev_link(list_pos) = (Telem*) 0p;
         }
+
+        static inline bool ?`is_empty(dlist(Tnode, Telem) &list) {
+                assert( &list != 0p );
+                $dlinks(Telem) *listLinks = & list.$links;
+                if (listLinks->next.is_terminator) {
+                        assert(listLinks->prev.is_terminator);
+                        assert(listLinks->next.terminator);
+                        assert(listLinks->prev.terminator);
+                        return true;
+                } else {
+                        assert(!listLinks->prev.is_terminator);
+                        assert(listLinks->next.elem);
+                        assert(listLinks->prev.elem);
+                        return false;
+                }
+        }
+
+        static inline Telem & pop_first(dlist(Tnode, Telem) &list) {
+                assert( &list != 0p );
+                assert( !list`is_empty );
+                $dlinks(Telem) *listLinks = & list.$links;
+                Telem & first = *listLinks->next.elem;
+                Tnode & list_pos_first  = $tempcv_e2n( first );
+                remove(list_pos_first);
+                return first;
+        }
+
+        static inline Telem & pop_last(dlist(Tnode, Telem) &list) {
+                assert( &list != 0p );
+                assert( !list`is_empty );
+                $dlinks(Telem) *listLinks = & list.$links;
+                Telem & last = *listLinks->prev.elem;
+                Tnode & list_pos_last  = $tempcv_e2n( last );
+                remove(list_pos_last);
+                return last;
+        }
+
 }
 

libcfa/src/exception.c

@@ -10 +10 @@
 // Created On       : Mon Jun 26 15:13:00 2017
 // Last Modified By : Andrew Beach
-// Last Modified On : Tue Apr 14 12:01:00 2020
-// Update Count     : 18
+// Last Modified On : Thr May 21 12:18:00 2020
+// Update Count     : 20
 //
 
@@ -80 +80 @@
 }
 
-void __cfaehm_throw_resume(exception_t * except) {
+void __cfaehm_throw_resume(exception_t * except, void (*defaultHandler)(exception_t *)) {
         struct exception_context_t * context = this_exception_context();
 
@@ -96 +96 @@
         }
 
+        // No handler found, fall back to the default operation.
         __cfadbg_print_safe(exception, "Unhandled exception\n");
-
-        // Fall back to termination:
-        __cfaehm_throw_terminate(except);
-        // TODO: Default handler for resumption.
+        defaultHandler(except);
 }
 
@@ -223 +221 @@
 
 // Cancel the current stack, prefroming approprate clean-up and messaging.
-static __attribute__((noreturn)) void __cfaehm_cancel_stack(
-                exception_t * exception ) {
+void __cfaehm_cancel_stack( exception_t * exception ) {
         // TODO: Detect current stack and pick a particular stop-function.
         _Unwind_Reason_Code ret;
@@ -240 +237 @@
 }
 
+static void __cfaehm_cleanup_default( exception_t ** except ) {
+        __cfaehm_delete_exception( *except );
+        *except = NULL;
+}
+
 // The exception that is being thrown must already be stored.
-static __attribute__((noreturn)) void __cfaehm_begin_unwind(void) {
-        if ( ! this_exception_context()->current_exception ) {
+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();
@@ -248 +252 @@
 
         // Call stdlibc to raise the exception
-        _Unwind_Reason_Code ret = _Unwind_RaiseException( &this_exception_storage );
+        __cfadbg_print_safe(exception, "Begin unwinding (storage &p, context %p)\n", storage, context);
+        _Unwind_Reason_Code ret = _Unwind_RaiseException( storage );
 
         // If we reach here it means something happened. For resumption to work we need to find a way
@@ -257 +262 @@
         // the whole stack.
 
+        // We did not simply reach the end of the stack without finding a handler. This is an error.
+        if ( ret != _URC_END_OF_STACK ) {
+                printf("UNWIND ERROR %d after raise exception\n", ret);
+                abort();
+        }
+
         // No handler found, go to the default operation.
-        // Currently this will always be a cancellation.
-        if ( ret == _URC_END_OF_STACK ) {
-                __cfadbg_print_safe(exception, "Uncaught exception %p\n", &this_exception_storage);
-
-                __cfaehm_cancel_stack(this_exception_context()->current_exception);
-        }
-
-        // We did not simply reach the end of the stack without finding a handler. This is an error.
-        printf("UNWIND ERROR %d after raise exception\n", ret);
+        __cfadbg_print_safe(exception, "Uncaught exception %p\n", storage);
+
+        __attribute__((cleanup(__cfaehm_cleanup_default)))
+        exception_t * exception = context->current_exception;
+        defaultHandler( exception );
+}
+
+void __cfaehm_throw_terminate( exception_t * val, void (*defaultHandler)(exception_t *) ) {
+        __cfadbg_print_safe(exception, "Throwing termination exception\n");
+
+        __cfaehm_allocate_exception( val );
+        __cfaehm_begin_unwind( defaultHandler );
+}
+
+static __attribute__((noreturn)) void __cfaehm_rethrow_adapter( exception_t * except ) {
+        // TODO: Print some error message.
+        (void)except;
         abort();
-}
-
-void __cfaehm_throw_terminate( exception_t * val ) {
-        __cfadbg_print_safe(exception, "Throwing termination exception\n");
-
-        __cfaehm_allocate_exception( val );
-        __cfaehm_begin_unwind();
 }
 
@@ -280 +292 @@
         __cfadbg_print_safe(exception, "Rethrowing termination exception\n");
 
-        __cfaehm_begin_unwind();
+        __cfaehm_begin_unwind( __cfaehm_rethrow_adapter );
+        abort();
 }
 

libcfa/src/exception.h

@@ -10 +10 @@
 // Created On       : Mon Jun 26 15:11:00 2017
 // Last Modified By : Andrew Beach
-// Last Modified On : Fri Mar 27 10:16:00 2020
-// Update Count     : 9
+// Last Modified On : Tue May 19 14:17:00 2020
+// Update Count     : 10
 //
 
@@ -38 +38 @@
 
 
+void __cfaehm_cancel_stack(exception_t * except) __attribute__((noreturn));
+
 // Used in throw statement translation.
-void __cfaehm_throw_terminate(exception_t * except) __attribute__((noreturn));
+void __cfaehm_throw_terminate(exception_t * except, void (*)(exception_t *));
 void __cfaehm_rethrow_terminate() __attribute__((noreturn));
-void __cfaehm_throw_resume(exception_t * except);
+void __cfaehm_throw_resume(exception_t * except, void (*)(exception_t *));
 
 // Function catches termination exceptions.
@@ -70 +72 @@
 #ifdef __cforall
 }
+
+// Not all the built-ins can be expressed in C. These can't be
+// implemented in the .c file either so they all have to be inline.
+
+trait is_exception(dtype T) {
+        /* The first field must be a pointer to a virtual table.
+         * That virtual table must be a decendent of the base exception virtual tab$
+         */
+        void mark_exception(T *);
+        // This is never used and should be a no-op.
+};
+
+trait is_termination_exception(dtype T | is_exception(T)) {
+        void defaultTerminationHandler(T &);
+};
+
+trait is_resumption_exception(dtype T | is_exception(T)) {
+        void defaultResumptionHandler(T &);
+};
+
+forall(dtype T | is_termination_exception(T))
+static inline void $throw(T & except) {
+        __cfaehm_throw_terminate(
+                (exception_t *)&except,
+                (void(*)(exception_t *))defaultTerminationHandler
+        );
+}
+
+forall(dtype T | is_resumption_exception(T))
+static inline void $throwResume(T & except) {
+        __cfaehm_throw_resume(
+                (exception_t *)&except,
+                (void(*)(exception_t *))defaultResumptionHandler
+        );
+}
+
+forall(dtype T | is_exception(T))
+static inline void cancel_stack(T & except) __attribute__((noreturn)) {
+        __cfaehm_cancel_stack( (exception_t *)&except );
+}
+
+forall(dtype T | is_exception(T))
+static inline void defaultTerminationHandler(T & except) {
+        return cancel_stack( except );
+}
+
+forall(dtype T | is_exception(T))
+static inline void defaultResumptionHandler(T & except) {
+        throw except;
+}
+
 #endif

libcfa/src/exception.hfa

@@ -10 +10 @@
 // Created On       : Thu Apr  7 10:25:00 2020
 // Last Modified By : Andrew Beach
-// Last Modified On : Thu Apr  7 10:25:00 2020
-// Update Count     : 0
+// Last Modified On : Tue May 19 14:17:00 2020
+// Update Count     : 2
 //
 
@@ -69 +69 @@
 #define _VTABLE_DECLARATION(exception_name, parent_name, ...) \
         struct exception_name; \
+        void mark_exception(exception_name *); \
         VTABLE_TYPE(exception_name); \
         extern VTABLE_TYPE(exception_name) VTABLE_NAME(exception_name); \
@@ -85 +86 @@
 #define VTABLE_INSTANCE(...) _EXC_DISPATCH(_VTABLE_INSTANCE, __VA_ARGS__)
 #define _VTABLE_INSTANCE(exception_name, parent_name, ...) \
+        void mark_exception(exception_name *) {} \
         void _GLUE2(exception_name,_copy)(exception_name * this, exception_name * other) { \
                 *this = *other; \

libcfa/src/executor.cfa

@@ -4 +4 @@
 // buffer.
 
-#include <bits/containers.hfa>
+#include <containers/list.hfa>
 #include <thread.hfa>
 #include <stdio.h>
 
-forall( dtype T )
-monitor Buffer {                                        // unbounded buffer
-    __queue_t( T ) queue;                               // unbounded list of work requests
-    condition delay;
-}; // Buffer
-forall( dtype T | is_node(T) ) {
-    void insert( Buffer( T ) & mutex buf, T * elem ) with(buf) {
-        append( queue, elem );                          // insert element into buffer
-        signal( delay );                                // restart
-    } // insert
-
-    T * remove( Buffer( T ) & mutex buf ) with(buf) {
-        if ( queue.head != 0 ) wait( delay );                   // no request to process ? => wait
-//      return pop_head( queue );
-    } // remove
-} // distribution
-
 struct WRequest {                                       // client request, no return
     void (* action)( void );
-    WRequest * next;                                    // intrusive queue field
+    DLISTED_MGD_IMPL_IN(WRequest)
 }; // WRequest
+DLISTED_MGD_IMPL_OUT(WRequest)
 
-WRequest *& get_next( WRequest & this ) { return this.next; }
-void ?{}( WRequest & req ) with(req) { action = 0; next = 0; }
-void ?{}( WRequest & req, void (* action)( void ) ) with(req) { req.action = action; next = 0; }
+void ?{}( WRequest & req ) with(req) { action = 0; }
+void ?{}( WRequest & req, void (* action)( void ) ) with(req) { req.action = action; }
 bool stop( WRequest & req ) { return req.action == 0; }
 void doit( WRequest & req ) { req.action(); }
+
+monitor WRBuffer {                                      // unbounded buffer
+    dlist( WRequest, WRequest ) queue;                  // unbounded list of work requests
+    condition delay;
+}; // WRBuffer
+
+void insert( WRBuffer & mutex buf, WRequest * elem ) with(buf) {
+    insert_last( queue, *elem );                        // insert element into buffer
+    signal( delay );                                    // restart
+} // insert
+
+WRequest * remove( WRBuffer & mutex buf ) with(buf) {
+    if ( queue`is_empty ) wait( delay );                // no request to process ? => wait
+    return & pop_first( queue );
+} // remove
 
 // Each worker has its own work buffer to reduce contention between client and server. Hence, work requests arrive and
@@ -40 +38 @@
 
 thread Worker {
-    Buffer( WRequest ) * requests;
+    WRBuffer * requests;
     unsigned int start, range;
 }; // Worker
@@ -54 +52 @@
 } // Worker::main
 
-void ?{}( Worker & worker, cluster * wc, Buffer( WRequest ) * requests, unsigned int start, unsigned int range ) {
+void ?{}( Worker & worker, cluster * wc, WRBuffer * requests, unsigned int start, unsigned int range ) {
     (*get_thread(worker)){ *wc };                       // create on given cluster
     worker.[requests, start, range] = [requests, start, range];
@@ -62 +60 @@
     cluster * cluster;                                  // if workers execute on separate cluster
     processor ** processors;                            // array of virtual processors adding parallelism for workers
-    Buffer( WRequest ) * requests;                      // list of work requests
+    WRBuffer * requests;                                // list of work requests
     Worker ** workers;                                  // array of workers executing work requests
     unsigned int nprocessors, nworkers, nmailboxes;     // number of mailboxes/workers/processor tasks
@@ -79 +77 @@
     cluster = sepClus ? new( "Executor" ) : active_cluster();
     processors = (processor **)anew( nprocessors );
-    requests = anew( nmailboxes );
+    requests = (WRBuffer *)anew( nmailboxes );
     workers = (Worker **)anew( nworkers );
 
@@ -141 +139 @@
         for ( i; 3000 ) {
             send( exector, workie );
-            if ( i % 100 ) yield();
+            if ( i % 100 == 0 ) {
+//              fprintf( stderr, "%d\n", i );
+                yield();
+            }
         } // for
     }

libcfa/src/heap.cfa

@@ -10 +10 @@
 // Created On       : Tue Dec 19 21:58:35 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed May  6 17:29:26 2020
-// Update Count     : 727
+// Last Modified On : Sun May 17 20:58:17 2020
+// Update Count     : 762
 //
 
@@ -128 +128 @@
 #define LOCKFREE 1
 #define BUCKETLOCK SPINLOCK
-#if BUCKETLOCK == LOCKFREE
-#include <uStackLF.h>
+#if BUCKETLOCK == SPINLOCK
+#elif BUCKETLOCK == LOCKFREE
+#include <stackLockFree.hfa>
+#else
+        #error undefined lock type for bucket lock
 #endif // LOCKFREE
 
@@ -137 +140 @@
 
 struct HeapManager {
-//      struct FreeHeader;                                                                      // forward declaration
-
         struct Storage {
                 struct Header {                                                                 // header
@@ -146 +147 @@
                                                 struct {                                                // 4-byte word => 8-byte header, 8-byte word => 16-byte header
                                                         #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ && __SIZEOF_POINTER__ == 4
-                                                        uint32_t padding;                       // unused, force home/blocksize to overlay alignment in fake header
+                                                        uint64_t padding;                       // unused, force home/blocksize to overlay alignment in fake header
                                                         #endif // __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ && __SIZEOF_POINTER__ == 4
 
                                                         union {
-//                                                              FreeHeader * home;              // allocated block points back to home locations (must overlay alignment)
+                                                                // FreeHeader * home;           // allocated block points back to home locations (must overlay alignment)
                                                                 // 2nd low-order bit => zero filled
                                                                 void * home;                    // allocated block points back to home locations (must overlay alignment)
                                                                 size_t blockSize;               // size for munmap (must overlay alignment)
-                                                                #if BUCKLOCK == SPINLOCK
+                                                                #if BUCKETLOCK == SPINLOCK
                                                                 Storage * next;                 // freed block points next freed block of same size
                                                                 #endif // SPINLOCK
                                                         };
+                                                        size_t size;                            // allocation size in bytes
 
                                                         #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ && __SIZEOF_POINTER__ == 4
-                                                        uint32_t padding;                       // unused, force home/blocksize to overlay alignment in fake header
+                                                        uint64_t padding;                       // unused, force home/blocksize to overlay alignment in fake header
                                                         #endif // __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ && __SIZEOF_POINTER__ == 4
                                                 };
-                                                // future code
-                                                #if BUCKLOCK == LOCKFREE
-                                                Stack<Storage>::Link next;              // freed block points next freed block of same size (double-wide)
+                                                #if BUCKETLOCK == LOCKFREE
+                                                Link(Storage) next;                             // freed block points next freed block of same size (double-wide)
                                                 #endif // LOCKFREE
                                         };
                                 } real; // RealHeader
+
                                 struct FakeHeader {
                                         #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-                                        // 1st low-order bit => fake header & alignment
-                                        uint32_t alignment;
+                                        uint32_t alignment;                                     // 1st low-order bit => fake header & alignment
                                         #endif // __ORDER_LITTLE_ENDIAN__
 
@@ -182 +183 @@
                                 } fake; // FakeHeader
                         } kind; // Kind
-                        size_t size;                                                            // allocation size in bytes
                 } header; // Header
                 char pad[libAlign() - sizeof( Header )];
@@ -191 +191 @@
 
         struct FreeHeader {
-                #if BUCKLOCK == SPINLOCK
+                #if BUCKETLOCK == SPINLOCK
                 __spinlock_t lock;                                                              // must be first field for alignment
                 Storage * freeList;
-                #elif BUCKLOCK == LOCKFREE
-                // future code
-                StackLF<Storage> freeList;
                 #else
-                        #error undefined lock type for bucket lock
-                #endif // SPINLOCK
+                StackLF(Storage) freeList;
+                #endif // BUCKETLOCK
                 size_t blockSize;                                                               // size of allocations on this list
         }; // FreeHeader
@@ -211 +208 @@
         size_t heapRemaining;                                                           // amount of storage not allocated in the current chunk
 }; // HeapManager
+
+#if BUCKETLOCK == LOCKFREE
+static inline Link(HeapManager.Storage) * getNext( HeapManager.Storage * this ) { return &this->header.kind.real.next; }
+static inline void ?{}( HeapManager.FreeHeader & ) {}
+static inline void ^?{}( HeapManager.FreeHeader & ) {}
+#endif // LOCKFREE
 
 static inline size_t getKey( const HeapManager.FreeHeader & freeheader ) { return freeheader.blockSize; }
@@ -251 +254 @@
 static bool heapBoot = 0;                                                               // detect recursion during boot
 #endif // __CFA_DEBUG__
+
+// The constructor for heapManager is called explicitly in memory_startup.
 static HeapManager heapManager __attribute__(( aligned (128) )) @= {}; // size of cache line to prevent false sharing
 
@@ -354 +359 @@
 
 
-// static inline void noMemory() {
-//      abort( "Heap memory exhausted at %zu bytes.\n"
-//                 "Possible cause is very large memory allocation and/or large amount of unfreed storage allocated by the program or system/library routines.",
-//                 ((char *)(sbrk( 0 )) - (char *)(heapManager.heapBegin)) );
-// } // noMemory
-
-
 // thunk problem
 size_t Bsearchl( unsigned int key, const unsigned int * vals, size_t dim ) {
@@ -406 +404 @@
 
 
+// static inline void noMemory() {
+//      abort( "Heap memory exhausted at %zu bytes.\n"
+//                 "Possible cause is very large memory allocation and/or large amount of unfreed storage allocated by the program or system/library routines.",
+//                 ((char *)(sbrk( 0 )) - (char *)(heapManager.heapBegin)) );
+// } // noMemory
+
+
 static inline void checkAlign( size_t alignment ) {
         if ( alignment < libAlign() || ! libPow2( alignment ) ) {
@@ -433 +438 @@
 
 
-static inline bool headers( const char name[] __attribute__(( unused )), void * addr, HeapManager.Storage.Header *& header, HeapManager.FreeHeader *& freeElem, size_t & size, size_t & alignment ) with ( heapManager ) {
+static inline bool headers( const char name[] __attribute__(( unused )), void * addr, HeapManager.Storage.Header *& header, HeapManager.FreeHeader *& freeElem,
+                                                        size_t & size, size_t & alignment ) with( heapManager ) {
         header = headerAddr( addr );
 
@@ -465 +471 @@
 
 
-static inline void * extend( size_t size ) with ( heapManager ) {
+static inline void * extend( size_t size ) with( heapManager ) {
         lock( extlock __cfaabi_dbg_ctx2 );
         ptrdiff_t rem = heapRemaining - size;
@@ -496 +502 @@
 
 
-static inline void * doMalloc( size_t size ) with ( heapManager ) {
+static inline void * doMalloc( size_t size ) with( heapManager ) {
         HeapManager.Storage * block;                                            // pointer to new block of storage
 
@@ -529 +535 @@
                 // Spin until the lock is acquired for this particular size of block.
 
-                #if defined( SPINLOCK )
+                #if BUCKETLOCK == SPINLOCK
                 lock( freeElem->lock __cfaabi_dbg_ctx2 );
                 block = freeElem->freeList;                                             // remove node from stack
                 #else
-                block = freeElem->freeList.pop();
-                #endif // SPINLOCK
+                block = pop( freeElem->freeList );
+                #endif // BUCKETLOCK
                 if ( unlikely( block == 0p ) ) {                                // no free block ?
-                        #if defined( SPINLOCK )
+                        #if BUCKETLOCK == SPINLOCK
                         unlock( freeElem->lock );
-                        #endif // SPINLOCK
+                        #endif // BUCKETLOCK
 
                         // Freelist for that size was empty, so carve it out of the heap if there's enough left, or get some more
@@ -544 +550 @@
 
                         block = (HeapManager.Storage *)extend( tsize ); // mutual exclusion on call
-  if ( unlikely( block == 0p ) ) return 0p;
-                #if defined( SPINLOCK )
+        if ( unlikely( block == 0p ) ) return 0p;
+                #if BUCKETLOCK == SPINLOCK
                 } else {
                         freeElem->freeList = block->header.kind.real.next;
                         unlock( freeElem->lock );
-                #endif // SPINLOCK
+                #endif // BUCKETLOCK
                 } // if
 
@@ -572 +578 @@
         } // if
 
-        block->header.size = size;                                                      // store allocation size
+        block->header.kind.real.size = size;                            // store allocation size
         void * addr = &(block->data);                                           // adjust off header to user bytes
 
@@ -591 +597 @@
 
 
-static inline void doFree( void * addr ) with ( heapManager ) {
+static inline void doFree( void * addr ) with( heapManager ) {
         #ifdef __CFA_DEBUG__
         if ( unlikely( heapManager.heapBegin == 0p ) ) {
@@ -623 +629 @@
                 free_storage += size;
                 #endif // __STATISTICS__
-                #if defined( SPINLOCK )
+                #if BUCKETLOCK == SPINLOCK
                 lock( freeElem->lock __cfaabi_dbg_ctx2 );               // acquire spin lock
                 header->kind.real.next = freeElem->freeList;    // push on stack
@@ -629 +635 @@
                 unlock( freeElem->lock );                                               // release spin lock
                 #else
-                freeElem->freeList.push( *(HeapManager.Storage *)header );
-                #endif // SPINLOCK
+                push( freeElem->freeList, *(HeapManager.Storage *)header );
+                #endif // BUCKETLOCK
         } // if
 
@@ -645 +651 @@
 
 
-size_t prtFree( HeapManager & manager ) with ( manager ) {
+size_t prtFree( HeapManager & manager ) with( manager ) {
         size_t total = 0;
         #ifdef __STATISTICS__
@@ -657 +663 @@
                 #endif // __STATISTICS__
 
-                #if defined( SPINLOCK )
+                #if BUCKETLOCK == SPINLOCK
                 for ( HeapManager.Storage * p = freeLists[i].freeList; p != 0p; p = p->header.kind.real.next ) {
                 #else
-                for ( HeapManager.Storage * p = freeLists[i].freeList.top(); p != 0p; p = p->header.kind.real.next.top ) {
-                #endif // SPINLOCK
+                for ( HeapManager.Storage * p = top( freeLists[i].freeList ); p != 0p; /* p = getNext( p )->top */) {
+                        typeof(p) temp = getNext( p )->top;                     // FIX ME: direct assignent fails, initialization works
+                        p = temp;
+                #endif // BUCKETLOCK
                         total += size;
                         #ifdef __STATISTICS__
@@ -681 +689 @@
 
 
-static void ?{}( HeapManager & manager ) with ( manager ) {
+static void ?{}( HeapManager & manager ) with( manager ) {
         pageSize = sysconf( _SC_PAGESIZE );
 
@@ -1095 +1103 @@
                         header = realHeader( header );                          // backup from fake to real header
                 } // if
-                return header->size;
+                return header->kind.real.size;
         } // malloc_size
 
@@ -1105 +1113 @@
                         header = realHeader( header );                          // backup from fake to real header
                 } // if
-                size_t ret = header->size;
-                header->size = size;
+                size_t ret = header->kind.real.size;
+                header->kind.real.size = size;
                 return ret;
         } // $malloc_size_set

libcfa/src/stdlib.hfa

@@ -10 +10 @@
 // Created On       : Thu Jan 28 17:12:35 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Apr 16 22:44:05 2020
-// Update Count     : 432
+// Last Modified On : Wed May 13 17:23:51 2020
+// Update Count     : 435
 //
 
@@ -23 +23 @@
 // Reduce includes by explicitly defining these routines.
 extern "C" {
+        void * aalloc( size_t dim, size_t elemSize );           // CFA heap
+        void * resize( void * oaddr, size_t size );                     // CFA heap
         void * memalign( size_t align, size_t size );           // malloc.h
+        void * amemalign( size_t align, size_t dim, size_t elemSize ); // CFA heap
+        void * cmemalign( size_t align, size_t noOfElems, size_t elemSize ); // CFA heap
+        size_t malloc_size( void * addr );                                      // CFA heap
         size_t malloc_usable_size( void * ptr );                        // malloc.h
-        size_t malloc_size( void * addr );                                      // CFA heap
-        void * cmemalign( size_t alignment, size_t noOfElems, size_t elemSize ); // CFA heap
         void * memset( void * dest, int fill, size_t size ); // string.h
         void * memcpy( void * dest, const void * src, size_t size ); // string.h
-        void * resize( void * oaddr, size_t size );                     // CFA heap
 } // extern "C"
 
@@ -52 +54 @@
         } // malloc
 
+        T * aalloc( size_t dim ) {
+                if ( _Alignof(T) <= libAlign() ) return (T *)(void *)aalloc( dim, (size_t)sizeof(T) ); // CFA aalloc
+                else return (T *)amemalign( _Alignof(T), dim, sizeof(T) );
+        } // aalloc
+
         T * calloc( size_t dim ) {
                 if ( _Alignof(T) <= libAlign() )return (T *)(void *)calloc( dim, sizeof(T) ); // C calloc
@@ -57 +64 @@
         } // calloc
 
+        T * resize( T * ptr, size_t size ) {                            // CFA realloc, eliminate return-type cast
+                return (T *)(void *)resize( (void *)ptr, size ); // C realloc
+        } // resize
+
         T * realloc( T * ptr, size_t size ) {                           // CFA realloc, eliminate return-type cast
                 return (T *)(void *)realloc( (void *)ptr, size ); // C realloc
@@ -65 +76 @@
         } // memalign
 
+        T * amemalign( size_t align, size_t dim ) {
+                return (T *)amemalign( align, dim, sizeof(T) ); // CFA amemalign
+        } // amemalign
+
         T * cmemalign( size_t align, size_t dim  ) {
                 return (T *)cmemalign( align, dim, sizeof(T) ); // CFA cmemalign
@@ -86 +101 @@
 
         T * alloc( size_t dim ) {
-                if ( _Alignof(T) <= libAlign() ) return (T *)(void *)malloc( dim * (size_t)sizeof(T) );
-                else return (T *)memalign( _Alignof(T), dim * sizeof(T) );
+                return aalloc( dim );
         } // alloc
 
@@ -106 +120 @@
                         return (T *)(void *)realloc( (void *)ptr, dim * sizeof(T) ); // C realloc
                 } else {
-                        struct __Unknown {};
-                        return alloc( (__Unknown *)ptr, dim );          // reuse, cheat making T/S different types
+                        return resize( ptr, dim * sizeof(T) );          // resize
                 } // if
         } // alloc
@@ -148 +161 @@
         } // alloc_align
 
-        T * alloc_align( T ptr[], size_t align ) {                      // aligned realloc array
+        T * alloc_align( T * ptr, size_t align ) {                      // aligned realloc array
                 return (T *)(void *)realloc( (void *)ptr, align, sizeof(T) ); // CFA realloc
         } // alloc_align

src/ControlStruct/ExceptTranslate.cc

@@ -10 +10 @@
 // Created On       : Wed Jun 14 16:49:00 2017
 // Last Modified By : Andrew Beach
-// Last Modified On : Fri Mar 27 11:58:00 2020
-// Update Count     : 13
+// Last Modified On : Thr May 21 13:18:00 2020
+// Update Count     : 15
 //
 
@@ -64 +64 @@
         }
 
-        class ExceptionMutatorCore : public WithGuards {
-                enum Context { NoHandler, TerHandler, ResHandler };
-
-                // Also need to handle goto, break & continue.
-                // They need to be cut off in a ResHandler, until we enter another
-                // loop, switch or the goto stays within the function.
-
-                Context cur_context;
-
-                // The current (innermost) termination handler exception declaration.
-                ObjectDecl * handler_except_decl;
-
+        class ThrowMutatorCore : public WithGuards {
+                ObjectDecl * terminate_handler_except;
+                enum Context { NoHandler, TerHandler, ResHandler } cur_context;
+
+                // The helper functions for code/syntree generation.
+                Statement * create_either_throw(
+                        ThrowStmt * throwStmt, const char * throwFunc );
+                Statement * create_terminate_rethrow( ThrowStmt * throwStmt );
+                Statement * create_resume_rethrow( ThrowStmt * throwStmt );
+
+        public:
+                ThrowMutatorCore() :
+                        terminate_handler_except( nullptr ),
+                        cur_context( NoHandler )
+                {}
+
+                void premutate( CatchStmt *catchStmt );
+                Statement * postmutate( ThrowStmt *throwStmt );
+        };
+
+        // ThrowStmt Mutation Helpers
+
+        Statement * ThrowMutatorCore::create_either_throw(
+                        ThrowStmt * throwStmt, const char * throwFunc ) {
+                // `throwFunc`( `throwStmt->get_name()` );
+                UntypedExpr * call = new UntypedExpr( new NameExpr( throwFunc ) );
+                call->get_args().push_back( throwStmt->get_expr() );
+                throwStmt->set_expr( nullptr );
+                delete throwStmt;
+                return new ExprStmt( call );
+        }
+
+        Statement * ThrowMutatorCore::create_terminate_rethrow(
+                        ThrowStmt *throwStmt ) {
+                // { `terminate_handler_except` = 0p; __rethrow_terminate(); }
+                assert( nullptr == throwStmt->get_expr() );
+                assert( terminate_handler_except );
+
+                CompoundStmt * result = new CompoundStmt();
+                result->labels =  throwStmt->labels;
+                result->push_back( new ExprStmt( UntypedExpr::createAssign(
+                        nameOf( terminate_handler_except ),
+                        new ConstantExpr( Constant::null(
+                                //new PointerType(
+                                //      noQualifiers,
+                                        terminate_handler_except->get_type()->clone()
+                                //      )
+                                ) )
+                        ) ) );
+                result->push_back( new ExprStmt(
+                        new UntypedExpr( new NameExpr( "__cfaehm_rethrow_terminate" ) )
+                        ) );
+                delete throwStmt;
+                return result;
+        }
+
+        Statement * ThrowMutatorCore::create_resume_rethrow(
+                        ThrowStmt *throwStmt ) {
+                // return false;
+                Statement * result = new ReturnStmt(
+                        new ConstantExpr( Constant::from_bool( false ) )
+                        );
+                result->labels = throwStmt->labels;
+                delete throwStmt;
+                return result;
+        }
+
+        // Visiting/Mutating Functions
+
+        void ThrowMutatorCore::premutate( CatchStmt *catchStmt ) {
+                // Validate the statement's form.
+                ObjectDecl * decl = dynamic_cast<ObjectDecl *>( catchStmt->get_decl() );
+                // Also checking the type would be nice.
+                if ( decl ) {
+                        // Pass.
+                } else if ( CatchStmt::Terminate == catchStmt->get_kind() ) {
+                        SemanticError(catchStmt->location, "catch must have exception type");
+                } else {
+                        SemanticError(catchStmt->location, "catchResume must have exception type");
+                }
+
+                // Track the handler context.
+                GuardValue( cur_context );
+                if ( CatchStmt::Terminate == catchStmt->get_kind() ) {
+                        cur_context = TerHandler;
+
+                        GuardValue( terminate_handler_except );
+                        terminate_handler_except = decl;
+                } else {
+                        cur_context = ResHandler;
+                }
+        }
+
+        Statement * ThrowMutatorCore::postmutate( ThrowStmt *throwStmt ) {
+                // Ignoring throwStmt->get_target() for now.
+                if ( ThrowStmt::Terminate == throwStmt->get_kind() ) {
+                        if ( throwStmt->get_expr() ) {
+                                return create_either_throw( throwStmt, "$throw" );
+                        } else if ( TerHandler == cur_context ) {
+                                return create_terminate_rethrow( throwStmt );
+                        } else {
+                                abort("Invalid throw in %s at %i\n",
+                                        throwStmt->location.filename.c_str(),
+                                        throwStmt->location.first_line);
+                        }
+                } else {
+                        if ( throwStmt->get_expr() ) {
+                                return create_either_throw( throwStmt, "$throwResume" );
+                        } else if ( ResHandler == cur_context ) {
+                                return create_resume_rethrow( throwStmt );
+                        } else {
+                                abort("Invalid throwResume in %s at %i\n",
+                                        throwStmt->location.filename.c_str(),
+                                        throwStmt->location.first_line);
+                        }
+                }
+        }
+
+        class TryMutatorCore {
                 // The built in types used in translation.
                 StructDecl * except_decl;
@@ -82 +189 @@
 
                 // The many helper functions for code/syntree generation.
-                Statement * create_given_throw(
-                        const char * throwFunc, ThrowStmt * throwStmt );
-                Statement * create_terminate_throw( ThrowStmt * throwStmt );
-                Statement * create_terminate_rethrow( ThrowStmt * throwStmt );
-                Statement * create_resume_throw( ThrowStmt * throwStmt );
-                Statement * create_resume_rethrow( ThrowStmt * throwStmt );
                 CompoundStmt * take_try_block( TryStmt * tryStmt );
                 FunctionDecl * create_try_wrapper( CompoundStmt * body );
@@ -121 +222 @@
 
         public:
-                ExceptionMutatorCore() :
-                        cur_context( NoHandler ),
-                        handler_except_decl( nullptr ),
+                TryMutatorCore() :
                         except_decl( nullptr ), node_decl( nullptr ), hook_decl( nullptr ),
                         try_func_t( noQualifiers, false ),
@@ -132 +231 @@
                 {}
 
-                void premutate( CatchStmt *catchStmt );
                 void premutate( StructDecl *structDecl );
                 Statement * postmutate( ThrowStmt *throwStmt );
@@ -138 +236 @@
         };
 
-        void ExceptionMutatorCore::init_func_types() {
+        void TryMutatorCore::init_func_types() {
                 assert( except_decl );
 
@@ -196 +294 @@
         }
 
-        // ThrowStmt Mutation Helpers
-
-        Statement * ExceptionMutatorCore::create_given_throw(
-                        const char * throwFunc, ThrowStmt * throwStmt ) {
-                // `throwFunc`( `throwStmt->get_name` );
-                UntypedExpr * call = new UntypedExpr( new NameExpr( throwFunc ) );
-                call->get_args().push_back( throwStmt->get_expr() );
-                throwStmt->set_expr( nullptr );
-                delete throwStmt;
-                return new ExprStmt( call );
-        }
-
-        Statement * ExceptionMutatorCore::create_terminate_throw(
-                        ThrowStmt *throwStmt ) {
-                // __throw_terminate( `throwStmt->get_name()` ); }
-                return create_given_throw( "__cfaehm_throw_terminate", throwStmt );
-        }
-
-        Statement * ExceptionMutatorCore::create_terminate_rethrow(
-                        ThrowStmt *throwStmt ) {
-                // { `handler_except_decl` = NULL; __rethrow_terminate(); }
-                assert( nullptr == throwStmt->get_expr() );
-                assert( handler_except_decl );
-
-                CompoundStmt * result = new CompoundStmt();
-                result->labels =  throwStmt->labels;
-                result->push_back( new ExprStmt( UntypedExpr::createAssign(
-                        nameOf( handler_except_decl ),
-                        new ConstantExpr( Constant::null(
-                                new PointerType(
-                                        noQualifiers,
-                                        handler_except_decl->get_type()->clone()
-                                        )
-                                ) )
-                        ) ) );
-                result->push_back( new ExprStmt(
-                        new UntypedExpr( new NameExpr( "__cfaehm_rethrow_terminate" ) )
-                        ) );
-                delete throwStmt;
-                return result;
-        }
-
-        Statement * ExceptionMutatorCore::create_resume_throw(
-                        ThrowStmt *throwStmt ) {
-                // __throw_resume( `throwStmt->get_name` );
-                return create_given_throw( "__cfaehm_throw_resume", throwStmt );
-        }
-
-        Statement * ExceptionMutatorCore::create_resume_rethrow(
-                        ThrowStmt *throwStmt ) {
-                // return false;
-                Statement * result = new ReturnStmt(
-                        new ConstantExpr( Constant::from_bool( false ) )
-                        );
-                result->labels = throwStmt->labels;
-                delete throwStmt;
-                return result;
-        }
-
         // TryStmt Mutation Helpers
 
-        CompoundStmt * ExceptionMutatorCore::take_try_block( TryStmt *tryStmt ) {
+        CompoundStmt * TryMutatorCore::take_try_block( TryStmt *tryStmt ) {
                 CompoundStmt * block = tryStmt->get_block();
                 tryStmt->set_block( nullptr );
@@ -263 +302 @@
         }
 
-        FunctionDecl * ExceptionMutatorCore::create_try_wrapper(
+        FunctionDecl * TryMutatorCore::create_try_wrapper(
                         CompoundStmt *body ) {
 
@@ -270 +309 @@
         }
 
-        FunctionDecl * ExceptionMutatorCore::create_terminate_catch(
+        FunctionDecl * TryMutatorCore::create_terminate_catch(
                         CatchList &handlers ) {
                 std::list<CaseStmt *> handler_wrappers;
@@ -350 +389 @@
         // Create a single check from a moddified handler.
         // except_obj is referenced, modded_handler will be freed.
-        CompoundStmt * ExceptionMutatorCore::create_single_matcher(
+        CompoundStmt * TryMutatorCore::create_single_matcher(
                         DeclarationWithType * except_obj, CatchStmt * modded_handler ) {
                 // {
@@ -388 +427 @@
         }
 
-        FunctionDecl * ExceptionMutatorCore::create_terminate_match(
+        FunctionDecl * TryMutatorCore::create_terminate_match(
                         CatchList &handlers ) {
                 // int match(exception * except) {
@@ -425 +464 @@
         }
 
-        CompoundStmt * ExceptionMutatorCore::create_terminate_caller(
+        CompoundStmt * TryMutatorCore::create_terminate_caller(
                         FunctionDecl * try_wrapper,
                         FunctionDecl * terminate_catch,
@@ -443 +482 @@
         }
 
-        FunctionDecl * ExceptionMutatorCore::create_resume_handler(
+        FunctionDecl * TryMutatorCore::create_resume_handler(
                         CatchList &handlers ) {
                 // bool handle(exception * except) {
@@ -480 +519 @@
         }
 
-        CompoundStmt * ExceptionMutatorCore::create_resume_wrapper(
+        CompoundStmt * TryMutatorCore::create_resume_wrapper(
                         Statement * wraps,
                         FunctionDecl * resume_handler ) {
@@ -524 +563 @@
         }
 
-        FunctionDecl * ExceptionMutatorCore::create_finally_wrapper(
+        FunctionDecl * TryMutatorCore::create_finally_wrapper(
                         TryStmt * tryStmt ) {
-                // void finally() { <finally code> }
+                // void finally() { `finally->block` }
                 FinallyStmt * finally = tryStmt->get_finally();
                 CompoundStmt * body = finally->get_block();
@@ -537 +576 @@
         }
 
-        ObjectDecl * ExceptionMutatorCore::create_finally_hook(
+        ObjectDecl * TryMutatorCore::create_finally_hook(
                         FunctionDecl * finally_wrapper ) {
                 // struct __cfaehm_cleanup_hook __finally_hook
-                //      __attribute__((cleanup( finally_wrapper )));
+                //      __attribute__((cleanup( `finally_wrapper` )));
 
                 // Make Cleanup Attribute.
@@ -565 +604 @@
 
         // Visiting/Mutating Functions
-        void ExceptionMutatorCore::premutate( CatchStmt *catchStmt ) {
-                // Validate the Statement's form.
-                ObjectDecl * decl =
-                        dynamic_cast<ObjectDecl *>( catchStmt->get_decl() );
-                if ( decl && true /* check decl->get_type() */ ) {
-                        // Pass.
-                } else if ( CatchStmt::Terminate == catchStmt->get_kind() ) {
-                        SemanticError(catchStmt->location, "catch must have exception type");
-                } else {
-                        SemanticError(catchStmt->location, "catchResume must have exception type");
-                }
-
-                // Track the handler context.
-                GuardValue( cur_context );
-                if ( CatchStmt::Terminate == catchStmt->get_kind() ) {
-                        cur_context = TerHandler;
-
-                        GuardValue( handler_except_decl );
-                        handler_except_decl = decl;
-                } else {
-                        cur_context = ResHandler;
-                }
-        }
-
-        void ExceptionMutatorCore::premutate( StructDecl *structDecl ) {
+        void TryMutatorCore::premutate( StructDecl *structDecl ) {
                 if ( !structDecl->has_body() ) {
                         // Skip children?
@@ -604 +619 @@
                         hook_decl = structDecl;
                 }
-                // Later we might get the exception type as well.
-        }
-
-        Statement * ExceptionMutatorCore::postmutate( ThrowStmt *throwStmt ) {
-                assert( except_decl );
-
-                // Ignoring throwStmt->get_target() for now.
-                if ( ThrowStmt::Terminate == throwStmt->get_kind() ) {
-                        if ( throwStmt->get_expr() ) {
-                                return create_terminate_throw( throwStmt );
-                        } else if ( TerHandler == cur_context ) {
-                                return create_terminate_rethrow( throwStmt );
-                        } else {
-                                abort("Invalid throw in %s at %i\n",
-                                        throwStmt->location.filename.c_str(),
-                                        throwStmt->location.first_line);
-                        }
-                } else {
-                        if ( throwStmt->get_expr() ) {
-                                return create_resume_throw( throwStmt );
-                        } else if ( ResHandler == cur_context ) {
-                                return create_resume_rethrow( throwStmt );
-                        } else {
-                                abort("Invalid throwResume in %s at %i\n",
-                                        throwStmt->location.filename.c_str(),
-                                        throwStmt->location.first_line);
-                        }
-                }
-        }
-
-        Statement * ExceptionMutatorCore::postmutate( TryStmt *tryStmt ) {
+        }
+
+        Statement * TryMutatorCore::postmutate( ThrowStmt * ) {
+                // All throws should be removed by this point.
+                assert( false );
+        }
+
+        Statement * TryMutatorCore::postmutate( TryStmt *tryStmt ) {
                 assert( except_decl );
                 assert( node_decl );
@@ -688 +680 @@
         }
 
-        void translateEHM( std::list< Declaration *> & translationUnit ) {
-                PassVisitor<ExceptionMutatorCore> translator;
+        void translateThrows( std::list< Declaration *> & translationUnit ) {
+                PassVisitor<ThrowMutatorCore> translator;
                 mutateAll( translationUnit, translator );
         }
+
+        void translateTries( std::list< Declaration *> & translationUnit ) {
+                PassVisitor<TryMutatorCore> translator;
+                mutateAll( translationUnit, translator );
+        }
 }

src/ControlStruct/ExceptTranslate.h

@@ -9 +9 @@
 // Author           : Andrew Beach
 // Created On       : Tus Jun 06 10:13:00 2017
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jul 22 09:19:23 2017
-// Update Count     : 4
+// Last Modified By : Andrew Beach
+// Last Modified On : Tus May 19 11:47:00 2020
+// Update Count     : 5
 //
 
@@ -21 +21 @@
 
 namespace ControlStruct {
-        void translateEHM( std::list< Declaration *> & translationUnit );
-        // Converts exception handling structures into their underlying C code.  Translation does use the exception
-        // handling header, make sure it is visible wherever translation occurs.
+        void translateThrows( std::list< Declaration *> & translationUnit );
+        /* Replaces all throw & throwResume statements with function calls.
+         * These still need to be resolved, so call this before the reslover.
+         */
+
+        void translateTries( std::list< Declaration *> & translationUnit );
+        /* Replaces all try blocks (and their many clauses) with function definitions and calls.
+         * This uses the exception built-ins to produce typed output and should take place after
+         * the resolver.
+         */
 }
 

src/main.cc

@@ -9 +9 @@
 // Author           : Peter Buhr and Rob Schluntz
 // Created On       : Fri May 15 23:12:02 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Feb  8 08:33:50 2020
-// Update Count     : 633
+// Last Modified By : Andrew Beach
+// Last Modified On : Tue May 19 12:03:00 2020
+// Update Count     : 634
 //
 
@@ -312 +312 @@
                 } // if
 
+                PASS( "Translate Throws", ControlStruct::translateThrows( translationUnit ) );
                 PASS( "Fix Labels", ControlStruct::fixLabels( translationUnit ) );
                 PASS( "Fix Names", CodeGen::fixNames( translationUnit ) );
@@ -354 +355 @@
                 PASS( "Expand Unique Expr", Tuples::expandUniqueExpr( translationUnit ) ); // xxx - is this the right place for this? want to expand ASAP so tha, sequent passes don't need to worry about double-visiting a unique expr - needs to go after InitTweak::fix so that copy constructed return declarations are reused
 
-                PASS( "Translate EHM" , ControlStruct::translateEHM( translationUnit ) );
+                PASS( "Translate Tries" , ControlStruct::translateTries( translationUnit ) );
 
                 PASS( "Gen Waitfor" , Concurrency::generateWaitFor( translationUnit ) );

tests/errors/.expect/completeType.txt

@@ -132 +132 @@
 ?=?: pointer to function
         ... with parameters
-          reference to instance of type _104_0_T (not function type)
-          instance of type _104_0_T (not function type)
+          reference to instance of type _108_0_T (not function type)
+          instance of type _108_0_T (not function type)
         ... returning
-          _retval__operator_assign: instance of type _104_0_T (not function type)
+          _retval__operator_assign: instance of type _108_0_T (not function type)
           ... with attributes:
             Attribute with name: unused

tests/exceptions/conditional.cfa

@@ -56 +56 @@
 
         try {
-                throw &exc;
+                throw exc;
         } catch (num_error * error ; 3 == error->virtual_table->code( error )) {
                 caught_num_error(3, error);
@@ -64 +64 @@
 
         try {
-                throwResume &exc;
+                throwResume exc;
         } catchResume (num_error * error ; 3 == error->virtual_table->code( error )) {
                 caught_num_error(3, error);

tests/exceptions/data-except.cfa

@@ -28 +28 @@
 
         try {
-                throw &except;
+                throw except;
         } catch (paired * exc) {
                 printf("%s(%d, %d)\n", paired_msg(exc), exc->first, exc->second);
@@ -37 +37 @@
 
         try {
-                throwResume &except;
+                throwResume except;
         } catchResume (paired * exc) {
                 printf("%s(%d, %d)\n", paired_msg(exc), exc->first, exc->second);

tests/exceptions/finally.cfa

@@ -12 +12 @@
                 try {
                         printf("termination throw\n");
-                        throw &exc;
+                        throw exc;
                 } finally {
                         loud_exit a = "termination inner finally";
@@ -28 +28 @@
                 try {
                         printf("resumption throw\n");
-                        throwResume &exc;
+                        throwResume exc;
                 } finally {
                         loud_exit a = "resumption inner finally";

tests/exceptions/interact.cfa

@@ -10 +10 @@
         // Resume falls back to terminate.
         try {
-                throwResume &(star){};
+                throwResume (star){};
         } catch (star *) {
                 printf("caught as termination\n");
@@ -17 +17 @@
         try {
                 loud_region a = "try block with resume throw";
-                throwResume &(star){};
+                throwResume (star){};
         } catch (star *) {
                 printf("caught as termination\n");
@@ -29 +29 @@
         try {
                 try {
-                        throw &(star){};
+                        throw (star){};
                 } catchResume (star *) {
                         printf("resume catch on terminate\n");
@@ -43 +43 @@
         try {
                 try {
-                        throwResume &(star){};
+                        throwResume (star){};
                 } catch (star *) {
                         printf("terminate catch on resume\n");
@@ -58 +58 @@
                 try {
                         try {
-                                throw &(star){};
+                                throw (star){};
                         } catchResume (star *) {
                                 printf("inner resume catch (error)\n");
@@ -64 +64 @@
                 } catch (star * error) {
                         printf("termination catch, will resume\n");
-                        throwResume error;
+                        throwResume *error;
                 }
         } catchResume (star *) {
@@ -75 +75 @@
                 try {
                         try {
-                                throwResume &(star){};
+                                throwResume (star){};
                         } catch (star *) {
                                 printf("inner termination catch\n");
@@ -81 +81 @@
                 } catchResume (star * error) {
                         printf("resumption catch, will terminate\n");
-                        throw error;
+                        throw *error;
                 }
         } catch (star *) {
@@ -94 +94 @@
                                 try {
                                         printf("throwing resume moon\n");
-                                        throwResume &(moon){};
+                                        throwResume (moon){};
                                 } catch (star *) {
                                         printf("termination catch\n");
                                 }
                                 printf("throwing resume star\n");
-                                throwResume &(star){};
+                                throwResume (star){};
                         } catchResume (star *) {
                                 printf("resumption star catch\n");
@@ -105 +105 @@
                 } catchResume (moon *) {
                         printf("resumption moon catch, will terminate\n");
-                        throw &(star){};
+                        throw (star){};
                 }
         } catchResume (star *) {

tests/exceptions/resume.cfa

@@ -14 +14 @@
                 loud_exit a = "simple try clause";
                 printf("simple throw\n");
-                throwResume &(zen){};
+                throwResume (zen){};
                 printf("end of try clause\n");
         } catchResume (zen * error) {
@@ -24 +24 @@
         // Throw catch-all test.
         try {
-                throwResume &(zen){};
+                throwResume (zen){};
         } catchResume (exception_t * error) {
                 printf("catch-all\n");
@@ -33 +33 @@
         try {
                 printf("throwing child exception\n");
-                throwResume &(moment_of){};
+                throwResume (moment_of){};
         } catchResume (zen *) {
                 printf("inner parent match\n");
@@ -44 +44 @@
         try {
                 try {
-                        throwResume &(yin){};
+                        throwResume (yin){};
                 } catchResume (zen *) {
                         printf("caught yin as zen\n");
@@ -60 +60 @@
                         loud_exit a = "rethrow inner try";
                         printf("rethrow inner try\n");
-                        throwResume &(zen){};
+                        throwResume (zen){};
                 } catchResume (zen *) {
                         loud_exit a = "rethrowing catch clause";
@@ -75 +75 @@
         try {
                 try {
-                        throwResume &(yin){};
+                        throwResume (yin){};
                 } catchResume (yin *) {
                         printf("caught yin, will throw yang\n");
-                        throwResume &(yang){};
+                        throwResume (yang){};
                 } catchResume (yang *) {
                         printf("caught exception from same try\n");
@@ -91 +91 @@
                 try {
                         printf("throwing first exception\n");
-                        throwResume &(yin){};
+                        throwResume (yin){};
                 } catchResume (yin *) {
                         printf("caught first exception\n");
                         try {
                                 printf("throwing second exception\n");
-                                throwResume &(yang){};
+                                throwResume (yang){};
                         } catchResume (yang *) {
                                 printf("caught second exception\n");
@@ -112 +112 @@
         try {
                 try {
-                        throwResume &(zen){};
-                        throwResume &(zen){};
+                        throwResume (zen){};
+                        throwResume (zen){};
                 } catchResume (zen *) {
                         printf("inner catch\n");
                 }
-                throwResume &(zen){};
+                throwResume (zen){};
         } catchResume (zen *) {
                 printf("outer catch\n");

tests/exceptions/terminate.cfa

@@ -14 +14 @@
                 loud_exit a = "simple try clause";
                 printf("simple throw\n");
-                throw &(zen){};
+                throw (zen){};
                 printf("end of try clause\n");
         } catch (zen * error) {
@@ -24 +24 @@
         // Throw catch-all test.
         try {
-                throw &(zen){};
+                throw (zen){};
         } catch (exception_t * error) {
                 printf("catch-all\n");
@@ -33 +33 @@
         try {
                 printf("throwing child exception\n");
-                throw &(moment_of){};
+                throw (moment_of){};
         } catch (zen *) {
                 printf("inner parent match\n");
@@ -44 +44 @@
         try {
                 try {
-                        throw &(yin){};
+                        throw (yin){};
                 } catch (zen *) {
                         printf("caught yin as zen\n");
@@ -60 +60 @@
                         loud_exit a = "rethrow inner try";
                         printf("rethrow inner try\n");
-                        throw &(zen){};
+                        throw (zen){};
                 } catch (zen *) {
                         loud_exit a = "rethrowing catch clause";
@@ -75 +75 @@
         try {
                 try {
-                        throw &(yin){};
+                        throw (yin){};
                 } catch (yin *) {
                         printf("caught yin, will throw yang\n");
-                        throw &(yang){};
+                        throw (yang){};
                 } catch (yang *) {
                         printf("caught exception from same try\n");
@@ -91 +91 @@
                 try {
                         printf("throwing first exception\n");
-                        throw &(yin){};
+                        throw (yin){};
                 } catch (yin *) {
                         printf("caught first exception\n");
                         try {
                                 printf("throwing second exception\n");
-                                throw &(yang){};
+                                throw (yang){};
                         } catch (yang *) {
                                 printf("caught second exception\n");
@@ -112 +112 @@
         try {
                 try {
-                        throw &(zen){};
-                        throw &(zen){};
+                        throw (zen){};
+                        throw (zen){};
                 } catch (zen *) {
                         printf("inner catch\n");
                 }
-                throw &(zen){};
+                throw (zen){};
         } catch (zen *) {
                 printf("outer catch\n");

tests/list/.expect/dlist-insert-remove.txt

@@ -1464 +1464 @@
 0.7
 -
+
+~~~~~~~~~~ End removal tests on Headed List: First ~~~~~~~~~~
+
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Test 16-i.  Modifying Freds on MINE
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+==== fred by MINE before 
+1.7
+2.7
+3.7
+-
+1.7
+-
+3.7
+-
+3.7
+2.7
+1.7
+-
+==== fred by YOURS before 
+1.7
+2.7
+3.7
+-
+1.7
+-
+3.7
+-
+3.7
+2.7
+1.7
+-
+==== fred by MINE after 
+2.7
+3.7
+-
+2.7
+-
+3.7
+-
+3.7
+2.7
+-
+==== fred by YOURS after 
+1.7
+2.7
+3.7
+-
+1.7
+-
+3.7
+-
+3.7
+2.7
+1.7
+-
+==== fred by MINE after 
+1.7
+-
+1.7
+-
+-
+-
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Test 16-ii.  Modifying Freds on YOURS
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+==== fred by MINE before 
+1.7
+2.7
+3.7
+-
+1.7
+-
+3.7
+-
+3.7
+2.7
+1.7
+-
+==== fred by YOURS before 
+1.7
+2.7
+3.7
+-
+1.7
+-
+3.7
+-
+3.7
+2.7
+1.7
+-
+==== fred by MINE after 
+1.7
+2.7
+3.7
+-
+1.7
+-
+3.7
+-
+3.7
+2.7
+1.7
+-
+==== fred by YOURS after 
+2.7
+3.7
+-
+2.7
+-
+3.7
+-
+3.7
+2.7
+-
+==== fred by YOURS after 
+1.7
+-
+1.7
+-
+-
+-
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Test 16-iii.  Modifying Maries
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+==== mary before 
+1.7
+2.7
+3.7
+-
+1.7
+-
+3.7
+-
+3.7
+2.7
+1.7
+-
+==== mary after 
+2.7
+3.7
+-
+2.7
+-
+3.7
+-
+3.7
+2.7
+-
+==== mary after 
+1.7
+-
+1.7
+-
+-
+-
+
+~~~~~~~~~~ End removal tests on Headed List: Last ~~~~~~~~~~
+
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Test 17-i.  Modifying Freds on MINE
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+==== fred by MINE before 
+1.7
+2.7
+3.7
+-
+1.7
+-
+3.7
+-
+3.7
+2.7
+1.7
+-
+==== fred by YOURS before 
+1.7
+2.7
+3.7
+-
+1.7
+-
+3.7
+-
+3.7
+2.7
+1.7
+-
+==== fred by MINE after 
+1.7
+2.7
+-
+1.7
+-
+2.7
+-
+2.7
+1.7
+-
+==== fred by YOURS after 
+1.7
+2.7
+3.7
+-
+1.7
+-
+3.7
+-
+3.7
+2.7
+1.7
+-
+==== fred by MINE after 
+3.7
+-
+3.7
+-
+-
+-
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Test 17-ii.  Modifying Freds on YOURS
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+==== fred by MINE before 
+1.7
+2.7
+3.7
+-
+1.7
+-
+3.7
+-
+3.7
+2.7
+1.7
+-
+==== fred by YOURS before 
+1.7
+2.7
+3.7
+-
+1.7
+-
+3.7
+-
+3.7
+2.7
+1.7
+-
+==== fred by MINE after 
+1.7
+2.7
+3.7
+-
+1.7
+-
+3.7
+-
+3.7
+2.7
+1.7
+-
+==== fred by YOURS after 
+1.7
+2.7
+-
+1.7
+-
+2.7
+-
+2.7
+1.7
+-
+==== fred by YOURS after 
+3.7
+-
+3.7
+-
+-
+-
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Test 17-iii.  Modifying Maries
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+==== mary before 
+1.7
+2.7
+3.7
+-
+1.7
+-
+3.7
+-
+3.7
+2.7
+1.7
+-
+==== mary after 
+1.7
+2.7
+-
+1.7
+-
+2.7
+-
+2.7
+1.7
+-
+==== mary after 
+3.7
+-
+3.7
+-
+-
+-

tests/list/dlist-insert-remove.cfa

@@ -1187 +1187 @@
 ////////////////////////////////////////////////////////////
 //
+// Section 4f
+//
+// Test cases of pop_first, pop_last
+//
+// Example of call-side user code
+//
+////////////////////////////////////////////////////////////
+
+// These cases assume element removal at first-last is correct
+
+void test__pop_first__fred_mine() {
+
+        fred f1 = {1.7};
+        fred f2 = {2.7};
+        fred f3 = {3.7};
+
+        dlist(fred_in_mine, fred) flm;
+        insert_last(flm, f1);
+        insert_last(flm, f2);
+        insert_last(flm, f3);
+
+        dlist(fred_in_yours, fred) fly;
+        insert_last(fly, f1);
+        insert_last(fly, f2);
+        insert_last(fly, f3);
+
+        printMyFreddies(flm`first, flm`last, 1);     // 1.7, 2.7, 3.7;  1.7;  3.7;  3.7, 2.7, 1.7 
+        printYourFreddies(fly`first, fly`last, 1);   // 1.7, 2.7, 3.7;  1.7;  3.7;  3.7, 2.7, 1.7 
+
+        verify(validate(fly));
+        verify(validate(flm));
+
+        fred & popped = pop_first(flm);
+
+        verify(validate(fly));
+        verify(validate(flm));
+
+        printMyFreddies(flm`first, flm`last, 0);     // 2.7, 3.7;       2.7;  3.7;  3.7, 2.7      (modified)
+        printYourFreddies(fly`first, fly`last, 0);   // 1.7, 2.7, 3.7;  1.7;  3.7;  3.7, 2.7, 1.7 (unmodified)
+
+        // observe f1 is now solo in mine; in yours, it was just traversed
+        printMyFreddies(f1, *0p, 0);    // 1.7; 1.7; ;
+
+        assert( &popped == & f1 );
+}
+
+void test__pop_first__fred_yours() {
+
+        fred f1 = {1.7};
+        fred f2 = {2.7};
+        fred f3 = {3.7};
+
+        dlist(fred_in_mine, fred) flm;
+        insert_last(flm, f1);
+        insert_last(flm, f2);
+        insert_last(flm, f3);
+
+        dlist(fred_in_yours, fred) fly;
+        insert_last(fly, f1);
+        insert_last(fly, f2);
+        insert_last(fly, f3);
+
+        printMyFreddies(flm`first, flm`last, 1);     // 1.7, 2.7, 3.7;  1.7;  3.7;  3.7, 2.7, 1.7 
+        printYourFreddies(fly`first, fly`last, 1);   // 1.7, 2.7, 3.7;  1.7;  3.7;  3.7, 2.7, 1.7 
+
+        verify(validate(fly));
+        verify(validate(flm));
+
+        fred & popped = pop_first(fly);
+
+        verify(validate(fly));
+        verify(validate(flm));
+
+        printMyFreddies(flm`first, flm`last, 0);     // 1.7, 2.7, 3.7;  1.7;  3.7;  3.7, 2.7, 1.7 (unmodified)
+        printYourFreddies(fly`first, fly`last, 0);   // 2.7, 3.7;       2.7;  3.7;  3.7, 2.7      (modified)
+
+        // observe f1 is now solo in yours; in mine, it was just traversed
+        printYourFreddies(f1, *0p, 0);    // 1.7; 1.7; ;
+
+        assert( &popped == &f1 );
+}
+
+void test__pop_first__maries() {
+
+        mary m1 = {1.7};
+        mary m2 = {2.7};
+        mary m3 = {3.7};
+
+        dlist(mary, mary) ml;
+        insert_last(ml, m1);
+        insert_last(ml, m2);
+        insert_last(ml, m3);
+
+        printMariatheotokos(ml`first, ml`last, 1);     // 1.7, 2.7, 3.7;  1.7;  3.7;  3.7, 2.7, 1.7 
+
+        verify(validate(ml));
+
+        mary & popped = pop_first(ml);
+
+        verify(validate(ml));
+
+        printMariatheotokos(ml`first, ml`last, 0);     // 2.7, 3.7;       2.7;  3.7;  3.7, 2.7      (modified)
+
+        // observe m1 is now solo
+        printMariatheotokos(m1, *0p, 0);               // 1.7; 1.7; ;
+
+        assert( &popped == &m1 );
+}
+
+void test__pop_last__fred_mine() {
+
+        fred f1 = {1.7};
+        fred f2 = {2.7};
+        fred f3 = {3.7};
+
+        dlist(fred_in_mine, fred) flm;
+        insert_last(flm, f1);
+        insert_last(flm, f2);
+        insert_last(flm, f3);
+
+        dlist(fred_in_yours, fred) fly;
+        insert_last(fly, f1);
+        insert_last(fly, f2);
+        insert_last(fly, f3);
+
+        printMyFreddies(flm`first, flm`last, 1);     // 1.7, 2.7, 3.7;  1.7;  3.7;  3.7, 2.7, 1.7 
+        printYourFreddies(fly`first, fly`last, 1);   // 1.7, 2.7, 3.7;  1.7;  3.7;  3.7, 2.7, 1.7 
+
+        verify(validate(fly));
+        verify(validate(flm));
+
+        fred & popped = pop_last(flm);
+
+        verify(validate(fly));
+        verify(validate(flm));
+
+        printMyFreddies(flm`first, flm`last, 0);     // 1.7, 2.7;       1.7;  2.7;  2.7, 1.7      (modified)
+        printYourFreddies(fly`first, fly`last, 0);   // 1.7, 2.7, 3.7;  1.7;  3.7;  3.7, 2.7, 1.7 (unmodified)
+
+        // observe f3 is now solo in mine; in yours, it was just traversed
+        printMyFreddies(f3, *0p, 0);    // 3.7; 3.7; ;
+
+        assert( &popped == & f3 );
+}
+
+void test__pop_last__fred_yours() {
+
+        fred f1 = {1.7};
+        fred f2 = {2.7};
+        fred f3 = {3.7};
+
+        dlist(fred_in_mine, fred) flm;
+        insert_last(flm, f1);
+        insert_last(flm, f2);
+        insert_last(flm, f3);
+
+        dlist(fred_in_yours, fred) fly;
+        insert_last(fly, f1);
+        insert_last(fly, f2);
+        insert_last(fly, f3);
+
+        printMyFreddies(flm`first, flm`last, 1);     // 1.7, 2.7, 3.7;  1.7;  3.7;  3.7, 2.7, 1.7 
+        printYourFreddies(fly`first, fly`last, 1);   // 1.7, 2.7, 3.7;  1.7;  3.7;  3.7, 2.7, 1.7 
+
+        verify(validate(fly));
+        verify(validate(flm));
+
+        fred & popped = pop_last(fly);
+
+        verify(validate(fly));
+        verify(validate(flm));
+
+        printMyFreddies(flm`first, flm`last, 0);     // 1.7, 2.7, 3.7;  1.7;  3.7;  3.7, 2.7, 1.7 (unmodified)
+        printYourFreddies(fly`first, fly`last, 0);   // 1.7, 2.7;       1.7;  2.7;  2.7, 1.7      (modified)
+
+        // observe f3 is now solo in yours; in mine, it was just traversed
+        printYourFreddies(f3, *0p, 0);    // 3.7; 3.7; ;
+
+        assert( &popped == & f3 );
+}
+
+void test__pop_last__maries() {
+
+        mary m1 = {1.7};
+        mary m2 = {2.7};
+        mary m3 = {3.7};
+
+        dlist(mary, mary) ml;
+        insert_last(ml, m1);
+        insert_last(ml, m2);
+        insert_last(ml, m3);
+
+        printMariatheotokos(ml`first, ml`last, 1);     // 1.7, 2.7, 3.7;  1.7;  3.7;  3.7, 2.7, 1.7 
+
+        verify(validate(ml));
+
+        mary & popped = pop_last(ml);
+
+        verify(validate(ml));
+
+        printMariatheotokos(ml`first, ml`last, 0);     // 1.7, 1.7;       1.7;  2.7;  2.7, 1.7      (modified)
+
+        // observe m1 is now solo
+        printMariatheotokos(m3, *0p, 0);               // 3.7; 3.7; ;
+
+        assert( &popped == &m3 );
+}
+
+////////////////////////////////////////////////////////////
+//
 // Section 5
 //
@@ -1422 +1632 @@
         test__remove_of_sole__mary();
 
+        sout | "";
+        sout | "~~~~~~~~~~ End removal tests on Headed List: First ~~~~~~~~~~";
+        sout | "";
+
+        sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~";
+        sout | "Test 16-i.  Modifying Freds on MINE";
+        sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~";
+        test__pop_first__fred_mine();
+
+        sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~";
+        sout | "Test 16-ii.  Modifying Freds on YOURS";
+        sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~";
+        test__pop_first__fred_yours();
+
+        sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~";
+        sout | "Test 16-iii.  Modifying Maries";
+        sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~";
+        test__pop_first__maries();
+
+        sout | "";
+        sout | "~~~~~~~~~~ End removal tests on Headed List: Last ~~~~~~~~~~";
+        sout | "";
+
+        sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~";
+        sout | "Test 17-i.  Modifying Freds on MINE";
+        sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~";
+        test__pop_last__fred_mine();
+
+        sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~";
+        sout | "Test 17-ii.  Modifying Freds on YOURS";
+        sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~";
+        test__pop_last__fred_yours();
+
+        sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~";
+        sout | "Test 17-iii.  Modifying Maries";
+        sout | "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~";
+        test__pop_last__maries();
+
         return 0;
 }