Changeset 3d5701e for src/ControlStruct

Timestamp:

Feb 25, 2020, 1:17:33 PM (6 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

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

Children:

7dc2e015

Parents:

9fb8f01 (diff), dd9e1ca (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:

resolve conflict

Location:

src/ControlStruct

Files:

• ExceptTranslate.cc (modified) (2 diffs)
• LabelFixer.cc (modified) (5 diffs)
• MLEMutator.cc (modified) (12 diffs)
• MLEMutator.h (modified) (5 diffs)
• Mutate.cc (modified) (2 diffs)

src/ControlStruct/ExceptTranslate.cc

@@ -10 +10 @@
 // Created On       : Wed Jun 14 16:49:00 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Feb 13 18:15:29 2019
-// Update Count     : 11
+// Last Modified On : Fri Dec 13 23:40:15 2019
+// Update Count     : 12
 //
 
@@ -24 +24 @@
 #include "Common/SemanticError.h"     // for SemanticError
 #include "Common/utility.h"           // for CodeLocation
-#include "Parser/LinkageSpec.h"       // for Cforall
+#include "SynTree/LinkageSpec.h"      // for Cforall
 #include "SynTree/Attribute.h"        // for Attribute
 #include "SynTree/Constant.h"         // for Constant

src/ControlStruct/LabelFixer.cc

@@ -9 +9 @@
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Mar 11 22:26:02 2019
-// Update Count     : 159
+// Last Modified By : Andrew Beach
+// Last Modified On : Tue Jan 21 10:32:00 2020
+// Update Count     : 160
 //
 
@@ -21 +21 @@
 #include "ControlStruct/LabelGenerator.h"  // for LabelGenerator
 #include "LabelFixer.h"
-#include "MLEMutator.h"                    // for MLEMutator
+#include "MLEMutator.h"                    // for MultiLevelExitMutator
 #include "SynTree/Declaration.h"           // for FunctionDecl
 #include "SynTree/Expression.h"            // for NameExpr, Expression, Unty...
@@ -44 +44 @@
 
         void LabelFixer::postvisit( FunctionDecl * functionDecl ) {
-                PassVisitor<MLEMutator> mlemut( resolveJumps(), generator );
-                functionDecl->acceptMutator( mlemut );
+                PassVisitor<MultiLevelExitMutator> mlem( resolveJumps(), generator );
+                // We start in the body so we can stop when we hit another FunctionDecl.
+                maybeMutate( functionDecl->statements, mlem );
         }
 
@@ -75 +76 @@
 
 
-        // sets the definition of the labelTable entry to be the provided statement for every label in the list
-        // parameter. Happens for every kind of statement
+        // Sets the definition of the labelTable entry to be the provided statement for every label in
+        // the list parameter. Happens for every kind of statement.
         Label LabelFixer::setLabelsDef( std::list< Label > & llabel, Statement * definition ) {
                 assert( definition != 0 );
                 assert( llabel.size() > 0 );
-
-                Entry * e = new Entry( definition );
 
                 for ( std::list< Label >::iterator i = llabel.begin(); i != llabel.end(); i++ ) {
@@ -87 +86 @@
                         l.set_statement( definition ); // attach statement to the label to be used later
                         if ( labelTable.find( l ) == labelTable.end() ) {
-                                // all labels on this statement need to use the same entry, so this should only be created once
+                                // All labels on this statement need to use the same entry,
+                                // so this should only be created once.
                                 // undefined and unused until now, add an entry
-                                labelTable[ l ] =  e;
+                                labelTable[ l ] = new Entry( definition );
                         } else if ( labelTable[ l ]->defined() ) {
                                 // defined twice, error
-                                SemanticError( l.get_statement()->location, "Duplicate definition of label: " + l.get_name() );
-                        }       else {
+                                SemanticError( l.get_statement()->location,
+                                        "Duplicate definition of label: " + l.get_name() );
+                        } else {
                                 // used previously, but undefined until now -> link with this entry
+                                // Question: Is changing objects important?
                                 delete labelTable[ l ];
-                                labelTable[ l ] = e;
+                                labelTable[ l ] = new Entry( definition );
                         } // if
                 } // for
 
-                // produce one of the labels attached to this statement to be temporarily used as the canonical label
+                // Produce one of the labels attached to this statement to be temporarily used as the
+                // canonical label.
                 return labelTable[ llabel.front() ]->get_label();
         }

src/ControlStruct/MLEMutator.cc

@@ -9 +9 @@
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Mar  8 17:08:25 2018
-// Update Count     : 219
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed Jan 22 11:50:00 2020
+// Update Count     : 223
 //
 
@@ -33 +33 @@
 
 namespace ControlStruct {
-        MLEMutator::~MLEMutator() {
+        MultiLevelExitMutator::~MultiLevelExitMutator() {
                 delete targetTable;
                 targetTable = 0;
         }
         namespace {
-                bool isLoop( const MLEMutator::Entry & e ) { return dynamic_cast< WhileStmt * >( e.get_controlStructure() ) || dynamic_cast< ForStmt * >( e.get_controlStructure() ); }
-                bool isSwitch( const MLEMutator::Entry & e ) { return dynamic_cast< SwitchStmt *>( e.get_controlStructure() ); }
-
-                bool isBreakTarget( const MLEMutator::Entry & e ) { return isLoop( e ) || isSwitch( e ) || dynamic_cast< CompoundStmt *>( e.get_controlStructure() ); }
-                bool isContinueTarget( const MLEMutator::Entry & e ) { return isLoop( e ); }
-                bool isFallthroughTarget( const MLEMutator::Entry & e ) { return dynamic_cast< CaseStmt *>( e.get_controlStructure() );; }
-                bool isFallthroughDefaultTarget( const MLEMutator::Entry & e ) { return isSwitch( e ); }
+                bool isLoop( const MultiLevelExitMutator::Entry & e ) {
+                        return dynamic_cast< WhileStmt * >( e.get_controlStructure() )
+                                || dynamic_cast< ForStmt * >( e.get_controlStructure() );
+                }
+                bool isSwitch( const MultiLevelExitMutator::Entry & e ) {
+                        return dynamic_cast< SwitchStmt *>( e.get_controlStructure() );
+                }
+
+                bool isBreakTarget( const MultiLevelExitMutator::Entry & e ) {
+                        return isLoop( e ) || isSwitch( e )
+                                || dynamic_cast< CompoundStmt *>( e.get_controlStructure() );
+                }
+                bool isContinueTarget( const MultiLevelExitMutator::Entry & e ) {
+                        return isLoop( e );
+                }
+                bool isFallthroughTarget( const MultiLevelExitMutator::Entry & e ) {
+                        return dynamic_cast< CaseStmt *>( e.get_controlStructure() );
+                }
+                bool isFallthroughDefaultTarget( const MultiLevelExitMutator::Entry & e ) {
+                        return isSwitch( e );
+                }
         } // namespace
+
+        void MultiLevelExitMutator::premutate( FunctionDecl * ) {
+                visit_children = false;
+        }
 
         // break labels have to come after the statement they break out of, so mutate a statement, then if they inform us
         // through the breakLabel field tha they need a place to jump to on a break statement, add the break label to the
         // body of statements
-        void MLEMutator::fixBlock( std::list< Statement * > &kids, bool caseClause ) {
+        void MultiLevelExitMutator::fixBlock( std::list< Statement * > &kids, bool caseClause ) {
                 SemanticErrorException errors;
 
@@ -81 +99 @@
         }
 
-        void MLEMutator::premutate( CompoundStmt *cmpndStmt ) {
+        void MultiLevelExitMutator::premutate( CompoundStmt *cmpndStmt ) {
                 visit_children = false;
                 bool labeledBlock = !(cmpndStmt->labels.empty());
@@ -118 +136 @@
                         }
                 }
-                assertf( false, "Could not find label '%s' on statement %s", originalTarget.get_name().c_str(), toString( stmt ).c_str() );
-        }
-
-
-        Statement *MLEMutator::postmutate( BranchStmt *branchStmt ) throw ( SemanticErrorException ) {
+                assertf( false, "Could not find label '%s' on statement %s",
+                        originalTarget.get_name().c_str(), toString( stmt ).c_str() );
+        }
+
+
+        Statement *MultiLevelExitMutator::postmutate( BranchStmt *branchStmt )
+                        throw ( SemanticErrorException ) {
                 std::string originalTarget = branchStmt->originalTarget;
 
@@ -230 +250 @@
         }
 
-        Statement *MLEMutator::mutateLoop( Statement *bodyLoop, Entry &e ) {
+        Statement *MultiLevelExitMutator::mutateLoop( Statement *bodyLoop, Entry &e ) {
+                // only generate these when needed
+                if( !e.isContUsed() && !e.isBreakUsed() ) return bodyLoop;
+
                 // ensure loop body is a block
-                CompoundStmt *newBody;
-                if ( ! (newBody = dynamic_cast<CompoundStmt *>( bodyLoop )) ) {
-                        newBody = new CompoundStmt();
-                        newBody->get_kids().push_back( bodyLoop );
-                } // if
-
-                // only generate these when needed
+                CompoundStmt * newBody = new CompoundStmt();
+                newBody->get_kids().push_back( bodyLoop );
 
                 if ( e.isContUsed() ) {
@@ -255 +273 @@
 
         template< typename LoopClass >
-        void MLEMutator::prehandleLoopStmt( LoopClass * loopStmt ) {
+        void MultiLevelExitMutator::prehandleLoopStmt( LoopClass * loopStmt ) {
                 // remember this as the most recent enclosing loop, then mutate the body of the loop -- this will determine
                 // whether brkLabel and contLabel are used with branch statements and will recursively do the same to nested
@@ -266 +284 @@
 
         template< typename LoopClass >
-        Statement * MLEMutator::posthandleLoopStmt( LoopClass * loopStmt ) {
+        Statement * MultiLevelExitMutator::posthandleLoopStmt( LoopClass * loopStmt ) {
                 assert( ! enclosingControlStructures.empty() );
                 Entry &e = enclosingControlStructures.back();
@@ -277 +295 @@
         }
 
-        void MLEMutator::premutate( WhileStmt * whileStmt ) {
+        void MultiLevelExitMutator::premutate( WhileStmt * whileStmt ) {
                 return prehandleLoopStmt( whileStmt );
         }
 
-        void MLEMutator::premutate( ForStmt * forStmt ) {
+        void MultiLevelExitMutator::premutate( ForStmt * forStmt ) {
                 return prehandleLoopStmt( forStmt );
         }
 
-        Statement * MLEMutator::postmutate( WhileStmt * whileStmt ) {
+        Statement * MultiLevelExitMutator::postmutate( WhileStmt * whileStmt ) {
                 return posthandleLoopStmt( whileStmt );
         }
 
-        Statement * MLEMutator::postmutate( ForStmt * forStmt ) {
+        Statement * MultiLevelExitMutator::postmutate( ForStmt * forStmt ) {
                 return posthandleLoopStmt( forStmt );
         }
 
-        void MLEMutator::premutate( IfStmt * ifStmt ) {
+        void MultiLevelExitMutator::premutate( IfStmt * ifStmt ) {
                 // generate a label for breaking out of a labeled if
                 bool labeledBlock = !(ifStmt->get_labels().empty());
@@ -303 +321 @@
         }
 
-        Statement * MLEMutator::postmutate( IfStmt * ifStmt ) {
+        Statement * MultiLevelExitMutator::postmutate( IfStmt * ifStmt ) {
                 bool labeledBlock = !(ifStmt->get_labels().empty());
                 if ( labeledBlock ) {
@@ -313 +331 @@
         }
 
-        void MLEMutator::premutate( CaseStmt *caseStmt ) {
+        void MultiLevelExitMutator::premutate( TryStmt * tryStmt ) {
+                // generate a label for breaking out of a labeled if
+                bool labeledBlock = !(tryStmt->get_labels().empty());
+                if ( labeledBlock ) {
+                        Label brkLabel = generator->newLabel("blockBreak", tryStmt);
+                        enclosingControlStructures.push_back( Entry( tryStmt, brkLabel ) );
+                        GuardAction( [this]() { enclosingControlStructures.pop_back(); } );
+                } // if
+        }
+
+        Statement * MultiLevelExitMutator::postmutate( TryStmt * tryStmt ) {
+                bool labeledBlock = !(tryStmt->get_labels().empty());
+                if ( labeledBlock ) {
+                        if ( ! enclosingControlStructures.back().useBreakExit().empty() ) {
+                                set_breakLabel( enclosingControlStructures.back().useBreakExit() );
+                        } // if
+                } // if
+                return tryStmt;
+        }
+
+        void MultiLevelExitMutator::premutate( FinallyStmt * ) {
+                GuardAction([this, old = std::move(enclosingControlStructures)]() {
+                        enclosingControlStructures = std::move(old);
+                });
+                enclosingControlStructures = std::list<Entry>();
+                GuardValue( inFinally );
+                inFinally = true;
+        }
+
+        void MultiLevelExitMutator::premutate( ReturnStmt *returnStmt ) {
+                if ( inFinally ) {
+                        SemanticError( returnStmt->location, "'return' may not appear in a finally clause" );
+                }
+        }
+
+        void MultiLevelExitMutator::premutate( CaseStmt *caseStmt ) {
                 visit_children = false;
 
@@ -352 +405 @@
         }
 
-        void MLEMutator::premutate( SwitchStmt *switchStmt ) {
+        void MultiLevelExitMutator::premutate( SwitchStmt *switchStmt ) {
                 // generate a label for breaking out of a labeled switch
                 Label brkLabel = generator->newLabel("switchBreak", switchStmt);
@@ -378 +431 @@
         }
 
-        Statement * MLEMutator::postmutate( SwitchStmt * switchStmt ) {
+        Statement * MultiLevelExitMutator::postmutate( SwitchStmt * switchStmt ) {
                 Entry &e = enclosingControlStructures.back();
                 assert ( e == switchStmt );

src/ControlStruct/MLEMutator.h

@@ -9 +9 @@
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Mar  8 16:42:32 2018
-// Update Count     : 41
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed Jan 22 11:50:00 2020
+// Update Count     : 48
 //
 
@@ -30 +30 @@
         class LabelGenerator;
 
-        class MLEMutator : public WithVisitorRef<MLEMutator>, public WithShortCircuiting, public WithGuards {
+        class MultiLevelExitMutator : public WithVisitorRef<MultiLevelExitMutator>,
+                        public WithShortCircuiting, public WithGuards {
           public:
                 class Entry;
-                MLEMutator( std::map<Label, Statement *> *t, LabelGenerator *gen = 0 ) : targetTable( t ), breakLabel(std::string("")), generator( gen ) {}
-                ~MLEMutator();
+                MultiLevelExitMutator( std::map<Label, Statement *> *t, LabelGenerator *gen = 0 ) :
+                        targetTable( t ), breakLabel(std::string("")), generator( gen ) {}
+                ~MultiLevelExitMutator();
+
+                void premutate( FunctionDecl * );
 
                 void premutate( CompoundStmt *cmpndStmt );
@@ -47 +51 @@
                 void premutate( SwitchStmt *switchStmt );
                 Statement * postmutate( SwitchStmt *switchStmt );
+                void premutate( ReturnStmt *returnStmt );
+                void premutate( TryStmt *tryStmt );
+                Statement * postmutate( TryStmt *tryStmt );
+                void premutate( FinallyStmt *finallyStmt );
 
                 Statement *mutateLoop( Statement *bodyLoop, Entry &e );
@@ -73 +81 @@
                         explicit Entry( SwitchStmt *stmt, Label breakExit, Label fallDefaultExit ) :
                                 stmt( stmt ), breakExit( breakExit ), fallDefaultExit( fallDefaultExit ) {}
+
+                        explicit Entry( TryStmt *stmt, Label breakExit ) :
+                                stmt( stmt ), breakExit( breakExit ) {}
 
                         bool operator==( const Statement *other ) { return stmt == other; }
@@ -105 +116 @@
                 Label breakLabel;
                 LabelGenerator *generator;
+                bool inFinally = false;
 
                 template< typename LoopClass >

src/ControlStruct/Mutate.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Aug  4 11:39:08 2016
-// Update Count     : 9
+// Last Modified On : Sun Feb 16 03:22:07 2020
+// Update Count     : 10
 //
 
@@ -37 +37 @@
                 mutateAll( translationUnit, formut );
         }
-} // namespace CodeGen
+} // namespace ControlStruct
 
 // Local Variables: //