Changeset 376c632a

Timestamp:

Feb 1, 2022, 10:10:46 AM (14 months ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

enum, forall-pointer-decay, master, pthread-emulation, qualifiedEnum

Children:

7b2c8c3c

Parents:

f681823 (diff), 89a5a1f (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Files:

• libcfa/src/concurrency/io.cfa (modified) (1 diff)
• libcfa/src/concurrency/kernel.cfa (modified) (13 diffs)
• libcfa/src/concurrency/kernel/fwd.hfa (modified) (1 diff)
• libcfa/src/concurrency/stats.cfa (modified) (3 diffs)
• libcfa/src/concurrency/stats.hfa (modified) (1 diff)
• src/AST/Copy.hpp (modified) (2 diffs)
• src/AST/Node.hpp (modified) (1 diff)
• src/AST/Pass.impl.hpp (modified) (120 diffs)
• src/AST/Stmt.hpp (modified) (12 diffs)
• src/ControlStruct/ExceptTranslateNew.cpp (modified) (3 diffs)
• src/ControlStruct/FixLabels.cpp (modified) (8 diffs)
• src/ControlStruct/FixLabels.hpp (modified) (2 diffs)
• src/ControlStruct/ForExprMutator.h (modified) (2 diffs)
• src/ControlStruct/HoistControlDecls.cpp (added)
• src/ControlStruct/HoistControlDecls.hpp (added)
• src/ControlStruct/LabelFixer.cc (modified) (2 diffs)
• src/ControlStruct/LabelFixer.h (modified) (2 diffs)
• src/ControlStruct/LabelGenerator.cc (modified) (3 diffs)
• src/ControlStruct/LabelGenerator.h (modified) (2 diffs)
• src/ControlStruct/LabelGeneratorNew.cpp (added)
• src/ControlStruct/LabelGeneratorNew.hpp (added)
• src/ControlStruct/MultiLevelExit.cpp (modified) (25 diffs)
• src/ControlStruct/MultiLevelExit.hpp (modified) (2 diffs)
• src/ControlStruct/module.mk (modified) (2 diffs)
• src/InitTweak/InitTweak.cc (modified) (2 diffs)
• src/InitTweak/InitTweak.h (modified) (2 diffs)
• src/Parser/ParseNode.h (modified) (3 diffs)
• src/Parser/StatementNode.cc (modified) (4 diffs)
• src/Parser/parser.yy (modified) (5 diffs)
• src/SymTab/Validate.cc (modified) (2 diffs)
• src/SymTab/Validate.h (modified) (1 diff)
• src/Validate/Autogen.cpp (added)
• src/Validate/Autogen.hpp (added)
• src/Validate/module.mk (modified) (1 diff)
• src/main.cc (modified) (7 diffs)
• tests/concurrent/preempt.cfa (modified) (5 diffs)

libcfa/src/concurrency/io.cfa

@@ -306 +306 @@
                 ctx->proc->io.pending = true;
                 ctx->proc->io.dirty   = true;
-                if(sq.to_submit > 30 || !lazy) {
+                if(sq.to_submit > 30) {
+                        __tls_stats()->io.flush.full++;
+                        __cfa_io_flush( ctx->proc, 0 );
+                }
+                if(!lazy) {
+                        __tls_stats()->io.flush.eager++;
                         __cfa_io_flush( ctx->proc, 0 );
                 }

libcfa/src/concurrency/kernel.cfa

@@ -42 +42 @@
 
 #if !defined(__CFA_NO_STATISTICS__)
-        #define __STATS( ...) __VA_ARGS__
+        #define __STATS_DEF( ...) __VA_ARGS__
 #else
-        #define __STATS( ...)
+        #define __STATS_DEF( ...)
 #endif
 
@@ -122 +122 @@
 static thread$ * __next_thread(cluster * this);
 static thread$ * __next_thread_slow(cluster * this);
+static thread$ * __next_thread_search(cluster * this);
 static inline bool __must_unpark( thread$ * thrd ) __attribute((nonnull(1)));
 static void __run_thread(processor * this, thread$ * dst);
@@ -187 +188 @@
                 MAIN_LOOP:
                 for() {
-                        #define OLD_MAIN 1
-                        #if OLD_MAIN
                         // Check if there is pending io
                         __maybe_io_drain( this );
@@ -196 +195 @@
 
                         if( !readyThread ) {
+                                __IO_STATS__(true, io.flush.idle++; )
                                 __cfa_io_flush( this, 0 );
 
+                                readyThread = __next_thread( this->cltr );
+                        }
+
+                        if( !readyThread ) for(5) {
+                                __IO_STATS__(true, io.flush.idle++; )
+
                                 readyThread = __next_thread_slow( this->cltr );
+
+                                if( readyThread ) break;
+
+                                __cfa_io_flush( this, 0 );
                         }
 
@@ -210 +220 @@
 
                                 // Confirm the ready-queue is empty
-                                readyThread = __next_thread_slow( this->cltr );
+                                readyThread = __next_thread_search( this->cltr );
                                 if( readyThread ) {
                                         // A thread was found, cancel the halt
                                         mark_awake(this->cltr->procs, * this);
 
-                                        #if !defined(__CFA_NO_STATISTICS__)
-                                                __tls_stats()->ready.sleep.cancels++;
-                                        #endif
+                                        __STATS__(true, ready.sleep.cancels++; )
 
                                         // continue the mai loop
@@ -244 +252 @@
 
                         if(this->io.pending && !this->io.dirty) {
+                                __IO_STATS__(true, io.flush.dirty++; )
                                 __cfa_io_flush( this, 0 );
                         }
-
-                        #else
-                                #warning new kernel loop
-                        SEARCH: {
-                                /* paranoid */ verify( ! __preemption_enabled() );
-
-                                // First, lock the scheduler since we are searching for a thread
-                                ready_schedule_lock();
-
-                                // Try to get the next thread
-                                readyThread = pop_fast( this->cltr );
-                                if(readyThread) { ready_schedule_unlock(); break SEARCH; }
-
-                                // If we can't find a thread, might as well flush any outstanding I/O
-                                if(this->io.pending) { __cfa_io_flush( this, 0 ); }
-
-                                // Spin a little on I/O, just in case
-                                for(5) {
-                                        __maybe_io_drain( this );
-                                        readyThread = pop_fast( this->cltr );
-                                        if(readyThread) { ready_schedule_unlock(); break SEARCH; }
-                                }
-
-                                // no luck, try stealing a few times
-                                for(5) {
-                                        if( __maybe_io_drain( this ) ) {
-                                                readyThread = pop_fast( this->cltr );
-                                        } else {
-                                                readyThread = pop_slow( this->cltr );
-                                        }
-                                        if(readyThread) { ready_schedule_unlock(); break SEARCH; }
-                                }
-
-                                // still no luck, search for a thread
-                                readyThread = pop_search( this->cltr );
-                                if(readyThread) { ready_schedule_unlock(); break SEARCH; }
-
-                                // Don't block if we are done
-                                if( __atomic_load_n(&this->do_terminate, __ATOMIC_SEQ_CST) ) {
-                                        ready_schedule_unlock();
-                                        break MAIN_LOOP;
-                                }
-
-                                __STATS( __tls_stats()->ready.sleep.halts++; )
-
-                                // Push self to idle stack
-                                ready_schedule_unlock();
-                                if(!mark_idle(this->cltr->procs, * this)) goto SEARCH;
-                                ready_schedule_lock();
-
-                                // Confirm the ready-queue is empty
-                                __maybe_io_drain( this );
-                                readyThread = pop_search( this->cltr );
-                                ready_schedule_unlock();
-
-                                if( readyThread ) {
-                                        // A thread was found, cancel the halt
-                                        mark_awake(this->cltr->procs, * this);
-
-                                        __STATS( __tls_stats()->ready.sleep.cancels++; )
-
-                                        // continue the main loop
-                                        break SEARCH;
-                                }
-
-                                __STATS( if(this->print_halts) __cfaabi_bits_print_safe( STDOUT_FILENO, "PH:%d - %lld 0\n", this->unique_id, rdtscl()); )
-                                __cfadbg_print_safe(runtime_core, "Kernel : core %p waiting on eventfd %d\n", this, this->idle_fd);
-
-                                {
-                                        eventfd_t val;
-                                        ssize_t ret = read( this->idle_fd, &val, sizeof(val) );
-                                        if(ret < 0) {
-                                                switch((int)errno) {
-                                                case EAGAIN:
-                                                #if EAGAIN != EWOULDBLOCK
-                                                        case EWOULDBLOCK:
-                                                #endif
-                                                case EINTR:
-                                                        // No need to do anything special here, just assume it's a legitimate wake-up
-                                                        break;
-                                                default:
-                                                        abort( "KERNEL : internal error, read failure on idle eventfd, error(%d) %s.", (int)errno, strerror( (int)errno ) );
-                                                }
-                                        }
-                                }
-
-                                        __STATS( if(this->print_halts) __cfaabi_bits_print_safe( STDOUT_FILENO, "PH:%d - %lld 1\n", this->unique_id, rdtscl()); )
-
-                                // We were woken up, remove self from idle
-                                mark_awake(this->cltr->procs, * this);
-
-                                // DON'T just proceed, start looking again
-                                continue MAIN_LOOP;
-                        }
-
-                RUN_THREAD:
-                        /* paranoid */ verify( ! __preemption_enabled() );
-                        /* paranoid */ verify( readyThread );
-
-                        // Reset io dirty bit
-                        this->io.dirty = false;
-
-                        // We found a thread run it
-                        __run_thread(this, readyThread);
-
-                        // Are we done?
-                        if( __atomic_load_n(&this->do_terminate, __ATOMIC_SEQ_CST) ) break MAIN_LOOP;
-
-                        if(this->io.pending && !this->io.dirty) {
-                                __cfa_io_flush( this, 0 );
-                        }
-
-                        ready_schedule_lock();
-                        __maybe_io_drain( this );
-                        ready_schedule_unlock();
-                        #endif
                 }
 
@@ -472 +365 @@
                                 break RUNNING;
                         case TICKET_UNBLOCK:
-                                #if !defined(__CFA_NO_STATISTICS__)
-                                        __tls_stats()->ready.threads.threads++;
-                                #endif
+                                __STATS__(true, ready.threads.threads++; )
                                 // This is case 2, the racy case, someone tried to run this thread before it finished blocking
                                 // In this case, just run it again.
@@ -489 +380 @@
         __cfadbg_print_safe(runtime_core, "Kernel : core %p finished running thread %p\n", this, thrd_dst);
 
-        #if !defined(__CFA_NO_STATISTICS__)
-                __tls_stats()->ready.threads.threads--;
-        #endif
+        __STATS__(true, ready.threads.threads--; )
 
         /* paranoid */ verify( ! __preemption_enabled() );
@@ -502 +391 @@
         thread$ * thrd_src = kernelTLS().this_thread;
 
-        __STATS( thrd_src->last_proc = kernelTLS().this_processor; )
+        __STATS_DEF( thrd_src->last_proc = kernelTLS().this_processor; )
 
         // Run the thread on this processor
@@ -554 +443 @@
         // Dereference the thread now because once we push it, there is not guaranteed it's still valid.
         struct cluster * cl = thrd->curr_cluster;
-        __STATS(bool outside = hint == UNPARK_LOCAL && thrd->last_proc && thrd->last_proc != kernelTLS().this_processor; )
+        __STATS_DEF(bool outside = hint == UNPARK_LOCAL && thrd->last_proc && thrd->last_proc != kernelTLS().this_processor; )
 
         // push the thread to the cluster ready-queue
@@ -605 +494 @@
 
         ready_schedule_lock();
-                thread$ * thrd;
-                for(25) {
-                        thrd = pop_slow( this );
-                        if(thrd) goto RET;
-                }
-                thrd = pop_search( this );
-
-                RET:
+                thread$ * thrd = pop_slow( this );
+        ready_schedule_unlock();
+
+        /* paranoid */ verify( ! __preemption_enabled() );
+        return thrd;
+}
+
+// KERNEL ONLY
+static inline thread$ * __next_thread_search(cluster * this) with( *this ) {
+        /* paranoid */ verify( ! __preemption_enabled() );
+
+        ready_schedule_lock();
+                thread$ * thrd = pop_search( this );
         ready_schedule_unlock();
 
@@ -854 +748 @@
 
 static bool mark_idle(__cluster_proc_list & this, processor & proc) {
-        #if !defined(__CFA_NO_STATISTICS__)
-                __tls_stats()->ready.sleep.halts++;
-        #endif
+        __STATS__(true, ready.sleep.halts++; )
 
         proc.idle_wctx.fd = 0;
@@ -949 +841 @@
                 unsigned tail = *ctx->cq.tail;
                 if(head == tail) return false;
-                #if OLD_MAIN
-                        ready_schedule_lock();
-                        ret = __cfa_io_drain( proc );
-                        ready_schedule_unlock();
-                #else
-                        ret = __cfa_io_drain( proc );
-                #endif
+                ready_schedule_lock();
+                ret = __cfa_io_drain( proc );
+                ready_schedule_unlock();
         #endif
         return ret;

libcfa/src/concurrency/kernel/fwd.hfa

@@ -396 +396 @@
                                 if( !(in_kernel) ) enable_interrupts(); \
                         }
+                        #if defined(CFA_HAVE_LINUX_IO_URING_H)
+                                #define __IO_STATS__(in_kernel, ...) { \
+                                        if( !(in_kernel) ) disable_interrupts(); \
+                                        with( *__tls_stats() ) { \
+                                                __VA_ARGS__ \
+                                        } \
+                                        if( !(in_kernel) ) enable_interrupts(); \
+                                }
+                        #else
+                                #define __IO_STATS__(in_kernel, ...)
+                        #endif
                 #else
                         #define __STATS__(in_kernel, ...)
+                        #define __IO_STATS__(in_kernel, ...)
                 #endif
         }

libcfa/src/concurrency/stats.cfa

@@ -45 +45 @@
                         stats->io.submit.slow       = 0;
                         stats->io.flush.external    = 0;
+                        stats->io.flush.dirty       = 0;
+                        stats->io.flush.full        = 0;
+                        stats->io.flush.idle        = 0;
+                        stats->io.flush.eager       = 0;
                         stats->io.calls.flush       = 0;
                         stats->io.calls.submitted   = 0;
@@ -107 +111 @@
                         tally_one( &cltr->io.submit.slow      , &proc->io.submit.slow       );
                         tally_one( &cltr->io.flush.external   , &proc->io.flush.external    );
+                        tally_one( &cltr->io.flush.dirty      , &proc->io.flush.dirty       );
+                        tally_one( &cltr->io.flush.full       , &proc->io.flush.full        );
+                        tally_one( &cltr->io.flush.idle       , &proc->io.flush.idle        );
+                        tally_one( &cltr->io.flush.eager      , &proc->io.flush.eager       );
                         tally_one( &cltr->io.calls.flush      , &proc->io.calls.flush       );
                         tally_one( &cltr->io.calls.submitted  , &proc->io.calls.submitted   );
@@ -184 +192 @@
                                 if(io.alloc.fail || io.alloc.revoke || io.alloc.block)
                                         sstr | "-     failures      : " | eng3(io.alloc.fail) | "oom, " | eng3(io.alloc.revoke) | "rvk, " | eng3(io.alloc.block) | "blk";
-                                if(io.flush.external)
-                                        sstr | "- flush external    : " | eng3(io.flush.external);
+                                // if(io.flush.external)
+                                //      sstr | "- flush external    : " | eng3(io.flush.external);
 
                                 double avgsubs = ((double)io.calls.submitted) / io.calls.flush;
                                 double avgcomp = ((double)io.calls.completed) / io.calls.drain;
                                 sstr | "- syscll : "
-                                     |   " sub " | eng3(io.calls.flush) | "/" | eng3(io.calls.submitted) | "(" | ws(3, 3, avgsubs) | "/flush)"
-                                     | " - cmp " | eng3(io.calls.drain) | "/" | eng3(io.calls.completed) | "(" | ws(3, 3, avgcomp) | "/drain)"
+                                     |   " sub " | eng3(io.calls.submitted) | "/" | eng3(io.calls.flush) | "(" | ws(3, 3, avgsubs) | "/flush)"
+                                     | " - cmp " | eng3(io.calls.completed) | "/" | eng3(io.calls.drain) | "(" | ws(3, 3, avgcomp) | "/drain)"
                                      | " - " | eng3(io.calls.errors.busy) | " EBUSY";
+                                sstr | " - sub: " | eng3(io.flush.full) | "full, " | eng3(io.flush.dirty) | "drty, " | eng3(io.flush.idle) | "idle, " | eng3(io.flush.eager) | "eagr, " | eng3(io.flush.external) | "ext";
                                 sstr | "- ops blk: "
                                      |   " sk rd: " | eng3(io.ops.sockread)  | "epll: " | eng3(io.ops.epllread)

libcfa/src/concurrency/stats.hfa

@@ -91 +91 @@
                         struct {
                                 volatile uint64_t external;
+                                volatile uint64_t dirty;
+                                volatile uint64_t full;
+                                volatile uint64_t idle;
+                                volatile uint64_t eager;
                         } flush;
                         struct {

src/AST/Copy.hpp

@@ -10 +10 @@
 // Created On       : Wed Jul 10 16:13:00 2019
 // Last Modified By : Andrew Beach
-// Last Modified On : Thr Nov 11  9:22:00 2021
-// Update Count     : 2
+// Last Modified On : Wed Dec 15 11:07:00 2021
+// Update Count     : 3
 //
 
@@ -52 +52 @@
 Node * deepCopy<Node>( const Node * localRoot );
 
+template<typename node_t, enum Node::ref_type ref_t>
+node_t * shallowCopy( const ptr_base<node_t, ref_t> & localRoot ) {
+        return shallowCopy( localRoot.get() );
+}
+
+template<typename node_t, enum Node::ref_type ref_t>
+node_t * deepCopy( const ptr_base<node_t, ref_t> & localRoot ) {
+        return deepCopy( localRoot.get() );
+}
+
 }
 

src/AST/Node.hpp

@@ -188 +188 @@
         }
 
+        ptr_base & operator=( const node_t * node ) {
+                assign( node );
+                return *this;
+        }
+
         template<typename o_node_t>
         ptr_base & operator=( const o_node_t * node ) {

src/AST/Pass.impl.hpp

@@ -33 +33 @@
         /* call the implementation of the previsit of this pass */ \
         __pass::previsit( core, node, 0 );
-
-#define VISIT( code... ) \
-        /* if this node should visit its children */ \
-        if ( __visit_children() ) { \
-                /* visit the children */ \
-                code \
-        }
 
 #define VISIT_END( type, node ) \
@@ -452 +445 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 {
                         guard_symtab guard { *this };
@@ -460 +453 @@
                 maybe_accept( node, &ObjectDecl::bitfieldWidth );
                 maybe_accept( node, &ObjectDecl::attributes    );
-        )
+        }
 
         __pass::symtab::addId( core, 0, node );
@@ -475 +468 @@
         __pass::symtab::addId( core, 0, node );
 
-        VISIT(maybe_accept( node, &FunctionDecl::withExprs );)
+        if ( __visit_children() ) {
+                maybe_accept( node, &FunctionDecl::withExprs );
+        }
         {
                 // with clause introduces a level of scope (for the with expression members).
@@ -493 +488 @@
                         } };
                         __pass::symtab::addId( core, 0, func );
-                        VISIT(
+                        if ( __visit_children() ) {
                                 // parameter declarations
                                 maybe_accept( node, &FunctionDecl::params );
@@ -509 +504 @@
                                 maybe_accept( node, &FunctionDecl::stmts );
                                 maybe_accept( node, &FunctionDecl::attributes );
-                        )
+                        }
                 }
         }
@@ -526 +521 @@
         __pass::symtab::addStructFwd( core, 0, node );
 
-        VISIT({
+        if ( __visit_children() ) {
                 guard_symtab guard { * this };
                 maybe_accept( node, &StructDecl::params     );
                 maybe_accept( node, &StructDecl::members    );
                 maybe_accept( node, &StructDecl::attributes );
-        })
+        }
 
         // this addition replaces the forward declaration
@@ -548 +543 @@
         __pass::symtab::addUnionFwd( core, 0, node );
 
-        VISIT({
+        if ( __visit_children() ) {
                 guard_symtab guard { * this };
                 maybe_accept( node, &UnionDecl::params     );
                 maybe_accept( node, &UnionDecl::members    );
                 maybe_accept( node, &UnionDecl::attributes );
-        })
+        }
 
         __pass::symtab::addUnion( core, 0, node );
@@ -568 +563 @@
         __pass::symtab::addEnum( core, 0, node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 // unlike structs, traits, and unions, enums inject their members into the global scope
                 maybe_accept( node, &EnumDecl::params     );
                 maybe_accept( node, &EnumDecl::members    );
                 maybe_accept( node, &EnumDecl::attributes );
-        )
+        }
 
         VISIT_END( Decl, node );
@@ -584 +579 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
                 guard_symtab guard { *this };
                 maybe_accept( node, &TraitDecl::params     );
                 maybe_accept( node, &TraitDecl::members    );
                 maybe_accept( node, &TraitDecl::attributes );
-        })
+        }
 
         __pass::symtab::addTrait( core, 0, node );
@@ -602 +597 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
                 guard_symtab guard { *this };
                 maybe_accept( node, &TypeDecl::base   );
-        })
+        }
 
         // see A NOTE ON THE ORDER OF TRAVERSAL, above
@@ -612 +607 @@
         __pass::symtab::addType( core, 0, node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 maybe_accept( node, &TypeDecl::assertions );
 
@@ -619 +614 @@
                         maybe_accept( node, &TypeDecl::init );
                 }
-        )
+        }
 
         VISIT_END( Decl, node );
@@ -630 +625 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
                 guard_symtab guard { *this };
                 maybe_accept( node, &TypedefDecl::base   );
-        })
+        }
 
         __pass::symtab::addType( core, 0, node );
 
-        VISIT( maybe_accept( node, &TypedefDecl::assertions ); )
+        if ( __visit_children() ) {
+                maybe_accept( node, &TypedefDecl::assertions );
+        }
 
         VISIT_END( Decl, node );
@@ -648 +645 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 maybe_accept( node, &AsmDecl::stmt );
-        )
+        }
 
         VISIT_END( AsmDecl, node );
@@ -661 +658 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 maybe_accept( node, &DirectiveDecl::stmt );
-        )
+        }
 
         VISIT_END( DirectiveDecl, node );
@@ -674 +671 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 maybe_accept( node, &StaticAssertDecl::cond );
                 maybe_accept( node, &StaticAssertDecl::msg  );
-        )
+        }
 
         VISIT_END( StaticAssertDecl, node );
@@ -687 +684 @@
 const ast::CompoundStmt * ast::Pass< core_t >::visit( const ast::CompoundStmt * node ) {
         VISIT_START( node );
-        VISIT(
+
+        if ( __visit_children() ) {
                 // Do not enter (or leave) a new scope if atFunctionTop. Remember to save the result.
                 auto guard1 = makeFuncGuard( [this, enterScope = !this->atFunctionTop]() {
@@ -704 +702 @@
                 guard_scope guard3 { *this };
                 maybe_accept( node, &CompoundStmt::kids );
-        )
+        }
+
         VISIT_END( CompoundStmt, node );
 }
@@ -714 +713 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 maybe_accept( node, &ExprStmt::expr );
-        )
+        }
 
         VISIT_END( Stmt, node );
@@ -727 +726 @@
         VISIT_START( node )
 
-        VISIT(
+        if ( __visit_children() ) {
                 maybe_accept( node, &AsmStmt::instruction );
                 maybe_accept( node, &AsmStmt::output      );
                 maybe_accept( node, &AsmStmt::input       );
                 maybe_accept( node, &AsmStmt::clobber     );
-        )
+        }
 
         VISIT_END( Stmt, node );
@@ -752 +751 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
                 // if statements introduce a level of scope (for the initialization)
                 guard_symtab guard { *this };
@@ -759 +758 @@
                 maybe_accept_as_compound( node, &IfStmt::thenPart );
                 maybe_accept_as_compound( node, &IfStmt::elsePart );
-        })
+        }
 
         VISIT_END( Stmt, node );
@@ -770 +769 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
                 // while statements introduce a level of scope (for the initialization)
                 guard_symtab guard { *this };
@@ -776 +775 @@
                 maybe_accept( node, &WhileStmt::cond  );
                 maybe_accept_as_compound( node, &WhileStmt::body  );
-        })
+        }
 
         VISIT_END( Stmt, node );
@@ -787 +786 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
                 // for statements introduce a level of scope (for the initialization)
                 guard_symtab guard { *this };
@@ -795 +794 @@
                 maybe_accept( node, &ForStmt::inc   );
                 maybe_accept_as_compound( node, &ForStmt::body  );
-        })
+        }
 
         VISIT_END( Stmt, node );
@@ -806 +805 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 maybe_accept( node, &SwitchStmt::cond  );
                 maybe_accept( node, &SwitchStmt::stmts );
-        )
+        }
 
         VISIT_END( Stmt, node );
@@ -820 +819 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 maybe_accept( node, &CaseStmt::cond  );
                 maybe_accept( node, &CaseStmt::stmts );
-        )
+        }
 
         VISIT_END( Stmt, node );
@@ -842 +841 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 maybe_accept( node, &ReturnStmt::expr );
-        )
+        }
 
         VISIT_END( Stmt, node );
@@ -855 +854 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 maybe_accept( node, &ThrowStmt::expr   );
                 maybe_accept( node, &ThrowStmt::target );
-        )
+        }
 
         VISIT_END( Stmt, node );
@@ -869 +868 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 maybe_accept( node, &TryStmt::body     );
                 maybe_accept( node, &TryStmt::handlers );
                 maybe_accept( node, &TryStmt::finally  );
-        )
+        }
 
         VISIT_END( Stmt, node );
@@ -884 +883 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
                 // catch statements introduce a level of scope (for the caught exception)
                 guard_symtab guard { *this };
@@ -890 +889 @@
                 maybe_accept( node, &CatchStmt::cond );
                 maybe_accept_as_compound( node, &CatchStmt::body );
-        })
+        }
 
         VISIT_END( Stmt, node );
@@ -901 +900 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 maybe_accept( node, &FinallyStmt::body );
-        )
+        }
 
         VISIT_END( Stmt, node );
@@ -914 +913 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 maybe_accept( node, &SuspendStmt::then   );
-        )
+        }
 
         VISIT_END( Stmt, node );
@@ -934 +933 @@
                 // }
 
-        VISIT({
+        if ( __visit_children() ) {
                 std::vector<WaitForStmt::Clause> new_clauses;
                 new_clauses.reserve( node->clauses.size() );
@@ -965 +964 @@
                         node = n;
                 }
-        })
+        }
 
         #define maybe_accept(field) \
@@ -977 +976 @@
                 }
 
-        VISIT(
+        if ( __visit_children() ) {
                 maybe_accept( timeout.time );
                 maybe_accept( timeout.stmt );
@@ -983 +982 @@
                 maybe_accept( orElse.stmt  );
                 maybe_accept( orElse.cond  );
-        )
+        }
 
         #undef maybe_accept
@@ -996 +995 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 maybe_accept( node, &WithStmt::exprs );
                 {
@@ -1004 +1003 @@
                         maybe_accept( node, &WithStmt::stmt );
                 }
-        )
+        }
+
         VISIT_END( Stmt, node );
 }
@@ -1022 +1022 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 maybe_accept( node, &DeclStmt::decl );
-        )
+        }
 
         VISIT_END( Stmt, node );
@@ -1037 +1037 @@
         // For now this isn't visited, it is unclear if this causes problem
         // if all tests are known to pass, remove this code
-        VISIT(
+        if ( __visit_children() ) {
                 maybe_accept( node, &ImplicitCtorDtorStmt::callStmt );
-        )
+        }
 
         VISIT_END( Stmt, node );
@@ -1050 +1050 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
                 // mutex statements introduce a level of scope (for the initialization)
                 guard_symtab guard { *this };
                 maybe_accept( node, &MutexStmt::stmt );
                 maybe_accept( node, &MutexStmt::mutexObjs );
-        })
+        }
 
         VISIT_END( Stmt, node );
@@ -1066 +1066 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 {
                         guard_symtab guard { *this };
@@ -1073 +1073 @@
                 maybe_accept( node, &ApplicationExpr::func );
                 maybe_accept( node, &ApplicationExpr::args );
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1084 +1084 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 {
                         guard_symtab guard { *this };
@@ -1091 +1091 @@
 
                 maybe_accept( node, &UntypedExpr::args );
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1102 +1102 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
                 guard_symtab guard { *this };
                 maybe_accept( node, &NameExpr::result );
-        })
+        }
 
         VISIT_END( Expr, node );
@@ -1116 +1116 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &CastExpr::result );
                 }
                 maybe_accept( node, &CastExpr::arg );
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1132 +1133 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &KeywordCastExpr::result );
                 }
                 maybe_accept( node, &KeywordCastExpr::arg );
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1148 +1150 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &VirtualCastExpr::result );
                 }
                 maybe_accept( node, &VirtualCastExpr::arg );
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1164 +1167 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &AddressExpr::result );
                 }
                 maybe_accept( node, &AddressExpr::arg );
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1180 +1184 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
                 guard_symtab guard { *this };
                 maybe_accept( node, &LabelAddressExpr::result );
-        })
+        }
 
         VISIT_END( Expr, node );
@@ -1194 +1198 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &UntypedMemberExpr::result );
@@ -1200 +1205 @@
                 maybe_accept( node, &UntypedMemberExpr::aggregate );
                 maybe_accept( node, &UntypedMemberExpr::member    );
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1211 +1216 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &MemberExpr::result );
                 }
                 maybe_accept( node, &MemberExpr::aggregate );
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1227 +1233 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
                 guard_symtab guard { *this };
                 maybe_accept( node, &VariableExpr::result );
-        })
+        }
 
         VISIT_END( Expr, node );
@@ -1241 +1247 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
                 guard_symtab guard { *this };
                 maybe_accept( node, &ConstantExpr::result );
-        })
+        }
 
         VISIT_END( Expr, node );
@@ -1255 +1261 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &SizeofExpr::result );
@@ -1264 +1271 @@
                         maybe_accept( node, &SizeofExpr::expr );
                 }
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1275 +1282 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &AlignofExpr::result );
@@ -1284 +1292 @@
                         maybe_accept( node, &AlignofExpr::expr );
                 }
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1295 +1303 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &UntypedOffsetofExpr::result );
                 }
                 maybe_accept( node, &UntypedOffsetofExpr::type   );
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1311 +1320 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &OffsetofExpr::result );
                 }
                 maybe_accept( node, &OffsetofExpr::type   );
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1327 +1337 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &OffsetPackExpr::result );
                 }
                 maybe_accept( node, &OffsetPackExpr::type   );
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1343 +1354 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &LogicalExpr::result );
@@ -1349 +1361 @@
                 maybe_accept( node, &LogicalExpr::arg1 );
                 maybe_accept( node, &LogicalExpr::arg2 );
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1360 +1372 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &ConditionalExpr::result );
@@ -1367 +1380 @@
                 maybe_accept( node, &ConditionalExpr::arg2 );
                 maybe_accept( node, &ConditionalExpr::arg3 );
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1378 +1391 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &CommaExpr::result );
@@ -1384 +1398 @@
                 maybe_accept( node, &CommaExpr::arg1 );
                 maybe_accept( node, &CommaExpr::arg2 );
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1395 +1409 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &TypeExpr::result );
                 }
                 maybe_accept( node, &TypeExpr::type );
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1411 +1426 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &AsmExpr::result );
@@ -1417 +1433 @@
                 maybe_accept( node, &AsmExpr::constraint );
                 maybe_accept( node, &AsmExpr::operand    );
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1428 +1444 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &ImplicitCopyCtorExpr::result );
                 }
                 maybe_accept( node, &ImplicitCopyCtorExpr::callExpr    );
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1444 +1461 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &ConstructorExpr::result );
                 }
                 maybe_accept( node, &ConstructorExpr::callExpr );
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1460 +1478 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &CompoundLiteralExpr::result );
                 }
                 maybe_accept( node, &CompoundLiteralExpr::init );
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1476 +1495 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &RangeExpr::result );
@@ -1482 +1502 @@
                 maybe_accept( node, &RangeExpr::low    );
                 maybe_accept( node, &RangeExpr::high   );
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1493 +1513 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &UntypedTupleExpr::result );
                 }
                 maybe_accept( node, &UntypedTupleExpr::exprs  );
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1509 +1530 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &TupleExpr::result );
                 }
                 maybe_accept( node, &TupleExpr::exprs  );
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1525 +1547 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &TupleIndexExpr::result );
                 }
                 maybe_accept( node, &TupleIndexExpr::tuple  );
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1541 +1564 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &TupleAssignExpr::result );
                 }
                 maybe_accept( node, &TupleAssignExpr::stmtExpr );
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1557 +1581 @@
         VISIT_START( node );
 
-        VISIT(// don't want statements from outer CompoundStmts to be added to this StmtExpr
+        if ( __visit_children() ) {
+                // don't want statements from outer CompoundStmts to be added to this StmtExpr
                 // get the stmts that will need to be spliced in
                 auto stmts_before = __pass::stmtsToAddBefore( core, 0);
@@ -1574 +1599 @@
                 maybe_accept( node, &StmtExpr::returnDecls );
                 maybe_accept( node, &StmtExpr::dtors       );
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1585 +1610 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &UniqueExpr::result );
                 }
                 maybe_accept( node, &UniqueExpr::expr   );
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1601 +1627 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &UntypedInitExpr::result );
@@ -1607 +1634 @@
                 maybe_accept( node, &UntypedInitExpr::expr   );
                 // not currently visiting initAlts, but this doesn't matter since this node is only used in the resolver.
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1618 +1645 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &InitExpr::result );
@@ -1624 +1652 @@
                 maybe_accept( node, &InitExpr::expr   );
                 maybe_accept( node, &InitExpr::designation );
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1635 +1663 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &DeletedExpr::result );
@@ -1641 +1670 @@
                 maybe_accept( node, &DeletedExpr::expr );
                 // don't visit deleteStmt, because it is a pointer to somewhere else in the tree.
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1652 +1681 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &DefaultArgExpr::result );
                 }
                 maybe_accept( node, &DefaultArgExpr::expr );
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1668 +1698 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
+                {
                         guard_symtab guard { *this };
                         maybe_accept( node, &GenericExpr::result );
@@ -1697 +1728 @@
                         node = n;
                 }
-        )
+        }
 
         VISIT_END( Expr, node );
@@ -1726 +1757 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 // xxx - should PointerType visit/mutate dimension?
                 maybe_accept( node, &PointerType::base );
-        )
+        }
 
         VISIT_END( Type, node );
@@ -1740 +1771 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 maybe_accept( node, &ArrayType::dimension );
                 maybe_accept( node, &ArrayType::base );
-        )
+        }
 
         VISIT_END( Type, node );
@@ -1754 +1785 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 maybe_accept( node, &ReferenceType::base );
-        )
+        }
 
         VISIT_END( Type, node );
@@ -1767 +1798 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 maybe_accept( node, &QualifiedType::parent );
                 maybe_accept( node, &QualifiedType::child );
-        )
+        }
 
         VISIT_END( Type, node );
@@ -1781 +1812 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
                 // guard_forall_subs forall_guard { *this, node };
                 // mutate_forall( node );
@@ -1787 +1818 @@
                 maybe_accept( node, &FunctionType::returns );
                 maybe_accept( node, &FunctionType::params  );
-        })
+        }
 
         VISIT_END( Type, node );
@@ -1800 +1831 @@
         __pass::symtab::addStruct( core, 0, node->name );
 
-        VISIT({
+        if ( __visit_children() ) {
                 guard_symtab guard { *this };
                 maybe_accept( node, &StructInstType::params );
-        })
+        }
 
         VISIT_END( Type, node );
@@ -1816 +1847 @@
         __pass::symtab::addUnion( core, 0, node->name );
 
-        VISIT({
+        if ( __visit_children() ) {
                 guard_symtab guard { *this };
                 maybe_accept( node, &UnionInstType::params );
-        })
+        }
 
         VISIT_END( Type, node );
@@ -1830 +1861 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
                 maybe_accept( node, &EnumInstType::params );
-        })
+        }
 
         VISIT_END( Type, node );
@@ -1843 +1874 @@
         VISIT_START( node );
 
-        VISIT({
+        if ( __visit_children() ) {
                 maybe_accept( node, &TraitInstType::params );
-        })
+        }
 
         VISIT_END( Type, node );
@@ -1856 +1887 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 {
                         maybe_accept( node, &TypeInstType::params );
@@ -1862 +1893 @@
                 // ensure that base re-bound if doing substitution
                 __pass::forall::replace( core, 0, node );
-        )
+        }
 
         VISIT_END( Type, node );
@@ -1873 +1904 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 maybe_accept( node, &TupleType::types );
                 maybe_accept( node, &TupleType::members );
-        )
+        }
 
         VISIT_END( Type, node );
@@ -1887 +1918 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 maybe_accept( node, &TypeofType::expr );
-        )
+        }
 
         VISIT_END( Type, node );
@@ -1900 +1931 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 maybe_accept( node, &VTableType::base );
-        )
+        }
 
         VISIT_END( Type, node );
@@ -1950 +1981 @@
         VISIT_START( node );
 
-        VISIT( maybe_accept( node, &Designation::designators ); )
+        if ( __visit_children() ) {
+                maybe_accept( node, &Designation::designators );
+        }
 
         VISIT_END( Designation, node );
@@ -1961 +1994 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 maybe_accept( node, &SingleInit::value );
-        )
+        }
 
         VISIT_END( Init, node );
@@ -1974 +2007 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 maybe_accept( node, &ListInit::designations );
                 maybe_accept( node, &ListInit::initializers );
-        )
+        }
 
         VISIT_END( Init, node );
@@ -1988 +2021 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 maybe_accept( node, &ConstructorInit::ctor );
                 maybe_accept( node, &ConstructorInit::dtor );
                 maybe_accept( node, &ConstructorInit::init );
-        )
+        }
 
         VISIT_END( Init, node );
@@ -2003 +2036 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 maybe_accept( node, &Attribute::params );
-        )
+        }
 
         VISIT_END( Attribute, node );
@@ -2016 +2049 @@
         VISIT_START( node );
 
-        VISIT(
+        if ( __visit_children() ) {
                 {
                         bool mutated = false;
@@ -2032 +2065 @@
                         }
                 }
-        )
+        }
 
         VISIT_END( TypeSubstitution, node );
@@ -2038 +2071 @@
 
 #undef VISIT_START
-#undef VISIT
 #undef VISIT_END

src/AST/Stmt.hpp

@@ -9 +9 @@
 // Author           : Aaron B. Moss
 // Created On       : Wed May  8 13:00:00 2019
-// Last Modified By : Andrew Beach
-// Last Modified On : Fri May 17 12:45:00 2019
-// Update Count     : 5
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Jan 31 22:38:53 2022
+// Update Count     : 12
 //
 
@@ -17 +17 @@
 
 #include <list>
-#include <utility>                // for move
+#include <utility>                                                                              // for move
 #include <vector>
 
 #include "Label.hpp"
-#include "Node.hpp"               // for node, ptr
+#include "Node.hpp"                                                                             // for node, ptr
 #include "ParseNode.hpp"
 #include "Visitor.hpp"
@@ -27 +27 @@
 
 // Must be included in *all* AST classes; should be #undef'd at the end of the file
-#define MUTATE_FRIEND \
+#define MUTATE_FRIEND                                                                                                   \
     template<typename node_t> friend node_t * mutate(const node_t * node); \
         template<typename node_t> friend node_t * shallowCopy(const node_t * node);
 
 namespace ast {
-
 class Expr;
 
-/// Base statement node
+// Base statement node
 class Stmt : public ParseNode {
-public:
+  public:
         std::vector<Label> labels;
 
         Stmt( const CodeLocation & loc, std::vector<Label> && labels = {} )
-        : ParseNode(loc), labels(std::move(labels)) {}
+                : ParseNode(loc), labels(std::move(labels)) {}
 
         Stmt(const Stmt& o) : ParseNode(o), labels(o.labels) {}
 
         const Stmt * accept( Visitor & v ) const override = 0;
-private:
+  private:
         Stmt * clone() const override = 0;
         MUTATE_FRIEND
 };
 
-/// Compound statement `{ ... }`
+// Compound statement: { ... }
 class CompoundStmt final : public Stmt {
-public:
+  public:
         std::list<ptr<Stmt>> kids;
 
         CompoundStmt(const CodeLocation & loc, std::list<ptr<Stmt>> && ks = {},
-                std::vector<Label>&& labels = {} )
-        : Stmt(loc, std::move(labels)), kids(std::move(ks)) {}
+                                 std::vector<Label>&& labels = {} )
+                : Stmt(loc, std::move(labels)), kids(std::move(ks)) {}
 
         CompoundStmt( const CompoundStmt& o );
@@ -67 +66 @@
 
         const CompoundStmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+  private:
         CompoundStmt * clone() const override { return new CompoundStmt{ *this }; }
         MUTATE_FRIEND
 };
 
-/// Empty statment `;`
+// Empty statment: ;
 class NullStmt final : public Stmt {
-public:
+  public:
         NullStmt( const CodeLocation & loc, std::vector<Label> && labels = {} )
-        : Stmt(loc, std::move(labels)) {}
+                : Stmt(loc, std::move(labels)) {}
 
         const NullStmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+  private:
         NullStmt * clone() const override { return new NullStmt{ *this }; }
         MUTATE_FRIEND
 };
 
-/// Expression wrapped by statement
+// Expression wrapped by statement
 class ExprStmt final : public Stmt {
-public:
+  public:
         ptr<Expr> expr;
 
         ExprStmt( const CodeLocation& loc, const Expr* e, std::vector<Label>&& labels = {} )
-        : Stmt(loc, std::move(labels)), expr(e) {}
-
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+                : Stmt(loc, std::move(labels)), expr(e) {}
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
         ExprStmt * clone() const override { return new ExprStmt{ *this }; }
         MUTATE_FRIEND
 };
 
-/// Assembly statement `asm ... ( "..." : ... )`
+// Assembly statement: asm ... ( "..." : ... )
 class AsmStmt final : public Stmt {
-public:
+  public:
         bool isVolatile;
         ptr<Expr> instruction;
@@ -108 +107 @@
 
         AsmStmt( const CodeLocation & loc, bool isVolatile, const Expr * instruction,
-                std::vector<ptr<Expr>> && output, std::vector<ptr<Expr>> && input,
-                std::vector<ptr<ConstantExpr>> && clobber, std::vector<Label> && gotoLabels,
-                std::vector<Label> && labels = {})
-        : Stmt(loc, std::move(labels)), isVolatile(isVolatile), instruction(instruction),
-          output(std::move(output)), input(std::move(input)), clobber(std::move(clobber)),
-          gotoLabels(std::move(gotoLabels)) {}
-
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+                         std::vector<ptr<Expr>> && output, std::vector<ptr<Expr>> && input,
+                         std::vector<ptr<ConstantExpr>> && clobber, std::vector<Label> && gotoLabels,
+                         std::vector<Label> && labels = {})
+                : Stmt(loc, std::move(labels)), isVolatile(isVolatile), instruction(instruction),
+                  output(std::move(output)), input(std::move(input)), clobber(std::move(clobber)),
+                  gotoLabels(std::move(gotoLabels)) {}
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
         AsmStmt * clone() const override { return new AsmStmt{ *this }; }
         MUTATE_FRIEND
 };
 
-/// C-preprocessor directive `#...`
+// C-preprocessor directive: #...
 class DirectiveStmt final : public Stmt {
-public:
+  public:
         std::string directive;
 
         DirectiveStmt( const CodeLocation & loc, const std::string & directive,
-                std::vector<Label> && labels = {} )
-        : Stmt(loc, std::move(labels)), directive(directive) {}
-
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+                                   std::vector<Label> && labels = {} )
+                : Stmt(loc, std::move(labels)), directive(directive) {}
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
         DirectiveStmt * clone() const override { return new DirectiveStmt{ *this }; }
         MUTATE_FRIEND
 };
 
-/// If conditional statement `if (...) ... else ...`
+// If statement: if (...) ... else ...
 class IfStmt final : public Stmt {
-public:
+  public:
         ptr<Expr> cond;
         ptr<Stmt> thenPart;
@@ -145 +144 @@
 
         IfStmt( const CodeLocation & loc, const Expr * cond, const Stmt * thenPart,
-                const Stmt * elsePart = nullptr, std::vector<ptr<Stmt>> && inits = {},
-                std::vector<Label> && labels = {} )
-        : Stmt(loc, std::move(labels)), cond(cond), thenPart(thenPart), elsePart(elsePart),
-          inits(std::move(inits)) {}
-
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+                        const Stmt * elsePart = nullptr, std::vector<ptr<Stmt>> && inits = {},
+                        std::vector<Label> && labels = {} )
+                : Stmt(loc, std::move(labels)), cond(cond), thenPart(thenPart), elsePart(elsePart),
+                  inits(std::move(inits)) {}
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
         IfStmt * clone() const override { return new IfStmt{ *this }; }
         MUTATE_FRIEND
 };
 
-/// Switch or choose conditional statement `switch (...) { ... }`
+// Switch or choose statement: switch (...) { ... }
 class SwitchStmt final : public Stmt {
-public:
+  public:
         ptr<Expr> cond;
         std::vector<ptr<Stmt>> stmts;
 
         SwitchStmt( const CodeLocation & loc, const Expr * cond, std::vector<ptr<Stmt>> && stmts,
-                std::vector<Label> && labels = {} )
-        : Stmt(loc, std::move(labels)), cond(cond), stmts(std::move(stmts)) {}
-
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+                                std::vector<Label> && labels = {} )
+                : Stmt(loc, std::move(labels)), cond(cond), stmts(std::move(stmts)) {}
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
         SwitchStmt * clone() const override { return new SwitchStmt{ *this }; }
         MUTATE_FRIEND
 };
 
-/// Case label `case ...:` `default:`
+// Case label: case ...: or default:
 class CaseStmt final : public Stmt {
-public:
-        /// Null for the default label.
+  public:
+        // Null for the default label.
         ptr<Expr> cond;
         std::vector<ptr<Stmt>> stmts;
 
         CaseStmt( const CodeLocation & loc, const Expr * cond, std::vector<ptr<Stmt>> && stmts,
-                std::vector<Label> && labels = {} )
-        : Stmt(loc, std::move(labels)), cond(cond), stmts(std::move(stmts)) {}
+                          std::vector<Label> && labels = {} )
+                : Stmt(loc, std::move(labels)), cond(cond), stmts(std::move(stmts)) {}
 
         bool isDefault() const { return !cond; }
 
         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+  private:
         CaseStmt * clone() const override { return new CaseStmt{ *this }; }
         MUTATE_FRIEND
 };
 
-/// While loop `while (...) ...` `do ... while (...);
+// While loop: while (...) ... else ... or do ... while (...) else ...;
 class WhileStmt final : public Stmt {
-public:
+  public:
         ptr<Expr> cond;
         ptr<Stmt> body;
+        ptr<Stmt> elsePart;
         std::vector<ptr<Stmt>> inits;
         bool isDoWhile;
 
         WhileStmt( const CodeLocation & loc, const Expr * cond, const Stmt * body,
-                std::vector<ptr<Stmt>> && inits, bool isDoWhile = false, std::vector<Label> && labels = {} )
-        : Stmt(loc, std::move(labels)), cond(cond), body(body), inits(std::move(inits)),
-          isDoWhile(isDoWhile) {}
-
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+                           std::vector<ptr<Stmt>> && inits, bool isDoWhile = false, std::vector<Label> && labels = {} )
+                : Stmt(loc, std::move(labels)), cond(cond), body(body), inits(std::move(inits)), isDoWhile(isDoWhile) {}
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
         WhileStmt * clone() const override { return new WhileStmt{ *this }; }
         MUTATE_FRIEND
 };
 
-/// For loop `for (... ; ... ; ...) ...`
+// For loop: for (... ; ... ; ...) ... else ...
 class ForStmt final : public Stmt {
-public:
+  public:
         std::vector<ptr<Stmt>> inits;
         ptr<Expr> cond;
         ptr<Expr> inc;
         ptr<Stmt> body;
+        ptr<Stmt> elsePart;
 
         ForStmt( const CodeLocation & loc, std::vector<ptr<Stmt>> && inits, const Expr * cond,
-                const Expr * inc, const Stmt * body, std::vector<Label> && labels = {} )
-        : Stmt(loc, std::move(labels)), inits(std::move(inits)), cond(cond), inc(inc),
-          body(body) {}
-
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+                         const Expr * inc, const Stmt * body, std::vector<Label> && labels = {} )
+                : Stmt(loc, std::move(labels)), inits(std::move(inits)), cond(cond), inc(inc), body(body) {}
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
         ForStmt * clone() const override { return new ForStmt{ *this }; }
         MUTATE_FRIEND
 };
 
-/// Branch control flow statement `goto ...` `break` `continue` `fallthru`
+// Branch control flow statement: goto ... or break or continue or fallthru
 class BranchStmt final : public Stmt {
-public:
+  public:
         enum Kind { Goto, Break, Continue, FallThrough, FallThroughDefault };
         static constexpr size_t kindEnd = 1 + (size_t)FallThroughDefault;
@@ -241 +240 @@
 
         BranchStmt( const CodeLocation & loc, Kind kind, Label target,
-                std::vector<Label> && labels = {} );
+                                std::vector<Label> && labels = {} );
         BranchStmt( const CodeLocation & loc, const Expr * computedTarget,
-                std::vector<Label> && labels = {} )
-        : Stmt(loc, std::move(labels)), originalTarget(loc), target(loc),
-          computedTarget(computedTarget), kind(Goto) {}
+                                std::vector<Label> && labels = {} )
+                : Stmt(loc, std::move(labels)), originalTarget(loc), target(loc),
+                  computedTarget(computedTarget), kind(Goto) {}
 
         const char * kindName() const { return kindNames[kind]; }
 
         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+  private:
         BranchStmt * clone() const override { return new BranchStmt{ *this }; }
         MUTATE_FRIEND
@@ -257 +256 @@
 };
 
-/// Return statement `return ...`
+// Return statement: return ...
 class ReturnStmt final : public Stmt {
-public:
+  public:
         ptr<Expr> expr;
 
         ReturnStmt( const CodeLocation & loc, const Expr * expr, std::vector<Label> && labels = {} )
-        : Stmt(loc, std::move(labels)), expr(expr) {}
-
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+                : Stmt(loc, std::move(labels)), expr(expr) {}
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
         ReturnStmt * clone() const override { return new ReturnStmt{ *this }; }
         MUTATE_FRIEND
 };
 
-/// Kind of exception
+// Kind of exception
 enum ExceptionKind { Terminate, Resume };
 
-/// Throw statement `throw ...`
+// Throw statement: throw ...
 class ThrowStmt final : public Stmt {
-public:
+  public:
         ptr<Expr> expr;
         ptr<Expr> target;
@@ -284 +283 @@
                 const CodeLocation & loc, ExceptionKind kind, const Expr * expr, const Expr * target,
                 std::vector<Label> && labels = {} )
-        : Stmt(loc, std::move(labels)), expr(expr), target(target), kind(kind) {}
-
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+                : Stmt(loc, std::move(labels)), expr(expr), target(target), kind(kind) {}
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
         ThrowStmt * clone() const override { return new ThrowStmt{ *this }; }
         MUTATE_FRIEND
 };
 
-/// Try statement `try { ... } ...`
+// Try statement: try { ... } ...
 class TryStmt final : public Stmt {
-public:
+  public:
         ptr<CompoundStmt> body;
         std::vector<ptr<CatchStmt>> handlers;
@@ -303 +302 @@
                 std::vector<ptr<CatchStmt>> && handlers, const FinallyStmt * finally,
                 std::vector<Label> && labels = {} )
-        : Stmt(loc, std::move(labels)), body(body), handlers(std::move(handlers)), finally(finally) {}
-
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+                : Stmt(loc, std::move(labels)), body(body), handlers(std::move(handlers)), finally(finally) {}
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
         TryStmt * clone() const override { return new TryStmt{ *this }; }
         MUTATE_FRIEND
 };
 
-/// Catch clause of try statement
+// Catch clause of try statement
 class CatchStmt final : public Stmt {
-public:
+  public:
         ptr<Decl> decl;
         ptr<Expr> cond;
@@ -322 +321 @@
                 const CodeLocation & loc, ExceptionKind kind, const Decl * decl, const Expr * cond,
                 const Stmt * body, std::vector<Label> && labels = {} )
-        : Stmt(loc, std::move(labels)), decl(decl), cond(cond), body(body), kind(kind) {}
-
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+                : Stmt(loc, std::move(labels)), decl(decl), cond(cond), body(body), kind(kind) {}
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
         CatchStmt * clone() const override { return new CatchStmt{ *this }; }
         MUTATE_FRIEND
 };
 
-/// Finally clause of try statement
+// Finally clause of try statement
 class FinallyStmt final : public Stmt {
-public:
+  public:
         ptr<CompoundStmt> body;
 
         FinallyStmt( const CodeLocation & loc, const CompoundStmt * body,
-                std::vector<Label> && labels = {} )
-        : Stmt(loc, std::move(labels)), body(body) {}
-
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+                                 std::vector<Label> && labels = {} )
+                : Stmt(loc, std::move(labels)), body(body) {}
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
         FinallyStmt * clone() const override { return new FinallyStmt{ *this }; }
         MUTATE_FRIEND
 };
 
-/// Suspend statement
+// Suspend statement
 class SuspendStmt final : public Stmt {
-public:
+  public:
         ptr<CompoundStmt> then;
         enum Type { None, Coroutine, Generator } type = None;
 
         SuspendStmt( const CodeLocation & loc, const CompoundStmt * then, Type type, std::vector<Label> && labels = {} )
-        : Stmt(loc, std::move(labels)), then(then), type(type) {}
-
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+                : Stmt(loc, std::move(labels)), then(then), type(type) {}
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
         SuspendStmt * clone() const override { return new SuspendStmt{ *this }; }
         MUTATE_FRIEND
 };
 
-/// Wait for concurrency statement `when (...) waitfor (... , ...) ... timeout(...) ... else ...`
+// Waitfor statement: when (...) waitfor (... , ...) ... timeout(...) ... else ...
 class WaitForStmt final : public Stmt {
-public:
+  public:
         struct Target {
                 ptr<Expr> func;
@@ -390 +389 @@
 
         WaitForStmt( const CodeLocation & loc, std::vector<Label> && labels = {} )
-        : Stmt(loc, std::move(labels)) {}
-
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+                : Stmt(loc, std::move(labels)) {}
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
         WaitForStmt * clone() const override { return new WaitForStmt{ *this }; }
         MUTATE_FRIEND
 };
 
-/// Any declaration in a (compound) statement.
+// Any declaration in a (compound) statement.
 class DeclStmt final : public Stmt {
-public:
+  public:
         ptr<Decl> decl;
 
         DeclStmt( const CodeLocation & loc, const Decl * decl, std::vector<Label> && labels = {} )
-        : Stmt(loc, std::move(labels)), decl(decl) {}
-
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+                : Stmt(loc, std::move(labels)), decl(decl) {}
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
         DeclStmt * clone() const override { return new DeclStmt{ *this }; }
         MUTATE_FRIEND
 };
 
-/// Represents an implicit application of a constructor or destructor.
+// Represents an implicit application of a constructor or destructor.
 class ImplicitCtorDtorStmt final : public Stmt {
-public:
+  public:
         ptr<Stmt> callStmt;
 
         ImplicitCtorDtorStmt( const CodeLocation & loc, const Stmt * callStmt,
-                std::vector<Label> && labels = {} )
-        : Stmt(loc, std::move(labels)), callStmt(callStmt) {}
-
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+                                                  std::vector<Label> && labels = {} )
+                : Stmt(loc, std::move(labels)), callStmt(callStmt) {}
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
         ImplicitCtorDtorStmt * clone() const override { return new ImplicitCtorDtorStmt{ *this }; }
         MUTATE_FRIEND
 };
 
-/// Mutex Statement
+// Mutex Statement
 class MutexStmt final : public Stmt {
-public:
+  public:
         ptr<Stmt> stmt;
         std::vector<ptr<Expr>> mutexObjs;
 
         MutexStmt( const CodeLocation & loc, const Stmt * stmt, 
-                std::vector<ptr<Expr>> && mutexes, std::vector<Label> && labels = {} )
-        : Stmt(loc, std::move(labels)), stmt(stmt), mutexObjs(std::move(mutexes)) {}
-
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
+                           std::vector<ptr<Expr>> && mutexes, std::vector<Label> && labels = {} )
+                : Stmt(loc, std::move(labels)), stmt(stmt), mutexObjs(std::move(mutexes)) {}
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
         MutexStmt * clone() const override { return new MutexStmt{ *this }; }
         MUTATE_FRIEND
 };
-
-}
+} // namespace ast
 
 #undef MUTATE_FRIEND
 
 // Local Variables: //
-// tab-width: 4 //
 // mode: c++ //
-// compile-command: "make install" //
 // End: //

src/ControlStruct/ExceptTranslateNew.cpp

@@ -9 +9 @@
 // Author           : Andrew Beach
 // Created On       : Mon Nov  8 11:53:00 2021
-// Last Modified By : Andrew Beach
-// Last Modified On : Mon Nov  8 16:50:00 2021
-// Update Count     : 0
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Jan 31 18:49:58 2022
+// Update Count     : 1
 //
 
@@ -22 +22 @@
 
 namespace ControlStruct {
-
-namespace {
 
 class TranslateThrowsCore : public ast::WithGuards {
@@ -128 +126 @@
 }
 
-} // namespace
-
 void translateThrows( ast::TranslationUnit & transUnit ) {
         ast::Pass<TranslateThrowsCore>::run( transUnit );

src/ControlStruct/FixLabels.cpp

@@ -9 +9 @@
 // Author           : Andrew Beach
 // Created On       : Mon Nov  1 09:39:00 2021
-// Last Modified By : Andrew Beach
-// Last Modified On : Mon Nov  8 10:53:00 2021
-// Update Count     : 3
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Jan 31 22:19:17 2022
+// Update Count     : 9
 //
 
@@ -20 +20 @@
 #include "AST/Stmt.hpp"
 #include "ControlStruct/MultiLevelExit.hpp"
+using namespace ast;
 
 namespace ControlStruct {
-
-namespace {
-
-class FixLabelsCore final : public ast::WithGuards {
+class FixLabelsCore final : public WithGuards {
         LabelToStmt labelTable;
-public:
+  public:
         FixLabelsCore() : labelTable() {}
 
-        void previsit( const ast::FunctionDecl * );
-        const ast::FunctionDecl * postvisit( const ast::FunctionDecl * );
-        void previsit( const ast::Stmt * );
-        void previsit( const ast::BranchStmt * );
-        void previsit( const ast::LabelAddressExpr * );
+        void previsit( const FunctionDecl * );
+        const FunctionDecl * postvisit( const FunctionDecl * );
+        void previsit( const Stmt * );
+        void previsit( const BranchStmt * );
+        void previsit( const LabelAddressExpr * );
 
-        void setLabelsDef( const std::vector<ast::Label> &, const ast::Stmt * );
-        void setLabelsUsage( const ast::Label & );
+        void setLabelsDef( const std::vector<Label> &, const Stmt * );
+        void setLabelsUsage( const Label & );
 };
 
-void FixLabelsCore::previsit( const ast::FunctionDecl * ) {
+void FixLabelsCore::previsit( const FunctionDecl * ) {
         GuardValue( labelTable ).clear();
 }
 
-const ast::FunctionDecl * FixLabelsCore::postvisit(
-                const ast::FunctionDecl * decl ) {
+const FunctionDecl * FixLabelsCore::postvisit(
+        const FunctionDecl * decl ) {
         if ( nullptr == decl->stmts ) return decl;
         for ( auto kvp : labelTable ) {
                 if ( nullptr == kvp.second ) {
                         SemanticError( kvp.first.location,
-                                "Use of undefined label: " + kvp.first.name );
+                                                   "Use of undefined label: " + kvp.first.name );
                 }
         }
-        return ast::mutate_field( decl, &ast::FunctionDecl::stmts,
-                multiLevelExitUpdate( decl->stmts.get(), labelTable ) );
+        return mutate_field( decl, &FunctionDecl::stmts,
+                                                 multiLevelExitUpdate( decl->stmts.get(), labelTable ) );
 }
 
-void FixLabelsCore::previsit( const ast::Stmt * stmt ) {
+void FixLabelsCore::previsit( const Stmt * stmt ) {
         if ( !stmt->labels.empty() ) {
                 setLabelsDef( stmt->labels, stmt );
@@ -63 +61 @@
 }
 
-void FixLabelsCore::previsit( const ast::BranchStmt * stmt ) {
+void FixLabelsCore::previsit( const BranchStmt * stmt ) {
         if ( !stmt->labels.empty() ) {
                 setLabelsDef( stmt->labels, stmt );
@@ -72 +70 @@
 }
 
-void FixLabelsCore::previsit( const ast::LabelAddressExpr * expr ) {
+void FixLabelsCore::previsit( const LabelAddressExpr * expr ) {
         assert( !expr->arg.empty() );
         setLabelsUsage( expr->arg );
@@ -78 +76 @@
 
 void FixLabelsCore::setLabelsDef(
-                const std::vector<ast::Label> & labels, const ast::Stmt * stmt ) {
+        const std::vector<Label> & labels, const Stmt * stmt ) {
         assert( !labels.empty() );
         assert( stmt );
@@ -89 +87 @@
                         // Duplicate definition, this is an error.
                         SemanticError( label.location,
-                                "Duplicate definition of label: " + label.name );
+                                                   "Duplicate definition of label: " + label.name );
                 } else {
                         // Perviously used, but not defined until now.
@@ -98 +96 @@
 
 // Label was used, if it is new add it to the table.
-void FixLabelsCore::setLabelsUsage( const ast::Label & label ) {
+void FixLabelsCore::setLabelsUsage( const Label & label ) {
         if ( labelTable.find( label ) == labelTable.end() ) {
                 labelTable[ label ] = nullptr;
@@ -104 +102 @@
 }
 
-} // namespace
-
-void fixLabels( ast::TranslationUnit & translationUnit ) {
-        ast::Pass<FixLabelsCore>::run( translationUnit );
+void fixLabels( TranslationUnit & translationUnit ) {
+        Pass<FixLabelsCore>::run( translationUnit );
 }
-
 } // namespace ControlStruct
 

src/ControlStruct/FixLabels.hpp

@@ -9 +9 @@
 // Author           : Andrew Beach
 // Created On       : Mon Nov  1 09:36:00 2021
-// Last Modified By : Andrew Beach
-// Last Modified On : Mon Nov  1 09:40:00 2021
-// Update Count     : 0
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Jan 31 22:18:43 2022
+// Update Count     : 2
 //
 
@@ -17 +17 @@
 
 namespace ast {
-        class TranslationUnit;
+class TranslationUnit;
 }
 
 namespace ControlStruct {
-
-/// normalizes label definitions and generates multi-level exit labels
+// normalizes label definitions and generates multi-level exit labels
 void fixLabels( ast::TranslationUnit & translationUnit );
-
 }
 

src/ControlStruct/ForExprMutator.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Aug 17 15:32:48 2017
-// Update Count     : 5
+// Last Modified On : Sun Jan 30 09:14:46 2022
+// Update Count     : 6
 //
 
@@ -24 +24 @@
         class ForExprMutator {
           public:
-                Statement *postmutate( IfStmt * );
-                Statement *postmutate( ForStmt * );
-                Statement *postmutate( WhileStmt * );
+                Statement * postmutate( IfStmt * );
+                Statement * postmutate( ForStmt * );
+                Statement * postmutate( WhileStmt * );
         };
 } // namespace ControlStruct

src/ControlStruct/LabelFixer.cc

@@ -9 +9 @@
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Andrew Beach
-// Last Modified On : Tue Jan 21 10:32:00 2020
-// Update Count     : 160
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Jan 31 22:28:31 2022
+// Update Count     : 161
 //
 
@@ -27 +27 @@
 
 namespace ControlStruct {
-        bool LabelFixer::Entry::insideLoop() {
-                return ( dynamic_cast< ForStmt * > ( definition ) ||
-                        dynamic_cast< WhileStmt * > ( definition )  );
+bool LabelFixer::Entry::insideLoop() {
+        return ( dynamic_cast< ForStmt * > ( definition ) ||
+                dynamic_cast< WhileStmt * > ( definition )  );
+}
+
+LabelFixer::LabelFixer( LabelGenerator * gen ) : generator ( gen ) {
+        if ( generator == 0 )
+                generator = LabelGenerator::getGenerator();
+}
+
+void LabelFixer::previsit( FunctionDecl * ) {
+        // need to go into a nested function in a fresh state
+        GuardValue( labelTable );
+        labelTable.clear();
+}
+
+void LabelFixer::postvisit( FunctionDecl * functionDecl ) {
+        PassVisitor<MultiLevelExitMutator> mlem( resolveJumps(), generator );
+        // We start in the body so we can stop when we hit another FunctionDecl.
+        maybeMutate( functionDecl->statements, mlem );
+}
+
+// prune to at most one label definition for each statement
+void LabelFixer::previsit( Statement * stmt ) {
+        std::list< Label > &labels = stmt->get_labels();
+
+        if ( ! labels.empty() ) {
+                // only remember one label for each statement
+                Label current = setLabelsDef( labels, stmt );
+        } // if
+}
+
+void LabelFixer::previsit( BranchStmt * branchStmt ) {
+        previsit( ( Statement *)branchStmt );
+
+        // for labeled branches, add an entry to the label table
+        Label target = branchStmt->get_target();
+        if ( target != "" ) {
+                setLabelsUsg( target, branchStmt );
+        }
+}
+
+void LabelFixer::previsit( LabelAddressExpr * addrExpr ) {
+        Label & target = addrExpr->arg;
+        assert( target != "" );
+        setLabelsUsg( target, addrExpr );
+}
+
+
+// Sets the definition of the labelTable entry to be the provided statement for every label in
+// the list parameter. Happens for every kind of statement.
+Label LabelFixer::setLabelsDef( std::list< Label > & llabel, Statement * definition ) {
+        assert( definition != 0 );
+        assert( llabel.size() > 0 );
+
+        for ( std::list< Label >::iterator i = llabel.begin(); i != llabel.end(); i++ ) {
+                Label & l = *i;
+                l.set_statement( definition ); // attach statement to the label to be used later
+                if ( labelTable.find( l ) == labelTable.end() ) {
+                        // All labels on this statement need to use the same entry,
+                        // so this should only be created once.
+                        // undefined and unused until now, add an entry
+                        labelTable[ l ] = new Entry( definition );
+                } else if ( labelTable[ l ]->defined() ) {
+                        // defined twice, error
+                        SemanticError( l.get_statement()->location,
+                                "Duplicate definition of label: " + l.get_name() );
+                } else {
+                        // used previously, but undefined until now -> link with this entry
+                        // Question: Is changing objects important?
+                        delete labelTable[ l ];
+                        labelTable[ l ] = new Entry( definition );
+                } // if
+        } // for
+
+        // Produce one of the labels attached to this statement to be temporarily used as the
+        // canonical label.
+        return labelTable[ llabel.front() ]->get_label();
+}
+
+// A label was used, add it to the table if it isn't already there
+template< typename UsageNode >
+void LabelFixer::setLabelsUsg( Label orgValue, UsageNode *use ) {
+        assert( use != 0 );
+
+        // add label with an unknown origin
+        if ( labelTable.find( orgValue ) == labelTable.end() ) {
+                labelTable[ orgValue ] = new Entry( 0 );
+        }
+}
+
+// Builds a table that maps a label to its defining statement.
+std::map<Label, Statement * > * LabelFixer::resolveJumps() throw ( SemanticErrorException ) {
+        std::map< Label, Statement * > *ret = new std::map< Label, Statement * >();
+        for ( std::map< Label, Entry * >::iterator i = labelTable.begin(); i != labelTable.end(); ++i ) {
+                if ( ! i->second->defined() ) {
+                        SemanticError( i->first.get_statement()->location, "Use of undefined label: " + i->first.get_name() );
+                }
+                (*ret)[ i->first ] = i->second->get_definition();
         }
 
-        LabelFixer::LabelFixer( LabelGenerator * gen ) : generator ( gen ) {
-                if ( generator == 0 )
-                        generator = LabelGenerator::getGenerator();
-        }
-
-        void LabelFixer::previsit( FunctionDecl * ) {
-                // need to go into a nested function in a fresh state
-                GuardValue( labelTable );
-                labelTable.clear();
-        }
-
-        void LabelFixer::postvisit( FunctionDecl * functionDecl ) {
-                PassVisitor<MultiLevelExitMutator> mlem( resolveJumps(), generator );
-                // We start in the body so we can stop when we hit another FunctionDecl.
-                maybeMutate( functionDecl->statements, mlem );
-        }
-
-        // prune to at most one label definition for each statement
-        void LabelFixer::previsit( Statement * stmt ) {
-                std::list< Label > &labels = stmt->get_labels();
-
-                if ( ! labels.empty() ) {
-                        // only remember one label for each statement
-                        Label current = setLabelsDef( labels, stmt );
-                } // if
-        }
-
-        void LabelFixer::previsit( BranchStmt * branchStmt ) {
-                previsit( ( Statement *)branchStmt );
-
-                // for labeled branches, add an entry to the label table
-                Label target = branchStmt->get_target();
-                if ( target != "" ) {
-                        setLabelsUsg( target, branchStmt );
-                }
-        }
-
-        void LabelFixer::previsit( LabelAddressExpr * addrExpr ) {
-                Label & target = addrExpr->arg;
-                assert( target != "" );
-                setLabelsUsg( target, addrExpr );
-        }
-
-
-        // Sets the definition of the labelTable entry to be the provided statement for every label in
-        // the list parameter. Happens for every kind of statement.
-        Label LabelFixer::setLabelsDef( std::list< Label > & llabel, Statement * definition ) {
-                assert( definition != 0 );
-                assert( llabel.size() > 0 );
-
-                for ( std::list< Label >::iterator i = llabel.begin(); i != llabel.end(); i++ ) {
-                        Label & l = *i;
-                        l.set_statement( definition ); // attach statement to the label to be used later
-                        if ( labelTable.find( l ) == labelTable.end() ) {
-                                // All labels on this statement need to use the same entry,
-                                // so this should only be created once.
-                                // undefined and unused until now, add an entry
-                                labelTable[ l ] = new Entry( definition );
-                        } else if ( labelTable[ l ]->defined() ) {
-                                // defined twice, error
-                                SemanticError( l.get_statement()->location,
-                                        "Duplicate definition of label: " + l.get_name() );
-                        } else {
-                                // used previously, but undefined until now -> link with this entry
-                                // Question: Is changing objects important?
-                                delete labelTable[ l ];
-                                labelTable[ l ] = new Entry( definition );
-                        } // if
-                } // for
-
-                // Produce one of the labels attached to this statement to be temporarily used as the
-                // canonical label.
-                return labelTable[ llabel.front() ]->get_label();
-        }
-
-        // A label was used, add it to the table if it isn't already there
-        template< typename UsageNode >
-        void LabelFixer::setLabelsUsg( Label orgValue, UsageNode *use ) {
-                assert( use != 0 );
-
-                // add label with an unknown origin
-                if ( labelTable.find( orgValue ) == labelTable.end() ) {
-                        labelTable[ orgValue ] = new Entry( 0 );
-                }
-        }
-
-        // Builds a table that maps a label to its defining statement.
-        std::map<Label, Statement * > * LabelFixer::resolveJumps() throw ( SemanticErrorException ) {
-                std::map< Label, Statement * > *ret = new std::map< Label, Statement * >();
-                for ( std::map< Label, Entry * >::iterator i = labelTable.begin(); i != labelTable.end(); ++i ) {
-                        if ( ! i->second->defined() ) {
-                                SemanticError( i->first.get_statement()->location, "Use of undefined label: " + i->first.get_name() );
-                        }
-                        (*ret)[ i->first ] = i->second->get_definition();
-                }
-
-                return ret;
-        }
+        return ret;
+}
 }  // namespace ControlStruct
 

src/ControlStruct/LabelFixer.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jul 22 09:17:24 2017
-// Update Count     : 34
+// Last Modified On : Mon Jan 31 22:28:04 2022
+// Update Count     : 35
 //
 
@@ -26 +26 @@
 
 namespace ControlStruct {
-        /// normalizes label definitions and generates multi-level exit labels
-        class LabelGenerator;
+// normalizes label definitions and generates multi-level exit labels
+class LabelGenerator;
 
-        class LabelFixer final : public WithGuards {
-          public:
-                LabelFixer( LabelGenerator *gen = 0 );
+class LabelFixer final : public WithGuards {
+  public:
+        LabelFixer( LabelGenerator *gen = 0 );
 
-                std::map < Label, Statement * > *resolveJumps() throw ( SemanticErrorException );
+        std::map < Label, Statement * > *resolveJumps() throw ( SemanticErrorException );
 
-                // Declarations
-                void previsit( FunctionDecl *functionDecl );
-                void postvisit( FunctionDecl *functionDecl );
+        // Declarations
+        void previsit( FunctionDecl *functionDecl );
+        void postvisit( FunctionDecl *functionDecl );
 
-                // Statements
-                void previsit( Statement *stmt );
-                void previsit( BranchStmt *branchStmt );
+        // Statements
+        void previsit( Statement *stmt );
+        void previsit( BranchStmt *branchStmt );
 
-                // Expressions
-                void previsit( LabelAddressExpr *addrExpr );
+        // Expressions
+        void previsit( LabelAddressExpr *addrExpr );
 
-                Label setLabelsDef( std::list< Label > &, Statement *definition );
-                template< typename UsageNode >
-                void setLabelsUsg( Label, UsageNode *usage = 0 );
+        Label setLabelsDef( std::list< Label > &, Statement *definition );
+        template< typename UsageNode >
+        void setLabelsUsg( Label, UsageNode *usage = 0 );
+
+  private:
+        class Entry {
+                public:
+                Entry( Statement *to ) : definition( to ) {}
+                bool defined() { return ( definition != 0 ); }
+                bool insideLoop();
+
+                Label get_label() const { return label; }
+                void set_label( Label lab ) { label = lab; }
+
+                Statement *get_definition() const { return definition; }
+                void set_definition( Statement *def ) { definition = def; }
 
           private:
-                class Entry {
-                        public:
-                        Entry( Statement *to ) : definition( to ) {}
-                        bool defined() { return ( definition != 0 ); }
-                        bool insideLoop();
+                Label label;
+                Statement *definition;
+        };
 
-                        Label get_label() const { return label; }
-                        void set_label( Label lab ) { label = lab; }
-
-                        Statement *get_definition() const { return definition; }
-                        void set_definition( Statement *def ) { definition = def; }
-
-                  private:
-                        Label label;
-                        Statement *definition;
-                };
-
-                std::map < Label, Entry *> labelTable;
-                LabelGenerator *generator;
-        };
+        std::map < Label, Entry *> labelTable;
+        LabelGenerator *generator;
+};
 } // namespace ControlStruct
 

src/ControlStruct/LabelGenerator.cc

@@ -9 +9 @@
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Andrew Beach
-// Last Modified On : Mon Nov  8 10:18:00 2021
-// Update Count     : 17
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Jan 31 22:30:26 2022
+// Update Count     : 28
 //
 
@@ -17 +17 @@
 #include <sstream>              // for ostringstream
 #include <list>                 // for list
+using namespace std;
 
 #include "LabelGenerator.h"
 
-#include "AST/Attribute.hpp"
-#include "AST/Label.hpp"
-#include "AST/Stmt.hpp"
 #include "SynTree/Attribute.h"  // for Attribute
 #include "SynTree/Label.h"      // for Label, operator<<
@@ -28 +26 @@
 
 namespace ControlStruct {
-
 int LabelGenerator::current = 0;
 LabelGenerator * LabelGenerator::labelGenerator = nullptr;
 
-        LabelGenerator * LabelGenerator::getGenerator() {
-                if ( LabelGenerator::labelGenerator == 0 )
-                        LabelGenerator::labelGenerator = new LabelGenerator();
-                return labelGenerator;
-        }
-
-        Label LabelGenerator::newLabel( std::string suffix, Statement * stmt ) {
-                std::ostringstream os;
-                os << "__L" << current++ << "__" << suffix;
-                if ( stmt && ! stmt->get_labels().empty() ) {
-                        os << "_" << stmt->get_labels().front() << "__";
-                } // if
-                std::string ret = os.str();
-                Label l( ret );
-                l.get_attributes().push_back( new Attribute("unused") );
-                return l;
-        }
-
-ast::Label LabelGenerator::newLabel(
-                const std::string & suffix, const ast::Stmt * stmt ) {
-        assert( stmt );
-
-        std::ostringstream os;
-        os << "__L" << current++ << "__" << suffix;
-        if ( stmt && !stmt->labels.empty() ) {
-                os << "_" << stmt->labels.front() << "__";
-        }
-        ast::Label ret_label( stmt->location, os.str() );
-        ret_label.attributes.push_back( new ast::Attribute( "unused" ) );
-        return ret_label;
+LabelGenerator * LabelGenerator::getGenerator() {
+        if ( LabelGenerator::labelGenerator == 0 )
+                LabelGenerator::labelGenerator = new LabelGenerator();
+        return labelGenerator;
 }
 
+Label LabelGenerator::newLabel( string suffix, Statement * stmt ) {
+        ostringstream os;
+        os << "__L_OLD" << current++ << "__" << suffix;
+        if ( stmt && ! stmt->get_labels().empty() ) {
+                os << "_" << stmt->get_labels().front() << "__";
+        } // if
+        string ret = os.str();
+        Label l( ret );
+        l.get_attributes().push_back( new Attribute( "unused" ) );
+        return l;
+}
 } // namespace ControlStruct
 
 // Local Variables: //
-// tab-width: 4 //
 // mode: c++ //
-// compile-command: "make install" //
 // End: //

src/ControlStruct/LabelGenerator.h

@@ -9 +9 @@
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Andrew Beach
-// Last Modified On : Mon Nov  8 10:16:00 2021
-// Update Count     : 8
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Jan 31 22:30:10 2022
+// Update Count     : 16
 //
 
@@ -21 +21 @@
 
 class Statement;
+
 namespace ast {
-        class Stmt;
-        class Label;
+class Stmt;
+class Label;
 }
 
 namespace ControlStruct {
-
 class LabelGenerator {
         static int current;
         static LabelGenerator *labelGenerator;
-protected:
+  protected:
         LabelGenerator() {}
-public:
+  public:
         static LabelGenerator *getGenerator();
         static Label newLabel(std::string suffix, Statement * stmt = nullptr);
-        static ast::Label newLabel( const std::string&, const ast::Stmt * );
-        static void reset() { current = 0; }
-        static void rewind() { current--; }
 };
-
 } // namespace ControlStruct
 

src/ControlStruct/MultiLevelExit.cpp

@@ -9 +9 @@
 // Author           : Andrew Beach
 // Created On       : Mon Nov  1 13:48:00 2021
-// Last Modified By : Andrew Beach
-// Last Modified On : Mon Nov  8 10:56:00 2021
-// Update Count     : 2
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Jan 31 22:35:08 2022
+// Update Count     : 28
 //
 
@@ -18 +18 @@
 #include "AST/Pass.hpp"
 #include "AST/Stmt.hpp"
-#include "ControlStruct/LabelGenerator.h"
+#include "LabelGeneratorNew.hpp"
 
 #include <set>
+using namespace std;
+using namespace ast;
 
 namespace ControlStruct {
-
-namespace {
-
 class Entry {
-public:
-        const ast::Stmt * stmt;
-private:
+  public:
+        const Stmt * stmt;
+  private:
         // Organized like a manual ADT. Avoids creating a bunch of dead data.
         struct Target {
-                ast::Label label;
+                Label label;
                 bool used = false;
-                Target( const ast::Label & label ) : label( label ) {}
+                Target( const Label & label ) : label( label ) {}
                 Target() : label( CodeLocation() ) {}
         };
@@ -41 +40 @@
 
         enum Kind {
-                ForStmt, WhileStmt, CompoundStmt, IfStmt, CaseStmt, SwitchStmt, TryStmt
+                ForStmtK, WhileStmtK, CompoundStmtK, IfStmtK, CaseStmtK, SwitchStmtK, TryStmtK
         } kind;
 
         bool fallDefaultValid = true;
 
-        static ast::Label & useTarget( Target & target ) {
+        static Label & useTarget( Target & target ) {
                 target.used = true;
                 return target.label;
         }
 
-public:
-        Entry( const ast::ForStmt * stmt, ast::Label breakExit, ast::Label contExit ) :
-                stmt( stmt ), firstTarget( breakExit ), secondTarget( contExit ), kind( ForStmt ) {}
-        Entry( const ast::WhileStmt * stmt, ast::Label breakExit, ast::Label contExit ) :
-                stmt( stmt ), firstTarget( breakExit ), secondTarget( contExit ), kind( WhileStmt ) {}
-        Entry( const ast::CompoundStmt *stmt, ast::Label breakExit ) :
-                stmt( stmt ), firstTarget( breakExit ), secondTarget(), kind( CompoundStmt ) {}
-        Entry( const ast::IfStmt *stmt, ast::Label breakExit ) :
-                stmt( stmt ), firstTarget( breakExit ), secondTarget(), kind( IfStmt ) {}
-        Entry( const ast::CaseStmt *stmt, ast::Label fallExit ) :
-                stmt( stmt ), firstTarget( fallExit ), secondTarget(), kind( CaseStmt ) {}
-        Entry( const ast::SwitchStmt *stmt, ast::Label breakExit, ast::Label fallDefaultExit ) :
-                stmt( stmt ), firstTarget( breakExit ), secondTarget( fallDefaultExit ), kind( SwitchStmt ) {}
-        Entry( const ast::TryStmt *stmt, ast::Label breakExit ) :
-                stmt( stmt ), firstTarget( breakExit ), secondTarget(), kind( TryStmt ) {}
-
-        bool isContTarget() const { return kind <= WhileStmt; }
-        bool isBreakTarget() const { return CaseStmt != kind; }
-        bool isFallTarget() const { return CaseStmt == kind; }
-        bool isFallDefaultTarget() const { return SwitchStmt == kind; }
-
-        ast::Label useContExit() { assert( kind <= WhileStmt ); return useTarget(secondTarget); }
-        ast::Label useBreakExit() { assert( CaseStmt != kind ); return useTarget(firstTarget); }
-        ast::Label useFallExit() { assert( CaseStmt == kind );  return useTarget(firstTarget); }
-        ast::Label useFallDefaultExit() { assert( SwitchStmt == kind ); return useTarget(secondTarget); }
-
-        bool isContUsed() const { assert( kind <= WhileStmt ); return secondTarget.used; }
-        bool isBreakUsed() const { assert( CaseStmt != kind ); return firstTarget.used; }
-        bool isFallUsed() const { assert( CaseStmt == kind ); return firstTarget.used; }
-        bool isFallDefaultUsed() const { assert( SwitchStmt == kind ); return secondTarget.used; }
+  public:
+        Entry( const ForStmt * stmt, Label breakExit, Label contExit ) :
+                stmt( stmt ), firstTarget( breakExit ), secondTarget( contExit ), kind( ForStmtK ) {}
+        Entry( const WhileStmt * stmt, Label breakExit, Label contExit ) :
+                stmt( stmt ), firstTarget( breakExit ), secondTarget( contExit ), kind( WhileStmtK ) {}
+        Entry( const CompoundStmt *stmt, Label breakExit ) :
+                stmt( stmt ), firstTarget( breakExit ), secondTarget(), kind( CompoundStmtK ) {}
+        Entry( const IfStmt *stmt, Label breakExit ) :
+                stmt( stmt ), firstTarget( breakExit ), secondTarget(), kind( IfStmtK ) {}
+        Entry( const CaseStmt *stmt, Label fallExit ) :
+                stmt( stmt ), firstTarget( fallExit ), secondTarget(), kind( CaseStmtK ) {}
+        Entry( const SwitchStmt *stmt, Label breakExit, Label fallDefaultExit ) :
+                stmt( stmt ), firstTarget( breakExit ), secondTarget( fallDefaultExit ), kind( SwitchStmtK ) {}
+        Entry( const TryStmt *stmt, Label breakExit ) :
+                stmt( stmt ), firstTarget( breakExit ), secondTarget(), kind( TryStmtK ) {}
+
+        bool isContTarget() const { return kind <= WhileStmtK; }
+        bool isBreakTarget() const { return kind != CaseStmtK; }
+        bool isFallTarget() const { return kind == CaseStmtK; }
+        bool isFallDefaultTarget() const { return kind == SwitchStmtK; }
+
+        Label useContExit() { assert( kind <= WhileStmtK ); return useTarget(secondTarget); }
+        Label useBreakExit() { assert( kind != CaseStmtK ); return useTarget(firstTarget); }
+        Label useFallExit() { assert( kind == CaseStmtK );  return useTarget(firstTarget); }
+        Label useFallDefaultExit() { assert( kind == SwitchStmtK ); return useTarget(secondTarget); }
+
+        bool isContUsed() const { assert( kind <= WhileStmtK ); return secondTarget.used; }
+        bool isBreakUsed() const { assert( kind != CaseStmtK ); return firstTarget.used; }
+        bool isFallUsed() const { assert( kind == CaseStmtK ); return firstTarget.used; }
+        bool isFallDefaultUsed() const { assert( kind == SwitchStmtK ); return secondTarget.used; }
         void seenDefault() { fallDefaultValid = false; }
         bool isFallDefaultValid() const { return fallDefaultValid; }
 };
 
-// Helper predicates used in std::find_if calls (it doesn't take methods):
+// Helper predicates used in find_if calls (it doesn't take methods):
 bool isBreakTarget( const Entry & entry ) {
         return entry.isBreakTarget();
@@ -103 +102 @@
 
 struct MultiLevelExitCore final :
-                public ast::WithVisitorRef<MultiLevelExitCore>,
-                public ast::WithShortCircuiting, public ast::WithGuards {
+        public WithVisitorRef<MultiLevelExitCore>,
+        public WithShortCircuiting, public WithGuards {
         MultiLevelExitCore( const LabelToStmt & lt );
 
-        void previsit( const ast::FunctionDecl * );
-
-        const ast::CompoundStmt * previsit( const ast::CompoundStmt * );
-        const ast::BranchStmt * postvisit( const ast::BranchStmt * );
-        void previsit( const ast::WhileStmt * );
-        const ast::WhileStmt * postvisit( const ast::WhileStmt * );
-        void previsit( const ast::ForStmt * );
-        const ast::ForStmt * postvisit( const ast::ForStmt * );
-        const ast::CaseStmt * previsit( const ast::CaseStmt * );
-        void previsit( const ast::IfStmt * );
-        const ast::IfStmt * postvisit( const ast::IfStmt * );
-        void previsit( const ast::SwitchStmt * );
-        const ast::SwitchStmt * postvisit( const ast::SwitchStmt * );
-        void previsit( const ast::ReturnStmt * );
-        void previsit( const ast::TryStmt * );
-        void postvisit( const ast::TryStmt * );
-        void previsit( const ast::FinallyStmt * );
-
-        const ast::Stmt * mutateLoop( const ast::Stmt * body, Entry& );
+        void previsit( const FunctionDecl * );
+
+        const CompoundStmt * previsit( const CompoundStmt * );
+        const BranchStmt * postvisit( const BranchStmt * );
+        void previsit( const WhileStmt * );
+        const WhileStmt * postvisit( const WhileStmt * );
+        void previsit( const ForStmt * );
+        const ForStmt * postvisit( const ForStmt * );
+        const CaseStmt * previsit( const CaseStmt * );
+        void previsit( const IfStmt * );
+        const IfStmt * postvisit( const IfStmt * );
+        void previsit( const SwitchStmt * );
+        const SwitchStmt * postvisit( const SwitchStmt * );
+        void previsit( const ReturnStmt * );
+        void previsit( const TryStmt * );
+        void postvisit( const TryStmt * );
+        void previsit( const FinallyStmt * );
+
+        const Stmt * mutateLoop( const Stmt * body, Entry& );
 
         const LabelToStmt & target_table;
-        std::set<ast::Label> fallthrough_labels;
-        std::vector<Entry> enclosing_control_structures;
-        ast::Label break_label;
+        set<Label> fallthrough_labels;
+        vector<Entry> enclosing_control_structures;
+        Label break_label;
         bool inFinally;
 
@@ -138 +137 @@
         const LoopNode * posthandleLoopStmt( const LoopNode * loopStmt );
 
-        std::list<ast::ptr<ast::Stmt>> fixBlock(
-                const std::list<ast::ptr<ast::Stmt>> & kids, bool caseClause );
+        list<ptr<Stmt>> fixBlock(
+                const list<ptr<Stmt>> & kids, bool caseClause );
 
         template<typename UnaryPredicate>
         auto findEnclosingControlStructure( UnaryPredicate pred ) {
-                return std::find_if( enclosing_control_structures.rbegin(),
-                        enclosing_control_structures.rend(), pred );
+                return find_if( enclosing_control_structures.rbegin(),
+                                                enclosing_control_structures.rend(), pred );
         }
 };
 
-ast::NullStmt * labelledNullStmt(
-                const CodeLocation & cl, const ast::Label & label ) {
-        return new ast::NullStmt( cl, std::vector<ast::Label>{ label } );
+NullStmt * labelledNullStmt(
+        const CodeLocation & cl, const Label & label ) {
+        return new NullStmt( cl, vector<Label>{ label } );
 }
 
@@ -158 +157 @@
 {}
 
-void MultiLevelExitCore::previsit( const ast::FunctionDecl * ) {
+void MultiLevelExitCore::previsit( const FunctionDecl * ) {
         visit_children = false;
 }
 
-const ast::CompoundStmt * MultiLevelExitCore::previsit(
-                const ast::CompoundStmt * stmt ) {
+const CompoundStmt * MultiLevelExitCore::previsit(
+        const CompoundStmt * stmt ) {
         visit_children = false;
         bool isLabeled = !stmt->labels.empty();
         if ( isLabeled ) {
-                ast::Label breakLabel = LabelGenerator::newLabel( "blockBreak", stmt );
+                Label breakLabel = newLabel( "blockBreak", stmt );
                 enclosing_control_structures.emplace_back( stmt, breakLabel );
                 GuardAction( [this]() { enclosing_control_structures.pop_back(); } );
         }
 
-        auto mutStmt = ast::mutate( stmt );
+        auto mutStmt = mutate( stmt );
         // A child statement may set the break label.
-        mutStmt->kids = std::move( fixBlock( stmt->kids, false ) );
+        mutStmt->kids = move( fixBlock( stmt->kids, false ) );
 
         if ( isLabeled ) {
@@ -187 +186 @@
 
 size_t getUnusedIndex(
-                const ast::Stmt * stmt, const ast::Label & originalTarget ) {
+        const Stmt * stmt, const Label & originalTarget ) {
         const size_t size = stmt->labels.size();
 
-        // If the label is empty, we can skip adding the unused attribute:
-        if ( originalTarget.empty() ) return size;
+        // If the label is empty, do not add unused attribute.
+  if ( originalTarget.empty() ) return size;
 
         // Search for a label that matches the originalTarget.
         for ( size_t i = 0 ; i < size ; ++i ) {
-                const ast::Label & label = stmt->labels[i];
+                const Label & label = stmt->labels[i];
                 if ( label == originalTarget ) {
-                        for ( const ast::Attribute * attr : label.attributes ) {
+                        for ( const Attribute * attr : label.attributes ) {
                                 if ( attr->name == "unused" ) return size;
                         }
@@ -204 +203 @@
         }
         assertf( false, "Could not find label '%s' on statement %s",
-                originalTarget.name.c_str(), toString( stmt ).c_str() );
-}
-
-const ast::Stmt * addUnused(
-                const ast::Stmt * stmt, const ast::Label & originalTarget ) {
+                         originalTarget.name.c_str(), toString( stmt ).c_str() );
+}
+
+const Stmt * addUnused(
+        const Stmt * stmt, const Label & originalTarget ) {
         size_t i = getUnusedIndex( stmt, originalTarget );
         if ( i == stmt->labels.size() ) {
                 return stmt;
         }
-        ast::Stmt * mutStmt = ast::mutate( stmt );
-        mutStmt->labels[i].attributes.push_back( new ast::Attribute( "unused" ) );
+        Stmt * mutStmt = mutate( stmt );
+        mutStmt->labels[i].attributes.push_back( new Attribute( "unused" ) );
         return mutStmt;
 }
 
-const ast::BranchStmt * MultiLevelExitCore::postvisit( const ast::BranchStmt * stmt ) {
-        std::vector<Entry>::reverse_iterator targetEntry =
+const BranchStmt * MultiLevelExitCore::postvisit( const BranchStmt * stmt ) {
+        vector<Entry>::reverse_iterator targetEntry =
                 enclosing_control_structures.rend();
         switch ( stmt->kind ) {
-        case ast::BranchStmt::Goto:
+          case BranchStmt::Goto:
                 return stmt;
-        case ast::BranchStmt::Continue:
-        case ast::BranchStmt::Break: {
-                bool isContinue = stmt->kind == ast::BranchStmt::Continue;
-                // Handle unlabeled break and continue.
-                if ( stmt->target.empty() ) {
-                        if ( isContinue ) {
-                                targetEntry = findEnclosingControlStructure( isContinueTarget );
-                        } else {
-                                if ( enclosing_control_structures.empty() ) {
-                                        SemanticError( stmt->location,
-                                                "'break' outside a loop, 'switch', or labelled block" );
-                                }
-                                targetEntry = findEnclosingControlStructure( isBreakTarget );
-                        }
-                // Handle labeled break and continue.
-                } else {
-                        // Lookup label in table to find attached control structure.
-                        targetEntry = findEnclosingControlStructure(
-                                [ targetStmt = target_table.at(stmt->target) ](auto entry){
-                                        return entry.stmt == targetStmt;
-                                } );
-                }
-                // Ensure that selected target is valid.
-                if ( targetEntry == enclosing_control_structures.rend() || ( isContinue && !isContinueTarget( *targetEntry ) ) ) {
-                        SemanticError(
-                                stmt->location,
-                                toString( (isContinue ? "'continue'" : "'break'"),
-                                        " target must be an enclosing ",
-                                        (isContinue ? "loop: " : "control structure: "),
-                                        stmt->originalTarget ) );
-                }
-                break;
-        }
-        case ast::BranchStmt::FallThrough: {
-                targetEntry = findEnclosingControlStructure( isFallthroughTarget );
-                // Check that target is valid.
-                if ( targetEntry == enclosing_control_structures.rend() ) {
-                        SemanticError( stmt->location, "'fallthrough' must be enclosed in a 'switch' or 'choose'" );
-                }
-                if ( !stmt->target.empty() ) {
-                        // Labelled fallthrough: target must be a valid fallthough label.
-                        if ( !fallthrough_labels.count( stmt->target ) ) {
-                                SemanticError( stmt->location, toString( "'fallthrough' target must be a later case statement: ", stmt->originalTarget ) );
-                        }
-                        return new ast::BranchStmt(
-                                stmt->location, ast::BranchStmt::Goto, stmt->originalTarget );
-                }
-                break;
-        }
-        case ast::BranchStmt::FallThroughDefault: {
-                targetEntry = findEnclosingControlStructure( isFallthroughDefaultTarget );
-
-                // Check that this is in a switch or choose statement.
-                if ( targetEntry == enclosing_control_structures.rend() ) {
-                        SemanticError( stmt->location, "'fallthrough' must be enclosed in a 'switch' or 'choose'" );
-                }
-
-                // Check that the switch or choose has a default clause.
-                auto switchStmt = strict_dynamic_cast< const ast::SwitchStmt * >(
-                        targetEntry->stmt );
-                bool foundDefault = false;
-                for ( auto subStmt : switchStmt->stmts ) {
-                        const ast::CaseStmt * caseStmt = subStmt.strict_as<ast::CaseStmt>();
-                        if ( caseStmt->isDefault() ) {
-                                foundDefault = true;
-                                break;
-                        }
-                }
-                if ( !foundDefault ) {
-                        SemanticError( stmt->location, "'fallthrough default' must be enclosed in a 'switch' or 'choose' control structure with a 'default' clause" );
-                }
-                break;
-        }
-        default:
+          case BranchStmt::Continue:
+          case BranchStmt::Break: {
+                  bool isContinue = stmt->kind == BranchStmt::Continue;
+                  // Handle unlabeled break and continue.
+                  if ( stmt->target.empty() ) {
+                          if ( isContinue ) {
+                                  targetEntry = findEnclosingControlStructure( isContinueTarget );
+                          } else {
+                                  if ( enclosing_control_structures.empty() ) {
+                                          SemanticError( stmt->location,
+                                                                         "'break' outside a loop, 'switch', or labelled block" );
+                                  }
+                                  targetEntry = findEnclosingControlStructure( isBreakTarget );
+                          }
+                          // Handle labeled break and continue.
+                  } else {
+                          // Lookup label in table to find attached control structure.
+                          targetEntry = findEnclosingControlStructure(
+                                  [ targetStmt = target_table.at(stmt->target) ](auto entry){
+                                          return entry.stmt == targetStmt;
+                                  } );
+                  }
+                  // Ensure that selected target is valid.
+                  if ( targetEntry == enclosing_control_structures.rend() || ( isContinue && !isContinueTarget( *targetEntry ) ) ) {
+                          SemanticError( stmt->location, toString( (isContinue ? "'continue'" : "'break'"),
+                                                        " target must be an enclosing ", (isContinue ? "loop: " : "control structure: "),
+                                                        stmt->originalTarget ) );
+                  }
+                  break;
+          }
+          case BranchStmt::FallThrough: {
+                  targetEntry = findEnclosingControlStructure( isFallthroughTarget );
+                  // Check that target is valid.
+                  if ( targetEntry == enclosing_control_structures.rend() ) {
+                          SemanticError( stmt->location, "'fallthrough' must be enclosed in a 'switch' or 'choose'" );
+                  }
+                  if ( !stmt->target.empty() ) {
+                          // Labelled fallthrough: target must be a valid fallthough label.
+                          if ( !fallthrough_labels.count( stmt->target ) ) {
+                                  SemanticError( stmt->location, toString( "'fallthrough' target must be a later case statement: ",
+                                                                                                                   stmt->originalTarget ) );
+                          }
+                          return new BranchStmt(
+                                  stmt->location, BranchStmt::Goto, stmt->originalTarget );
+                  }
+                  break;
+          }
+          case BranchStmt::FallThroughDefault: {
+                  targetEntry = findEnclosingControlStructure( isFallthroughDefaultTarget );
+
+                  // Check if in switch or choose statement.
+                  if ( targetEntry == enclosing_control_structures.rend() ) {
+                          SemanticError( stmt->location, "'fallthrough' must be enclosed in a 'switch' or 'choose'" );
+                  }
+
+                  // Check if switch or choose has default clause.
+                  auto switchStmt = strict_dynamic_cast< const SwitchStmt * >( targetEntry->stmt );
+                  bool foundDefault = false;
+                  for ( auto subStmt : switchStmt->stmts ) {
+                          const CaseStmt * caseStmt = subStmt.strict_as<CaseStmt>();
+                          if ( caseStmt->isDefault() ) {
+                                  foundDefault = true;
+                                  break;
+                          }
+                  }
+                  if ( ! foundDefault ) {
+                          SemanticError( stmt->location, "'fallthrough default' must be enclosed in a 'switch' or 'choose'"
+                                                         "control structure with a 'default' clause" );
+                  }
+                  break;
+          }
+          default:
                 assert( false );
         }
 
         // Branch error checks: get the appropriate label name:
-        // (This label will always be replaced.)
-        ast::Label exitLabel( CodeLocation(), "" );
+        // (This label is always replaced.)
+        Label exitLabel( CodeLocation(), "" );
         switch ( stmt->kind ) {
-        case ast::BranchStmt::Break:
+          case BranchStmt::Break:
                 assert( !targetEntry->useBreakExit().empty() );
                 exitLabel = targetEntry->useBreakExit();
                 break;
-        case ast::BranchStmt::Continue:
+          case BranchStmt::Continue:
                 assert( !targetEntry->useContExit().empty() );
                 exitLabel = targetEntry->useContExit();
                 break;
-        case ast::BranchStmt::FallThrough:
+          case BranchStmt::FallThrough:
                 assert( !targetEntry->useFallExit().empty() );
                 exitLabel = targetEntry->useFallExit();
                 break;
-        case ast::BranchStmt::FallThroughDefault:
+          case BranchStmt::FallThroughDefault:
                 assert( !targetEntry->useFallDefaultExit().empty() );
                 exitLabel = targetEntry->useFallDefaultExit();
                 // Check that fallthrough default comes before the default clause.
                 if ( !targetEntry->isFallDefaultValid() ) {
-                        SemanticError( stmt->location,
-                                "'fallthrough default' must precede the 'default' clause" );
+                        SemanticError( stmt->location, "'fallthrough default' must precede the 'default' clause" );
                 }
                 break;
-        default:
+          default:
                 assert(0);
         }
@@ -333 +329 @@
         targetEntry->stmt = addUnused( targetEntry->stmt, stmt->originalTarget );
 
-        // Replace this with a goto to make later passes more uniform.
-        return new ast::BranchStmt( stmt->location, ast::BranchStmt::Goto, exitLabel );
-}
-
-void MultiLevelExitCore::previsit( const ast::WhileStmt * stmt ) {
+        // Replace with goto to make later passes more uniform.
+        return new BranchStmt( stmt->location, BranchStmt::Goto, exitLabel );
+}
+
+void MultiLevelExitCore::previsit( const WhileStmt * stmt ) {
         return prehandleLoopStmt( stmt );
 }
 
-const ast::WhileStmt * MultiLevelExitCore::postvisit( const ast::WhileStmt * stmt ) {
+const WhileStmt * MultiLevelExitCore::postvisit( const WhileStmt * stmt ) {
         return posthandleLoopStmt( stmt );
 }
 
-void MultiLevelExitCore::previsit( const ast::ForStmt * stmt ) {
+void MultiLevelExitCore::previsit( const ForStmt * stmt ) {
         return prehandleLoopStmt( stmt );
 }
 
-const ast::ForStmt * MultiLevelExitCore::postvisit( const ast::ForStmt * stmt ) {
+const ForStmt * MultiLevelExitCore::postvisit( const ForStmt * stmt ) {
         return posthandleLoopStmt( stmt );
 }
@@ -355 +351 @@
 // Mimic what the built-in push_front would do anyways. It is O(n).
 void push_front(
-                std::vector<ast::ptr<ast::Stmt>> & vec, const ast::Stmt * element ) {
+        vector<ptr<Stmt>> & vec, const Stmt * element ) {
         vec.emplace_back( nullptr );
         for ( size_t i = vec.size() - 1 ; 0 < i ; --i ) {
-                vec[ i ] = std::move( vec[ i - 1 ] );
+                vec[ i ] = move( vec[ i - 1 ] );
         }
         vec[ 0 ] = element;
 }
 
-const ast::CaseStmt * MultiLevelExitCore::previsit( const ast::CaseStmt * stmt ) {
+const CaseStmt * MultiLevelExitCore::previsit( const CaseStmt * stmt ) {
         visit_children = false;
 
-        // If it is the default, mark the default as seen.
+        // If default, mark seen.
         if ( stmt->isDefault() ) {
                 assert( !enclosing_control_structures.empty() );
@@ -373 +369 @@
 
         // The cond may not exist, but if it does update it now.
-        visitor->maybe_accept( stmt, &ast::CaseStmt::cond );
+        visitor->maybe_accept( stmt, &CaseStmt::cond );
 
         // Just save the mutated node for simplicity.
-        ast::CaseStmt * mutStmt = ast::mutate( stmt );
-
-        ast::Label fallLabel = LabelGenerator::newLabel( "fallThrough", stmt );
-        if ( !mutStmt->stmts.empty() ) {
+        CaseStmt * mutStmt = mutate( stmt );
+
+        Label fallLabel = newLabel( "fallThrough", stmt );
+        if ( ! mutStmt->stmts.empty() ) {
                 // Ensure that the stack isn't corrupted by exceptions in fixBlock.
                 auto guard = makeFuncGuard(
                         [&](){ enclosing_control_structures.emplace_back( mutStmt, fallLabel ); },
                         [this](){ enclosing_control_structures.pop_back(); }
-                );
+                        );
 
                 // These should already be in a block.
-                auto block = ast::mutate( mutStmt->stmts.front().strict_as<ast::CompoundStmt>() );
+                auto block = mutate( mutStmt->stmts.front().strict_as<CompoundStmt>() );
                 block->kids = fixBlock( block->kids, true );
 
                 // Add fallthrough label if necessary.
-                assert( !enclosing_control_structures.empty() );
+                assert( ! enclosing_control_structures.empty() );
                 Entry & entry = enclosing_control_structures.back();
                 if ( entry.isFallUsed() ) {
@@ -398 +394 @@
                 }
         }
-        assert( !enclosing_control_structures.empty() );
+        assert( ! enclosing_control_structures.empty() );
         Entry & entry = enclosing_control_structures.back();
-        assertf( dynamic_cast< const ast::SwitchStmt * >( entry.stmt ),
-                "Control structure enclosing a case clause must be a switch, but is: %s",
-                toString( entry.stmt ).c_str() );
+        assertf( dynamic_cast< const SwitchStmt * >( entry.stmt ),
+                         "Control structure enclosing a case clause must be a switch, but is: %s",
+                         toString( entry.stmt ).c_str() );
         if ( mutStmt->isDefault() ) {
                 if ( entry.isFallDefaultUsed() ) {
                         // Add fallthrough default label if necessary.
                         push_front( mutStmt->stmts, labelledNullStmt(
-                                stmt->location, entry.useFallDefaultExit()
-                        ) );
+                                                        stmt->location, entry.useFallDefaultExit()
+                                                        ) );
                 }
         }
@@ -414 +410 @@
 }
 
-void MultiLevelExitCore::previsit( const ast::IfStmt * stmt ) {
+void MultiLevelExitCore::previsit( const IfStmt * stmt ) {
         bool labeledBlock = !stmt->labels.empty();
         if ( labeledBlock ) {
-                ast::Label breakLabel = LabelGenerator::newLabel( "blockBreak", stmt );
+                Label breakLabel = newLabel( "blockBreak", stmt );
                 enclosing_control_structures.emplace_back( stmt, breakLabel );
                 GuardAction( [this](){ enclosing_control_structures.pop_back(); } );
@@ -423 +419 @@
 }
 
-const ast::IfStmt * MultiLevelExitCore::postvisit( const ast::IfStmt * stmt ) {
+const IfStmt * MultiLevelExitCore::postvisit( const IfStmt * stmt ) {
         bool labeledBlock = !stmt->labels.empty();
         if ( labeledBlock ) {
@@ -434 +430 @@
 }
 
-bool isDefaultCase( const ast::ptr<ast::Stmt> & stmt ) {
-        const ast::CaseStmt * caseStmt = stmt.strict_as<ast::CaseStmt>();
+bool isDefaultCase( const ptr<Stmt> & stmt ) {
+        const CaseStmt * caseStmt = stmt.strict_as<CaseStmt>();
         return caseStmt->isDefault();
 }
 
-void MultiLevelExitCore::previsit( const ast::SwitchStmt * stmt ) {
-        ast::Label label = LabelGenerator::newLabel( "switchBreak", stmt );
-        auto it = std::find_if( stmt->stmts.rbegin(), stmt->stmts.rend(), isDefaultCase );
-
-        const ast::CaseStmt * defaultCase = it != stmt->stmts.rend()
-                ? (it)->strict_as<ast::CaseStmt>() : nullptr;
-        ast::Label defaultLabel = defaultCase
-                ? LabelGenerator::newLabel( "fallThroughDefault", defaultCase )
-                : ast::Label( stmt->location, "" );
+void MultiLevelExitCore::previsit( const SwitchStmt * stmt ) {
+        Label label = newLabel( "switchBreak", stmt );
+        auto it = find_if( stmt->stmts.rbegin(), stmt->stmts.rend(), isDefaultCase );
+
+        const CaseStmt * defaultCase = it != stmt->stmts.rend()
+                ? (it)->strict_as<CaseStmt>() : nullptr;
+        Label defaultLabel = defaultCase
+                ? newLabel( "fallThroughDefault", defaultCase )
+                : Label( stmt->location, "" );
         enclosing_control_structures.emplace_back( stmt, label, defaultLabel );
         GuardAction( [this]() { enclosing_control_structures.pop_back(); } );
 
         // Collect valid labels for fallthrough. It starts with all labels at
-        // this level, then removed as we see them in traversal.
-        for ( const ast::Stmt * stmt : stmt->stmts ) {
-                auto * caseStmt = strict_dynamic_cast< const ast::CaseStmt * >( stmt );
+        // this level, then remove as each is seen during traversal.
+        for ( const Stmt * stmt : stmt->stmts ) {
+                auto * caseStmt = strict_dynamic_cast< const CaseStmt * >( stmt );
                 if ( caseStmt->stmts.empty() ) continue;
-                auto block = caseStmt->stmts.front().strict_as<ast::CompoundStmt>();
-                for ( const ast::Stmt * stmt : block->kids ) {
-                        for ( const ast::Label & l : stmt->labels ) {
+                auto block = caseStmt->stmts.front().strict_as<CompoundStmt>();
+                for ( const Stmt * stmt : block->kids ) {
+                        for ( const Label & l : stmt->labels ) {
                                 fallthrough_labels.insert( l );
                         }
@@ -465 +461 @@
 }
 
-const ast::SwitchStmt * MultiLevelExitCore::postvisit( const ast::SwitchStmt * stmt ) {
+const SwitchStmt * MultiLevelExitCore::postvisit( const SwitchStmt * stmt ) {
         assert( !enclosing_control_structures.empty() );
         Entry & entry = enclosing_control_structures.back();
         assert( entry.stmt == stmt );
 
-        // Only run if we need to generate the break label.
+        // Only run to generate the break label.
         if ( entry.isBreakUsed() ) {
                 // To keep the switch statements uniform (all direct children of a
                 // SwitchStmt should be CastStmts), append the exit label and break
                 // to the last case, create a default case is there are no cases.
-                ast::SwitchStmt * mutStmt = ast::mutate( stmt );
+                SwitchStmt * mutStmt = mutate( stmt );
                 if ( mutStmt->stmts.empty() ) {
-                        mutStmt->stmts.push_back( new ast::CaseStmt(
-                                mutStmt->location, nullptr, {} ));
-                }
-
-                auto caseStmt = mutStmt->stmts.back().strict_as<ast::CaseStmt>();
-                auto mutCase = ast::mutate( caseStmt );
+                        mutStmt->stmts.push_back( new CaseStmt(
+                                                                                  mutStmt->location, nullptr, {} ));
+                }
+
+                auto caseStmt = mutStmt->stmts.back().strict_as<CaseStmt>();
+                auto mutCase = mutate( caseStmt );
                 mutStmt->stmts.back() = mutCase;
 
-                ast::Label label( mutCase->location, "breakLabel" );
-                auto branch = new ast::BranchStmt( mutCase->location, ast::BranchStmt::Break, label );
+                Label label( mutCase->location, "breakLabel" );
+                auto branch = new BranchStmt( mutCase->location, BranchStmt::Break, label );
                 branch->labels.push_back( entry.useBreakExit() );
                 mutCase->stmts.push_back( branch );
@@ -495 +491 @@
 }
 
-void MultiLevelExitCore::previsit( const ast::ReturnStmt * stmt ) {
+void MultiLevelExitCore::previsit( const ReturnStmt * stmt ) {
         if ( inFinally ) {
                 SemanticError( stmt->location, "'return' may not appear in a finally clause" );
@@ -501 +497 @@
 }
 
-void MultiLevelExitCore::previsit( const ast::TryStmt * stmt ) {
+void MultiLevelExitCore::previsit( const TryStmt * stmt ) {
         bool isLabeled = !stmt->labels.empty();
         if ( isLabeled ) {
-                ast::Label breakLabel = LabelGenerator::newLabel( "blockBreak", stmt );
+                Label breakLabel = newLabel( "blockBreak", stmt );
                 enclosing_control_structures.emplace_back( stmt, breakLabel );
                 GuardAction([this](){ enclosing_control_structures.pop_back(); } );
@@ -510 +506 @@
 }
 
-void MultiLevelExitCore::postvisit( const ast::TryStmt * stmt ) {
+void MultiLevelExitCore::postvisit( const TryStmt * stmt ) {
         bool isLabeled = !stmt->labels.empty();
         if ( isLabeled ) {
@@ -520 +516 @@
 }
 
-void MultiLevelExitCore::previsit( const ast::FinallyStmt * ) {
-        GuardAction([this, old = std::move(enclosing_control_structures)](){
-                enclosing_control_structures = std::move(old);
-        });
-        enclosing_control_structures = std::vector<Entry>();
+void MultiLevelExitCore::previsit( const FinallyStmt * ) {
+        GuardAction([this, old = move(enclosing_control_structures)](){
+                                        enclosing_control_structures = move(old);
+                                });
+        enclosing_control_structures = vector<Entry>();
         GuardValue( inFinally ) = true;
 }
 
-const ast::Stmt * MultiLevelExitCore::mutateLoop(
-                const ast::Stmt * body, Entry & entry ) {
+const Stmt * MultiLevelExitCore::mutateLoop(
+        const Stmt * body, Entry & entry ) {
         if ( entry.isBreakUsed() ) {
                 break_label = entry.useBreakExit();
@@ -535 +531 @@
 
         if ( entry.isContUsed() ) {
-                ast::CompoundStmt * new_body = new ast::CompoundStmt( body->location );
+                CompoundStmt * new_body = new CompoundStmt( body->location );
                 new_body->kids.push_back( body );
                 new_body->kids.push_back(
@@ -549 +545 @@
         // Remember is loop before going onto mutate the body.
         // The labels will be folded in if they are used.
-        ast::Label breakLabel = LabelGenerator::newLabel( "loopBreak", loopStmt );
-        ast::Label contLabel = LabelGenerator::newLabel( "loopContinue", loopStmt );
+        Label breakLabel = newLabel( "loopBreak", loopStmt );
+        Label contLabel = newLabel( "loopContinue", loopStmt );
         enclosing_control_structures.emplace_back( loopStmt, breakLabel, contLabel );
         GuardAction( [this](){ enclosing_control_structures.pop_back(); } );
@@ -561 +557 @@
         assert( entry.stmt == loopStmt );
 
-        // Now we check if the labels are used and add them if so.
-        return ast::mutate_field(
+        // Now check if the labels are used and add them if so.
+        return mutate_field(
                 loopStmt, &LoopNode::body, mutateLoop( loopStmt->body, entry ) );
 }
 
-std::list<ast::ptr<ast::Stmt>> MultiLevelExitCore::fixBlock(
-                const std::list<ast::ptr<ast::Stmt>> & kids, bool is_case_clause ) {
-        // Unfortunately we can't use the automatic error collection.
+list<ptr<Stmt>> MultiLevelExitCore::fixBlock(
+        const list<ptr<Stmt>> & kids, bool is_case_clause ) {
+        // Unfortunately cannot use automatic error collection.
         SemanticErrorException errors;
 
-        std::list<ast::ptr<ast::Stmt>> ret;
+        list<ptr<Stmt>> ret;
 
         // Manually visit each child.
-        for ( const ast::ptr<ast::Stmt> & kid : kids ) {
+        for ( const ptr<Stmt> & kid : kids ) {
                 if ( is_case_clause ) {
                         // Once a label is seen, it's no longer a valid for fallthrough.
-                        for ( const ast::Label & l : kid->labels ) {
+                        for ( const Label & l : kid->labels ) {
                                 fallthrough_labels.erase( l );
                         }
@@ -591 +587 @@
                         ret.push_back(
                                 labelledNullStmt( ret.back()->location, break_label ) );
-                        break_label = ast::Label( CodeLocation(), "" );
+                        break_label = Label( CodeLocation(), "" );
                 }
         }
@@ -601 +597 @@
 }
 
-} // namespace
-
-const ast::CompoundStmt * multiLevelExitUpdate(
-        const ast::CompoundStmt * stmt,
-                const LabelToStmt & labelTable ) {
+const CompoundStmt * multiLevelExitUpdate(
+        const CompoundStmt * stmt,
+        const LabelToStmt & labelTable ) {
         // Must start in the body, so FunctionDecls can be a stopping point.
-        ast::Pass<MultiLevelExitCore> visitor( labelTable );
-        const ast::CompoundStmt * ret = stmt->accept( visitor );
+        Pass<MultiLevelExitCore> visitor( labelTable );
+        const CompoundStmt * ret = stmt->accept( visitor );
         return ret;
 }
-
 } // namespace ControlStruct
 

src/ControlStruct/MultiLevelExit.hpp

@@ -9 +9 @@
 // Author           : Andrew Beach
 // Created On       : Mon Nov  1 13:49:00 2021
-// Last Modified By : Andrew Beach
-// Last Modified On : Mon Nov  8 10:53:00 2021
-// Update Count     : 3
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Jan 31 22:34:06 2022
+// Update Count     : 6
 //
 
@@ -19 +19 @@
 
 namespace ast {
-        class CompoundStmt;
-        class Label;
-        class Stmt;
+class CompoundStmt;
+class Label;
+class Stmt;
 }
 
 namespace ControlStruct {
-
 using LabelToStmt = std::map<ast::Label, const ast::Stmt *>;
 
-/// Mutate a function body to handle multi-level exits.
-const ast::CompoundStmt * multiLevelExitUpdate(
-        const ast::CompoundStmt *, const LabelToStmt & );
-
+// Mutate a function body to handle multi-level exits.
+const ast::CompoundStmt * multiLevelExitUpdate( const ast::CompoundStmt *, const LabelToStmt & );
 }
 

src/ControlStruct/module.mk

@@ -10 +10 @@
 ## Author           : Richard C. Bilson
 ## Created On       : Mon Jun  1 17:49:17 2015
-## Last Modified By : Henry Xue
-## Last Modified On : Tue Jul 20 04:10:50 2021
-## Update Count     : 5
+## Last Modified By : Peter A. Buhr
+## Last Modified On : Sat Jan 29 12:04:19 2022
+## Update Count     : 7
 ###############################################################################
 
@@ -22 +22 @@
         ControlStruct/ForExprMutator.cc \
         ControlStruct/ForExprMutator.h \
+        ControlStruct/HoistControlDecls.cpp \
+        ControlStruct/HoistControlDecls.hpp \
         ControlStruct/LabelFixer.cc \
         ControlStruct/LabelFixer.h \
         ControlStruct/LabelGenerator.cc \
         ControlStruct/LabelGenerator.h \
+        ControlStruct/LabelGeneratorNew.cpp \
+        ControlStruct/LabelGeneratorNew.hpp \
         ControlStruct/MLEMutator.cc \
         ControlStruct/MLEMutator.h \

src/InitTweak/InitTweak.cc

@@ -10 +10 @@
 // Created On       : Fri May 13 11:26:36 2016
 // Last Modified By : Andrew Beach
-// Last Modified On : Fri Nov 19 19:22:00 2021
-// Update Count     : 19
+// Last Modified On : Mon Dec  6 13:21:00 2021
+// Update Count     : 20
 //
 
@@ -1191 +1191 @@
         }
 
-        bool isCopyFunction( const ast::FunctionDecl * decl ) {
-                const ast::FunctionType * ftype = decl->type;
-                if ( ftype->params.size() != 2 ) return false;
-
-                const ast::Type * t1 = getPointerBase( ftype->params.front() );
-                if ( ! t1 ) return false;
-                const ast::Type * t2 = ftype->params.back();
-
-                return ResolvExpr::typesCompatibleIgnoreQualifiers( t1, t2, ast::SymbolTable{} );
-        }
+bool isAssignment( const ast::FunctionDecl * decl ) {
+        return isAssignment( decl->name ) && isCopyFunction( decl );
+}
+
+bool isDestructor( const ast::FunctionDecl * decl ) {
+        return isDestructor( decl->name );
+}
+
+bool isDefaultConstructor( const ast::FunctionDecl * decl ) {
+        return isConstructor( decl->name ) && 1 == decl->params.size();
+}
+
+bool isCopyConstructor( const ast::FunctionDecl * decl ) {
+        return isConstructor( decl->name ) && 2 == decl->params.size();
+}
+
+bool isCopyFunction( const ast::FunctionDecl * decl ) {
+        const ast::FunctionType * ftype = decl->type;
+        if ( ftype->params.size() != 2 ) return false;
+
+        const ast::Type * t1 = getPointerBase( ftype->params.front() );
+        if ( ! t1 ) return false;
+        const ast::Type * t2 = ftype->params.back();
+
+        return ResolvExpr::typesCompatibleIgnoreQualifiers( t1, t2, ast::SymbolTable{} );
+}
 
         const FunctionDecl * isAssignment( const Declaration * decl ) {

src/InitTweak/InitTweak.h

@@ -10 +10 @@
 // Created On       : Fri May 13 11:26:36 2016
 // Last Modified By : Andrew Beach
-// Last Modified On : Fri Nov 19 14:18:00 2021
-// Update Count     : 7
+// Last Modified On : Mon Dec  6 13:20:00 2021
+// Update Count     : 8
 //
 
@@ -31 +31 @@
         const FunctionDecl * isCopyConstructor( const Declaration * decl );
         const FunctionDecl * isCopyFunction( const Declaration * decl, const std::string & fname );
+        bool isAssignment( const ast::FunctionDecl * decl );
+        bool isDestructor( const ast::FunctionDecl * decl );
+        bool isDefaultConstructor( const ast::FunctionDecl * decl );
+        bool isCopyConstructor( const ast::FunctionDecl * decl );
         bool isCopyFunction( const ast::FunctionDecl * decl );
 

src/Parser/ParseNode.h

@@ -10 +10 @@
 // Created On       : Sat May 16 13:28:16 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Jul 14 17:28:53 2021
-// Update Count     : 900
+// Last Modified On : Sat Jan 29 09:45:56 2022
+// Update Count     : 901
 //
 
@@ -390 +390 @@
 Statement * build_expr( ExpressionNode * ctl );
 
-struct IfCtrl {
-        IfCtrl( DeclarationNode * decl, ExpressionNode * condition ) :
+struct CondCtl {
+        CondCtl( DeclarationNode * decl, ExpressionNode * condition ) :
                 init( decl ? new StatementNode( decl ) : nullptr ), condition( condition ) {}
 
@@ -409 +409 @@
 };
 
-Expression * build_if_control( IfCtrl * ctl, std::list< Statement * > & init );
-Statement * build_if( IfCtrl * ctl, StatementNode * then_stmt, StatementNode * else_stmt );
+Expression * build_if_control( CondCtl * ctl, std::list< Statement * > & init );
+Statement * build_if( CondCtl * ctl, StatementNode * then_stmt, StatementNode * else_stmt );
 Statement * build_switch( bool isSwitch, ExpressionNode * ctl, StatementNode * stmt );
 Statement * build_case( ExpressionNode * ctl );
 Statement * build_default();
-Statement * build_while( IfCtrl * ctl, StatementNode * stmt );
+Statement * build_while( CondCtl * ctl, StatementNode * stmt );
 Statement * build_do_while( ExpressionNode * ctl, StatementNode * stmt );
 Statement * build_for( ForCtrl * forctl, StatementNode * stmt );

src/Parser/StatementNode.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 14:59:41 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Oct 24 04:20:55 2020
-// Update Count     : 383
+// Last Modified On : Sat Jan 29 09:45:51 2022
+// Update Count     : 384
 //
 
@@ -78 +78 @@
 } // build_expr
 
-Expression * build_if_control( IfCtrl * ctl, std::list< Statement * > & init ) {
+Expression * build_if_control( CondCtl * ctl, std::list< Statement * > & init ) {
         if ( ctl->init != 0 ) {
                 buildMoveList( ctl->init, init );
@@ -100 +100 @@
 } // build_if_control
 
-Statement * build_if( IfCtrl * ctl, StatementNode * then_stmt, StatementNode * else_stmt ) {
+Statement * build_if( CondCtl * ctl, StatementNode * then_stmt, StatementNode * else_stmt ) {
         Statement * thenb, * elseb = nullptr;
         std::list< Statement * > branches;
@@ -145 +145 @@
 } // build_default
 
-Statement * build_while( IfCtrl * ctl, StatementNode * stmt ) {
+Statement * build_while( CondCtl * ctl, StatementNode * stmt ) {
         std::list< Statement * > branches;
         buildMoveList< Statement, StatementNode >( stmt, branches );

src/Parser/parser.yy

@@ -10 +10 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Oct 15 09:20:17 2021
-// Update Count     : 5163
+// Last Modified On : Sun Jan 30 09:41:13 2022
+// Update Count     : 5165
 //
 
@@ -238 +238 @@
         WaitForStmt * wfs;
         Expression * constant;
-        IfCtrl * ifctl;
+        CondCtl * ifctl;
         ForCtrl * fctl;
         enum OperKinds compop;
@@ -327 +327 @@
 %type<en> comma_expression                              comma_expression_opt
 %type<en> argument_expression_list_opt  argument_expression_list        argument_expression                     default_initializer_opt
-%type<ifctl> if_control_expression
+%type<ifctl> conditional_declaration
 %type<fctl> for_control_expression              for_control_expression_list
 %type<compop> inclexcl
@@ -1123 +1123 @@
 
 if_statement:
-        IF '(' if_control_expression ')' statement                      %prec THEN
+        IF '(' conditional_declaration ')' statement            %prec THEN
                 // explicitly deal with the shift/reduce conflict on if/else
                 { $$ = new StatementNode( build_if( $3, maybe_build_compound( $5 ), nullptr ) ); }
-        | IF '(' if_control_expression ')' statement ELSE statement
+        | IF '(' conditional_declaration ')' statement ELSE statement
                 { $$ = new StatementNode( build_if( $3, maybe_build_compound( $5 ), maybe_build_compound( $7 ) ) ); }
         ;
 
-if_control_expression:
+conditional_declaration:
         comma_expression
-                { $$ = new IfCtrl( nullptr, $1 ); }
+                { $$ = new CondCtl( nullptr, $1 ); }
         | c_declaration                                                                         // no semi-colon
-                { $$ = new IfCtrl( $1, nullptr ); }
+                { $$ = new CondCtl( $1, nullptr ); }
         | cfa_declaration                                                                       // no semi-colon
-                { $$ = new IfCtrl( $1, nullptr ); }
+                { $$ = new CondCtl( $1, nullptr ); }
         | declaration comma_expression                                          // semi-colon separated
-                { $$ = new IfCtrl( $1, $2 ); }
+                { $$ = new CondCtl( $1, $2 ); }
         ;
 
@@ -1193 +1193 @@
 iteration_statement:
         WHILE '(' ')' statement                                                         // CFA => while ( 1 )
-                { $$ = new StatementNode( build_while( new IfCtrl( nullptr, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ), maybe_build_compound( $4 ) ) ); }
-        | WHILE '(' if_control_expression ')' statement         %prec THEN
+                { $$ = new StatementNode( build_while( new CondCtl( nullptr, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ), maybe_build_compound( $4 ) ) ); }
+        | WHILE '(' conditional_declaration ')' statement       %prec THEN
                 { $$ = new StatementNode( build_while( $3, maybe_build_compound( $5 ) ) ); }
-        | WHILE '(' if_control_expression ')' statement ELSE statement // CFA
+        | WHILE '(' conditional_declaration ')' statement ELSE statement // CFA
                 { SemanticError( yylloc, "Loop default block is currently unimplemented." ); $$ = nullptr; }
         | DO statement WHILE '(' ')' ';'                                        // CFA => do while( 1 )

src/SymTab/Validate.cc

@@ -453 +453 @@
         }
 
+        void decayForallPointers( std::list< Declaration * > & translationUnit ) {
+                PassVisitor<ForallPointerDecay_old> fpd;
+                acceptAll( translationUnit, fpd );
+        }
+
         void validate( std::list< Declaration * > &translationUnit, __attribute__((unused)) bool doDebug ) {
                 validate_A( translationUnit );
@@ -470 +475 @@
                 type->accept( fpd );
         }
-
 
         void HoistTypeDecls::handleType( Type * type ) {

src/SymTab/Validate.h

@@ -42 +42 @@
         void validate_E( std::list< Declaration * > &translationUnit );
         void validate_F( std::list< Declaration * > &translationUnit );
+        void decayForallPointers( std::list< Declaration * > & translationUnit );
 
         const ast::Type * validateType(

src/Validate/module.mk

@@ -16 +16 @@
 
 SRC_VALIDATE = \
+        Validate/Autogen.cpp \
+        Validate/Autogen.hpp \
         Validate/CompoundLiteral.cpp \
         Validate/CompoundLiteral.hpp \

src/main.cc

@@ -10 +10 @@
 // Created On       : Fri May 15 23:12:02 2015
 // Last Modified By : Andrew Beach
-// Last Modified On : Tue Nov 30 10:25:00 2021
-// Update Count     : 659
+// Last Modified On : Wed Jan 26 14:09:00 2022
+// Update Count     : 670
 //
 
@@ -55 +55 @@
 #include "ControlStruct/ExceptTranslate.h"  // for translateEHM
 #include "ControlStruct/FixLabels.hpp"      // for fixLabels
+#include "ControlStruct/HoistControlDecls.hpp" //  hoistControlDecls
 #include "ControlStruct/Mutate.h"           // for mutate
 #include "GenPoly/Box.h"                    // for box
@@ -73 +74 @@
 #include "SynTree/Visitor.h"                // for acceptAll
 #include "Tuples/Tuples.h"                  // for expandMemberTuples, expan...
+#include "Validate/Autogen.hpp"             // for autogenerateRoutines
 #include "Validate/FindSpecialDecls.h"      // for findGlobalDecls
 #include "Validate/CompoundLiteral.hpp"     // for handleCompoundLiterals
@@ -78 +80 @@
 #include "Validate/LabelAddressFixer.hpp"   // for fixLabelAddresses
 #include "Virtual/ExpandCasts.h"            // for expandCasts
-
 
 static void NewPass( const char * const name ) {
@@ -326 +327 @@
                 PASS( "Validate-B", SymTab::validate_B( translationUnit ) );
                 PASS( "Validate-C", SymTab::validate_C( translationUnit ) );
-                PASS( "Validate-D", SymTab::validate_D( translationUnit ) );
 
                 CodeTools::fillLocations( translationUnit );
 
                 if( useNewAST ) {
+                        PASS( "Apply Concurrent Keywords", Concurrency::applyKeywords( translationUnit ) );
+                        PASS( "Forall Pointer Decay", SymTab::decayForallPointers( translationUnit ) );
+                        CodeTools::fillLocations( translationUnit );
+
                         if (Stats::Counters::enabled) {
                                 ast::pass_visitor_stats.avg = Stats::Counters::build<Stats::Counters::AverageCounter<double>>("Average Depth - New");
@@ -338 +342 @@
 
                         forceFillCodeLocations( transUnit );
+
+                        // Must happen before autogen routines are added.
+                        PASS( "Hoist Control Declarations", ControlStruct::hoistControlDecls( transUnit ) );
+
+                        // Must be after enum and pointer decay.
+                        // Must be before compound literals.
+                        PASS( "Generate Autogen Routines", Validate::autogenerateRoutines( transUnit ) );
 
                         PASS( "Implement Mutex", Concurrency::implementMutex( transUnit ) );
@@ -406 +417 @@
                         translationUnit = convert( move( transUnit ) );
                 } else {
+                        PASS( "Validate-D", SymTab::validate_D( translationUnit ) );
                         PASS( "Validate-E", SymTab::validate_E( translationUnit ) );
                         PASS( "Validate-F", SymTab::validate_F( translationUnit ) );

tests/concurrent/preempt.cfa

@@ +1 @@
+#include <clock.hfa>
 #include <fstream.hfa>
 #include <kernel.hfa>
@@ -18 +19 @@
 #else
 static const unsigned long N = 500ul;
+static volatile Time prev;
+static Duration preempt_durations[6] = { 0 };
 #endif
 
@@ -26 +29 @@
 thread worker_t {
         int value;
-        unsigned spin;
+        unsigned long long spin;
 };
 
@@ -36 +39 @@
 void main(worker_t & this) {
         while(TEST(counter < N)) {
-                if(this.spin > 100_000_000) abort | "Worker" | this.value | "has been spinning too long! (" | this.spin | ")";
+                if(this.spin > 50_000_000_000) abort | "Worker" | this.value | "has been spinning too long! (" | this.spin | ")";
                 __cfaabi_check_preemption();
                 if( (counter % 7) == this.value ) {
                         __cfaabi_check_preemption();
+                        #if !defined(TEST_LONG)
+                                Time now = timeHiRes();
+                                Duration diff = now - prev;
+                                prev = now;
+                        #endif
                         int next = __atomic_add_fetch( &counter, 1, __ATOMIC_SEQ_CST );
                         __cfaabi_check_preemption();
-                        if( (next % 100) == 0 ) printf("%d\n", (int)next);
+                        if( (next % 100) == 0 ) {
+                                #if !defined(TEST_LONG)
+                                        unsigned idx = next / 100;
+                                        if (idx >= 6) abort | "Idx from next is invalid: " | idx | "vs" | next;
+                                        preempt_durations[idx] = diff;
+                                        if(diff > 12`s) serr | "Duration suspiciously large:" | diff;
+                                #endif
+                                printf("%d\n", (int)next);
+
+                        }
                         __cfaabi_check_preemption();
                         this.spin = 0;
@@ -55 +72 @@
         processor p;
         {
+                prev = timeHiRes();
                 worker_t w0 = 0;
                 worker_t w1 = 1;