Changeset 376c632a


Ignore:
Timestamp:
Feb 1, 2022, 10:10:46 AM (2 years ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
ADT, ast-experimental, 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:
6 added
30 edited

Legend:

Unmodified
Added
Removed
  • libcfa/src/concurrency/io.cfa

    rf681823 r376c632a  
    306306                ctx->proc->io.pending = true;
    307307                ctx->proc->io.dirty   = true;
    308                 if(sq.to_submit > 30 || !lazy) {
     308                if(sq.to_submit > 30) {
     309                        __tls_stats()->io.flush.full++;
     310                        __cfa_io_flush( ctx->proc, 0 );
     311                }
     312                if(!lazy) {
     313                        __tls_stats()->io.flush.eager++;
    309314                        __cfa_io_flush( ctx->proc, 0 );
    310315                }
  • libcfa/src/concurrency/kernel.cfa

    rf681823 r376c632a  
    4242
    4343#if !defined(__CFA_NO_STATISTICS__)
    44         #define __STATS( ...) __VA_ARGS__
     44        #define __STATS_DEF( ...) __VA_ARGS__
    4545#else
    46         #define __STATS( ...)
     46        #define __STATS_DEF( ...)
    4747#endif
    4848
     
    122122static thread$ * __next_thread(cluster * this);
    123123static thread$ * __next_thread_slow(cluster * this);
     124static thread$ * __next_thread_search(cluster * this);
    124125static inline bool __must_unpark( thread$ * thrd ) __attribute((nonnull(1)));
    125126static void __run_thread(processor * this, thread$ * dst);
     
    187188                MAIN_LOOP:
    188189                for() {
    189                         #define OLD_MAIN 1
    190                         #if OLD_MAIN
    191190                        // Check if there is pending io
    192191                        __maybe_io_drain( this );
     
    196195
    197196                        if( !readyThread ) {
     197                                __IO_STATS__(true, io.flush.idle++; )
    198198                                __cfa_io_flush( this, 0 );
    199199
     200                                readyThread = __next_thread( this->cltr );
     201                        }
     202
     203                        if( !readyThread ) for(5) {
     204                                __IO_STATS__(true, io.flush.idle++; )
     205
    200206                                readyThread = __next_thread_slow( this->cltr );
     207
     208                                if( readyThread ) break;
     209
     210                                __cfa_io_flush( this, 0 );
    201211                        }
    202212
     
    210220
    211221                                // Confirm the ready-queue is empty
    212                                 readyThread = __next_thread_slow( this->cltr );
     222                                readyThread = __next_thread_search( this->cltr );
    213223                                if( readyThread ) {
    214224                                        // A thread was found, cancel the halt
    215225                                        mark_awake(this->cltr->procs, * this);
    216226
    217                                         #if !defined(__CFA_NO_STATISTICS__)
    218                                                 __tls_stats()->ready.sleep.cancels++;
    219                                         #endif
     227                                        __STATS__(true, ready.sleep.cancels++; )
    220228
    221229                                        // continue the mai loop
     
    244252
    245253                        if(this->io.pending && !this->io.dirty) {
     254                                __IO_STATS__(true, io.flush.dirty++; )
    246255                                __cfa_io_flush( this, 0 );
    247256                        }
    248 
    249                         #else
    250                                 #warning new kernel loop
    251                         SEARCH: {
    252                                 /* paranoid */ verify( ! __preemption_enabled() );
    253 
    254                                 // First, lock the scheduler since we are searching for a thread
    255                                 ready_schedule_lock();
    256 
    257                                 // Try to get the next thread
    258                                 readyThread = pop_fast( this->cltr );
    259                                 if(readyThread) { ready_schedule_unlock(); break SEARCH; }
    260 
    261                                 // If we can't find a thread, might as well flush any outstanding I/O
    262                                 if(this->io.pending) { __cfa_io_flush( this, 0 ); }
    263 
    264                                 // Spin a little on I/O, just in case
    265                                 for(5) {
    266                                         __maybe_io_drain( this );
    267                                         readyThread = pop_fast( this->cltr );
    268                                         if(readyThread) { ready_schedule_unlock(); break SEARCH; }
    269                                 }
    270 
    271                                 // no luck, try stealing a few times
    272                                 for(5) {
    273                                         if( __maybe_io_drain( this ) ) {
    274                                                 readyThread = pop_fast( this->cltr );
    275                                         } else {
    276                                                 readyThread = pop_slow( this->cltr );
    277                                         }
    278                                         if(readyThread) { ready_schedule_unlock(); break SEARCH; }
    279                                 }
    280 
    281                                 // still no luck, search for a thread
    282                                 readyThread = pop_search( this->cltr );
    283                                 if(readyThread) { ready_schedule_unlock(); break SEARCH; }
    284 
    285                                 // Don't block if we are done
    286                                 if( __atomic_load_n(&this->do_terminate, __ATOMIC_SEQ_CST) ) {
    287                                         ready_schedule_unlock();
    288                                         break MAIN_LOOP;
    289                                 }
    290 
    291                                 __STATS( __tls_stats()->ready.sleep.halts++; )
    292 
    293                                 // Push self to idle stack
    294                                 ready_schedule_unlock();
    295                                 if(!mark_idle(this->cltr->procs, * this)) goto SEARCH;
    296                                 ready_schedule_lock();
    297 
    298                                 // Confirm the ready-queue is empty
    299                                 __maybe_io_drain( this );
    300                                 readyThread = pop_search( this->cltr );
    301                                 ready_schedule_unlock();
    302 
    303                                 if( readyThread ) {
    304                                         // A thread was found, cancel the halt
    305                                         mark_awake(this->cltr->procs, * this);
    306 
    307                                         __STATS( __tls_stats()->ready.sleep.cancels++; )
    308 
    309                                         // continue the main loop
    310                                         break SEARCH;
    311                                 }
    312 
    313                                 __STATS( if(this->print_halts) __cfaabi_bits_print_safe( STDOUT_FILENO, "PH:%d - %lld 0\n", this->unique_id, rdtscl()); )
    314                                 __cfadbg_print_safe(runtime_core, "Kernel : core %p waiting on eventfd %d\n", this, this->idle_fd);
    315 
    316                                 {
    317                                         eventfd_t val;
    318                                         ssize_t ret = read( this->idle_fd, &val, sizeof(val) );
    319                                         if(ret < 0) {
    320                                                 switch((int)errno) {
    321                                                 case EAGAIN:
    322                                                 #if EAGAIN != EWOULDBLOCK
    323                                                         case EWOULDBLOCK:
    324                                                 #endif
    325                                                 case EINTR:
    326                                                         // No need to do anything special here, just assume it's a legitimate wake-up
    327                                                         break;
    328                                                 default:
    329                                                         abort( "KERNEL : internal error, read failure on idle eventfd, error(%d) %s.", (int)errno, strerror( (int)errno ) );
    330                                                 }
    331                                         }
    332                                 }
    333 
    334                                         __STATS( if(this->print_halts) __cfaabi_bits_print_safe( STDOUT_FILENO, "PH:%d - %lld 1\n", this->unique_id, rdtscl()); )
    335 
    336                                 // We were woken up, remove self from idle
    337                                 mark_awake(this->cltr->procs, * this);
    338 
    339                                 // DON'T just proceed, start looking again
    340                                 continue MAIN_LOOP;
    341                         }
    342 
    343                 RUN_THREAD:
    344                         /* paranoid */ verify( ! __preemption_enabled() );
    345                         /* paranoid */ verify( readyThread );
    346 
    347                         // Reset io dirty bit
    348                         this->io.dirty = false;
    349 
    350                         // We found a thread run it
    351                         __run_thread(this, readyThread);
    352 
    353                         // Are we done?
    354                         if( __atomic_load_n(&this->do_terminate, __ATOMIC_SEQ_CST) ) break MAIN_LOOP;
    355 
    356                         if(this->io.pending && !this->io.dirty) {
    357                                 __cfa_io_flush( this, 0 );
    358                         }
    359 
    360                         ready_schedule_lock();
    361                         __maybe_io_drain( this );
    362                         ready_schedule_unlock();
    363                         #endif
    364257                }
    365258
     
    472365                                break RUNNING;
    473366                        case TICKET_UNBLOCK:
    474                                 #if !defined(__CFA_NO_STATISTICS__)
    475                                         __tls_stats()->ready.threads.threads++;
    476                                 #endif
     367                                __STATS__(true, ready.threads.threads++; )
    477368                                // This is case 2, the racy case, someone tried to run this thread before it finished blocking
    478369                                // In this case, just run it again.
     
    489380        __cfadbg_print_safe(runtime_core, "Kernel : core %p finished running thread %p\n", this, thrd_dst);
    490381
    491         #if !defined(__CFA_NO_STATISTICS__)
    492                 __tls_stats()->ready.threads.threads--;
    493         #endif
     382        __STATS__(true, ready.threads.threads--; )
    494383
    495384        /* paranoid */ verify( ! __preemption_enabled() );
     
    502391        thread$ * thrd_src = kernelTLS().this_thread;
    503392
    504         __STATS( thrd_src->last_proc = kernelTLS().this_processor; )
     393        __STATS_DEF( thrd_src->last_proc = kernelTLS().this_processor; )
    505394
    506395        // Run the thread on this processor
     
    554443        // Dereference the thread now because once we push it, there is not guaranteed it's still valid.
    555444        struct cluster * cl = thrd->curr_cluster;
    556         __STATS(bool outside = hint == UNPARK_LOCAL && thrd->last_proc && thrd->last_proc != kernelTLS().this_processor; )
     445        __STATS_DEF(bool outside = hint == UNPARK_LOCAL && thrd->last_proc && thrd->last_proc != kernelTLS().this_processor; )
    557446
    558447        // push the thread to the cluster ready-queue
     
    605494
    606495        ready_schedule_lock();
    607                 thread$ * thrd;
    608                 for(25) {
    609                         thrd = pop_slow( this );
    610                         if(thrd) goto RET;
    611                 }
    612                 thrd = pop_search( this );
    613 
    614                 RET:
     496                thread$ * thrd = pop_slow( this );
     497        ready_schedule_unlock();
     498
     499        /* paranoid */ verify( ! __preemption_enabled() );
     500        return thrd;
     501}
     502
     503// KERNEL ONLY
     504static inline thread$ * __next_thread_search(cluster * this) with( *this ) {
     505        /* paranoid */ verify( ! __preemption_enabled() );
     506
     507        ready_schedule_lock();
     508                thread$ * thrd = pop_search( this );
    615509        ready_schedule_unlock();
    616510
     
    854748
    855749static bool mark_idle(__cluster_proc_list & this, processor & proc) {
    856         #if !defined(__CFA_NO_STATISTICS__)
    857                 __tls_stats()->ready.sleep.halts++;
    858         #endif
     750        __STATS__(true, ready.sleep.halts++; )
    859751
    860752        proc.idle_wctx.fd = 0;
     
    949841                unsigned tail = *ctx->cq.tail;
    950842                if(head == tail) return false;
    951                 #if OLD_MAIN
    952                         ready_schedule_lock();
    953                         ret = __cfa_io_drain( proc );
    954                         ready_schedule_unlock();
    955                 #else
    956                         ret = __cfa_io_drain( proc );
    957                 #endif
     843                ready_schedule_lock();
     844                ret = __cfa_io_drain( proc );
     845                ready_schedule_unlock();
    958846        #endif
    959847        return ret;
  • libcfa/src/concurrency/kernel/fwd.hfa

    rf681823 r376c632a  
    396396                                if( !(in_kernel) ) enable_interrupts(); \
    397397                        }
     398                        #if defined(CFA_HAVE_LINUX_IO_URING_H)
     399                                #define __IO_STATS__(in_kernel, ...) { \
     400                                        if( !(in_kernel) ) disable_interrupts(); \
     401                                        with( *__tls_stats() ) { \
     402                                                __VA_ARGS__ \
     403                                        } \
     404                                        if( !(in_kernel) ) enable_interrupts(); \
     405                                }
     406                        #else
     407                                #define __IO_STATS__(in_kernel, ...)
     408                        #endif
    398409                #else
    399410                        #define __STATS__(in_kernel, ...)
     411                        #define __IO_STATS__(in_kernel, ...)
    400412                #endif
    401413        }
  • libcfa/src/concurrency/stats.cfa

    rf681823 r376c632a  
    4545                        stats->io.submit.slow       = 0;
    4646                        stats->io.flush.external    = 0;
     47                        stats->io.flush.dirty       = 0;
     48                        stats->io.flush.full        = 0;
     49                        stats->io.flush.idle        = 0;
     50                        stats->io.flush.eager       = 0;
    4751                        stats->io.calls.flush       = 0;
    4852                        stats->io.calls.submitted   = 0;
     
    107111                        tally_one( &cltr->io.submit.slow      , &proc->io.submit.slow       );
    108112                        tally_one( &cltr->io.flush.external   , &proc->io.flush.external    );
     113                        tally_one( &cltr->io.flush.dirty      , &proc->io.flush.dirty       );
     114                        tally_one( &cltr->io.flush.full       , &proc->io.flush.full        );
     115                        tally_one( &cltr->io.flush.idle       , &proc->io.flush.idle        );
     116                        tally_one( &cltr->io.flush.eager      , &proc->io.flush.eager       );
    109117                        tally_one( &cltr->io.calls.flush      , &proc->io.calls.flush       );
    110118                        tally_one( &cltr->io.calls.submitted  , &proc->io.calls.submitted   );
     
    184192                                if(io.alloc.fail || io.alloc.revoke || io.alloc.block)
    185193                                        sstr | "-     failures      : " | eng3(io.alloc.fail) | "oom, " | eng3(io.alloc.revoke) | "rvk, " | eng3(io.alloc.block) | "blk";
    186                                 if(io.flush.external)
    187                                         sstr | "- flush external    : " | eng3(io.flush.external);
     194                                // if(io.flush.external)
     195                                //      sstr | "- flush external    : " | eng3(io.flush.external);
    188196
    189197                                double avgsubs = ((double)io.calls.submitted) / io.calls.flush;
    190198                                double avgcomp = ((double)io.calls.completed) / io.calls.drain;
    191199                                sstr | "- syscll : "
    192                                      |   " sub " | eng3(io.calls.flush) | "/" | eng3(io.calls.submitted) | "(" | ws(3, 3, avgsubs) | "/flush)"
    193                                      | " - cmp " | eng3(io.calls.drain) | "/" | eng3(io.calls.completed) | "(" | ws(3, 3, avgcomp) | "/drain)"
     200                                     |   " sub " | eng3(io.calls.submitted) | "/" | eng3(io.calls.flush) | "(" | ws(3, 3, avgsubs) | "/flush)"
     201                                     | " - cmp " | eng3(io.calls.completed) | "/" | eng3(io.calls.drain) | "(" | ws(3, 3, avgcomp) | "/drain)"
    194202                                     | " - " | eng3(io.calls.errors.busy) | " EBUSY";
     203                                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";
    195204                                sstr | "- ops blk: "
    196205                                     |   " sk rd: " | eng3(io.ops.sockread)  | "epll: " | eng3(io.ops.epllread)
  • libcfa/src/concurrency/stats.hfa

    rf681823 r376c632a  
    9191                        struct {
    9292                                volatile uint64_t external;
     93                                volatile uint64_t dirty;
     94                                volatile uint64_t full;
     95                                volatile uint64_t idle;
     96                                volatile uint64_t eager;
    9397                        } flush;
    9498                        struct {
  • src/AST/Copy.hpp

    rf681823 r376c632a  
    1010// Created On       : Wed Jul 10 16:13:00 2019
    1111// Last Modified By : Andrew Beach
    12 // Last Modified On : Thr Nov 11  9:22:00 2021
    13 // Update Count     : 2
     12// Last Modified On : Wed Dec 15 11:07:00 2021
     13// Update Count     : 3
    1414//
    1515
     
    5252Node * deepCopy<Node>( const Node * localRoot );
    5353
     54template<typename node_t, enum Node::ref_type ref_t>
     55node_t * shallowCopy( const ptr_base<node_t, ref_t> & localRoot ) {
     56        return shallowCopy( localRoot.get() );
     57}
     58
     59template<typename node_t, enum Node::ref_type ref_t>
     60node_t * deepCopy( const ptr_base<node_t, ref_t> & localRoot ) {
     61        return deepCopy( localRoot.get() );
     62}
     63
    5464}
    5565
  • src/AST/Node.hpp

    rf681823 r376c632a  
    188188        }
    189189
     190        ptr_base & operator=( const node_t * node ) {
     191                assign( node );
     192                return *this;
     193        }
     194
    190195        template<typename o_node_t>
    191196        ptr_base & operator=( const o_node_t * node ) {
  • src/AST/Pass.impl.hpp

    rf681823 r376c632a  
    3333        /* call the implementation of the previsit of this pass */ \
    3434        __pass::previsit( core, node, 0 );
    35 
    36 #define VISIT( code... ) \
    37         /* if this node should visit its children */ \
    38         if ( __visit_children() ) { \
    39                 /* visit the children */ \
    40                 code \
    41         }
    4235
    4336#define VISIT_END( type, node ) \
     
    452445        VISIT_START( node );
    453446
    454         VISIT(
     447        if ( __visit_children() ) {
    455448                {
    456449                        guard_symtab guard { *this };
     
    460453                maybe_accept( node, &ObjectDecl::bitfieldWidth );
    461454                maybe_accept( node, &ObjectDecl::attributes    );
    462         )
     455        }
    463456
    464457        __pass::symtab::addId( core, 0, node );
     
    475468        __pass::symtab::addId( core, 0, node );
    476469
    477         VISIT(maybe_accept( node, &FunctionDecl::withExprs );)
     470        if ( __visit_children() ) {
     471                maybe_accept( node, &FunctionDecl::withExprs );
     472        }
    478473        {
    479474                // with clause introduces a level of scope (for the with expression members).
     
    493488                        } };
    494489                        __pass::symtab::addId( core, 0, func );
    495                         VISIT(
     490                        if ( __visit_children() ) {
    496491                                // parameter declarations
    497492                                maybe_accept( node, &FunctionDecl::params );
     
    509504                                maybe_accept( node, &FunctionDecl::stmts );
    510505                                maybe_accept( node, &FunctionDecl::attributes );
    511                         )
     506                        }
    512507                }
    513508        }
     
    526521        __pass::symtab::addStructFwd( core, 0, node );
    527522
    528         VISIT({
     523        if ( __visit_children() ) {
    529524                guard_symtab guard { * this };
    530525                maybe_accept( node, &StructDecl::params     );
    531526                maybe_accept( node, &StructDecl::members    );
    532527                maybe_accept( node, &StructDecl::attributes );
    533         })
     528        }
    534529
    535530        // this addition replaces the forward declaration
     
    548543        __pass::symtab::addUnionFwd( core, 0, node );
    549544
    550         VISIT({
     545        if ( __visit_children() ) {
    551546                guard_symtab guard { * this };
    552547                maybe_accept( node, &UnionDecl::params     );
    553548                maybe_accept( node, &UnionDecl::members    );
    554549                maybe_accept( node, &UnionDecl::attributes );
    555         })
     550        }
    556551
    557552        __pass::symtab::addUnion( core, 0, node );
     
    568563        __pass::symtab::addEnum( core, 0, node );
    569564
    570         VISIT(
     565        if ( __visit_children() ) {
    571566                // unlike structs, traits, and unions, enums inject their members into the global scope
    572567                maybe_accept( node, &EnumDecl::params     );
    573568                maybe_accept( node, &EnumDecl::members    );
    574569                maybe_accept( node, &EnumDecl::attributes );
    575         )
     570        }
    576571
    577572        VISIT_END( Decl, node );
     
    584579        VISIT_START( node );
    585580
    586         VISIT({
     581        if ( __visit_children() ) {
    587582                guard_symtab guard { *this };
    588583                maybe_accept( node, &TraitDecl::params     );
    589584                maybe_accept( node, &TraitDecl::members    );
    590585                maybe_accept( node, &TraitDecl::attributes );
    591         })
     586        }
    592587
    593588        __pass::symtab::addTrait( core, 0, node );
     
    602597        VISIT_START( node );
    603598
    604         VISIT({
     599        if ( __visit_children() ) {
    605600                guard_symtab guard { *this };
    606601                maybe_accept( node, &TypeDecl::base   );
    607         })
     602        }
    608603
    609604        // see A NOTE ON THE ORDER OF TRAVERSAL, above
     
    612607        __pass::symtab::addType( core, 0, node );
    613608
    614         VISIT(
     609        if ( __visit_children() ) {
    615610                maybe_accept( node, &TypeDecl::assertions );
    616611
     
    619614                        maybe_accept( node, &TypeDecl::init );
    620615                }
    621         )
     616        }
    622617
    623618        VISIT_END( Decl, node );
     
    630625        VISIT_START( node );
    631626
    632         VISIT({
     627        if ( __visit_children() ) {
    633628                guard_symtab guard { *this };
    634629                maybe_accept( node, &TypedefDecl::base   );
    635         })
     630        }
    636631
    637632        __pass::symtab::addType( core, 0, node );
    638633
    639         VISIT( maybe_accept( node, &TypedefDecl::assertions ); )
     634        if ( __visit_children() ) {
     635                maybe_accept( node, &TypedefDecl::assertions );
     636        }
    640637
    641638        VISIT_END( Decl, node );
     
    648645        VISIT_START( node );
    649646
    650         VISIT(
     647        if ( __visit_children() ) {
    651648                maybe_accept( node, &AsmDecl::stmt );
    652         )
     649        }
    653650
    654651        VISIT_END( AsmDecl, node );
     
    661658        VISIT_START( node );
    662659
    663         VISIT(
     660        if ( __visit_children() ) {
    664661                maybe_accept( node, &DirectiveDecl::stmt );
    665         )
     662        }
    666663
    667664        VISIT_END( DirectiveDecl, node );
     
    674671        VISIT_START( node );
    675672
    676         VISIT(
     673        if ( __visit_children() ) {
    677674                maybe_accept( node, &StaticAssertDecl::cond );
    678675                maybe_accept( node, &StaticAssertDecl::msg  );
    679         )
     676        }
    680677
    681678        VISIT_END( StaticAssertDecl, node );
     
    687684const ast::CompoundStmt * ast::Pass< core_t >::visit( const ast::CompoundStmt * node ) {
    688685        VISIT_START( node );
    689         VISIT(
     686
     687        if ( __visit_children() ) {
    690688                // Do not enter (or leave) a new scope if atFunctionTop. Remember to save the result.
    691689                auto guard1 = makeFuncGuard( [this, enterScope = !this->atFunctionTop]() {
     
    704702                guard_scope guard3 { *this };
    705703                maybe_accept( node, &CompoundStmt::kids );
    706         )
     704        }
     705
    707706        VISIT_END( CompoundStmt, node );
    708707}
     
    714713        VISIT_START( node );
    715714
    716         VISIT(
     715        if ( __visit_children() ) {
    717716                maybe_accept( node, &ExprStmt::expr );
    718         )
     717        }
    719718
    720719        VISIT_END( Stmt, node );
     
    727726        VISIT_START( node )
    728727
    729         VISIT(
     728        if ( __visit_children() ) {
    730729                maybe_accept( node, &AsmStmt::instruction );
    731730                maybe_accept( node, &AsmStmt::output      );
    732731                maybe_accept( node, &AsmStmt::input       );
    733732                maybe_accept( node, &AsmStmt::clobber     );
    734         )
     733        }
    735734
    736735        VISIT_END( Stmt, node );
     
    752751        VISIT_START( node );
    753752
    754         VISIT({
     753        if ( __visit_children() ) {
    755754                // if statements introduce a level of scope (for the initialization)
    756755                guard_symtab guard { *this };
     
    759758                maybe_accept_as_compound( node, &IfStmt::thenPart );
    760759                maybe_accept_as_compound( node, &IfStmt::elsePart );
    761         })
     760        }
    762761
    763762        VISIT_END( Stmt, node );
     
    770769        VISIT_START( node );
    771770
    772         VISIT({
     771        if ( __visit_children() ) {
    773772                // while statements introduce a level of scope (for the initialization)
    774773                guard_symtab guard { *this };
     
    776775                maybe_accept( node, &WhileStmt::cond  );
    777776                maybe_accept_as_compound( node, &WhileStmt::body  );
    778         })
     777        }
    779778
    780779        VISIT_END( Stmt, node );
     
    787786        VISIT_START( node );
    788787
    789         VISIT({
     788        if ( __visit_children() ) {
    790789                // for statements introduce a level of scope (for the initialization)
    791790                guard_symtab guard { *this };
     
    795794                maybe_accept( node, &ForStmt::inc   );
    796795                maybe_accept_as_compound( node, &ForStmt::body  );
    797         })
     796        }
    798797
    799798        VISIT_END( Stmt, node );
     
    806805        VISIT_START( node );
    807806
    808         VISIT(
     807        if ( __visit_children() ) {
    809808                maybe_accept( node, &SwitchStmt::cond  );
    810809                maybe_accept( node, &SwitchStmt::stmts );
    811         )
     810        }
    812811
    813812        VISIT_END( Stmt, node );
     
    820819        VISIT_START( node );
    821820
    822         VISIT(
     821        if ( __visit_children() ) {
    823822                maybe_accept( node, &CaseStmt::cond  );
    824823                maybe_accept( node, &CaseStmt::stmts );
    825         )
     824        }
    826825
    827826        VISIT_END( Stmt, node );
     
    842841        VISIT_START( node );
    843842
    844         VISIT(
     843        if ( __visit_children() ) {
    845844                maybe_accept( node, &ReturnStmt::expr );
    846         )
     845        }
    847846
    848847        VISIT_END( Stmt, node );
     
    855854        VISIT_START( node );
    856855
    857         VISIT(
     856        if ( __visit_children() ) {
    858857                maybe_accept( node, &ThrowStmt::expr   );
    859858                maybe_accept( node, &ThrowStmt::target );
    860         )
     859        }
    861860
    862861        VISIT_END( Stmt, node );
     
    869868        VISIT_START( node );
    870869
    871         VISIT(
     870        if ( __visit_children() ) {
    872871                maybe_accept( node, &TryStmt::body     );
    873872                maybe_accept( node, &TryStmt::handlers );
    874873                maybe_accept( node, &TryStmt::finally  );
    875         )
     874        }
    876875
    877876        VISIT_END( Stmt, node );
     
    884883        VISIT_START( node );
    885884
    886         VISIT({
     885        if ( __visit_children() ) {
    887886                // catch statements introduce a level of scope (for the caught exception)
    888887                guard_symtab guard { *this };
     
    890889                maybe_accept( node, &CatchStmt::cond );
    891890                maybe_accept_as_compound( node, &CatchStmt::body );
    892         })
     891        }
    893892
    894893        VISIT_END( Stmt, node );
     
    901900        VISIT_START( node );
    902901
    903         VISIT(
     902        if ( __visit_children() ) {
    904903                maybe_accept( node, &FinallyStmt::body );
    905         )
     904        }
    906905
    907906        VISIT_END( Stmt, node );
     
    914913        VISIT_START( node );
    915914
    916         VISIT(
     915        if ( __visit_children() ) {
    917916                maybe_accept( node, &SuspendStmt::then   );
    918         )
     917        }
    919918
    920919        VISIT_END( Stmt, node );
     
    934933                // }
    935934
    936         VISIT({
     935        if ( __visit_children() ) {
    937936                std::vector<WaitForStmt::Clause> new_clauses;
    938937                new_clauses.reserve( node->clauses.size() );
     
    965964                        node = n;
    966965                }
    967         })
     966        }
    968967
    969968        #define maybe_accept(field) \
     
    977976                }
    978977
    979         VISIT(
     978        if ( __visit_children() ) {
    980979                maybe_accept( timeout.time );
    981980                maybe_accept( timeout.stmt );
     
    983982                maybe_accept( orElse.stmt  );
    984983                maybe_accept( orElse.cond  );
    985         )
     984        }
    986985
    987986        #undef maybe_accept
     
    996995        VISIT_START( node );
    997996
    998         VISIT(
     997        if ( __visit_children() ) {
    999998                maybe_accept( node, &WithStmt::exprs );
    1000999                {
     
    10041003                        maybe_accept( node, &WithStmt::stmt );
    10051004                }
    1006         )
     1005        }
     1006
    10071007        VISIT_END( Stmt, node );
    10081008}
     
    10221022        VISIT_START( node );
    10231023
    1024         VISIT(
     1024        if ( __visit_children() ) {
    10251025                maybe_accept( node, &DeclStmt::decl );
    1026         )
     1026        }
    10271027
    10281028        VISIT_END( Stmt, node );
     
    10371037        // For now this isn't visited, it is unclear if this causes problem
    10381038        // if all tests are known to pass, remove this code
    1039         VISIT(
     1039        if ( __visit_children() ) {
    10401040                maybe_accept( node, &ImplicitCtorDtorStmt::callStmt );
    1041         )
     1041        }
    10421042
    10431043        VISIT_END( Stmt, node );
     
    10501050        VISIT_START( node );
    10511051
    1052         VISIT({
     1052        if ( __visit_children() ) {
    10531053                // mutex statements introduce a level of scope (for the initialization)
    10541054                guard_symtab guard { *this };
    10551055                maybe_accept( node, &MutexStmt::stmt );
    10561056                maybe_accept( node, &MutexStmt::mutexObjs );
    1057         })
     1057        }
    10581058
    10591059        VISIT_END( Stmt, node );
     
    10661066        VISIT_START( node );
    10671067
    1068         VISIT(
     1068        if ( __visit_children() ) {
    10691069                {
    10701070                        guard_symtab guard { *this };
     
    10731073                maybe_accept( node, &ApplicationExpr::func );
    10741074                maybe_accept( node, &ApplicationExpr::args );
    1075         )
     1075        }
    10761076
    10771077        VISIT_END( Expr, node );
     
    10841084        VISIT_START( node );
    10851085
    1086         VISIT(
     1086        if ( __visit_children() ) {
    10871087                {
    10881088                        guard_symtab guard { *this };
     
    10911091
    10921092                maybe_accept( node, &UntypedExpr::args );
    1093         )
     1093        }
    10941094
    10951095        VISIT_END( Expr, node );
     
    11021102        VISIT_START( node );
    11031103
    1104         VISIT({
     1104        if ( __visit_children() ) {
    11051105                guard_symtab guard { *this };
    11061106                maybe_accept( node, &NameExpr::result );
    1107         })
     1107        }
    11081108
    11091109        VISIT_END( Expr, node );
     
    11161116        VISIT_START( node );
    11171117
    1118         VISIT({
     1118        if ( __visit_children() ) {
     1119                {
    11191120                        guard_symtab guard { *this };
    11201121                        maybe_accept( node, &CastExpr::result );
    11211122                }
    11221123                maybe_accept( node, &CastExpr::arg );
    1123         )
     1124        }
    11241125
    11251126        VISIT_END( Expr, node );
     
    11321133        VISIT_START( node );
    11331134
    1134         VISIT({
     1135        if ( __visit_children() ) {
     1136                {
    11351137                        guard_symtab guard { *this };
    11361138                        maybe_accept( node, &KeywordCastExpr::result );
    11371139                }
    11381140                maybe_accept( node, &KeywordCastExpr::arg );
    1139         )
     1141        }
    11401142
    11411143        VISIT_END( Expr, node );
     
    11481150        VISIT_START( node );
    11491151
    1150         VISIT({
     1152        if ( __visit_children() ) {
     1153                {
    11511154                        guard_symtab guard { *this };
    11521155                        maybe_accept( node, &VirtualCastExpr::result );
    11531156                }
    11541157                maybe_accept( node, &VirtualCastExpr::arg );
    1155         )
     1158        }
    11561159
    11571160        VISIT_END( Expr, node );
     
    11641167        VISIT_START( node );
    11651168
    1166         VISIT({
     1169        if ( __visit_children() ) {
     1170                {
    11671171                        guard_symtab guard { *this };
    11681172                        maybe_accept( node, &AddressExpr::result );
    11691173                }
    11701174                maybe_accept( node, &AddressExpr::arg );
    1171         )
     1175        }
    11721176
    11731177        VISIT_END( Expr, node );
     
    11801184        VISIT_START( node );
    11811185
    1182         VISIT({
     1186        if ( __visit_children() ) {
    11831187                guard_symtab guard { *this };
    11841188                maybe_accept( node, &LabelAddressExpr::result );
    1185         })
     1189        }
    11861190
    11871191        VISIT_END( Expr, node );
     
    11941198        VISIT_START( node );
    11951199
    1196         VISIT({
     1200        if ( __visit_children() ) {
     1201                {
    11971202                        guard_symtab guard { *this };
    11981203                        maybe_accept( node, &UntypedMemberExpr::result );
     
    12001205                maybe_accept( node, &UntypedMemberExpr::aggregate );
    12011206                maybe_accept( node, &UntypedMemberExpr::member    );
    1202         )
     1207        }
    12031208
    12041209        VISIT_END( Expr, node );
     
    12111216        VISIT_START( node );
    12121217
    1213         VISIT({
     1218        if ( __visit_children() ) {
     1219                {
    12141220                        guard_symtab guard { *this };
    12151221                        maybe_accept( node, &MemberExpr::result );
    12161222                }
    12171223                maybe_accept( node, &MemberExpr::aggregate );
    1218         )
     1224        }
    12191225
    12201226        VISIT_END( Expr, node );
     
    12271233        VISIT_START( node );
    12281234
    1229         VISIT({
     1235        if ( __visit_children() ) {
    12301236                guard_symtab guard { *this };
    12311237                maybe_accept( node, &VariableExpr::result );
    1232         })
     1238        }
    12331239
    12341240        VISIT_END( Expr, node );
     
    12411247        VISIT_START( node );
    12421248
    1243         VISIT({
     1249        if ( __visit_children() ) {
    12441250                guard_symtab guard { *this };
    12451251                maybe_accept( node, &ConstantExpr::result );
    1246         })
     1252        }
    12471253
    12481254        VISIT_END( Expr, node );
     
    12551261        VISIT_START( node );
    12561262
    1257         VISIT({
     1263        if ( __visit_children() ) {
     1264                {
    12581265                        guard_symtab guard { *this };
    12591266                        maybe_accept( node, &SizeofExpr::result );
     
    12641271                        maybe_accept( node, &SizeofExpr::expr );
    12651272                }
    1266         )
     1273        }
    12671274
    12681275        VISIT_END( Expr, node );
     
    12751282        VISIT_START( node );
    12761283
    1277         VISIT({
     1284        if ( __visit_children() ) {
     1285                {
    12781286                        guard_symtab guard { *this };
    12791287                        maybe_accept( node, &AlignofExpr::result );
     
    12841292                        maybe_accept( node, &AlignofExpr::expr );
    12851293                }
    1286         )
     1294        }
    12871295
    12881296        VISIT_END( Expr, node );
     
    12951303        VISIT_START( node );
    12961304
    1297         VISIT({
     1305        if ( __visit_children() ) {
     1306                {
    12981307                        guard_symtab guard { *this };
    12991308                        maybe_accept( node, &UntypedOffsetofExpr::result );
    13001309                }
    13011310                maybe_accept( node, &UntypedOffsetofExpr::type   );
    1302         )
     1311        }
    13031312
    13041313        VISIT_END( Expr, node );
     
    13111320        VISIT_START( node );
    13121321
    1313         VISIT({
     1322        if ( __visit_children() ) {
     1323                {
    13141324                        guard_symtab guard { *this };
    13151325                        maybe_accept( node, &OffsetofExpr::result );
    13161326                }
    13171327                maybe_accept( node, &OffsetofExpr::type   );
    1318         )
     1328        }
    13191329
    13201330        VISIT_END( Expr, node );
     
    13271337        VISIT_START( node );
    13281338
    1329         VISIT({
     1339        if ( __visit_children() ) {
     1340                {
    13301341                        guard_symtab guard { *this };
    13311342                        maybe_accept( node, &OffsetPackExpr::result );
    13321343                }
    13331344                maybe_accept( node, &OffsetPackExpr::type   );
    1334         )
     1345        }
    13351346
    13361347        VISIT_END( Expr, node );
     
    13431354        VISIT_START( node );
    13441355
    1345         VISIT({
     1356        if ( __visit_children() ) {
     1357                {
    13461358                        guard_symtab guard { *this };
    13471359                        maybe_accept( node, &LogicalExpr::result );
     
    13491361                maybe_accept( node, &LogicalExpr::arg1 );
    13501362                maybe_accept( node, &LogicalExpr::arg2 );
    1351         )
     1363        }
    13521364
    13531365        VISIT_END( Expr, node );
     
    13601372        VISIT_START( node );
    13611373
    1362         VISIT({
     1374        if ( __visit_children() ) {
     1375                {
    13631376                        guard_symtab guard { *this };
    13641377                        maybe_accept( node, &ConditionalExpr::result );
     
    13671380                maybe_accept( node, &ConditionalExpr::arg2 );
    13681381                maybe_accept( node, &ConditionalExpr::arg3 );
    1369         )
     1382        }
    13701383
    13711384        VISIT_END( Expr, node );
     
    13781391        VISIT_START( node );
    13791392
    1380         VISIT({
     1393        if ( __visit_children() ) {
     1394                {
    13811395                        guard_symtab guard { *this };
    13821396                        maybe_accept( node, &CommaExpr::result );
     
    13841398                maybe_accept( node, &CommaExpr::arg1 );
    13851399                maybe_accept( node, &CommaExpr::arg2 );
    1386         )
     1400        }
    13871401
    13881402        VISIT_END( Expr, node );
     
    13951409        VISIT_START( node );
    13961410
    1397         VISIT({
     1411        if ( __visit_children() ) {
     1412                {
    13981413                        guard_symtab guard { *this };
    13991414                        maybe_accept( node, &TypeExpr::result );
    14001415                }
    14011416                maybe_accept( node, &TypeExpr::type );
    1402         )
     1417        }
    14031418
    14041419        VISIT_END( Expr, node );
     
    14111426        VISIT_START( node );
    14121427
    1413         VISIT({
     1428        if ( __visit_children() ) {
     1429                {
    14141430                        guard_symtab guard { *this };
    14151431                        maybe_accept( node, &AsmExpr::result );
     
    14171433                maybe_accept( node, &AsmExpr::constraint );
    14181434                maybe_accept( node, &AsmExpr::operand    );
    1419         )
     1435        }
    14201436
    14211437        VISIT_END( Expr, node );
     
    14281444        VISIT_START( node );
    14291445
    1430         VISIT({
     1446        if ( __visit_children() ) {
     1447                {
    14311448                        guard_symtab guard { *this };
    14321449                        maybe_accept( node, &ImplicitCopyCtorExpr::result );
    14331450                }
    14341451                maybe_accept( node, &ImplicitCopyCtorExpr::callExpr    );
    1435         )
     1452        }
    14361453
    14371454        VISIT_END( Expr, node );
     
    14441461        VISIT_START( node );
    14451462
    1446         VISIT({
     1463        if ( __visit_children() ) {
     1464                {
    14471465                        guard_symtab guard { *this };
    14481466                        maybe_accept( node, &ConstructorExpr::result );
    14491467                }
    14501468                maybe_accept( node, &ConstructorExpr::callExpr );
    1451         )
     1469        }
    14521470
    14531471        VISIT_END( Expr, node );
     
    14601478        VISIT_START( node );
    14611479
    1462         VISIT({
     1480        if ( __visit_children() ) {
     1481                {
    14631482                        guard_symtab guard { *this };
    14641483                        maybe_accept( node, &CompoundLiteralExpr::result );
    14651484                }
    14661485                maybe_accept( node, &CompoundLiteralExpr::init );
    1467         )
     1486        }
    14681487
    14691488        VISIT_END( Expr, node );
     
    14761495        VISIT_START( node );
    14771496
    1478         VISIT({
     1497        if ( __visit_children() ) {
     1498                {
    14791499                        guard_symtab guard { *this };
    14801500                        maybe_accept( node, &RangeExpr::result );
     
    14821502                maybe_accept( node, &RangeExpr::low    );
    14831503                maybe_accept( node, &RangeExpr::high   );
    1484         )
     1504        }
    14851505
    14861506        VISIT_END( Expr, node );
     
    14931513        VISIT_START( node );
    14941514
    1495         VISIT({
     1515        if ( __visit_children() ) {
     1516                {
    14961517                        guard_symtab guard { *this };
    14971518                        maybe_accept( node, &UntypedTupleExpr::result );
    14981519                }
    14991520                maybe_accept( node, &UntypedTupleExpr::exprs  );
    1500         )
     1521        }
    15011522
    15021523        VISIT_END( Expr, node );
     
    15091530        VISIT_START( node );
    15101531
    1511         VISIT({
     1532        if ( __visit_children() ) {
     1533                {
    15121534                        guard_symtab guard { *this };
    15131535                        maybe_accept( node, &TupleExpr::result );
    15141536                }
    15151537                maybe_accept( node, &TupleExpr::exprs  );
    1516         )
     1538        }
    15171539
    15181540        VISIT_END( Expr, node );
     
    15251547        VISIT_START( node );
    15261548
    1527         VISIT({
     1549        if ( __visit_children() ) {
     1550                {
    15281551                        guard_symtab guard { *this };
    15291552                        maybe_accept( node, &TupleIndexExpr::result );
    15301553                }
    15311554                maybe_accept( node, &TupleIndexExpr::tuple  );
    1532         )
     1555        }
    15331556
    15341557        VISIT_END( Expr, node );
     
    15411564        VISIT_START( node );
    15421565
    1543         VISIT({
     1566        if ( __visit_children() ) {
     1567                {
    15441568                        guard_symtab guard { *this };
    15451569                        maybe_accept( node, &TupleAssignExpr::result );
    15461570                }
    15471571                maybe_accept( node, &TupleAssignExpr::stmtExpr );
    1548         )
     1572        }
    15491573
    15501574        VISIT_END( Expr, node );
     
    15571581        VISIT_START( node );
    15581582
    1559         VISIT(// don't want statements from outer CompoundStmts to be added to this StmtExpr
     1583        if ( __visit_children() ) {
     1584                // don't want statements from outer CompoundStmts to be added to this StmtExpr
    15601585                // get the stmts that will need to be spliced in
    15611586                auto stmts_before = __pass::stmtsToAddBefore( core, 0);
     
    15741599                maybe_accept( node, &StmtExpr::returnDecls );
    15751600                maybe_accept( node, &StmtExpr::dtors       );
    1576         )
     1601        }
    15771602
    15781603        VISIT_END( Expr, node );
     
    15851610        VISIT_START( node );
    15861611
    1587         VISIT({
     1612        if ( __visit_children() ) {
     1613                {
    15881614                        guard_symtab guard { *this };
    15891615                        maybe_accept( node, &UniqueExpr::result );
    15901616                }
    15911617                maybe_accept( node, &UniqueExpr::expr   );
    1592         )
     1618        }
    15931619
    15941620        VISIT_END( Expr, node );
     
    16011627        VISIT_START( node );
    16021628
    1603         VISIT({
     1629        if ( __visit_children() ) {
     1630                {
    16041631                        guard_symtab guard { *this };
    16051632                        maybe_accept( node, &UntypedInitExpr::result );
     
    16071634                maybe_accept( node, &UntypedInitExpr::expr   );
    16081635                // not currently visiting initAlts, but this doesn't matter since this node is only used in the resolver.
    1609         )
     1636        }
    16101637
    16111638        VISIT_END( Expr, node );
     
    16181645        VISIT_START( node );
    16191646
    1620         VISIT({
     1647        if ( __visit_children() ) {
     1648                {
    16211649                        guard_symtab guard { *this };
    16221650                        maybe_accept( node, &InitExpr::result );
     
    16241652                maybe_accept( node, &InitExpr::expr   );
    16251653                maybe_accept( node, &InitExpr::designation );
    1626         )
     1654        }
    16271655
    16281656        VISIT_END( Expr, node );
     
    16351663        VISIT_START( node );
    16361664
    1637         VISIT({
     1665        if ( __visit_children() ) {
     1666                {
    16381667                        guard_symtab guard { *this };
    16391668                        maybe_accept( node, &DeletedExpr::result );
     
    16411670                maybe_accept( node, &DeletedExpr::expr );
    16421671                // don't visit deleteStmt, because it is a pointer to somewhere else in the tree.
    1643         )
     1672        }
    16441673
    16451674        VISIT_END( Expr, node );
     
    16521681        VISIT_START( node );
    16531682
    1654         VISIT({
     1683        if ( __visit_children() ) {
     1684                {
    16551685                        guard_symtab guard { *this };
    16561686                        maybe_accept( node, &DefaultArgExpr::result );
    16571687                }
    16581688                maybe_accept( node, &DefaultArgExpr::expr );
    1659         )
     1689        }
    16601690
    16611691        VISIT_END( Expr, node );
     
    16681698        VISIT_START( node );
    16691699
    1670         VISIT({
     1700        if ( __visit_children() ) {
     1701                {
    16711702                        guard_symtab guard { *this };
    16721703                        maybe_accept( node, &GenericExpr::result );
     
    16971728                        node = n;
    16981729                }
    1699         )
     1730        }
    17001731
    17011732        VISIT_END( Expr, node );
     
    17261757        VISIT_START( node );
    17271758
    1728         VISIT(
     1759        if ( __visit_children() ) {
    17291760                // xxx - should PointerType visit/mutate dimension?
    17301761                maybe_accept( node, &PointerType::base );
    1731         )
     1762        }
    17321763
    17331764        VISIT_END( Type, node );
     
    17401771        VISIT_START( node );
    17411772
    1742         VISIT(
     1773        if ( __visit_children() ) {
    17431774                maybe_accept( node, &ArrayType::dimension );
    17441775                maybe_accept( node, &ArrayType::base );
    1745         )
     1776        }
    17461777
    17471778        VISIT_END( Type, node );
     
    17541785        VISIT_START( node );
    17551786
    1756         VISIT(
     1787        if ( __visit_children() ) {
    17571788                maybe_accept( node, &ReferenceType::base );
    1758         )
     1789        }
    17591790
    17601791        VISIT_END( Type, node );
     
    17671798        VISIT_START( node );
    17681799
    1769         VISIT(
     1800        if ( __visit_children() ) {
    17701801                maybe_accept( node, &QualifiedType::parent );
    17711802                maybe_accept( node, &QualifiedType::child );
    1772         )
     1803        }
    17731804
    17741805        VISIT_END( Type, node );
     
    17811812        VISIT_START( node );
    17821813
    1783         VISIT({
     1814        if ( __visit_children() ) {
    17841815                // guard_forall_subs forall_guard { *this, node };
    17851816                // mutate_forall( node );
     
    17871818                maybe_accept( node, &FunctionType::returns );
    17881819                maybe_accept( node, &FunctionType::params  );
    1789         })
     1820        }
    17901821
    17911822        VISIT_END( Type, node );
     
    18001831        __pass::symtab::addStruct( core, 0, node->name );
    18011832
    1802         VISIT({
     1833        if ( __visit_children() ) {
    18031834                guard_symtab guard { *this };
    18041835                maybe_accept( node, &StructInstType::params );
    1805         })
     1836        }
    18061837
    18071838        VISIT_END( Type, node );
     
    18161847        __pass::symtab::addUnion( core, 0, node->name );
    18171848
    1818         VISIT({
     1849        if ( __visit_children() ) {
    18191850                guard_symtab guard { *this };
    18201851                maybe_accept( node, &UnionInstType::params );
    1821         })
     1852        }
    18221853
    18231854        VISIT_END( Type, node );
     
    18301861        VISIT_START( node );
    18311862
    1832         VISIT({
     1863        if ( __visit_children() ) {
    18331864                maybe_accept( node, &EnumInstType::params );
    1834         })
     1865        }
    18351866
    18361867        VISIT_END( Type, node );
     
    18431874        VISIT_START( node );
    18441875
    1845         VISIT({
     1876        if ( __visit_children() ) {
    18461877                maybe_accept( node, &TraitInstType::params );
    1847         })
     1878        }
    18481879
    18491880        VISIT_END( Type, node );
     
    18561887        VISIT_START( node );
    18571888
    1858         VISIT(
     1889        if ( __visit_children() ) {
    18591890                {
    18601891                        maybe_accept( node, &TypeInstType::params );
     
    18621893                // ensure that base re-bound if doing substitution
    18631894                __pass::forall::replace( core, 0, node );
    1864         )
     1895        }
    18651896
    18661897        VISIT_END( Type, node );
     
    18731904        VISIT_START( node );
    18741905
    1875         VISIT(
     1906        if ( __visit_children() ) {
    18761907                maybe_accept( node, &TupleType::types );
    18771908                maybe_accept( node, &TupleType::members );
    1878         )
     1909        }
    18791910
    18801911        VISIT_END( Type, node );
     
    18871918        VISIT_START( node );
    18881919
    1889         VISIT(
     1920        if ( __visit_children() ) {
    18901921                maybe_accept( node, &TypeofType::expr );
    1891         )
     1922        }
    18921923
    18931924        VISIT_END( Type, node );
     
    19001931        VISIT_START( node );
    19011932
    1902         VISIT(
     1933        if ( __visit_children() ) {
    19031934                maybe_accept( node, &VTableType::base );
    1904         )
     1935        }
    19051936
    19061937        VISIT_END( Type, node );
     
    19501981        VISIT_START( node );
    19511982
    1952         VISIT( maybe_accept( node, &Designation::designators ); )
     1983        if ( __visit_children() ) {
     1984                maybe_accept( node, &Designation::designators );
     1985        }
    19531986
    19541987        VISIT_END( Designation, node );
     
    19611994        VISIT_START( node );
    19621995
    1963         VISIT(
     1996        if ( __visit_children() ) {
    19641997                maybe_accept( node, &SingleInit::value );
    1965         )
     1998        }
    19661999
    19672000        VISIT_END( Init, node );
     
    19742007        VISIT_START( node );
    19752008
    1976         VISIT(
     2009        if ( __visit_children() ) {
    19772010                maybe_accept( node, &ListInit::designations );
    19782011                maybe_accept( node, &ListInit::initializers );
    1979         )
     2012        }
    19802013
    19812014        VISIT_END( Init, node );
     
    19882021        VISIT_START( node );
    19892022
    1990         VISIT(
     2023        if ( __visit_children() ) {
    19912024                maybe_accept( node, &ConstructorInit::ctor );
    19922025                maybe_accept( node, &ConstructorInit::dtor );
    19932026                maybe_accept( node, &ConstructorInit::init );
    1994         )
     2027        }
    19952028
    19962029        VISIT_END( Init, node );
     
    20032036        VISIT_START( node );
    20042037
    2005         VISIT(
     2038        if ( __visit_children() ) {
    20062039                maybe_accept( node, &Attribute::params );
    2007         )
     2040        }
    20082041
    20092042        VISIT_END( Attribute, node );
     
    20162049        VISIT_START( node );
    20172050
    2018         VISIT(
     2051        if ( __visit_children() ) {
    20192052                {
    20202053                        bool mutated = false;
     
    20322065                        }
    20332066                }
    2034         )
     2067        }
    20352068
    20362069        VISIT_END( TypeSubstitution, node );
     
    20382071
    20392072#undef VISIT_START
    2040 #undef VISIT
    20412073#undef VISIT_END
  • src/AST/Stmt.hpp

    rf681823 r376c632a  
    99// Author           : Aaron B. Moss
    1010// Created On       : Wed May  8 13:00:00 2019
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Fri May 17 12:45:00 2019
    13 // Update Count     : 5
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Mon Jan 31 22:38:53 2022
     13// Update Count     : 12
    1414//
    1515
     
    1717
    1818#include <list>
    19 #include <utility>                // for move
     19#include <utility>                                                                              // for move
    2020#include <vector>
    2121
    2222#include "Label.hpp"
    23 #include "Node.hpp"               // for node, ptr
     23#include "Node.hpp"                                                                             // for node, ptr
    2424#include "ParseNode.hpp"
    2525#include "Visitor.hpp"
     
    2727
    2828// Must be included in *all* AST classes; should be #undef'd at the end of the file
    29 #define MUTATE_FRIEND \
     29#define MUTATE_FRIEND                                                                                                   \
    3030    template<typename node_t> friend node_t * mutate(const node_t * node); \
    3131        template<typename node_t> friend node_t * shallowCopy(const node_t * node);
    3232
    3333namespace ast {
    34 
    3534class Expr;
    3635
    37 /// Base statement node
     36// Base statement node
    3837class Stmt : public ParseNode {
    39 public:
     38  public:
    4039        std::vector<Label> labels;
    4140
    4241        Stmt( const CodeLocation & loc, std::vector<Label> && labels = {} )
    43         : ParseNode(loc), labels(std::move(labels)) {}
     42                : ParseNode(loc), labels(std::move(labels)) {}
    4443
    4544        Stmt(const Stmt& o) : ParseNode(o), labels(o.labels) {}
    4645
    4746        const Stmt * accept( Visitor & v ) const override = 0;
    48 private:
     47  private:
    4948        Stmt * clone() const override = 0;
    5049        MUTATE_FRIEND
    5150};
    5251
    53 /// Compound statement `{ ... }`
     52// Compound statement: { ... }
    5453class CompoundStmt final : public Stmt {
    55 public:
     54  public:
    5655        std::list<ptr<Stmt>> kids;
    5756
    5857        CompoundStmt(const CodeLocation & loc, std::list<ptr<Stmt>> && ks = {},
    59                 std::vector<Label>&& labels = {} )
    60         : Stmt(loc, std::move(labels)), kids(std::move(ks)) {}
     58                                 std::vector<Label>&& labels = {} )
     59                : Stmt(loc, std::move(labels)), kids(std::move(ks)) {}
    6160
    6261        CompoundStmt( const CompoundStmt& o );
     
    6766
    6867        const CompoundStmt * accept( Visitor & v ) const override { return v.visit( this ); }
    69 private:
     68  private:
    7069        CompoundStmt * clone() const override { return new CompoundStmt{ *this }; }
    7170        MUTATE_FRIEND
    7271};
    7372
    74 /// Empty statment `;`
     73// Empty statment: ;
    7574class NullStmt final : public Stmt {
    76 public:
     75  public:
    7776        NullStmt( const CodeLocation & loc, std::vector<Label> && labels = {} )
    78         : Stmt(loc, std::move(labels)) {}
     77                : Stmt(loc, std::move(labels)) {}
    7978
    8079        const NullStmt * accept( Visitor & v ) const override { return v.visit( this ); }
    81 private:
     80  private:
    8281        NullStmt * clone() const override { return new NullStmt{ *this }; }
    8382        MUTATE_FRIEND
    8483};
    8584
    86 /// Expression wrapped by statement
     85// Expression wrapped by statement
    8786class ExprStmt final : public Stmt {
    88 public:
     87  public:
    8988        ptr<Expr> expr;
    9089
    9190        ExprStmt( const CodeLocation& loc, const Expr* e, std::vector<Label>&& labels = {} )
    92         : Stmt(loc, std::move(labels)), expr(e) {}
    93 
    94         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
    95 private:
     91                : Stmt(loc, std::move(labels)), expr(e) {}
     92
     93        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
     94  private:
    9695        ExprStmt * clone() const override { return new ExprStmt{ *this }; }
    9796        MUTATE_FRIEND
    9897};
    9998
    100 /// Assembly statement `asm ... ( "..." : ... )`
     99// Assembly statement: asm ... ( "..." : ... )
    101100class AsmStmt final : public Stmt {
    102 public:
     101  public:
    103102        bool isVolatile;
    104103        ptr<Expr> instruction;
     
    108107
    109108        AsmStmt( const CodeLocation & loc, bool isVolatile, const Expr * instruction,
    110                 std::vector<ptr<Expr>> && output, std::vector<ptr<Expr>> && input,
    111                 std::vector<ptr<ConstantExpr>> && clobber, std::vector<Label> && gotoLabels,
    112                 std::vector<Label> && labels = {})
    113         : Stmt(loc, std::move(labels)), isVolatile(isVolatile), instruction(instruction),
    114           output(std::move(output)), input(std::move(input)), clobber(std::move(clobber)),
    115           gotoLabels(std::move(gotoLabels)) {}
    116 
    117         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
    118 private:
     109                         std::vector<ptr<Expr>> && output, std::vector<ptr<Expr>> && input,
     110                         std::vector<ptr<ConstantExpr>> && clobber, std::vector<Label> && gotoLabels,
     111                         std::vector<Label> && labels = {})
     112                : Stmt(loc, std::move(labels)), isVolatile(isVolatile), instruction(instruction),
     113                  output(std::move(output)), input(std::move(input)), clobber(std::move(clobber)),
     114                  gotoLabels(std::move(gotoLabels)) {}
     115
     116        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
     117  private:
    119118        AsmStmt * clone() const override { return new AsmStmt{ *this }; }
    120119        MUTATE_FRIEND
    121120};
    122121
    123 /// C-preprocessor directive `#...`
     122// C-preprocessor directive: #...
    124123class DirectiveStmt final : public Stmt {
    125 public:
     124  public:
    126125        std::string directive;
    127126
    128127        DirectiveStmt( const CodeLocation & loc, const std::string & directive,
    129                 std::vector<Label> && labels = {} )
    130         : Stmt(loc, std::move(labels)), directive(directive) {}
    131 
    132         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
    133 private:
     128                                   std::vector<Label> && labels = {} )
     129                : Stmt(loc, std::move(labels)), directive(directive) {}
     130
     131        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
     132  private:
    134133        DirectiveStmt * clone() const override { return new DirectiveStmt{ *this }; }
    135134        MUTATE_FRIEND
    136135};
    137136
    138 /// If conditional statement `if (...) ... else ...`
     137// If statement: if (...) ... else ...
    139138class IfStmt final : public Stmt {
    140 public:
     139  public:
    141140        ptr<Expr> cond;
    142141        ptr<Stmt> thenPart;
     
    145144
    146145        IfStmt( const CodeLocation & loc, const Expr * cond, const Stmt * thenPart,
    147                 const Stmt * elsePart = nullptr, std::vector<ptr<Stmt>> && inits = {},
    148                 std::vector<Label> && labels = {} )
    149         : Stmt(loc, std::move(labels)), cond(cond), thenPart(thenPart), elsePart(elsePart),
    150           inits(std::move(inits)) {}
    151 
    152         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
    153 private:
     146                        const Stmt * elsePart = nullptr, std::vector<ptr<Stmt>> && inits = {},
     147                        std::vector<Label> && labels = {} )
     148                : Stmt(loc, std::move(labels)), cond(cond), thenPart(thenPart), elsePart(elsePart),
     149                  inits(std::move(inits)) {}
     150
     151        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
     152  private:
    154153        IfStmt * clone() const override { return new IfStmt{ *this }; }
    155154        MUTATE_FRIEND
    156155};
    157156
    158 /// Switch or choose conditional statement `switch (...) { ... }`
     157// Switch or choose statement: switch (...) { ... }
    159158class SwitchStmt final : public Stmt {
    160 public:
     159  public:
    161160        ptr<Expr> cond;
    162161        std::vector<ptr<Stmt>> stmts;
    163162
    164163        SwitchStmt( const CodeLocation & loc, const Expr * cond, std::vector<ptr<Stmt>> && stmts,
    165                 std::vector<Label> && labels = {} )
    166         : Stmt(loc, std::move(labels)), cond(cond), stmts(std::move(stmts)) {}
    167 
    168         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
    169 private:
     164                                std::vector<Label> && labels = {} )
     165                : Stmt(loc, std::move(labels)), cond(cond), stmts(std::move(stmts)) {}
     166
     167        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
     168  private:
    170169        SwitchStmt * clone() const override { return new SwitchStmt{ *this }; }
    171170        MUTATE_FRIEND
    172171};
    173172
    174 /// Case label `case ...:` `default:`
     173// Case label: case ...: or default:
    175174class CaseStmt final : public Stmt {
    176 public:
    177         /// Null for the default label.
     175  public:
     176        // Null for the default label.
    178177        ptr<Expr> cond;
    179178        std::vector<ptr<Stmt>> stmts;
    180179
    181180        CaseStmt( const CodeLocation & loc, const Expr * cond, std::vector<ptr<Stmt>> && stmts,
    182                 std::vector<Label> && labels = {} )
    183         : Stmt(loc, std::move(labels)), cond(cond), stmts(std::move(stmts)) {}
     181                          std::vector<Label> && labels = {} )
     182                : Stmt(loc, std::move(labels)), cond(cond), stmts(std::move(stmts)) {}
    184183
    185184        bool isDefault() const { return !cond; }
    186185
    187186        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
    188 private:
     187  private:
    189188        CaseStmt * clone() const override { return new CaseStmt{ *this }; }
    190189        MUTATE_FRIEND
    191190};
    192191
    193 /// While loop `while (...) ...` `do ... while (...);
     192// While loop: while (...) ... else ... or do ... while (...) else ...;
    194193class WhileStmt final : public Stmt {
    195 public:
     194  public:
    196195        ptr<Expr> cond;
    197196        ptr<Stmt> body;
     197        ptr<Stmt> elsePart;
    198198        std::vector<ptr<Stmt>> inits;
    199199        bool isDoWhile;
    200200
    201201        WhileStmt( const CodeLocation & loc, const Expr * cond, const Stmt * body,
    202                 std::vector<ptr<Stmt>> && inits, bool isDoWhile = false, std::vector<Label> && labels = {} )
    203         : Stmt(loc, std::move(labels)), cond(cond), body(body), inits(std::move(inits)),
    204           isDoWhile(isDoWhile) {}
    205 
    206         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
    207 private:
     202                           std::vector<ptr<Stmt>> && inits, bool isDoWhile = false, std::vector<Label> && labels = {} )
     203                : Stmt(loc, std::move(labels)), cond(cond), body(body), inits(std::move(inits)), isDoWhile(isDoWhile) {}
     204
     205        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
     206  private:
    208207        WhileStmt * clone() const override { return new WhileStmt{ *this }; }
    209208        MUTATE_FRIEND
    210209};
    211210
    212 /// For loop `for (... ; ... ; ...) ...`
     211// For loop: for (... ; ... ; ...) ... else ...
    213212class ForStmt final : public Stmt {
    214 public:
     213  public:
    215214        std::vector<ptr<Stmt>> inits;
    216215        ptr<Expr> cond;
    217216        ptr<Expr> inc;
    218217        ptr<Stmt> body;
     218        ptr<Stmt> elsePart;
    219219
    220220        ForStmt( const CodeLocation & loc, std::vector<ptr<Stmt>> && inits, const Expr * cond,
    221                 const Expr * inc, const Stmt * body, std::vector<Label> && labels = {} )
    222         : Stmt(loc, std::move(labels)), inits(std::move(inits)), cond(cond), inc(inc),
    223           body(body) {}
    224 
    225         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
    226 private:
     221                         const Expr * inc, const Stmt * body, std::vector<Label> && labels = {} )
     222                : Stmt(loc, std::move(labels)), inits(std::move(inits)), cond(cond), inc(inc), body(body) {}
     223
     224        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
     225  private:
    227226        ForStmt * clone() const override { return new ForStmt{ *this }; }
    228227        MUTATE_FRIEND
    229228};
    230229
    231 /// Branch control flow statement `goto ...` `break` `continue` `fallthru`
     230// Branch control flow statement: goto ... or break or continue or fallthru
    232231class BranchStmt final : public Stmt {
    233 public:
     232  public:
    234233        enum Kind { Goto, Break, Continue, FallThrough, FallThroughDefault };
    235234        static constexpr size_t kindEnd = 1 + (size_t)FallThroughDefault;
     
    241240
    242241        BranchStmt( const CodeLocation & loc, Kind kind, Label target,
    243                 std::vector<Label> && labels = {} );
     242                                std::vector<Label> && labels = {} );
    244243        BranchStmt( const CodeLocation & loc, const Expr * computedTarget,
    245                 std::vector<Label> && labels = {} )
    246         : Stmt(loc, std::move(labels)), originalTarget(loc), target(loc),
    247           computedTarget(computedTarget), kind(Goto) {}
     244                                std::vector<Label> && labels = {} )
     245                : Stmt(loc, std::move(labels)), originalTarget(loc), target(loc),
     246                  computedTarget(computedTarget), kind(Goto) {}
    248247
    249248        const char * kindName() const { return kindNames[kind]; }
    250249
    251250        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
    252 private:
     251  private:
    253252        BranchStmt * clone() const override { return new BranchStmt{ *this }; }
    254253        MUTATE_FRIEND
     
    257256};
    258257
    259 /// Return statement `return ...`
     258// Return statement: return ...
    260259class ReturnStmt final : public Stmt {
    261 public:
     260  public:
    262261        ptr<Expr> expr;
    263262
    264263        ReturnStmt( const CodeLocation & loc, const Expr * expr, std::vector<Label> && labels = {} )
    265         : Stmt(loc, std::move(labels)), expr(expr) {}
    266 
    267         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
    268 private:
     264                : Stmt(loc, std::move(labels)), expr(expr) {}
     265
     266        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
     267  private:
    269268        ReturnStmt * clone() const override { return new ReturnStmt{ *this }; }
    270269        MUTATE_FRIEND
    271270};
    272271
    273 /// Kind of exception
     272// Kind of exception
    274273enum ExceptionKind { Terminate, Resume };
    275274
    276 /// Throw statement `throw ...`
     275// Throw statement: throw ...
    277276class ThrowStmt final : public Stmt {
    278 public:
     277  public:
    279278        ptr<Expr> expr;
    280279        ptr<Expr> target;
     
    284283                const CodeLocation & loc, ExceptionKind kind, const Expr * expr, const Expr * target,
    285284                std::vector<Label> && labels = {} )
    286         : Stmt(loc, std::move(labels)), expr(expr), target(target), kind(kind) {}
    287 
    288         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
    289 private:
     285                : Stmt(loc, std::move(labels)), expr(expr), target(target), kind(kind) {}
     286
     287        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
     288  private:
    290289        ThrowStmt * clone() const override { return new ThrowStmt{ *this }; }
    291290        MUTATE_FRIEND
    292291};
    293292
    294 /// Try statement `try { ... } ...`
     293// Try statement: try { ... } ...
    295294class TryStmt final : public Stmt {
    296 public:
     295  public:
    297296        ptr<CompoundStmt> body;
    298297        std::vector<ptr<CatchStmt>> handlers;
     
    303302                std::vector<ptr<CatchStmt>> && handlers, const FinallyStmt * finally,
    304303                std::vector<Label> && labels = {} )
    305         : Stmt(loc, std::move(labels)), body(body), handlers(std::move(handlers)), finally(finally) {}
    306 
    307         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
    308 private:
     304                : Stmt(loc, std::move(labels)), body(body), handlers(std::move(handlers)), finally(finally) {}
     305
     306        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
     307  private:
    309308        TryStmt * clone() const override { return new TryStmt{ *this }; }
    310309        MUTATE_FRIEND
    311310};
    312311
    313 /// Catch clause of try statement
     312// Catch clause of try statement
    314313class CatchStmt final : public Stmt {
    315 public:
     314  public:
    316315        ptr<Decl> decl;
    317316        ptr<Expr> cond;
     
    322321                const CodeLocation & loc, ExceptionKind kind, const Decl * decl, const Expr * cond,
    323322                const Stmt * body, std::vector<Label> && labels = {} )
    324         : Stmt(loc, std::move(labels)), decl(decl), cond(cond), body(body), kind(kind) {}
    325 
    326         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
    327 private:
     323                : Stmt(loc, std::move(labels)), decl(decl), cond(cond), body(body), kind(kind) {}
     324
     325        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
     326  private:
    328327        CatchStmt * clone() const override { return new CatchStmt{ *this }; }
    329328        MUTATE_FRIEND
    330329};
    331330
    332 /// Finally clause of try statement
     331// Finally clause of try statement
    333332class FinallyStmt final : public Stmt {
    334 public:
     333  public:
    335334        ptr<CompoundStmt> body;
    336335
    337336        FinallyStmt( const CodeLocation & loc, const CompoundStmt * body,
    338                 std::vector<Label> && labels = {} )
    339         : Stmt(loc, std::move(labels)), body(body) {}
    340 
    341         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
    342 private:
     337                                 std::vector<Label> && labels = {} )
     338                : Stmt(loc, std::move(labels)), body(body) {}
     339
     340        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
     341  private:
    343342        FinallyStmt * clone() const override { return new FinallyStmt{ *this }; }
    344343        MUTATE_FRIEND
    345344};
    346345
    347 /// Suspend statement
     346// Suspend statement
    348347class SuspendStmt final : public Stmt {
    349 public:
     348  public:
    350349        ptr<CompoundStmt> then;
    351350        enum Type { None, Coroutine, Generator } type = None;
    352351
    353352        SuspendStmt( const CodeLocation & loc, const CompoundStmt * then, Type type, std::vector<Label> && labels = {} )
    354         : Stmt(loc, std::move(labels)), then(then), type(type) {}
    355 
    356         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
    357 private:
     353                : Stmt(loc, std::move(labels)), then(then), type(type) {}
     354
     355        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
     356  private:
    358357        SuspendStmt * clone() const override { return new SuspendStmt{ *this }; }
    359358        MUTATE_FRIEND
    360359};
    361360
    362 /// Wait for concurrency statement `when (...) waitfor (... , ...) ... timeout(...) ... else ...`
     361// Waitfor statement: when (...) waitfor (... , ...) ... timeout(...) ... else ...
    363362class WaitForStmt final : public Stmt {
    364 public:
     363  public:
    365364        struct Target {
    366365                ptr<Expr> func;
     
    390389
    391390        WaitForStmt( const CodeLocation & loc, std::vector<Label> && labels = {} )
    392         : Stmt(loc, std::move(labels)) {}
    393 
    394         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
    395 private:
     391                : Stmt(loc, std::move(labels)) {}
     392
     393        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
     394  private:
    396395        WaitForStmt * clone() const override { return new WaitForStmt{ *this }; }
    397396        MUTATE_FRIEND
    398397};
    399398
    400 /// Any declaration in a (compound) statement.
     399// Any declaration in a (compound) statement.
    401400class DeclStmt final : public Stmt {
    402 public:
     401  public:
    403402        ptr<Decl> decl;
    404403
    405404        DeclStmt( const CodeLocation & loc, const Decl * decl, std::vector<Label> && labels = {} )
    406         : Stmt(loc, std::move(labels)), decl(decl) {}
    407 
    408         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
    409 private:
     405                : Stmt(loc, std::move(labels)), decl(decl) {}
     406
     407        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
     408  private:
    410409        DeclStmt * clone() const override { return new DeclStmt{ *this }; }
    411410        MUTATE_FRIEND
    412411};
    413412
    414 /// Represents an implicit application of a constructor or destructor.
     413// Represents an implicit application of a constructor or destructor.
    415414class ImplicitCtorDtorStmt final : public Stmt {
    416 public:
     415  public:
    417416        ptr<Stmt> callStmt;
    418417
    419418        ImplicitCtorDtorStmt( const CodeLocation & loc, const Stmt * callStmt,
    420                 std::vector<Label> && labels = {} )
    421         : Stmt(loc, std::move(labels)), callStmt(callStmt) {}
    422 
    423         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
    424 private:
     419                                                  std::vector<Label> && labels = {} )
     420                : Stmt(loc, std::move(labels)), callStmt(callStmt) {}
     421
     422        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
     423  private:
    425424        ImplicitCtorDtorStmt * clone() const override { return new ImplicitCtorDtorStmt{ *this }; }
    426425        MUTATE_FRIEND
    427426};
    428427
    429 /// Mutex Statement
     428// Mutex Statement
    430429class MutexStmt final : public Stmt {
    431 public:
     430  public:
    432431        ptr<Stmt> stmt;
    433432        std::vector<ptr<Expr>> mutexObjs;
    434433
    435434        MutexStmt( const CodeLocation & loc, const Stmt * stmt,
    436                 std::vector<ptr<Expr>> && mutexes, std::vector<Label> && labels = {} )
    437         : Stmt(loc, std::move(labels)), stmt(stmt), mutexObjs(std::move(mutexes)) {}
    438 
    439         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
    440 private:
     435                           std::vector<ptr<Expr>> && mutexes, std::vector<Label> && labels = {} )
     436                : Stmt(loc, std::move(labels)), stmt(stmt), mutexObjs(std::move(mutexes)) {}
     437
     438        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
     439  private:
    441440        MutexStmt * clone() const override { return new MutexStmt{ *this }; }
    442441        MUTATE_FRIEND
    443442};
    444 
    445 }
     443} // namespace ast
    446444
    447445#undef MUTATE_FRIEND
    448446
    449447// Local Variables: //
    450 // tab-width: 4 //
    451448// mode: c++ //
    452 // compile-command: "make install" //
    453449// End: //
  • src/ControlStruct/ExceptTranslateNew.cpp

    rf681823 r376c632a  
    99// Author           : Andrew Beach
    1010// Created On       : Mon Nov  8 11:53:00 2021
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Mon Nov  8 16:50:00 2021
    13 // Update Count     : 0
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Mon Jan 31 18:49:58 2022
     13// Update Count     : 1
    1414//
    1515
     
    2222
    2323namespace ControlStruct {
    24 
    25 namespace {
    2624
    2725class TranslateThrowsCore : public ast::WithGuards {
     
    128126}
    129127
    130 } // namespace
    131 
    132128void translateThrows( ast::TranslationUnit & transUnit ) {
    133129        ast::Pass<TranslateThrowsCore>::run( transUnit );
  • src/ControlStruct/FixLabels.cpp

    rf681823 r376c632a  
    99// Author           : Andrew Beach
    1010// Created On       : Mon Nov  1 09:39:00 2021
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Mon Nov  8 10:53:00 2021
    13 // Update Count     : 3
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Mon Jan 31 22:19:17 2022
     13// Update Count     : 9
    1414//
    1515
     
    2020#include "AST/Stmt.hpp"
    2121#include "ControlStruct/MultiLevelExit.hpp"
     22using namespace ast;
    2223
    2324namespace ControlStruct {
    24 
    25 namespace {
    26 
    27 class FixLabelsCore final : public ast::WithGuards {
     25class FixLabelsCore final : public WithGuards {
    2826        LabelToStmt labelTable;
    29 public:
     27  public:
    3028        FixLabelsCore() : labelTable() {}
    3129
    32         void previsit( const ast::FunctionDecl * );
    33         const ast::FunctionDecl * postvisit( const ast::FunctionDecl * );
    34         void previsit( const ast::Stmt * );
    35         void previsit( const ast::BranchStmt * );
    36         void previsit( const ast::LabelAddressExpr * );
     30        void previsit( const FunctionDecl * );
     31        const FunctionDecl * postvisit( const FunctionDecl * );
     32        void previsit( const Stmt * );
     33        void previsit( const BranchStmt * );
     34        void previsit( const LabelAddressExpr * );
    3735
    38         void setLabelsDef( const std::vector<ast::Label> &, const ast::Stmt * );
    39         void setLabelsUsage( const ast::Label & );
     36        void setLabelsDef( const std::vector<Label> &, const Stmt * );
     37        void setLabelsUsage( const Label & );
    4038};
    4139
    42 void FixLabelsCore::previsit( const ast::FunctionDecl * ) {
     40void FixLabelsCore::previsit( const FunctionDecl * ) {
    4341        GuardValue( labelTable ).clear();
    4442}
    4543
    46 const ast::FunctionDecl * FixLabelsCore::postvisit(
    47                 const ast::FunctionDecl * decl ) {
     44const FunctionDecl * FixLabelsCore::postvisit(
     45        const FunctionDecl * decl ) {
    4846        if ( nullptr == decl->stmts ) return decl;
    4947        for ( auto kvp : labelTable ) {
    5048                if ( nullptr == kvp.second ) {
    5149                        SemanticError( kvp.first.location,
    52                                 "Use of undefined label: " + kvp.first.name );
     50                                                   "Use of undefined label: " + kvp.first.name );
    5351                }
    5452        }
    55         return ast::mutate_field( decl, &ast::FunctionDecl::stmts,
    56                 multiLevelExitUpdate( decl->stmts.get(), labelTable ) );
     53        return mutate_field( decl, &FunctionDecl::stmts,
     54                                                 multiLevelExitUpdate( decl->stmts.get(), labelTable ) );
    5755}
    5856
    59 void FixLabelsCore::previsit( const ast::Stmt * stmt ) {
     57void FixLabelsCore::previsit( const Stmt * stmt ) {
    6058        if ( !stmt->labels.empty() ) {
    6159                setLabelsDef( stmt->labels, stmt );
     
    6361}
    6462
    65 void FixLabelsCore::previsit( const ast::BranchStmt * stmt ) {
     63void FixLabelsCore::previsit( const BranchStmt * stmt ) {
    6664        if ( !stmt->labels.empty() ) {
    6765                setLabelsDef( stmt->labels, stmt );
     
    7270}
    7371
    74 void FixLabelsCore::previsit( const ast::LabelAddressExpr * expr ) {
     72void FixLabelsCore::previsit( const LabelAddressExpr * expr ) {
    7573        assert( !expr->arg.empty() );
    7674        setLabelsUsage( expr->arg );
     
    7876
    7977void FixLabelsCore::setLabelsDef(
    80                 const std::vector<ast::Label> & labels, const ast::Stmt * stmt ) {
     78        const std::vector<Label> & labels, const Stmt * stmt ) {
    8179        assert( !labels.empty() );
    8280        assert( stmt );
     
    8987                        // Duplicate definition, this is an error.
    9088                        SemanticError( label.location,
    91                                 "Duplicate definition of label: " + label.name );
     89                                                   "Duplicate definition of label: " + label.name );
    9290                } else {
    9391                        // Perviously used, but not defined until now.
     
    9896
    9997// Label was used, if it is new add it to the table.
    100 void FixLabelsCore::setLabelsUsage( const ast::Label & label ) {
     98void FixLabelsCore::setLabelsUsage( const Label & label ) {
    10199        if ( labelTable.find( label ) == labelTable.end() ) {
    102100                labelTable[ label ] = nullptr;
     
    104102}
    105103
    106 } // namespace
    107 
    108 void fixLabels( ast::TranslationUnit & translationUnit ) {
    109         ast::Pass<FixLabelsCore>::run( translationUnit );
     104void fixLabels( TranslationUnit & translationUnit ) {
     105        Pass<FixLabelsCore>::run( translationUnit );
    110106}
    111 
    112107} // namespace ControlStruct
    113108
  • src/ControlStruct/FixLabels.hpp

    rf681823 r376c632a  
    99// Author           : Andrew Beach
    1010// Created On       : Mon Nov  1 09:36:00 2021
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Mon Nov  1 09:40:00 2021
    13 // Update Count     : 0
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Mon Jan 31 22:18:43 2022
     13// Update Count     : 2
    1414//
    1515
     
    1717
    1818namespace ast {
    19         class TranslationUnit;
     19class TranslationUnit;
    2020}
    2121
    2222namespace ControlStruct {
    23 
    24 /// normalizes label definitions and generates multi-level exit labels
     23// normalizes label definitions and generates multi-level exit labels
    2524void fixLabels( ast::TranslationUnit & translationUnit );
    26 
    2725}
    2826
  • src/ControlStruct/ForExprMutator.h

    rf681823 r376c632a  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Aug 17 15:32:48 2017
    13 // Update Count     : 5
     12// Last Modified On : Sun Jan 30 09:14:46 2022
     13// Update Count     : 6
    1414//
    1515
     
    2424        class ForExprMutator {
    2525          public:
    26                 Statement *postmutate( IfStmt * );
    27                 Statement *postmutate( ForStmt * );
    28                 Statement *postmutate( WhileStmt * );
     26                Statement * postmutate( IfStmt * );
     27                Statement * postmutate( ForStmt * );
     28                Statement * postmutate( WhileStmt * );
    2929        };
    3030} // namespace ControlStruct
  • src/ControlStruct/LabelFixer.cc

    rf681823 r376c632a  
    99// Author           : Rodolfo G. Esteves
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Tue Jan 21 10:32:00 2020
    13 // Update Count     : 160
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Mon Jan 31 22:28:31 2022
     13// Update Count     : 161
    1414//
    1515
     
    2727
    2828namespace ControlStruct {
    29         bool LabelFixer::Entry::insideLoop() {
    30                 return ( dynamic_cast< ForStmt * > ( definition ) ||
    31                         dynamic_cast< WhileStmt * > ( definition )  );
     29bool LabelFixer::Entry::insideLoop() {
     30        return ( dynamic_cast< ForStmt * > ( definition ) ||
     31                dynamic_cast< WhileStmt * > ( definition )  );
     32}
     33
     34LabelFixer::LabelFixer( LabelGenerator * gen ) : generator ( gen ) {
     35        if ( generator == 0 )
     36                generator = LabelGenerator::getGenerator();
     37}
     38
     39void LabelFixer::previsit( FunctionDecl * ) {
     40        // need to go into a nested function in a fresh state
     41        GuardValue( labelTable );
     42        labelTable.clear();
     43}
     44
     45void LabelFixer::postvisit( FunctionDecl * functionDecl ) {
     46        PassVisitor<MultiLevelExitMutator> mlem( resolveJumps(), generator );
     47        // We start in the body so we can stop when we hit another FunctionDecl.
     48        maybeMutate( functionDecl->statements, mlem );
     49}
     50
     51// prune to at most one label definition for each statement
     52void LabelFixer::previsit( Statement * stmt ) {
     53        std::list< Label > &labels = stmt->get_labels();
     54
     55        if ( ! labels.empty() ) {
     56                // only remember one label for each statement
     57                Label current = setLabelsDef( labels, stmt );
     58        } // if
     59}
     60
     61void LabelFixer::previsit( BranchStmt * branchStmt ) {
     62        previsit( ( Statement *)branchStmt );
     63
     64        // for labeled branches, add an entry to the label table
     65        Label target = branchStmt->get_target();
     66        if ( target != "" ) {
     67                setLabelsUsg( target, branchStmt );
     68        }
     69}
     70
     71void LabelFixer::previsit( LabelAddressExpr * addrExpr ) {
     72        Label & target = addrExpr->arg;
     73        assert( target != "" );
     74        setLabelsUsg( target, addrExpr );
     75}
     76
     77
     78// Sets the definition of the labelTable entry to be the provided statement for every label in
     79// the list parameter. Happens for every kind of statement.
     80Label LabelFixer::setLabelsDef( std::list< Label > & llabel, Statement * definition ) {
     81        assert( definition != 0 );
     82        assert( llabel.size() > 0 );
     83
     84        for ( std::list< Label >::iterator i = llabel.begin(); i != llabel.end(); i++ ) {
     85                Label & l = *i;
     86                l.set_statement( definition ); // attach statement to the label to be used later
     87                if ( labelTable.find( l ) == labelTable.end() ) {
     88                        // All labels on this statement need to use the same entry,
     89                        // so this should only be created once.
     90                        // undefined and unused until now, add an entry
     91                        labelTable[ l ] = new Entry( definition );
     92                } else if ( labelTable[ l ]->defined() ) {
     93                        // defined twice, error
     94                        SemanticError( l.get_statement()->location,
     95                                "Duplicate definition of label: " + l.get_name() );
     96                } else {
     97                        // used previously, but undefined until now -> link with this entry
     98                        // Question: Is changing objects important?
     99                        delete labelTable[ l ];
     100                        labelTable[ l ] = new Entry( definition );
     101                } // if
     102        } // for
     103
     104        // Produce one of the labels attached to this statement to be temporarily used as the
     105        // canonical label.
     106        return labelTable[ llabel.front() ]->get_label();
     107}
     108
     109// A label was used, add it to the table if it isn't already there
     110template< typename UsageNode >
     111void LabelFixer::setLabelsUsg( Label orgValue, UsageNode *use ) {
     112        assert( use != 0 );
     113
     114        // add label with an unknown origin
     115        if ( labelTable.find( orgValue ) == labelTable.end() ) {
     116                labelTable[ orgValue ] = new Entry( 0 );
     117        }
     118}
     119
     120// Builds a table that maps a label to its defining statement.
     121std::map<Label, Statement * > * LabelFixer::resolveJumps() throw ( SemanticErrorException ) {
     122        std::map< Label, Statement * > *ret = new std::map< Label, Statement * >();
     123        for ( std::map< Label, Entry * >::iterator i = labelTable.begin(); i != labelTable.end(); ++i ) {
     124                if ( ! i->second->defined() ) {
     125                        SemanticError( i->first.get_statement()->location, "Use of undefined label: " + i->first.get_name() );
     126                }
     127                (*ret)[ i->first ] = i->second->get_definition();
    32128        }
    33129
    34         LabelFixer::LabelFixer( LabelGenerator * gen ) : generator ( gen ) {
    35                 if ( generator == 0 )
    36                         generator = LabelGenerator::getGenerator();
    37         }
    38 
    39         void LabelFixer::previsit( FunctionDecl * ) {
    40                 // need to go into a nested function in a fresh state
    41                 GuardValue( labelTable );
    42                 labelTable.clear();
    43         }
    44 
    45         void LabelFixer::postvisit( FunctionDecl * functionDecl ) {
    46                 PassVisitor<MultiLevelExitMutator> mlem( resolveJumps(), generator );
    47                 // We start in the body so we can stop when we hit another FunctionDecl.
    48                 maybeMutate( functionDecl->statements, mlem );
    49         }
    50 
    51         // prune to at most one label definition for each statement
    52         void LabelFixer::previsit( Statement * stmt ) {
    53                 std::list< Label > &labels = stmt->get_labels();
    54 
    55                 if ( ! labels.empty() ) {
    56                         // only remember one label for each statement
    57                         Label current = setLabelsDef( labels, stmt );
    58                 } // if
    59         }
    60 
    61         void LabelFixer::previsit( BranchStmt * branchStmt ) {
    62                 previsit( ( Statement *)branchStmt );
    63 
    64                 // for labeled branches, add an entry to the label table
    65                 Label target = branchStmt->get_target();
    66                 if ( target != "" ) {
    67                         setLabelsUsg( target, branchStmt );
    68                 }
    69         }
    70 
    71         void LabelFixer::previsit( LabelAddressExpr * addrExpr ) {
    72                 Label & target = addrExpr->arg;
    73                 assert( target != "" );
    74                 setLabelsUsg( target, addrExpr );
    75         }
    76 
    77 
    78         // Sets the definition of the labelTable entry to be the provided statement for every label in
    79         // the list parameter. Happens for every kind of statement.
    80         Label LabelFixer::setLabelsDef( std::list< Label > & llabel, Statement * definition ) {
    81                 assert( definition != 0 );
    82                 assert( llabel.size() > 0 );
    83 
    84                 for ( std::list< Label >::iterator i = llabel.begin(); i != llabel.end(); i++ ) {
    85                         Label & l = *i;
    86                         l.set_statement( definition ); // attach statement to the label to be used later
    87                         if ( labelTable.find( l ) == labelTable.end() ) {
    88                                 // All labels on this statement need to use the same entry,
    89                                 // so this should only be created once.
    90                                 // undefined and unused until now, add an entry
    91                                 labelTable[ l ] = new Entry( definition );
    92                         } else if ( labelTable[ l ]->defined() ) {
    93                                 // defined twice, error
    94                                 SemanticError( l.get_statement()->location,
    95                                         "Duplicate definition of label: " + l.get_name() );
    96                         } else {
    97                                 // used previously, but undefined until now -> link with this entry
    98                                 // Question: Is changing objects important?
    99                                 delete labelTable[ l ];
    100                                 labelTable[ l ] = new Entry( definition );
    101                         } // if
    102                 } // for
    103 
    104                 // Produce one of the labels attached to this statement to be temporarily used as the
    105                 // canonical label.
    106                 return labelTable[ llabel.front() ]->get_label();
    107         }
    108 
    109         // A label was used, add it to the table if it isn't already there
    110         template< typename UsageNode >
    111         void LabelFixer::setLabelsUsg( Label orgValue, UsageNode *use ) {
    112                 assert( use != 0 );
    113 
    114                 // add label with an unknown origin
    115                 if ( labelTable.find( orgValue ) == labelTable.end() ) {
    116                         labelTable[ orgValue ] = new Entry( 0 );
    117                 }
    118         }
    119 
    120         // Builds a table that maps a label to its defining statement.
    121         std::map<Label, Statement * > * LabelFixer::resolveJumps() throw ( SemanticErrorException ) {
    122                 std::map< Label, Statement * > *ret = new std::map< Label, Statement * >();
    123                 for ( std::map< Label, Entry * >::iterator i = labelTable.begin(); i != labelTable.end(); ++i ) {
    124                         if ( ! i->second->defined() ) {
    125                                 SemanticError( i->first.get_statement()->location, "Use of undefined label: " + i->first.get_name() );
    126                         }
    127                         (*ret)[ i->first ] = i->second->get_definition();
    128                 }
    129 
    130                 return ret;
    131         }
     130        return ret;
     131}
    132132}  // namespace ControlStruct
    133133
  • src/ControlStruct/LabelFixer.h

    rf681823 r376c632a  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Jul 22 09:17:24 2017
    13 // Update Count     : 34
     12// Last Modified On : Mon Jan 31 22:28:04 2022
     13// Update Count     : 35
    1414//
    1515
     
    2626
    2727namespace ControlStruct {
    28         /// normalizes label definitions and generates multi-level exit labels
    29         class LabelGenerator;
     28// normalizes label definitions and generates multi-level exit labels
     29class LabelGenerator;
    3030
    31         class LabelFixer final : public WithGuards {
    32           public:
    33                 LabelFixer( LabelGenerator *gen = 0 );
     31class LabelFixer final : public WithGuards {
     32  public:
     33        LabelFixer( LabelGenerator *gen = 0 );
    3434
    35                 std::map < Label, Statement * > *resolveJumps() throw ( SemanticErrorException );
     35        std::map < Label, Statement * > *resolveJumps() throw ( SemanticErrorException );
    3636
    37                 // Declarations
    38                 void previsit( FunctionDecl *functionDecl );
    39                 void postvisit( FunctionDecl *functionDecl );
     37        // Declarations
     38        void previsit( FunctionDecl *functionDecl );
     39        void postvisit( FunctionDecl *functionDecl );
    4040
    41                 // Statements
    42                 void previsit( Statement *stmt );
    43                 void previsit( BranchStmt *branchStmt );
     41        // Statements
     42        void previsit( Statement *stmt );
     43        void previsit( BranchStmt *branchStmt );
    4444
    45                 // Expressions
    46                 void previsit( LabelAddressExpr *addrExpr );
     45        // Expressions
     46        void previsit( LabelAddressExpr *addrExpr );
    4747
    48                 Label setLabelsDef( std::list< Label > &, Statement *definition );
    49                 template< typename UsageNode >
    50                 void setLabelsUsg( Label, UsageNode *usage = 0 );
     48        Label setLabelsDef( std::list< Label > &, Statement *definition );
     49        template< typename UsageNode >
     50        void setLabelsUsg( Label, UsageNode *usage = 0 );
     51
     52  private:
     53        class Entry {
     54                public:
     55                Entry( Statement *to ) : definition( to ) {}
     56                bool defined() { return ( definition != 0 ); }
     57                bool insideLoop();
     58
     59                Label get_label() const { return label; }
     60                void set_label( Label lab ) { label = lab; }
     61
     62                Statement *get_definition() const { return definition; }
     63                void set_definition( Statement *def ) { definition = def; }
    5164
    5265          private:
    53                 class Entry {
    54                         public:
    55                         Entry( Statement *to ) : definition( to ) {}
    56                         bool defined() { return ( definition != 0 ); }
    57                         bool insideLoop();
     66                Label label;
     67                Statement *definition;
     68        };
    5869
    59                         Label get_label() const { return label; }
    60                         void set_label( Label lab ) { label = lab; }
    61 
    62                         Statement *get_definition() const { return definition; }
    63                         void set_definition( Statement *def ) { definition = def; }
    64 
    65                   private:
    66                         Label label;
    67                         Statement *definition;
    68                 };
    69 
    70                 std::map < Label, Entry *> labelTable;
    71                 LabelGenerator *generator;
    72         };
     70        std::map < Label, Entry *> labelTable;
     71        LabelGenerator *generator;
     72};
    7373} // namespace ControlStruct
    7474
  • src/ControlStruct/LabelGenerator.cc

    rf681823 r376c632a  
    99// Author           : Rodolfo G. Esteves
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Mon Nov  8 10:18:00 2021
    13 // Update Count     : 17
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Mon Jan 31 22:30:26 2022
     13// Update Count     : 28
    1414//
    1515
     
    1717#include <sstream>              // for ostringstream
    1818#include <list>                 // for list
     19using namespace std;
    1920
    2021#include "LabelGenerator.h"
    2122
    22 #include "AST/Attribute.hpp"
    23 #include "AST/Label.hpp"
    24 #include "AST/Stmt.hpp"
    2523#include "SynTree/Attribute.h"  // for Attribute
    2624#include "SynTree/Label.h"      // for Label, operator<<
     
    2826
    2927namespace ControlStruct {
    30 
    3128int LabelGenerator::current = 0;
    3229LabelGenerator * LabelGenerator::labelGenerator = nullptr;
    3330
    34         LabelGenerator * LabelGenerator::getGenerator() {
    35                 if ( LabelGenerator::labelGenerator == 0 )
    36                         LabelGenerator::labelGenerator = new LabelGenerator();
    37                 return labelGenerator;
    38         }
    39 
    40         Label LabelGenerator::newLabel( std::string suffix, Statement * stmt ) {
    41                 std::ostringstream os;
    42                 os << "__L" << current++ << "__" << suffix;
    43                 if ( stmt && ! stmt->get_labels().empty() ) {
    44                         os << "_" << stmt->get_labels().front() << "__";
    45                 } // if
    46                 std::string ret = os.str();
    47                 Label l( ret );
    48                 l.get_attributes().push_back( new Attribute("unused") );
    49                 return l;
    50         }
    51 
    52 ast::Label LabelGenerator::newLabel(
    53                 const std::string & suffix, const ast::Stmt * stmt ) {
    54         assert( stmt );
    55 
    56         std::ostringstream os;
    57         os << "__L" << current++ << "__" << suffix;
    58         if ( stmt && !stmt->labels.empty() ) {
    59                 os << "_" << stmt->labels.front() << "__";
    60         }
    61         ast::Label ret_label( stmt->location, os.str() );
    62         ret_label.attributes.push_back( new ast::Attribute( "unused" ) );
    63         return ret_label;
     31LabelGenerator * LabelGenerator::getGenerator() {
     32        if ( LabelGenerator::labelGenerator == 0 )
     33                LabelGenerator::labelGenerator = new LabelGenerator();
     34        return labelGenerator;
    6435}
    6536
     37Label LabelGenerator::newLabel( string suffix, Statement * stmt ) {
     38        ostringstream os;
     39        os << "__L_OLD" << current++ << "__" << suffix;
     40        if ( stmt && ! stmt->get_labels().empty() ) {
     41                os << "_" << stmt->get_labels().front() << "__";
     42        } // if
     43        string ret = os.str();
     44        Label l( ret );
     45        l.get_attributes().push_back( new Attribute( "unused" ) );
     46        return l;
     47}
    6648} // namespace ControlStruct
    6749
    6850// Local Variables: //
    69 // tab-width: 4 //
    7051// mode: c++ //
    71 // compile-command: "make install" //
    7252// End: //
  • src/ControlStruct/LabelGenerator.h

    rf681823 r376c632a  
    99// Author           : Rodolfo G. Esteves
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Mon Nov  8 10:16:00 2021
    13 // Update Count     : 8
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Mon Jan 31 22:30:10 2022
     13// Update Count     : 16
    1414//
    1515
     
    2121
    2222class Statement;
     23
    2324namespace ast {
    24         class Stmt;
    25         class Label;
     25class Stmt;
     26class Label;
    2627}
    2728
    2829namespace ControlStruct {
    29 
    3030class LabelGenerator {
    3131        static int current;
    3232        static LabelGenerator *labelGenerator;
    33 protected:
     33  protected:
    3434        LabelGenerator() {}
    35 public:
     35  public:
    3636        static LabelGenerator *getGenerator();
    3737        static Label newLabel(std::string suffix, Statement * stmt = nullptr);
    38         static ast::Label newLabel( const std::string&, const ast::Stmt * );
    39         static void reset() { current = 0; }
    40         static void rewind() { current--; }
    4138};
    42 
    4339} // namespace ControlStruct
    4440
  • src/ControlStruct/MultiLevelExit.cpp

    rf681823 r376c632a  
    99// Author           : Andrew Beach
    1010// Created On       : Mon Nov  1 13:48:00 2021
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Mon Nov  8 10:56:00 2021
    13 // Update Count     : 2
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Mon Jan 31 22:35:08 2022
     13// Update Count     : 28
    1414//
    1515
     
    1818#include "AST/Pass.hpp"
    1919#include "AST/Stmt.hpp"
    20 #include "ControlStruct/LabelGenerator.h"
     20#include "LabelGeneratorNew.hpp"
    2121
    2222#include <set>
     23using namespace std;
     24using namespace ast;
    2325
    2426namespace ControlStruct {
    25 
    26 namespace {
    27 
    2827class Entry {
    29 public:
    30         const ast::Stmt * stmt;
    31 private:
     28  public:
     29        const Stmt * stmt;
     30  private:
    3231        // Organized like a manual ADT. Avoids creating a bunch of dead data.
    3332        struct Target {
    34                 ast::Label label;
     33                Label label;
    3534                bool used = false;
    36                 Target( const ast::Label & label ) : label( label ) {}
     35                Target( const Label & label ) : label( label ) {}
    3736                Target() : label( CodeLocation() ) {}
    3837        };
     
    4140
    4241        enum Kind {
    43                 ForStmt, WhileStmt, CompoundStmt, IfStmt, CaseStmt, SwitchStmt, TryStmt
     42                ForStmtK, WhileStmtK, CompoundStmtK, IfStmtK, CaseStmtK, SwitchStmtK, TryStmtK
    4443        } kind;
    4544
    4645        bool fallDefaultValid = true;
    4746
    48         static ast::Label & useTarget( Target & target ) {
     47        static Label & useTarget( Target & target ) {
    4948                target.used = true;
    5049                return target.label;
    5150        }
    5251
    53 public:
    54         Entry( const ast::ForStmt * stmt, ast::Label breakExit, ast::Label contExit ) :
    55                 stmt( stmt ), firstTarget( breakExit ), secondTarget( contExit ), kind( ForStmt ) {}
    56         Entry( const ast::WhileStmt * stmt, ast::Label breakExit, ast::Label contExit ) :
    57                 stmt( stmt ), firstTarget( breakExit ), secondTarget( contExit ), kind( WhileStmt ) {}
    58         Entry( const ast::CompoundStmt *stmt, ast::Label breakExit ) :
    59                 stmt( stmt ), firstTarget( breakExit ), secondTarget(), kind( CompoundStmt ) {}
    60         Entry( const ast::IfStmt *stmt, ast::Label breakExit ) :
    61                 stmt( stmt ), firstTarget( breakExit ), secondTarget(), kind( IfStmt ) {}
    62         Entry( const ast::CaseStmt *stmt, ast::Label fallExit ) :
    63                 stmt( stmt ), firstTarget( fallExit ), secondTarget(), kind( CaseStmt ) {}
    64         Entry( const ast::SwitchStmt *stmt, ast::Label breakExit, ast::Label fallDefaultExit ) :
    65                 stmt( stmt ), firstTarget( breakExit ), secondTarget( fallDefaultExit ), kind( SwitchStmt ) {}
    66         Entry( const ast::TryStmt *stmt, ast::Label breakExit ) :
    67                 stmt( stmt ), firstTarget( breakExit ), secondTarget(), kind( TryStmt ) {}
    68 
    69         bool isContTarget() const { return kind <= WhileStmt; }
    70         bool isBreakTarget() const { return CaseStmt != kind; }
    71         bool isFallTarget() const { return CaseStmt == kind; }
    72         bool isFallDefaultTarget() const { return SwitchStmt == kind; }
    73 
    74         ast::Label useContExit() { assert( kind <= WhileStmt ); return useTarget(secondTarget); }
    75         ast::Label useBreakExit() { assert( CaseStmt != kind ); return useTarget(firstTarget); }
    76         ast::Label useFallExit() { assert( CaseStmt == kind );  return useTarget(firstTarget); }
    77         ast::Label useFallDefaultExit() { assert( SwitchStmt == kind ); return useTarget(secondTarget); }
    78 
    79         bool isContUsed() const { assert( kind <= WhileStmt ); return secondTarget.used; }
    80         bool isBreakUsed() const { assert( CaseStmt != kind ); return firstTarget.used; }
    81         bool isFallUsed() const { assert( CaseStmt == kind ); return firstTarget.used; }
    82         bool isFallDefaultUsed() const { assert( SwitchStmt == kind ); return secondTarget.used; }
     52  public:
     53        Entry( const ForStmt * stmt, Label breakExit, Label contExit ) :
     54                stmt( stmt ), firstTarget( breakExit ), secondTarget( contExit ), kind( ForStmtK ) {}
     55        Entry( const WhileStmt * stmt, Label breakExit, Label contExit ) :
     56                stmt( stmt ), firstTarget( breakExit ), secondTarget( contExit ), kind( WhileStmtK ) {}
     57        Entry( const CompoundStmt *stmt, Label breakExit ) :
     58                stmt( stmt ), firstTarget( breakExit ), secondTarget(), kind( CompoundStmtK ) {}
     59        Entry( const IfStmt *stmt, Label breakExit ) :
     60                stmt( stmt ), firstTarget( breakExit ), secondTarget(), kind( IfStmtK ) {}
     61        Entry( const CaseStmt *stmt, Label fallExit ) :
     62                stmt( stmt ), firstTarget( fallExit ), secondTarget(), kind( CaseStmtK ) {}
     63        Entry( const SwitchStmt *stmt, Label breakExit, Label fallDefaultExit ) :
     64                stmt( stmt ), firstTarget( breakExit ), secondTarget( fallDefaultExit ), kind( SwitchStmtK ) {}
     65        Entry( const TryStmt *stmt, Label breakExit ) :
     66                stmt( stmt ), firstTarget( breakExit ), secondTarget(), kind( TryStmtK ) {}
     67
     68        bool isContTarget() const { return kind <= WhileStmtK; }
     69        bool isBreakTarget() const { return kind != CaseStmtK; }
     70        bool isFallTarget() const { return kind == CaseStmtK; }
     71        bool isFallDefaultTarget() const { return kind == SwitchStmtK; }
     72
     73        Label useContExit() { assert( kind <= WhileStmtK ); return useTarget(secondTarget); }
     74        Label useBreakExit() { assert( kind != CaseStmtK ); return useTarget(firstTarget); }
     75        Label useFallExit() { assert( kind == CaseStmtK );  return useTarget(firstTarget); }
     76        Label useFallDefaultExit() { assert( kind == SwitchStmtK ); return useTarget(secondTarget); }
     77
     78        bool isContUsed() const { assert( kind <= WhileStmtK ); return secondTarget.used; }
     79        bool isBreakUsed() const { assert( kind != CaseStmtK ); return firstTarget.used; }
     80        bool isFallUsed() const { assert( kind == CaseStmtK ); return firstTarget.used; }
     81        bool isFallDefaultUsed() const { assert( kind == SwitchStmtK ); return secondTarget.used; }
    8382        void seenDefault() { fallDefaultValid = false; }
    8483        bool isFallDefaultValid() const { return fallDefaultValid; }
    8584};
    8685
    87 // Helper predicates used in std::find_if calls (it doesn't take methods):
     86// Helper predicates used in find_if calls (it doesn't take methods):
    8887bool isBreakTarget( const Entry & entry ) {
    8988        return entry.isBreakTarget();
     
    103102
    104103struct MultiLevelExitCore final :
    105                 public ast::WithVisitorRef<MultiLevelExitCore>,
    106                 public ast::WithShortCircuiting, public ast::WithGuards {
     104        public WithVisitorRef<MultiLevelExitCore>,
     105        public WithShortCircuiting, public WithGuards {
    107106        MultiLevelExitCore( const LabelToStmt & lt );
    108107
    109         void previsit( const ast::FunctionDecl * );
    110 
    111         const ast::CompoundStmt * previsit( const ast::CompoundStmt * );
    112         const ast::BranchStmt * postvisit( const ast::BranchStmt * );
    113         void previsit( const ast::WhileStmt * );
    114         const ast::WhileStmt * postvisit( const ast::WhileStmt * );
    115         void previsit( const ast::ForStmt * );
    116         const ast::ForStmt * postvisit( const ast::ForStmt * );
    117         const ast::CaseStmt * previsit( const ast::CaseStmt * );
    118         void previsit( const ast::IfStmt * );
    119         const ast::IfStmt * postvisit( const ast::IfStmt * );
    120         void previsit( const ast::SwitchStmt * );
    121         const ast::SwitchStmt * postvisit( const ast::SwitchStmt * );
    122         void previsit( const ast::ReturnStmt * );
    123         void previsit( const ast::TryStmt * );
    124         void postvisit( const ast::TryStmt * );
    125         void previsit( const ast::FinallyStmt * );
    126 
    127         const ast::Stmt * mutateLoop( const ast::Stmt * body, Entry& );
     108        void previsit( const FunctionDecl * );
     109
     110        const CompoundStmt * previsit( const CompoundStmt * );
     111        const BranchStmt * postvisit( const BranchStmt * );
     112        void previsit( const WhileStmt * );
     113        const WhileStmt * postvisit( const WhileStmt * );
     114        void previsit( const ForStmt * );
     115        const ForStmt * postvisit( const ForStmt * );
     116        const CaseStmt * previsit( const CaseStmt * );
     117        void previsit( const IfStmt * );
     118        const IfStmt * postvisit( const IfStmt * );
     119        void previsit( const SwitchStmt * );
     120        const SwitchStmt * postvisit( const SwitchStmt * );
     121        void previsit( const ReturnStmt * );
     122        void previsit( const TryStmt * );
     123        void postvisit( const TryStmt * );
     124        void previsit( const FinallyStmt * );
     125
     126        const Stmt * mutateLoop( const Stmt * body, Entry& );
    128127
    129128        const LabelToStmt & target_table;
    130         std::set<ast::Label> fallthrough_labels;
    131         std::vector<Entry> enclosing_control_structures;
    132         ast::Label break_label;
     129        set<Label> fallthrough_labels;
     130        vector<Entry> enclosing_control_structures;
     131        Label break_label;
    133132        bool inFinally;
    134133
     
    138137        const LoopNode * posthandleLoopStmt( const LoopNode * loopStmt );
    139138
    140         std::list<ast::ptr<ast::Stmt>> fixBlock(
    141                 const std::list<ast::ptr<ast::Stmt>> & kids, bool caseClause );
     139        list<ptr<Stmt>> fixBlock(
     140                const list<ptr<Stmt>> & kids, bool caseClause );
    142141
    143142        template<typename UnaryPredicate>
    144143        auto findEnclosingControlStructure( UnaryPredicate pred ) {
    145                 return std::find_if( enclosing_control_structures.rbegin(),
    146                         enclosing_control_structures.rend(), pred );
     144                return find_if( enclosing_control_structures.rbegin(),
     145                                                enclosing_control_structures.rend(), pred );
    147146        }
    148147};
    149148
    150 ast::NullStmt * labelledNullStmt(
    151                 const CodeLocation & cl, const ast::Label & label ) {
    152         return new ast::NullStmt( cl, std::vector<ast::Label>{ label } );
     149NullStmt * labelledNullStmt(
     150        const CodeLocation & cl, const Label & label ) {
     151        return new NullStmt( cl, vector<Label>{ label } );
    153152}
    154153
     
    158157{}
    159158
    160 void MultiLevelExitCore::previsit( const ast::FunctionDecl * ) {
     159void MultiLevelExitCore::previsit( const FunctionDecl * ) {
    161160        visit_children = false;
    162161}
    163162
    164 const ast::CompoundStmt * MultiLevelExitCore::previsit(
    165                 const ast::CompoundStmt * stmt ) {
     163const CompoundStmt * MultiLevelExitCore::previsit(
     164        const CompoundStmt * stmt ) {
    166165        visit_children = false;
    167166        bool isLabeled = !stmt->labels.empty();
    168167        if ( isLabeled ) {
    169                 ast::Label breakLabel = LabelGenerator::newLabel( "blockBreak", stmt );
     168                Label breakLabel = newLabel( "blockBreak", stmt );
    170169                enclosing_control_structures.emplace_back( stmt, breakLabel );
    171170                GuardAction( [this]() { enclosing_control_structures.pop_back(); } );
    172171        }
    173172
    174         auto mutStmt = ast::mutate( stmt );
     173        auto mutStmt = mutate( stmt );
    175174        // A child statement may set the break label.
    176         mutStmt->kids = std::move( fixBlock( stmt->kids, false ) );
     175        mutStmt->kids = move( fixBlock( stmt->kids, false ) );
    177176
    178177        if ( isLabeled ) {
     
    187186
    188187size_t getUnusedIndex(
    189                 const ast::Stmt * stmt, const ast::Label & originalTarget ) {
     188        const Stmt * stmt, const Label & originalTarget ) {
    190189        const size_t size = stmt->labels.size();
    191190
    192         // If the label is empty, we can skip adding the unused attribute:
    193         if ( originalTarget.empty() ) return size;
     191        // If the label is empty, do not add unused attribute.
     192  if ( originalTarget.empty() ) return size;
    194193
    195194        // Search for a label that matches the originalTarget.
    196195        for ( size_t i = 0 ; i < size ; ++i ) {
    197                 const ast::Label & label = stmt->labels[i];
     196                const Label & label = stmt->labels[i];
    198197                if ( label == originalTarget ) {
    199                         for ( const ast::Attribute * attr : label.attributes ) {
     198                        for ( const Attribute * attr : label.attributes ) {
    200199                                if ( attr->name == "unused" ) return size;
    201200                        }
     
    204203        }
    205204        assertf( false, "Could not find label '%s' on statement %s",
    206                 originalTarget.name.c_str(), toString( stmt ).c_str() );
    207 }
    208 
    209 const ast::Stmt * addUnused(
    210                 const ast::Stmt * stmt, const ast::Label & originalTarget ) {
     205                         originalTarget.name.c_str(), toString( stmt ).c_str() );
     206}
     207
     208const Stmt * addUnused(
     209        const Stmt * stmt, const Label & originalTarget ) {
    211210        size_t i = getUnusedIndex( stmt, originalTarget );
    212211        if ( i == stmt->labels.size() ) {
    213212                return stmt;
    214213        }
    215         ast::Stmt * mutStmt = ast::mutate( stmt );
    216         mutStmt->labels[i].attributes.push_back( new ast::Attribute( "unused" ) );
     214        Stmt * mutStmt = mutate( stmt );
     215        mutStmt->labels[i].attributes.push_back( new Attribute( "unused" ) );
    217216        return mutStmt;
    218217}
    219218
    220 const ast::BranchStmt * MultiLevelExitCore::postvisit( const ast::BranchStmt * stmt ) {
    221         std::vector<Entry>::reverse_iterator targetEntry =
     219const BranchStmt * MultiLevelExitCore::postvisit( const BranchStmt * stmt ) {
     220        vector<Entry>::reverse_iterator targetEntry =
    222221                enclosing_control_structures.rend();
    223222        switch ( stmt->kind ) {
    224         case ast::BranchStmt::Goto:
     223          case BranchStmt::Goto:
    225224                return stmt;
    226         case ast::BranchStmt::Continue:
    227         case ast::BranchStmt::Break: {
    228                 bool isContinue = stmt->kind == ast::BranchStmt::Continue;
    229                 // Handle unlabeled break and continue.
    230                 if ( stmt->target.empty() ) {
    231                         if ( isContinue ) {
    232                                 targetEntry = findEnclosingControlStructure( isContinueTarget );
    233                         } else {
    234                                 if ( enclosing_control_structures.empty() ) {
    235                                         SemanticError( stmt->location,
    236                                                 "'break' outside a loop, 'switch', or labelled block" );
    237                                 }
    238                                 targetEntry = findEnclosingControlStructure( isBreakTarget );
    239                         }
    240                 // Handle labeled break and continue.
    241                 } else {
    242                         // Lookup label in table to find attached control structure.
    243                         targetEntry = findEnclosingControlStructure(
    244                                 [ targetStmt = target_table.at(stmt->target) ](auto entry){
    245                                         return entry.stmt == targetStmt;
    246                                 } );
    247                 }
    248                 // Ensure that selected target is valid.
    249                 if ( targetEntry == enclosing_control_structures.rend() || ( isContinue && !isContinueTarget( *targetEntry ) ) ) {
    250                         SemanticError(
    251                                 stmt->location,
    252                                 toString( (isContinue ? "'continue'" : "'break'"),
    253                                         " target must be an enclosing ",
    254                                         (isContinue ? "loop: " : "control structure: "),
    255                                         stmt->originalTarget ) );
    256                 }
    257                 break;
    258         }
    259         case ast::BranchStmt::FallThrough: {
    260                 targetEntry = findEnclosingControlStructure( isFallthroughTarget );
    261                 // Check that target is valid.
    262                 if ( targetEntry == enclosing_control_structures.rend() ) {
    263                         SemanticError( stmt->location, "'fallthrough' must be enclosed in a 'switch' or 'choose'" );
    264                 }
    265                 if ( !stmt->target.empty() ) {
    266                         // Labelled fallthrough: target must be a valid fallthough label.
    267                         if ( !fallthrough_labels.count( stmt->target ) ) {
    268                                 SemanticError( stmt->location, toString( "'fallthrough' target must be a later case statement: ", stmt->originalTarget ) );
    269                         }
    270                         return new ast::BranchStmt(
    271                                 stmt->location, ast::BranchStmt::Goto, stmt->originalTarget );
    272                 }
    273                 break;
    274         }
    275         case ast::BranchStmt::FallThroughDefault: {
    276                 targetEntry = findEnclosingControlStructure( isFallthroughDefaultTarget );
    277 
    278                 // Check that this is in a switch or choose statement.
    279                 if ( targetEntry == enclosing_control_structures.rend() ) {
    280                         SemanticError( stmt->location, "'fallthrough' must be enclosed in a 'switch' or 'choose'" );
    281                 }
    282 
    283                 // Check that the switch or choose has a default clause.
    284                 auto switchStmt = strict_dynamic_cast< const ast::SwitchStmt * >(
    285                         targetEntry->stmt );
    286                 bool foundDefault = false;
    287                 for ( auto subStmt : switchStmt->stmts ) {
    288                         const ast::CaseStmt * caseStmt = subStmt.strict_as<ast::CaseStmt>();
    289                         if ( caseStmt->isDefault() ) {
    290                                 foundDefault = true;
    291                                 break;
    292                         }
    293                 }
    294                 if ( !foundDefault ) {
    295                         SemanticError( stmt->location, "'fallthrough default' must be enclosed in a 'switch' or 'choose' control structure with a 'default' clause" );
    296                 }
    297                 break;
    298         }
    299         default:
     225          case BranchStmt::Continue:
     226          case BranchStmt::Break: {
     227                  bool isContinue = stmt->kind == BranchStmt::Continue;
     228                  // Handle unlabeled break and continue.
     229                  if ( stmt->target.empty() ) {
     230                          if ( isContinue ) {
     231                                  targetEntry = findEnclosingControlStructure( isContinueTarget );
     232                          } else {
     233                                  if ( enclosing_control_structures.empty() ) {
     234                                          SemanticError( stmt->location,
     235                                                                         "'break' outside a loop, 'switch', or labelled block" );
     236                                  }
     237                                  targetEntry = findEnclosingControlStructure( isBreakTarget );
     238                          }
     239                          // Handle labeled break and continue.
     240                  } else {
     241                          // Lookup label in table to find attached control structure.
     242                          targetEntry = findEnclosingControlStructure(
     243                                  [ targetStmt = target_table.at(stmt->target) ](auto entry){
     244                                          return entry.stmt == targetStmt;
     245                                  } );
     246                  }
     247                  // Ensure that selected target is valid.
     248                  if ( targetEntry == enclosing_control_structures.rend() || ( isContinue && !isContinueTarget( *targetEntry ) ) ) {
     249                          SemanticError( stmt->location, toString( (isContinue ? "'continue'" : "'break'"),
     250                                                        " target must be an enclosing ", (isContinue ? "loop: " : "control structure: "),
     251                                                        stmt->originalTarget ) );
     252                  }
     253                  break;
     254          }
     255          case BranchStmt::FallThrough: {
     256                  targetEntry = findEnclosingControlStructure( isFallthroughTarget );
     257                  // Check that target is valid.
     258                  if ( targetEntry == enclosing_control_structures.rend() ) {
     259                          SemanticError( stmt->location, "'fallthrough' must be enclosed in a 'switch' or 'choose'" );
     260                  }
     261                  if ( !stmt->target.empty() ) {
     262                          // Labelled fallthrough: target must be a valid fallthough label.
     263                          if ( !fallthrough_labels.count( stmt->target ) ) {
     264                                  SemanticError( stmt->location, toString( "'fallthrough' target must be a later case statement: ",
     265                                                                                                                   stmt->originalTarget ) );
     266                          }
     267                          return new BranchStmt(
     268                                  stmt->location, BranchStmt::Goto, stmt->originalTarget );
     269                  }
     270                  break;
     271          }
     272          case BranchStmt::FallThroughDefault: {
     273                  targetEntry = findEnclosingControlStructure( isFallthroughDefaultTarget );
     274
     275                  // Check if in switch or choose statement.
     276                  if ( targetEntry == enclosing_control_structures.rend() ) {
     277                          SemanticError( stmt->location, "'fallthrough' must be enclosed in a 'switch' or 'choose'" );
     278                  }
     279
     280                  // Check if switch or choose has default clause.
     281                  auto switchStmt = strict_dynamic_cast< const SwitchStmt * >( targetEntry->stmt );
     282                  bool foundDefault = false;
     283                  for ( auto subStmt : switchStmt->stmts ) {
     284                          const CaseStmt * caseStmt = subStmt.strict_as<CaseStmt>();
     285                          if ( caseStmt->isDefault() ) {
     286                                  foundDefault = true;
     287                                  break;
     288                          }
     289                  }
     290                  if ( ! foundDefault ) {
     291                          SemanticError( stmt->location, "'fallthrough default' must be enclosed in a 'switch' or 'choose'"
     292                                                         "control structure with a 'default' clause" );
     293                  }
     294                  break;
     295          }
     296          default:
    300297                assert( false );
    301298        }
    302299
    303300        // Branch error checks: get the appropriate label name:
    304         // (This label will always be replaced.)
    305         ast::Label exitLabel( CodeLocation(), "" );
     301        // (This label is always replaced.)
     302        Label exitLabel( CodeLocation(), "" );
    306303        switch ( stmt->kind ) {
    307         case ast::BranchStmt::Break:
     304          case BranchStmt::Break:
    308305                assert( !targetEntry->useBreakExit().empty() );
    309306                exitLabel = targetEntry->useBreakExit();
    310307                break;
    311         case ast::BranchStmt::Continue:
     308          case BranchStmt::Continue:
    312309                assert( !targetEntry->useContExit().empty() );
    313310                exitLabel = targetEntry->useContExit();
    314311                break;
    315         case ast::BranchStmt::FallThrough:
     312          case BranchStmt::FallThrough:
    316313                assert( !targetEntry->useFallExit().empty() );
    317314                exitLabel = targetEntry->useFallExit();
    318315                break;
    319         case ast::BranchStmt::FallThroughDefault:
     316          case BranchStmt::FallThroughDefault:
    320317                assert( !targetEntry->useFallDefaultExit().empty() );
    321318                exitLabel = targetEntry->useFallDefaultExit();
    322319                // Check that fallthrough default comes before the default clause.
    323320                if ( !targetEntry->isFallDefaultValid() ) {
    324                         SemanticError( stmt->location,
    325                                 "'fallthrough default' must precede the 'default' clause" );
     321                        SemanticError( stmt->location, "'fallthrough default' must precede the 'default' clause" );
    326322                }
    327323                break;
    328         default:
     324          default:
    329325                assert(0);
    330326        }
     
    333329        targetEntry->stmt = addUnused( targetEntry->stmt, stmt->originalTarget );
    334330
    335         // Replace this with a goto to make later passes more uniform.
    336         return new ast::BranchStmt( stmt->location, ast::BranchStmt::Goto, exitLabel );
    337 }
    338 
    339 void MultiLevelExitCore::previsit( const ast::WhileStmt * stmt ) {
     331        // Replace with goto to make later passes more uniform.
     332        return new BranchStmt( stmt->location, BranchStmt::Goto, exitLabel );
     333}
     334
     335void MultiLevelExitCore::previsit( const WhileStmt * stmt ) {
    340336        return prehandleLoopStmt( stmt );
    341337}
    342338
    343 const ast::WhileStmt * MultiLevelExitCore::postvisit( const ast::WhileStmt * stmt ) {
     339const WhileStmt * MultiLevelExitCore::postvisit( const WhileStmt * stmt ) {
    344340        return posthandleLoopStmt( stmt );
    345341}
    346342
    347 void MultiLevelExitCore::previsit( const ast::ForStmt * stmt ) {
     343void MultiLevelExitCore::previsit( const ForStmt * stmt ) {
    348344        return prehandleLoopStmt( stmt );
    349345}
    350346
    351 const ast::ForStmt * MultiLevelExitCore::postvisit( const ast::ForStmt * stmt ) {
     347const ForStmt * MultiLevelExitCore::postvisit( const ForStmt * stmt ) {
    352348        return posthandleLoopStmt( stmt );
    353349}
     
    355351// Mimic what the built-in push_front would do anyways. It is O(n).
    356352void push_front(
    357                 std::vector<ast::ptr<ast::Stmt>> & vec, const ast::Stmt * element ) {
     353        vector<ptr<Stmt>> & vec, const Stmt * element ) {
    358354        vec.emplace_back( nullptr );
    359355        for ( size_t i = vec.size() - 1 ; 0 < i ; --i ) {
    360                 vec[ i ] = std::move( vec[ i - 1 ] );
     356                vec[ i ] = move( vec[ i - 1 ] );
    361357        }
    362358        vec[ 0 ] = element;
    363359}
    364360
    365 const ast::CaseStmt * MultiLevelExitCore::previsit( const ast::CaseStmt * stmt ) {
     361const CaseStmt * MultiLevelExitCore::previsit( const CaseStmt * stmt ) {
    366362        visit_children = false;
    367363
    368         // If it is the default, mark the default as seen.
     364        // If default, mark seen.
    369365        if ( stmt->isDefault() ) {
    370366                assert( !enclosing_control_structures.empty() );
     
    373369
    374370        // The cond may not exist, but if it does update it now.
    375         visitor->maybe_accept( stmt, &ast::CaseStmt::cond );
     371        visitor->maybe_accept( stmt, &CaseStmt::cond );
    376372
    377373        // Just save the mutated node for simplicity.
    378         ast::CaseStmt * mutStmt = ast::mutate( stmt );
    379 
    380         ast::Label fallLabel = LabelGenerator::newLabel( "fallThrough", stmt );
    381         if ( !mutStmt->stmts.empty() ) {
     374        CaseStmt * mutStmt = mutate( stmt );
     375
     376        Label fallLabel = newLabel( "fallThrough", stmt );
     377        if ( ! mutStmt->stmts.empty() ) {
    382378                // Ensure that the stack isn't corrupted by exceptions in fixBlock.
    383379                auto guard = makeFuncGuard(
    384380                        [&](){ enclosing_control_structures.emplace_back( mutStmt, fallLabel ); },
    385381                        [this](){ enclosing_control_structures.pop_back(); }
    386                 );
     382                        );
    387383
    388384                // These should already be in a block.
    389                 auto block = ast::mutate( mutStmt->stmts.front().strict_as<ast::CompoundStmt>() );
     385                auto block = mutate( mutStmt->stmts.front().strict_as<CompoundStmt>() );
    390386                block->kids = fixBlock( block->kids, true );
    391387
    392388                // Add fallthrough label if necessary.
    393                 assert( !enclosing_control_structures.empty() );
     389                assert( ! enclosing_control_structures.empty() );
    394390                Entry & entry = enclosing_control_structures.back();
    395391                if ( entry.isFallUsed() ) {
     
    398394                }
    399395        }
    400         assert( !enclosing_control_structures.empty() );
     396        assert( ! enclosing_control_structures.empty() );
    401397        Entry & entry = enclosing_control_structures.back();
    402         assertf( dynamic_cast< const ast::SwitchStmt * >( entry.stmt ),
    403                 "Control structure enclosing a case clause must be a switch, but is: %s",
    404                 toString( entry.stmt ).c_str() );
     398        assertf( dynamic_cast< const SwitchStmt * >( entry.stmt ),
     399                         "Control structure enclosing a case clause must be a switch, but is: %s",
     400                         toString( entry.stmt ).c_str() );
    405401        if ( mutStmt->isDefault() ) {
    406402                if ( entry.isFallDefaultUsed() ) {
    407403                        // Add fallthrough default label if necessary.
    408404                        push_front( mutStmt->stmts, labelledNullStmt(
    409                                 stmt->location, entry.useFallDefaultExit()
    410                         ) );
     405                                                        stmt->location, entry.useFallDefaultExit()
     406                                                        ) );
    411407                }
    412408        }
     
    414410}
    415411
    416 void MultiLevelExitCore::previsit( const ast::IfStmt * stmt ) {
     412void MultiLevelExitCore::previsit( const IfStmt * stmt ) {
    417413        bool labeledBlock = !stmt->labels.empty();
    418414        if ( labeledBlock ) {
    419                 ast::Label breakLabel = LabelGenerator::newLabel( "blockBreak", stmt );
     415                Label breakLabel = newLabel( "blockBreak", stmt );
    420416                enclosing_control_structures.emplace_back( stmt, breakLabel );
    421417                GuardAction( [this](){ enclosing_control_structures.pop_back(); } );
     
    423419}
    424420
    425 const ast::IfStmt * MultiLevelExitCore::postvisit( const ast::IfStmt * stmt ) {
     421const IfStmt * MultiLevelExitCore::postvisit( const IfStmt * stmt ) {
    426422        bool labeledBlock = !stmt->labels.empty();
    427423        if ( labeledBlock ) {
     
    434430}
    435431
    436 bool isDefaultCase( const ast::ptr<ast::Stmt> & stmt ) {
    437         const ast::CaseStmt * caseStmt = stmt.strict_as<ast::CaseStmt>();
     432bool isDefaultCase( const ptr<Stmt> & stmt ) {
     433        const CaseStmt * caseStmt = stmt.strict_as<CaseStmt>();
    438434        return caseStmt->isDefault();
    439435}
    440436
    441 void MultiLevelExitCore::previsit( const ast::SwitchStmt * stmt ) {
    442         ast::Label label = LabelGenerator::newLabel( "switchBreak", stmt );
    443         auto it = std::find_if( stmt->stmts.rbegin(), stmt->stmts.rend(), isDefaultCase );
    444 
    445         const ast::CaseStmt * defaultCase = it != stmt->stmts.rend()
    446                 ? (it)->strict_as<ast::CaseStmt>() : nullptr;
    447         ast::Label defaultLabel = defaultCase
    448                 ? LabelGenerator::newLabel( "fallThroughDefault", defaultCase )
    449                 : ast::Label( stmt->location, "" );
     437void MultiLevelExitCore::previsit( const SwitchStmt * stmt ) {
     438        Label label = newLabel( "switchBreak", stmt );
     439        auto it = find_if( stmt->stmts.rbegin(), stmt->stmts.rend(), isDefaultCase );
     440
     441        const CaseStmt * defaultCase = it != stmt->stmts.rend()
     442                ? (it)->strict_as<CaseStmt>() : nullptr;
     443        Label defaultLabel = defaultCase
     444                ? newLabel( "fallThroughDefault", defaultCase )
     445                : Label( stmt->location, "" );
    450446        enclosing_control_structures.emplace_back( stmt, label, defaultLabel );
    451447        GuardAction( [this]() { enclosing_control_structures.pop_back(); } );
    452448
    453449        // Collect valid labels for fallthrough. It starts with all labels at
    454         // this level, then removed as we see them in traversal.
    455         for ( const ast::Stmt * stmt : stmt->stmts ) {
    456                 auto * caseStmt = strict_dynamic_cast< const ast::CaseStmt * >( stmt );
     450        // this level, then remove as each is seen during traversal.
     451        for ( const Stmt * stmt : stmt->stmts ) {
     452                auto * caseStmt = strict_dynamic_cast< const CaseStmt * >( stmt );
    457453                if ( caseStmt->stmts.empty() ) continue;
    458                 auto block = caseStmt->stmts.front().strict_as<ast::CompoundStmt>();
    459                 for ( const ast::Stmt * stmt : block->kids ) {
    460                         for ( const ast::Label & l : stmt->labels ) {
     454                auto block = caseStmt->stmts.front().strict_as<CompoundStmt>();
     455                for ( const Stmt * stmt : block->kids ) {
     456                        for ( const Label & l : stmt->labels ) {
    461457                                fallthrough_labels.insert( l );
    462458                        }
     
    465461}
    466462
    467 const ast::SwitchStmt * MultiLevelExitCore::postvisit( const ast::SwitchStmt * stmt ) {
     463const SwitchStmt * MultiLevelExitCore::postvisit( const SwitchStmt * stmt ) {
    468464        assert( !enclosing_control_structures.empty() );
    469465        Entry & entry = enclosing_control_structures.back();
    470466        assert( entry.stmt == stmt );
    471467
    472         // Only run if we need to generate the break label.
     468        // Only run to generate the break label.
    473469        if ( entry.isBreakUsed() ) {
    474470                // To keep the switch statements uniform (all direct children of a
    475471                // SwitchStmt should be CastStmts), append the exit label and break
    476472                // to the last case, create a default case is there are no cases.
    477                 ast::SwitchStmt * mutStmt = ast::mutate( stmt );
     473                SwitchStmt * mutStmt = mutate( stmt );
    478474                if ( mutStmt->stmts.empty() ) {
    479                         mutStmt->stmts.push_back( new ast::CaseStmt(
    480                                 mutStmt->location, nullptr, {} ));
    481                 }
    482 
    483                 auto caseStmt = mutStmt->stmts.back().strict_as<ast::CaseStmt>();
    484                 auto mutCase = ast::mutate( caseStmt );
     475                        mutStmt->stmts.push_back( new CaseStmt(
     476                                                                                  mutStmt->location, nullptr, {} ));
     477                }
     478
     479                auto caseStmt = mutStmt->stmts.back().strict_as<CaseStmt>();
     480                auto mutCase = mutate( caseStmt );
    485481                mutStmt->stmts.back() = mutCase;
    486482
    487                 ast::Label label( mutCase->location, "breakLabel" );
    488                 auto branch = new ast::BranchStmt( mutCase->location, ast::BranchStmt::Break, label );
     483                Label label( mutCase->location, "breakLabel" );
     484                auto branch = new BranchStmt( mutCase->location, BranchStmt::Break, label );
    489485                branch->labels.push_back( entry.useBreakExit() );
    490486                mutCase->stmts.push_back( branch );
     
    495491}
    496492
    497 void MultiLevelExitCore::previsit( const ast::ReturnStmt * stmt ) {
     493void MultiLevelExitCore::previsit( const ReturnStmt * stmt ) {
    498494        if ( inFinally ) {
    499495                SemanticError( stmt->location, "'return' may not appear in a finally clause" );
     
    501497}
    502498
    503 void MultiLevelExitCore::previsit( const ast::TryStmt * stmt ) {
     499void MultiLevelExitCore::previsit( const TryStmt * stmt ) {
    504500        bool isLabeled = !stmt->labels.empty();
    505501        if ( isLabeled ) {
    506                 ast::Label breakLabel = LabelGenerator::newLabel( "blockBreak", stmt );
     502                Label breakLabel = newLabel( "blockBreak", stmt );
    507503                enclosing_control_structures.emplace_back( stmt, breakLabel );
    508504                GuardAction([this](){ enclosing_control_structures.pop_back(); } );
     
    510506}
    511507
    512 void MultiLevelExitCore::postvisit( const ast::TryStmt * stmt ) {
     508void MultiLevelExitCore::postvisit( const TryStmt * stmt ) {
    513509        bool isLabeled = !stmt->labels.empty();
    514510        if ( isLabeled ) {
     
    520516}
    521517
    522 void MultiLevelExitCore::previsit( const ast::FinallyStmt * ) {
    523         GuardAction([this, old = std::move(enclosing_control_structures)](){
    524                 enclosing_control_structures = std::move(old);
    525         });
    526         enclosing_control_structures = std::vector<Entry>();
     518void MultiLevelExitCore::previsit( const FinallyStmt * ) {
     519        GuardAction([this, old = move(enclosing_control_structures)](){
     520                                        enclosing_control_structures = move(old);
     521                                });
     522        enclosing_control_structures = vector<Entry>();
    527523        GuardValue( inFinally ) = true;
    528524}
    529525
    530 const ast::Stmt * MultiLevelExitCore::mutateLoop(
    531                 const ast::Stmt * body, Entry & entry ) {
     526const Stmt * MultiLevelExitCore::mutateLoop(
     527        const Stmt * body, Entry & entry ) {
    532528        if ( entry.isBreakUsed() ) {
    533529                break_label = entry.useBreakExit();
     
    535531
    536532        if ( entry.isContUsed() ) {
    537                 ast::CompoundStmt * new_body = new ast::CompoundStmt( body->location );
     533                CompoundStmt * new_body = new CompoundStmt( body->location );
    538534                new_body->kids.push_back( body );
    539535                new_body->kids.push_back(
     
    549545        // Remember is loop before going onto mutate the body.
    550546        // The labels will be folded in if they are used.
    551         ast::Label breakLabel = LabelGenerator::newLabel( "loopBreak", loopStmt );
    552         ast::Label contLabel = LabelGenerator::newLabel( "loopContinue", loopStmt );
     547        Label breakLabel = newLabel( "loopBreak", loopStmt );
     548        Label contLabel = newLabel( "loopContinue", loopStmt );
    553549        enclosing_control_structures.emplace_back( loopStmt, breakLabel, contLabel );
    554550        GuardAction( [this](){ enclosing_control_structures.pop_back(); } );
     
    561557        assert( entry.stmt == loopStmt );
    562558
    563         // Now we check if the labels are used and add them if so.
    564         return ast::mutate_field(
     559        // Now check if the labels are used and add them if so.
     560        return mutate_field(
    565561                loopStmt, &LoopNode::body, mutateLoop( loopStmt->body, entry ) );
    566562}
    567563
    568 std::list<ast::ptr<ast::Stmt>> MultiLevelExitCore::fixBlock(
    569                 const std::list<ast::ptr<ast::Stmt>> & kids, bool is_case_clause ) {
    570         // Unfortunately we can't use the automatic error collection.
     564list<ptr<Stmt>> MultiLevelExitCore::fixBlock(
     565        const list<ptr<Stmt>> & kids, bool is_case_clause ) {
     566        // Unfortunately cannot use automatic error collection.
    571567        SemanticErrorException errors;
    572568
    573         std::list<ast::ptr<ast::Stmt>> ret;
     569        list<ptr<Stmt>> ret;
    574570
    575571        // Manually visit each child.
    576         for ( const ast::ptr<ast::Stmt> & kid : kids ) {
     572        for ( const ptr<Stmt> & kid : kids ) {
    577573                if ( is_case_clause ) {
    578574                        // Once a label is seen, it's no longer a valid for fallthrough.
    579                         for ( const ast::Label & l : kid->labels ) {
     575                        for ( const Label & l : kid->labels ) {
    580576                                fallthrough_labels.erase( l );
    581577                        }
     
    591587                        ret.push_back(
    592588                                labelledNullStmt( ret.back()->location, break_label ) );
    593                         break_label = ast::Label( CodeLocation(), "" );
     589                        break_label = Label( CodeLocation(), "" );
    594590                }
    595591        }
     
    601597}
    602598
    603 } // namespace
    604 
    605 const ast::CompoundStmt * multiLevelExitUpdate(
    606         const ast::CompoundStmt * stmt,
    607                 const LabelToStmt & labelTable ) {
     599const CompoundStmt * multiLevelExitUpdate(
     600        const CompoundStmt * stmt,
     601        const LabelToStmt & labelTable ) {
    608602        // Must start in the body, so FunctionDecls can be a stopping point.
    609         ast::Pass<MultiLevelExitCore> visitor( labelTable );
    610         const ast::CompoundStmt * ret = stmt->accept( visitor );
     603        Pass<MultiLevelExitCore> visitor( labelTable );
     604        const CompoundStmt * ret = stmt->accept( visitor );
    611605        return ret;
    612606}
    613 
    614607} // namespace ControlStruct
    615608
  • src/ControlStruct/MultiLevelExit.hpp

    rf681823 r376c632a  
    99// Author           : Andrew Beach
    1010// Created On       : Mon Nov  1 13:49:00 2021
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Mon Nov  8 10:53:00 2021
    13 // Update Count     : 3
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Mon Jan 31 22:34:06 2022
     13// Update Count     : 6
    1414//
    1515
     
    1919
    2020namespace ast {
    21         class CompoundStmt;
    22         class Label;
    23         class Stmt;
     21class CompoundStmt;
     22class Label;
     23class Stmt;
    2424}
    2525
    2626namespace ControlStruct {
    27 
    2827using LabelToStmt = std::map<ast::Label, const ast::Stmt *>;
    2928
    30 /// Mutate a function body to handle multi-level exits.
    31 const ast::CompoundStmt * multiLevelExitUpdate(
    32         const ast::CompoundStmt *, const LabelToStmt & );
    33 
     29// Mutate a function body to handle multi-level exits.
     30const ast::CompoundStmt * multiLevelExitUpdate( const ast::CompoundStmt *, const LabelToStmt & );
    3431}
    3532
  • src/ControlStruct/module.mk

    rf681823 r376c632a  
    1010## Author           : Richard C. Bilson
    1111## Created On       : Mon Jun  1 17:49:17 2015
    12 ## Last Modified By : Henry Xue
    13 ## Last Modified On : Tue Jul 20 04:10:50 2021
    14 ## Update Count     : 5
     12## Last Modified By : Peter A. Buhr
     13## Last Modified On : Sat Jan 29 12:04:19 2022
     14## Update Count     : 7
    1515###############################################################################
    1616
     
    2222        ControlStruct/ForExprMutator.cc \
    2323        ControlStruct/ForExprMutator.h \
     24        ControlStruct/HoistControlDecls.cpp \
     25        ControlStruct/HoistControlDecls.hpp \
    2426        ControlStruct/LabelFixer.cc \
    2527        ControlStruct/LabelFixer.h \
    2628        ControlStruct/LabelGenerator.cc \
    2729        ControlStruct/LabelGenerator.h \
     30        ControlStruct/LabelGeneratorNew.cpp \
     31        ControlStruct/LabelGeneratorNew.hpp \
    2832        ControlStruct/MLEMutator.cc \
    2933        ControlStruct/MLEMutator.h \
  • src/InitTweak/InitTweak.cc

    rf681823 r376c632a  
    1010// Created On       : Fri May 13 11:26:36 2016
    1111// Last Modified By : Andrew Beach
    12 // Last Modified On : Fri Nov 19 19:22:00 2021
    13 // Update Count     : 19
     12// Last Modified On : Mon Dec  6 13:21:00 2021
     13// Update Count     : 20
    1414//
    1515
     
    11911191        }
    11921192
    1193         bool isCopyFunction( const ast::FunctionDecl * decl ) {
    1194                 const ast::FunctionType * ftype = decl->type;
    1195                 if ( ftype->params.size() != 2 ) return false;
    1196 
    1197                 const ast::Type * t1 = getPointerBase( ftype->params.front() );
    1198                 if ( ! t1 ) return false;
    1199                 const ast::Type * t2 = ftype->params.back();
    1200 
    1201                 return ResolvExpr::typesCompatibleIgnoreQualifiers( t1, t2, ast::SymbolTable{} );
    1202         }
     1193bool isAssignment( const ast::FunctionDecl * decl ) {
     1194        return isAssignment( decl->name ) && isCopyFunction( decl );
     1195}
     1196
     1197bool isDestructor( const ast::FunctionDecl * decl ) {
     1198        return isDestructor( decl->name );
     1199}
     1200
     1201bool isDefaultConstructor( const ast::FunctionDecl * decl ) {
     1202        return isConstructor( decl->name ) && 1 == decl->params.size();
     1203}
     1204
     1205bool isCopyConstructor( const ast::FunctionDecl * decl ) {
     1206        return isConstructor( decl->name ) && 2 == decl->params.size();
     1207}
     1208
     1209bool isCopyFunction( const ast::FunctionDecl * decl ) {
     1210        const ast::FunctionType * ftype = decl->type;
     1211        if ( ftype->params.size() != 2 ) return false;
     1212
     1213        const ast::Type * t1 = getPointerBase( ftype->params.front() );
     1214        if ( ! t1 ) return false;
     1215        const ast::Type * t2 = ftype->params.back();
     1216
     1217        return ResolvExpr::typesCompatibleIgnoreQualifiers( t1, t2, ast::SymbolTable{} );
     1218}
    12031219
    12041220        const FunctionDecl * isAssignment( const Declaration * decl ) {
  • src/InitTweak/InitTweak.h

    rf681823 r376c632a  
    1010// Created On       : Fri May 13 11:26:36 2016
    1111// Last Modified By : Andrew Beach
    12 // Last Modified On : Fri Nov 19 14:18:00 2021
    13 // Update Count     : 7
     12// Last Modified On : Mon Dec  6 13:20:00 2021
     13// Update Count     : 8
    1414//
    1515
     
    3131        const FunctionDecl * isCopyConstructor( const Declaration * decl );
    3232        const FunctionDecl * isCopyFunction( const Declaration * decl, const std::string & fname );
     33        bool isAssignment( const ast::FunctionDecl * decl );
     34        bool isDestructor( const ast::FunctionDecl * decl );
     35        bool isDefaultConstructor( const ast::FunctionDecl * decl );
     36        bool isCopyConstructor( const ast::FunctionDecl * decl );
    3337        bool isCopyFunction( const ast::FunctionDecl * decl );
    3438
  • src/Parser/ParseNode.h

    rf681823 r376c632a  
    1010// Created On       : Sat May 16 13:28:16 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Jul 14 17:28:53 2021
    13 // Update Count     : 900
     12// Last Modified On : Sat Jan 29 09:45:56 2022
     13// Update Count     : 901
    1414//
    1515
     
    390390Statement * build_expr( ExpressionNode * ctl );
    391391
    392 struct IfCtrl {
    393         IfCtrl( DeclarationNode * decl, ExpressionNode * condition ) :
     392struct CondCtl {
     393        CondCtl( DeclarationNode * decl, ExpressionNode * condition ) :
    394394                init( decl ? new StatementNode( decl ) : nullptr ), condition( condition ) {}
    395395
     
    409409};
    410410
    411 Expression * build_if_control( IfCtrl * ctl, std::list< Statement * > & init );
    412 Statement * build_if( IfCtrl * ctl, StatementNode * then_stmt, StatementNode * else_stmt );
     411Expression * build_if_control( CondCtl * ctl, std::list< Statement * > & init );
     412Statement * build_if( CondCtl * ctl, StatementNode * then_stmt, StatementNode * else_stmt );
    413413Statement * build_switch( bool isSwitch, ExpressionNode * ctl, StatementNode * stmt );
    414414Statement * build_case( ExpressionNode * ctl );
    415415Statement * build_default();
    416 Statement * build_while( IfCtrl * ctl, StatementNode * stmt );
     416Statement * build_while( CondCtl * ctl, StatementNode * stmt );
    417417Statement * build_do_while( ExpressionNode * ctl, StatementNode * stmt );
    418418Statement * build_for( ForCtrl * forctl, StatementNode * stmt );
  • src/Parser/StatementNode.cc

    rf681823 r376c632a  
    1010// Created On       : Sat May 16 14:59:41 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Oct 24 04:20:55 2020
    13 // Update Count     : 383
     12// Last Modified On : Sat Jan 29 09:45:51 2022
     13// Update Count     : 384
    1414//
    1515
     
    7878} // build_expr
    7979
    80 Expression * build_if_control( IfCtrl * ctl, std::list< Statement * > & init ) {
     80Expression * build_if_control( CondCtl * ctl, std::list< Statement * > & init ) {
    8181        if ( ctl->init != 0 ) {
    8282                buildMoveList( ctl->init, init );
     
    100100} // build_if_control
    101101
    102 Statement * build_if( IfCtrl * ctl, StatementNode * then_stmt, StatementNode * else_stmt ) {
     102Statement * build_if( CondCtl * ctl, StatementNode * then_stmt, StatementNode * else_stmt ) {
    103103        Statement * thenb, * elseb = nullptr;
    104104        std::list< Statement * > branches;
     
    145145} // build_default
    146146
    147 Statement * build_while( IfCtrl * ctl, StatementNode * stmt ) {
     147Statement * build_while( CondCtl * ctl, StatementNode * stmt ) {
    148148        std::list< Statement * > branches;
    149149        buildMoveList< Statement, StatementNode >( stmt, branches );
  • src/Parser/parser.yy

    rf681823 r376c632a  
    1010// Created On       : Sat Sep  1 20:22:55 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Oct 15 09:20:17 2021
    13 // Update Count     : 5163
     12// Last Modified On : Sun Jan 30 09:41:13 2022
     13// Update Count     : 5165
    1414//
    1515
     
    238238        WaitForStmt * wfs;
    239239        Expression * constant;
    240         IfCtrl * ifctl;
     240        CondCtl * ifctl;
    241241        ForCtrl * fctl;
    242242        enum OperKinds compop;
     
    327327%type<en> comma_expression                              comma_expression_opt
    328328%type<en> argument_expression_list_opt  argument_expression_list        argument_expression                     default_initializer_opt
    329 %type<ifctl> if_control_expression
     329%type<ifctl> conditional_declaration
    330330%type<fctl> for_control_expression              for_control_expression_list
    331331%type<compop> inclexcl
     
    11231123
    11241124if_statement:
    1125         IF '(' if_control_expression ')' statement                      %prec THEN
     1125        IF '(' conditional_declaration ')' statement            %prec THEN
    11261126                // explicitly deal with the shift/reduce conflict on if/else
    11271127                { $$ = new StatementNode( build_if( $3, maybe_build_compound( $5 ), nullptr ) ); }
    1128         | IF '(' if_control_expression ')' statement ELSE statement
     1128        | IF '(' conditional_declaration ')' statement ELSE statement
    11291129                { $$ = new StatementNode( build_if( $3, maybe_build_compound( $5 ), maybe_build_compound( $7 ) ) ); }
    11301130        ;
    11311131
    1132 if_control_expression:
     1132conditional_declaration:
    11331133        comma_expression
    1134                 { $$ = new IfCtrl( nullptr, $1 ); }
     1134                { $$ = new CondCtl( nullptr, $1 ); }
    11351135        | c_declaration                                                                         // no semi-colon
    1136                 { $$ = new IfCtrl( $1, nullptr ); }
     1136                { $$ = new CondCtl( $1, nullptr ); }
    11371137        | cfa_declaration                                                                       // no semi-colon
    1138                 { $$ = new IfCtrl( $1, nullptr ); }
     1138                { $$ = new CondCtl( $1, nullptr ); }
    11391139        | declaration comma_expression                                          // semi-colon separated
    1140                 { $$ = new IfCtrl( $1, $2 ); }
     1140                { $$ = new CondCtl( $1, $2 ); }
    11411141        ;
    11421142
     
    11931193iteration_statement:
    11941194        WHILE '(' ')' statement                                                         // CFA => while ( 1 )
    1195                 { $$ = new StatementNode( build_while( new IfCtrl( nullptr, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ), maybe_build_compound( $4 ) ) ); }
    1196         | WHILE '(' if_control_expression ')' statement         %prec THEN
     1195                { $$ = new StatementNode( build_while( new CondCtl( nullptr, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ), maybe_build_compound( $4 ) ) ); }
     1196        | WHILE '(' conditional_declaration ')' statement       %prec THEN
    11971197                { $$ = new StatementNode( build_while( $3, maybe_build_compound( $5 ) ) ); }
    1198         | WHILE '(' if_control_expression ')' statement ELSE statement // CFA
     1198        | WHILE '(' conditional_declaration ')' statement ELSE statement // CFA
    11991199                { SemanticError( yylloc, "Loop default block is currently unimplemented." ); $$ = nullptr; }
    12001200        | DO statement WHILE '(' ')' ';'                                        // CFA => do while( 1 )
  • src/SymTab/Validate.cc

    rf681823 r376c632a  
    453453        }
    454454
     455        void decayForallPointers( std::list< Declaration * > & translationUnit ) {
     456                PassVisitor<ForallPointerDecay_old> fpd;
     457                acceptAll( translationUnit, fpd );
     458        }
     459
    455460        void validate( std::list< Declaration * > &translationUnit, __attribute__((unused)) bool doDebug ) {
    456461                validate_A( translationUnit );
     
    470475                type->accept( fpd );
    471476        }
    472 
    473477
    474478        void HoistTypeDecls::handleType( Type * type ) {
  • src/SymTab/Validate.h

    rf681823 r376c632a  
    4242        void validate_E( std::list< Declaration * > &translationUnit );
    4343        void validate_F( std::list< Declaration * > &translationUnit );
     44        void decayForallPointers( std::list< Declaration * > & translationUnit );
    4445
    4546        const ast::Type * validateType(
  • src/Validate/module.mk

    rf681823 r376c632a  
    1616
    1717SRC_VALIDATE = \
     18        Validate/Autogen.cpp \
     19        Validate/Autogen.hpp \
    1820        Validate/CompoundLiteral.cpp \
    1921        Validate/CompoundLiteral.hpp \
  • src/main.cc

    rf681823 r376c632a  
    1010// Created On       : Fri May 15 23:12:02 2015
    1111// Last Modified By : Andrew Beach
    12 // Last Modified On : Tue Nov 30 10:25:00 2021
    13 // Update Count     : 659
     12// Last Modified On : Wed Jan 26 14:09:00 2022
     13// Update Count     : 670
    1414//
    1515
     
    5555#include "ControlStruct/ExceptTranslate.h"  // for translateEHM
    5656#include "ControlStruct/FixLabels.hpp"      // for fixLabels
     57#include "ControlStruct/HoistControlDecls.hpp" //  hoistControlDecls
    5758#include "ControlStruct/Mutate.h"           // for mutate
    5859#include "GenPoly/Box.h"                    // for box
     
    7374#include "SynTree/Visitor.h"                // for acceptAll
    7475#include "Tuples/Tuples.h"                  // for expandMemberTuples, expan...
     76#include "Validate/Autogen.hpp"             // for autogenerateRoutines
    7577#include "Validate/FindSpecialDecls.h"      // for findGlobalDecls
    7678#include "Validate/CompoundLiteral.hpp"     // for handleCompoundLiterals
     
    7880#include "Validate/LabelAddressFixer.hpp"   // for fixLabelAddresses
    7981#include "Virtual/ExpandCasts.h"            // for expandCasts
    80 
    8182
    8283static void NewPass( const char * const name ) {
     
    326327                PASS( "Validate-B", SymTab::validate_B( translationUnit ) );
    327328                PASS( "Validate-C", SymTab::validate_C( translationUnit ) );
    328                 PASS( "Validate-D", SymTab::validate_D( translationUnit ) );
    329329
    330330                CodeTools::fillLocations( translationUnit );
    331331
    332332                if( useNewAST ) {
     333                        PASS( "Apply Concurrent Keywords", Concurrency::applyKeywords( translationUnit ) );
     334                        PASS( "Forall Pointer Decay", SymTab::decayForallPointers( translationUnit ) );
     335                        CodeTools::fillLocations( translationUnit );
     336
    333337                        if (Stats::Counters::enabled) {
    334338                                ast::pass_visitor_stats.avg = Stats::Counters::build<Stats::Counters::AverageCounter<double>>("Average Depth - New");
     
    338342
    339343                        forceFillCodeLocations( transUnit );
     344
     345                        // Must happen before autogen routines are added.
     346                        PASS( "Hoist Control Declarations", ControlStruct::hoistControlDecls( transUnit ) );
     347
     348                        // Must be after enum and pointer decay.
     349                        // Must be before compound literals.
     350                        PASS( "Generate Autogen Routines", Validate::autogenerateRoutines( transUnit ) );
    340351
    341352                        PASS( "Implement Mutex", Concurrency::implementMutex( transUnit ) );
     
    406417                        translationUnit = convert( move( transUnit ) );
    407418                } else {
     419                        PASS( "Validate-D", SymTab::validate_D( translationUnit ) );
    408420                        PASS( "Validate-E", SymTab::validate_E( translationUnit ) );
    409421                        PASS( "Validate-F", SymTab::validate_F( translationUnit ) );
  • tests/concurrent/preempt.cfa

    rf681823 r376c632a  
     1#include <clock.hfa>
    12#include <fstream.hfa>
    23#include <kernel.hfa>
     
    1819#else
    1920static const unsigned long N = 500ul;
     21static volatile Time prev;
     22static Duration preempt_durations[6] = { 0 };
    2023#endif
    2124
     
    2629thread worker_t {
    2730        int value;
    28         unsigned spin;
     31        unsigned long long spin;
    2932};
    3033
     
    3639void main(worker_t & this) {
    3740        while(TEST(counter < N)) {
    38                 if(this.spin > 100_000_000) abort | "Worker" | this.value | "has been spinning too long! (" | this.spin | ")";
     41                if(this.spin > 50_000_000_000) abort | "Worker" | this.value | "has been spinning too long! (" | this.spin | ")";
    3942                __cfaabi_check_preemption();
    4043                if( (counter % 7) == this.value ) {
    4144                        __cfaabi_check_preemption();
     45                        #if !defined(TEST_LONG)
     46                                Time now = timeHiRes();
     47                                Duration diff = now - prev;
     48                                prev = now;
     49                        #endif
    4250                        int next = __atomic_add_fetch( &counter, 1, __ATOMIC_SEQ_CST );
    4351                        __cfaabi_check_preemption();
    44                         if( (next % 100) == 0 ) printf("%d\n", (int)next);
     52                        if( (next % 100) == 0 ) {
     53                                #if !defined(TEST_LONG)
     54                                        unsigned idx = next / 100;
     55                                        if (idx >= 6) abort | "Idx from next is invalid: " | idx | "vs" | next;
     56                                        preempt_durations[idx] = diff;
     57                                        if(diff > 12`s) serr | "Duration suspiciously large:" | diff;
     58                                #endif
     59                                printf("%d\n", (int)next);
     60
     61                        }
    4562                        __cfaabi_check_preemption();
    4663                        this.spin = 0;
     
    5572        processor p;
    5673        {
     74                prev = timeHiRes();
    5775                worker_t w0 = 0;
    5876                worker_t w1 = 1;
Note: See TracChangeset for help on using the changeset viewer.