source: src/ControlStruct/MultiLevelExit.cpp @ 3e5db5b4

ADTast-experimentalenumforall-pointer-decaypthread-emulationqualifiedEnum
Last change on this file since 3e5db5b4 was 3e5db5b4, checked in by caparsons <caparson@…>, 2 years ago

added comments to loop portion of pass

  • Property mode set to 100644
File size: 22.1 KB
Line 
1//
2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
3//
4// The contents of this file are covered under the licence agreement in the
5// file "LICENCE" distributed with Cforall.
6//
7// MultiLevelExit.cpp -- Replaces CFA's local control flow with C's versions.
8//
9// Author           : Andrew Beach
10// 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
14//
15
16#include "MultiLevelExit.hpp"
17
18#include "AST/Pass.hpp"
19#include "AST/Stmt.hpp"
20#include "ControlStruct/LabelGenerator.h"
21
22#include <set>
23
24namespace ControlStruct {
25
26namespace {
27
28class Entry {
29public:
30        const ast::Stmt * stmt;
31private:
32        // Organized like a manual ADT. Avoids creating a bunch of dead data.
33        struct Target {
34                ast::Label label;
35                bool used = false;
36                Target( const ast::Label & label ) : label( label ) {}
37                Target() : label( CodeLocation() ) {}
38        };
39        Target firstTarget;
40        Target secondTarget;
41
42        enum Kind {
43                ForStmt, WhileStmt, CompoundStmt, IfStmt, CaseStmt, SwitchStmt, TryStmt
44        } kind;
45
46        bool fallDefaultValid = true;
47
48        static ast::Label & useTarget( Target & target ) {
49                target.used = true;
50                return target.label;
51        }
52
53public:
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        // These routines set a target as being "used" by a BranchStmt
75        ast::Label useContExit() { assert( kind <= WhileStmt ); return useTarget(secondTarget); }
76        ast::Label useBreakExit() { assert( CaseStmt != kind ); return useTarget(firstTarget); }
77        ast::Label useFallExit() { assert( CaseStmt == kind );  return useTarget(firstTarget); }
78        ast::Label useFallDefaultExit() { assert( SwitchStmt == kind ); return useTarget(secondTarget); }
79
80        // These routines check if a specific label for a statement is used by a BranchStmt
81        bool isContUsed() const { assert( kind <= WhileStmt ); return secondTarget.used; }
82        bool isBreakUsed() const { assert( CaseStmt != kind ); return firstTarget.used; }
83        bool isFallUsed() const { assert( CaseStmt == kind ); return firstTarget.used; }
84        bool isFallDefaultUsed() const { assert( SwitchStmt == kind ); return secondTarget.used; }
85        void seenDefault() { fallDefaultValid = false; }
86        bool isFallDefaultValid() const { return fallDefaultValid; }
87};
88
89// Helper predicates used in std::find_if calls (it doesn't take methods):
90bool isBreakTarget( const Entry & entry ) {
91        return entry.isBreakTarget();
92}
93
94bool isContinueTarget( const Entry & entry ) {
95        return entry.isContTarget();
96}
97
98bool isFallthroughTarget( const Entry & entry ) {
99        return entry.isFallTarget();
100}
101
102bool isFallthroughDefaultTarget( const Entry & entry ) {
103        return entry.isFallDefaultTarget();
104}
105
106struct MultiLevelExitCore final :
107                public ast::WithVisitorRef<MultiLevelExitCore>,
108                public ast::WithShortCircuiting, public ast::WithGuards {
109        MultiLevelExitCore( const LabelToStmt & lt );
110
111        void previsit( const ast::FunctionDecl * );
112
113        const ast::CompoundStmt * previsit( const ast::CompoundStmt * );
114        const ast::BranchStmt * postvisit( const ast::BranchStmt * );
115        void previsit( const ast::WhileStmt * );
116        const ast::WhileStmt * postvisit( const ast::WhileStmt * );
117        void previsit( const ast::ForStmt * );
118        const ast::ForStmt * postvisit( const ast::ForStmt * );
119        const ast::CaseStmt * previsit( const ast::CaseStmt * );
120        void previsit( const ast::IfStmt * );
121        const ast::IfStmt * postvisit( const ast::IfStmt * );
122        void previsit( const ast::SwitchStmt * );
123        const ast::SwitchStmt * postvisit( const ast::SwitchStmt * );
124        void previsit( const ast::ReturnStmt * );
125        void previsit( const ast::TryStmt * );
126        void postvisit( const ast::TryStmt * );
127        void previsit( const ast::FinallyStmt * );
128
129        const ast::Stmt * mutateLoop( const ast::Stmt * body, Entry& );
130
131        const LabelToStmt & target_table;
132        std::set<ast::Label> fallthrough_labels;
133        std::vector<Entry> enclosing_control_structures;
134        ast::Label break_label;
135        bool inFinally;
136
137        template<typename LoopNode>
138        void prehandleLoopStmt( const LoopNode * loopStmt );
139        template<typename LoopNode>
140        const LoopNode * posthandleLoopStmt( const LoopNode * loopStmt );
141
142        std::list<ast::ptr<ast::Stmt>> fixBlock(
143                const std::list<ast::ptr<ast::Stmt>> & kids, bool caseClause );
144
145        template<typename UnaryPredicate>
146        auto findEnclosingControlStructure( UnaryPredicate pred ) {
147                return std::find_if( enclosing_control_structures.rbegin(),
148                        enclosing_control_structures.rend(), pred );
149        }
150};
151
152ast::NullStmt * labelledNullStmt(
153                const CodeLocation & cl, const ast::Label & label ) {
154        return new ast::NullStmt( cl, std::vector<ast::Label>{ label } );
155}
156
157MultiLevelExitCore::MultiLevelExitCore( const LabelToStmt & lt ) :
158        target_table( lt ), break_label( CodeLocation(), "" ),
159        inFinally( false )
160{}
161
162void MultiLevelExitCore::previsit( const ast::FunctionDecl * ) {
163        visit_children = false;
164}
165
166const ast::CompoundStmt * MultiLevelExitCore::previsit(
167                const ast::CompoundStmt * stmt ) {
168        visit_children = false;
169
170        // if the stmt is labelled then generate a label to check in postvisit if the label is used
171        bool isLabeled = !stmt->labels.empty();
172        if ( isLabeled ) {
173                ast::Label breakLabel = LabelGenerator::newLabel( "blockBreak", stmt );
174                enclosing_control_structures.emplace_back( stmt, breakLabel );
175                GuardAction( [this]() { enclosing_control_structures.pop_back(); } );
176        }
177
178        auto mutStmt = ast::mutate( stmt );
179        // A child statement may set the break label.
180        mutStmt->kids = std::move( fixBlock( stmt->kids, false ) );
181
182        if ( isLabeled ) {
183                assert( !enclosing_control_structures.empty() );
184                Entry & entry = enclosing_control_structures.back();
185                if ( !entry.useBreakExit().empty() ) {
186                        break_label = entry.useBreakExit();
187                }
188        }
189        return mutStmt;
190}
191
192size_t getUnusedIndex(
193                const ast::Stmt * stmt, const ast::Label & originalTarget ) {
194        const size_t size = stmt->labels.size();
195
196        // If the label is empty, we can skip adding the unused attribute:
197        if ( originalTarget.empty() ) return size;
198
199        // Search for a label that matches the originalTarget.
200        for ( size_t i = 0 ; i < size ; ++i ) {
201                const ast::Label & label = stmt->labels[i];
202                if ( label == originalTarget ) {
203                        for ( const ast::Attribute * attr : label.attributes ) {
204                                if ( attr->name == "unused" ) return size;
205                        }
206                        return i;
207                }
208        }
209        assertf( false, "Could not find label '%s' on statement %s",
210                originalTarget.name.c_str(), toString( stmt ).c_str() );
211}
212
213const ast::Stmt * addUnused(
214                const ast::Stmt * stmt, const ast::Label & originalTarget ) {
215        size_t i = getUnusedIndex( stmt, originalTarget );
216        if ( i == stmt->labels.size() ) {
217                return stmt;
218        }
219        ast::Stmt * mutStmt = ast::mutate( stmt );
220        mutStmt->labels[i].attributes.push_back( new ast::Attribute( "unused" ) );
221        return mutStmt;
222}
223
224// This routine updates targets on enclosing control structures to indicate which
225//     label is used by the BranchStmt that is passed
226const ast::BranchStmt * MultiLevelExitCore::postvisit( const ast::BranchStmt * stmt ) {
227        std::vector<Entry>::reverse_iterator targetEntry =
228                enclosing_control_structures.rend();
229
230        // Labels on different stmts require different approaches to access
231        switch ( stmt->kind ) {
232        case ast::BranchStmt::Goto:
233                return stmt;
234        case ast::BranchStmt::Continue:
235        case ast::BranchStmt::Break: {
236                bool isContinue = stmt->kind == ast::BranchStmt::Continue;
237                // Handle unlabeled break and continue.
238                if ( stmt->target.empty() ) {
239                        if ( isContinue ) {
240                                targetEntry = findEnclosingControlStructure( isContinueTarget );
241                        } else {
242                                if ( enclosing_control_structures.empty() ) {
243                                        SemanticError( stmt->location,
244                                                "'break' outside a loop, 'switch', or labelled block" );
245                                }
246                                targetEntry = findEnclosingControlStructure( isBreakTarget );
247                        }
248                // Handle labeled break and continue.
249                } else {
250                        // Lookup label in table to find attached control structure.
251                        targetEntry = findEnclosingControlStructure(
252                                [ targetStmt = target_table.at(stmt->target) ](auto entry){
253                                        return entry.stmt == targetStmt;
254                                } );
255                }
256                // Ensure that selected target is valid.
257                if ( targetEntry == enclosing_control_structures.rend() || ( isContinue && !isContinueTarget( *targetEntry ) ) ) {
258                        SemanticError(
259                                stmt->location,
260                                toString( (isContinue ? "'continue'" : "'break'"),
261                                        " target must be an enclosing ",
262                                        (isContinue ? "loop: " : "control structure: "),
263                                        stmt->originalTarget ) );
264                }
265                break;
266        }
267        // handle fallthrough in case/switch stmts
268        case ast::BranchStmt::FallThrough: {
269                targetEntry = findEnclosingControlStructure( isFallthroughTarget );
270                // Check that target is valid.
271                if ( targetEntry == enclosing_control_structures.rend() ) {
272                        SemanticError( stmt->location, "'fallthrough' must be enclosed in a 'switch' or 'choose'" );
273                }
274                if ( !stmt->target.empty() ) {
275                        // Labelled fallthrough: target must be a valid fallthough label.
276                        if ( !fallthrough_labels.count( stmt->target ) ) {
277                                SemanticError( stmt->location, toString( "'fallthrough' target must be a later case statement: ", stmt->originalTarget ) );
278                        }
279                        return new ast::BranchStmt(
280                                stmt->location, ast::BranchStmt::Goto, stmt->originalTarget );
281                }
282                break;
283        }
284        case ast::BranchStmt::FallThroughDefault: {
285                targetEntry = findEnclosingControlStructure( isFallthroughDefaultTarget );
286
287                // Check that this is in a switch or choose statement.
288                if ( targetEntry == enclosing_control_structures.rend() ) {
289                        SemanticError( stmt->location, "'fallthrough' must be enclosed in a 'switch' or 'choose'" );
290                }
291
292                // Check that the switch or choose has a default clause.
293                auto switchStmt = strict_dynamic_cast< const ast::SwitchStmt * >(
294                        targetEntry->stmt );
295                bool foundDefault = false;
296                for ( auto subStmt : switchStmt->stmts ) {
297                        const ast::CaseStmt * caseStmt = subStmt.strict_as<ast::CaseStmt>();
298                        if ( caseStmt->isDefault() ) {
299                                foundDefault = true;
300                                break;
301                        }
302                }
303                if ( !foundDefault ) {
304                        SemanticError( stmt->location, "'fallthrough default' must be enclosed in a 'switch' or 'choose' control structure with a 'default' clause" );
305                }
306                break;
307        }
308        default:
309                assert( false );
310        }
311
312        // Branch error checks: get the appropriate label name:
313        // (This label will always be replaced.)
314        ast::Label exitLabel( CodeLocation(), "" );
315        switch ( stmt->kind ) {
316        case ast::BranchStmt::Break:
317                assert( !targetEntry->useBreakExit().empty() );
318                exitLabel = targetEntry->useBreakExit();
319                break;
320        case ast::BranchStmt::Continue:
321                assert( !targetEntry->useContExit().empty() );
322                exitLabel = targetEntry->useContExit();
323                break;
324        case ast::BranchStmt::FallThrough:
325                assert( !targetEntry->useFallExit().empty() );
326                exitLabel = targetEntry->useFallExit();
327                break;
328        case ast::BranchStmt::FallThroughDefault:
329                assert( !targetEntry->useFallDefaultExit().empty() );
330                exitLabel = targetEntry->useFallDefaultExit();
331                // Check that fallthrough default comes before the default clause.
332                if ( !targetEntry->isFallDefaultValid() ) {
333                        SemanticError( stmt->location,
334                                "'fallthrough default' must precede the 'default' clause" );
335                }
336                break;
337        default:
338                assert(0);
339        }
340
341        // Add unused attribute to silence warnings.
342        targetEntry->stmt = addUnused( targetEntry->stmt, stmt->originalTarget );
343
344        // Replace this with a goto to make later passes more uniform.
345        return new ast::BranchStmt( stmt->location, ast::BranchStmt::Goto, exitLabel );
346}
347
348void MultiLevelExitCore::previsit( const ast::WhileStmt * stmt ) {
349        return prehandleLoopStmt( stmt );
350}
351
352const ast::WhileStmt * MultiLevelExitCore::postvisit( const ast::WhileStmt * stmt ) {
353        return posthandleLoopStmt( stmt );
354}
355
356void MultiLevelExitCore::previsit( const ast::ForStmt * stmt ) {
357        return prehandleLoopStmt( stmt );
358}
359
360const ast::ForStmt * MultiLevelExitCore::postvisit( const ast::ForStmt * stmt ) {
361        return posthandleLoopStmt( stmt );
362}
363
364// Mimic what the built-in push_front would do anyways. It is O(n).
365void push_front(
366                std::vector<ast::ptr<ast::Stmt>> & vec, const ast::Stmt * element ) {
367        vec.emplace_back( nullptr );
368        for ( size_t i = vec.size() - 1 ; 0 < i ; --i ) {
369                vec[ i ] = std::move( vec[ i - 1 ] );
370        }
371        vec[ 0 ] = element;
372}
373
374const ast::CaseStmt * MultiLevelExitCore::previsit( const ast::CaseStmt * stmt ) {
375        visit_children = false;
376
377        // If it is the default, mark the default as seen.
378        if ( stmt->isDefault() ) {
379                assert( !enclosing_control_structures.empty() );
380                enclosing_control_structures.back().seenDefault();
381        }
382
383        // The cond may not exist, but if it does update it now.
384        visitor->maybe_accept( stmt, &ast::CaseStmt::cond );
385
386        // Just save the mutated node for simplicity.
387        ast::CaseStmt * mutStmt = ast::mutate( stmt );
388
389        ast::Label fallLabel = LabelGenerator::newLabel( "fallThrough", stmt );
390        if ( !mutStmt->stmts.empty() ) {
391                // Ensure that the stack isn't corrupted by exceptions in fixBlock.
392                auto guard = makeFuncGuard(
393                        [&](){ enclosing_control_structures.emplace_back( mutStmt, fallLabel ); },
394                        [this](){ enclosing_control_structures.pop_back(); }
395                );
396
397                // These should already be in a block.
398                auto block = ast::mutate( mutStmt->stmts.front().strict_as<ast::CompoundStmt>() );
399                block->kids = fixBlock( block->kids, true );
400
401                // Add fallthrough label if necessary.
402                assert( !enclosing_control_structures.empty() );
403                Entry & entry = enclosing_control_structures.back();
404                if ( entry.isFallUsed() ) {
405                        mutStmt->stmts.push_back(
406                                labelledNullStmt( mutStmt->location, entry.useFallExit() ) );
407                }
408        }
409        assert( !enclosing_control_structures.empty() );
410        Entry & entry = enclosing_control_structures.back();
411        assertf( dynamic_cast< const ast::SwitchStmt * >( entry.stmt ),
412                "Control structure enclosing a case clause must be a switch, but is: %s",
413                toString( entry.stmt ).c_str() );
414        if ( mutStmt->isDefault() ) {
415                if ( entry.isFallDefaultUsed() ) {
416                        // Add fallthrough default label if necessary.
417                        push_front( mutStmt->stmts, labelledNullStmt(
418                                stmt->location, entry.useFallDefaultExit()
419                        ) );
420                }
421        }
422        return mutStmt;
423}
424
425void MultiLevelExitCore::previsit( const ast::IfStmt * stmt ) {
426        bool labeledBlock = !stmt->labels.empty();
427        if ( labeledBlock ) {
428                ast::Label breakLabel = LabelGenerator::newLabel( "blockBreak", stmt );
429                enclosing_control_structures.emplace_back( stmt, breakLabel );
430                GuardAction( [this](){ enclosing_control_structures.pop_back(); } );
431        }
432}
433
434const ast::IfStmt * MultiLevelExitCore::postvisit( const ast::IfStmt * stmt ) {
435        bool labeledBlock = !stmt->labels.empty();
436        if ( labeledBlock ) {
437                auto this_label = enclosing_control_structures.back().useBreakExit();
438                if ( !this_label.empty() ) {
439                        break_label = this_label;
440                }
441        }
442        return stmt;
443}
444
445bool isDefaultCase( const ast::ptr<ast::Stmt> & stmt ) {
446        const ast::CaseStmt * caseStmt = stmt.strict_as<ast::CaseStmt>();
447        return caseStmt->isDefault();
448}
449
450void MultiLevelExitCore::previsit( const ast::SwitchStmt * stmt ) {
451        ast::Label label = LabelGenerator::newLabel( "switchBreak", stmt );
452        auto it = std::find_if( stmt->stmts.rbegin(), stmt->stmts.rend(), isDefaultCase );
453
454        const ast::CaseStmt * defaultCase = it != stmt->stmts.rend()
455                ? (it)->strict_as<ast::CaseStmt>() : nullptr;
456        ast::Label defaultLabel = defaultCase
457                ? LabelGenerator::newLabel( "fallThroughDefault", defaultCase )
458                : ast::Label( stmt->location, "" );
459        enclosing_control_structures.emplace_back( stmt, label, defaultLabel );
460        GuardAction( [this]() { enclosing_control_structures.pop_back(); } );
461
462        // Collect valid labels for fallthrough. It starts with all labels at
463        // this level, then removed as we see them in traversal.
464        for ( const ast::Stmt * stmt : stmt->stmts ) {
465                auto * caseStmt = strict_dynamic_cast< const ast::CaseStmt * >( stmt );
466                if ( caseStmt->stmts.empty() ) continue;
467                auto block = caseStmt->stmts.front().strict_as<ast::CompoundStmt>();
468                for ( const ast::Stmt * stmt : block->kids ) {
469                        for ( const ast::Label & l : stmt->labels ) {
470                                fallthrough_labels.insert( l );
471                        }
472                }
473        }
474}
475
476const ast::SwitchStmt * MultiLevelExitCore::postvisit( const ast::SwitchStmt * stmt ) {
477        assert( !enclosing_control_structures.empty() );
478        Entry & entry = enclosing_control_structures.back();
479        assert( entry.stmt == stmt );
480
481        // Only run if we need to generate the break label.
482        if ( entry.isBreakUsed() ) {
483                // To keep the switch statements uniform (all direct children of a
484                // SwitchStmt should be CastStmts), append the exit label and break
485                // to the last case, create a default case is there are no cases.
486                ast::SwitchStmt * mutStmt = ast::mutate( stmt );
487                if ( mutStmt->stmts.empty() ) {
488                        mutStmt->stmts.push_back( new ast::CaseStmt(
489                                mutStmt->location, nullptr, {} ));
490                }
491
492                auto caseStmt = mutStmt->stmts.back().strict_as<ast::CaseStmt>();
493                auto mutCase = ast::mutate( caseStmt );
494                mutStmt->stmts.back() = mutCase;
495
496                ast::Label label( mutCase->location, "breakLabel" );
497                auto branch = new ast::BranchStmt( mutCase->location, ast::BranchStmt::Break, label );
498                branch->labels.push_back( entry.useBreakExit() );
499                mutCase->stmts.push_back( branch );
500
501                return mutStmt;
502        }
503        return stmt;
504}
505
506void MultiLevelExitCore::previsit( const ast::ReturnStmt * stmt ) {
507        if ( inFinally ) {
508                SemanticError( stmt->location, "'return' may not appear in a finally clause" );
509        }
510}
511
512void MultiLevelExitCore::previsit( const ast::TryStmt * stmt ) {
513        bool isLabeled = !stmt->labels.empty();
514        if ( isLabeled ) {
515                ast::Label breakLabel = LabelGenerator::newLabel( "blockBreak", stmt );
516                enclosing_control_structures.emplace_back( stmt, breakLabel );
517                GuardAction([this](){ enclosing_control_structures.pop_back(); } );
518        }
519}
520
521void MultiLevelExitCore::postvisit( const ast::TryStmt * stmt ) {
522        bool isLabeled = !stmt->labels.empty();
523        if ( isLabeled ) {
524                auto this_label = enclosing_control_structures.back().useBreakExit();
525                if ( !this_label.empty() ) {
526                        break_label = this_label;
527                }
528        }
529}
530
531void MultiLevelExitCore::previsit( const ast::FinallyStmt * ) {
532        GuardAction([this, old = std::move(enclosing_control_structures)](){
533                enclosing_control_structures = std::move(old);
534        });
535        enclosing_control_structures = std::vector<Entry>();
536        GuardValue( inFinally ) = true;
537}
538
539const ast::Stmt * MultiLevelExitCore::mutateLoop(
540                const ast::Stmt * body, Entry & entry ) {
541        if ( entry.isBreakUsed() ) {
542                break_label = entry.useBreakExit();
543        }
544
545        // if continue is used insert a continue label into the back of the body of the loop
546        if ( entry.isContUsed() ) {
547                ast::CompoundStmt * new_body = new ast::CompoundStmt( body->location );
548                // {}
549                new_body->kids.push_back( body );
550                // {
551                //  body
552                // }
553                new_body->kids.push_back(
554                        labelledNullStmt( body->location, entry.useContExit() ) );
555                // {
556                //  body
557                //  ContinueLabel: {}
558                // }
559                return new_body;
560        }
561
562        return body;
563}
564
565template<typename LoopNode>
566void MultiLevelExitCore::prehandleLoopStmt( const LoopNode * loopStmt ) {
567        // Remember is loop before going onto mutate the body.
568        // The labels will be folded in if they are used.
569        ast::Label breakLabel = LabelGenerator::newLabel( "loopBreak", loopStmt );
570        ast::Label contLabel = LabelGenerator::newLabel( "loopContinue", loopStmt );
571        enclosing_control_structures.emplace_back( loopStmt, breakLabel, contLabel );
572        // labels are added temporarily to see if they are used and then added permanently in postvisit if ther are used
573        // children will tag labels as being used during their traversal which occurs before postvisit
574
575        // GuardAction calls the lambda after the node is done being visited
576        GuardAction( [this](){ enclosing_control_structures.pop_back(); } );
577}
578
579template<typename LoopNode>
580const LoopNode * MultiLevelExitCore::posthandleLoopStmt( const LoopNode * loopStmt ) {
581        assert( !enclosing_control_structures.empty() );
582        Entry & entry = enclosing_control_structures.back();
583        assert( entry.stmt == loopStmt );
584
585        // Now we check if the labels are used and add them if so.
586        return ast::mutate_field(
587                loopStmt, &LoopNode::body, mutateLoop( loopStmt->body, entry ) );
588        // this call to mutate_field compares loopStmt->body and the result of mutateLoop
589        //              if they are the same the node isn't mutated, if they differ then the new mutated node is returned
590        //              the stmts will only differ if a label is used
591}
592
593std::list<ast::ptr<ast::Stmt>> MultiLevelExitCore::fixBlock(
594                const std::list<ast::ptr<ast::Stmt>> & kids, bool is_case_clause ) {
595        // Unfortunately we can't use the automatic error collection.
596        SemanticErrorException errors;
597
598        std::list<ast::ptr<ast::Stmt>> ret;
599
600        // Manually visit each child.
601        for ( const ast::ptr<ast::Stmt> & kid : kids ) {
602                if ( is_case_clause ) {
603                        // Once a label is seen, it's no longer a valid for fallthrough.
604                        for ( const ast::Label & l : kid->labels ) {
605                                fallthrough_labels.erase( l );
606                        }
607                }
608
609                try {
610                        ret.push_back( kid->accept( *visitor ) );
611                } catch ( SemanticErrorException & e ) {
612                        errors.append( e );
613                }
614
615                if ( !break_label.empty() ) {
616                        ret.push_back(
617                                labelledNullStmt( ret.back()->location, break_label ) );
618                        break_label = ast::Label( CodeLocation(), "" );
619                }
620        }
621
622        if ( !errors.isEmpty() ) {
623                throw errors;
624        }
625        return ret;
626}
627
628} // namespace
629
630const ast::CompoundStmt * multiLevelExitUpdate(
631        const ast::CompoundStmt * stmt,
632                const LabelToStmt & labelTable ) {
633        // Must start in the body, so FunctionDecls can be a stopping point.
634        ast::Pass<MultiLevelExitCore> visitor( labelTable );
635        const ast::CompoundStmt * ret = stmt->accept( visitor );
636        return ret;
637}
638
639} // namespace ControlStruct
640
641// Local Variables: //
642// tab-width: 4 //
643// mode: c++ //
644// compile-command: "make install" //
645// End: //
Note: See TracBrowser for help on using the repository browser.