Changeset dc2334c

Timestamp:

Sep 25, 2017, 5:49:16 PM (7 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

cf90b88

Parents:

92b3de1

Message:

Convert FixCopyCtors? to PassVisitor?

File:

• src/InitTweak/FixInit.cc (modified) (10 diffs)

src/InitTweak/FixInit.cc

@@ -185 +185 @@
                 };
 
-                class FixCopyCtors final : public GenPoly::PolyMutator {
+                class FixCopyCtors final : public WithStmtsToAdd, public WithShortCircuiting, public WithVisitorRef<FixCopyCtors> {
                   public:
                         FixCopyCtors( UnqCount & unqCount ) : unqCount( unqCount ){}
@@ -192 +192 @@
                         static void fixCopyCtors( std::list< Declaration * > &translationUnit, UnqCount & unqCount );
 
-                        typedef GenPoly::PolyMutator Parent;
-                        using Parent::mutate;
-                        virtual Expression * mutate( ImplicitCopyCtorExpr * impCpCtorExpr ) override;
-                        virtual Expression * mutate( UniqueExpr * unqExpr ) override;
-                        virtual Expression * mutate( StmtExpr * stmtExpr ) override;
+                        Expression * postmutate( ImplicitCopyCtorExpr * impCpCtorExpr );
+                        void premutate( StmtExpr * stmtExpr );
+                        void premutate( UniqueExpr * unqExpr );
 
                         UnqCount & unqCount;
@@ -312 +310 @@
 
                 void FixCopyCtors::fixCopyCtors( std::list< Declaration * > & translationUnit, UnqCount & unqCount ) {
-                        FixCopyCtors fixer( unqCount );
+                        PassVisitor<FixCopyCtors> fixer( unqCount );
                         mutateAll( translationUnit, fixer );
                 }
@@ -512 +510 @@
                 }
 
-                Expression * FixCopyCtors::mutate( ImplicitCopyCtorExpr * impCpCtorExpr ) {
+                Expression * FixCopyCtors::postmutate( ImplicitCopyCtorExpr * impCpCtorExpr ) {
                         CP_CTOR_PRINT( std::cerr << "FixCopyCtors: " << impCpCtorExpr << std::endl; )
 
-                        impCpCtorExpr = strict_dynamic_cast< ImplicitCopyCtorExpr * >( Parent::mutate( impCpCtorExpr ) );
                         std::list< ObjectDecl * > & tempDecls = impCpCtorExpr->get_tempDecls();
                         std::list< ObjectDecl * > & returnDecls = impCpCtorExpr->get_returnDecls();
@@ -522 +519 @@
                         // add all temporary declarations and their constructors
                         for ( ObjectDecl * obj : tempDecls ) {
-                                stmtsToAdd.push_back( new DeclStmt( noLabels, obj ) );
+                                stmtsToAddBefore.push_back( new DeclStmt( noLabels, obj ) );
                         } // for
                         for ( ObjectDecl * obj : returnDecls ) {
-                                stmtsToAdd.push_back( new DeclStmt( noLabels, obj ) );
+                                stmtsToAddBefore.push_back( new DeclStmt( noLabels, obj ) );
                         } // for
 
@@ -533 +530 @@
                         } // for
 
-                        // xxx - update to work with multiple return values
                         ObjectDecl * returnDecl = returnDecls.empty() ? nullptr : returnDecls.front();
                         Expression * callExpr = impCpCtorExpr->get_callExpr();
@@ -566 +562 @@
                 }
 
-                Expression * FixCopyCtors::mutate( StmtExpr * stmtExpr ) {
+                void FixCopyCtors::premutate( StmtExpr * stmtExpr ) {
                         // function call temporaries should be placed at statement-level, rather than nested inside of a new statement expression,
                         // since temporaries can be shared across sub-expressions, e.g.
                         //   [A, A] f();
                         //   g([A] x, [A] y);
-                        //   f(g());
+                        //   g(f());
                         // f is executed once, so the return temporary is shared across the tuple constructors for x and y.
+                        // Explicitly mutating children instead of mutating the inner compound statment forces the temporaries to be added
+                        // to the outer context, rather than inside of the statement expression.
+                        visit_children = false;
                         std::list< Statement * > & stmts = stmtExpr->get_statements()->get_kids();
                         for ( Statement *& stmt : stmts ) {
-                                stmt = stmt->acceptMutator( *this );
+                                stmt = stmt->acceptMutator( *visitor );
                         } // for
-                        // stmtExpr = strict_dynamic_cast< StmtExpr * >( Parent::mutate( stmtExpr ) );
                         assert( stmtExpr->get_result() );
                         Type * result = stmtExpr->get_result();
                         if ( ! result->isVoid() ) {
                                 for ( ObjectDecl * obj : stmtExpr->get_returnDecls() ) {
-                                        stmtsToAdd.push_back( new DeclStmt( noLabels, obj ) );
+                                        stmtsToAddBefore.push_back( new DeclStmt( noLabels, obj ) );
                                 } // for
                                 // add destructors after current statement
@@ -589 +587 @@
                                 } // for
                                 // must have a non-empty body, otherwise it wouldn't have a result
-                                CompoundStmt * body = stmtExpr->get_statements();
-                                assert( ! body->get_kids().empty() );
+                                assert( ! stmts.empty() );
                                 assert( ! stmtExpr->get_returnDecls().empty() );
-                                body->get_kids().push_back( new ExprStmt( noLabels, new VariableExpr( stmtExpr->get_returnDecls().front() ) ) );
+                                stmts.push_back( new ExprStmt( noLabels, new VariableExpr( stmtExpr->get_returnDecls().front() ) ) );
                                 stmtExpr->get_returnDecls().clear();
                                 stmtExpr->get_dtors().clear();
@@ -598 +595 @@
                         assert( stmtExpr->get_returnDecls().empty() );
                         assert( stmtExpr->get_dtors().empty() );
-                        return stmtExpr;
-                }
-
-                Expression * FixCopyCtors::mutate( UniqueExpr * unqExpr ) {
+                }
+
+                void FixCopyCtors::premutate( UniqueExpr * unqExpr ) {
+                        visit_children = false;
                         unqCount[ unqExpr->get_id() ]--;
                         static std::unordered_map< int, std::list< Statement * > > dtors;
                         static std::unordered_map< int, UniqueExpr * > unqMap;
-                        static std::unordered_set< int > addDeref;
                         // has to be done to clean up ImplicitCopyCtorExpr nodes, even when this node was skipped in previous passes
                         if ( unqMap.count( unqExpr->get_id() ) ) {
@@ -616 +612 @@
                                         stmtsToAddAfter.splice( stmtsToAddAfter.end(), dtors[ unqExpr->get_id() ] );
                                 }
-                                if ( addDeref.count( unqExpr->get_id() ) ) {
-                                        // other UniqueExpr was dereferenced because it was an lvalue return, so this one should be too
-                                        return UntypedExpr::createDeref( unqExpr );
-                                }
-                                return unqExpr;
-                        }
-                        FixCopyCtors fixer( unqCount );
+                                return;
+                        }
+                        PassVisitor<FixCopyCtors> fixer( unqCount );
                         unqExpr->set_expr( unqExpr->get_expr()->acceptMutator( fixer ) ); // stmtexprs contained should not be separately fixed, so this must occur after the lookup
-                        stmtsToAdd.splice( stmtsToAdd.end(), fixer.stmtsToAdd );
+                        stmtsToAddBefore.splice( stmtsToAddBefore.end(), fixer.pass.stmtsToAddBefore );
                         unqMap[unqExpr->get_id()] = unqExpr;
                         if ( unqCount[ unqExpr->get_id() ] == 0 ) {  // insert destructor after the last use of the unique expression
                                 stmtsToAddAfter.splice( stmtsToAddAfter.end(), dtors[ unqExpr->get_id() ] );
                         } else { // remember dtors for last instance of unique expr
-                                dtors[ unqExpr->get_id() ] = fixer.stmtsToAddAfter;
-                        }
-                        if ( UntypedExpr * deref = dynamic_cast< UntypedExpr * >( unqExpr->get_expr() ) ) {
-                                // unique expression is now a dereference, because the inner expression is an lvalue returning function call.
-                                // Normalize the expression by dereferencing the unique expression, rather than the inner expression
-                                // (i.e. move the dereference out a level)
-                                assert( getFunctionName( deref ) == "*?" );
-                                unqExpr->set_expr( getCallArg( deref, 0 ) );
-                                getCallArg( deref, 0 ) = unqExpr;
-                                addDeref.insert( unqExpr->get_id() );
-                                return deref;
-                        }
-                        return unqExpr;
+                                dtors[ unqExpr->get_id() ] = fixer.pass.stmtsToAddAfter;
+                        }
+                        return;
                 }