Changeset ec42ff2e

Timestamp:

Sep 6, 2018, 10:49:09 AM (6 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

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

Children:

2f86ddf

Parents:

7ba1324

Message:

Add SplitExpressions? pass to wrap top-level expressions in CompoundStmts?

File:

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

src/InitTweak/FixInit.cc

@@ -234 +234 @@
                         Expression * postmutate( ConstructorExpr * ctorExpr );
                 };
+
+                struct SplitExpressions : public WithShortCircuiting, public WithTypeSubstitution, public WithStmtsToAdd {
+                        /// add CompoundStmts around top-level expressions so that temporaries are destroyed in the correct places.
+                        static void split( std::list< Declaration * > &translationUnit );
+
+                        Statement * postmutate( ExprStmt * stmt );
+                        void premutate( TupleAssignExpr * expr );
+                };
         } // namespace
 
@@ -244 +252 @@
 
                 UnqCount unqCount;
+
+                // must happen before ResolveCopyCtors because temporaries have to be inserted into the correct scope
+                SplitExpressions::split( translationUnit );
 
                 InsertImplicitCalls::insert( translationUnit );
@@ -312 +323 @@
 
                         return dtorFunc;
+                }
+
+                void SplitExpressions::split( std::list< Declaration * > & translationUnit ) {
+                        PassVisitor<SplitExpressions> splitter;
+                        mutateAll( translationUnit, splitter );
                 }
 
@@ -364 +380 @@
                 }
 
-                namespace {
-                        // Relatively simple structural comparison for expressions, needed to determine
-                        // if two expressions are "the same" (used to determine if self assignment occurs)
-                        struct StructuralChecker {
-                                Expression * stripCasts( Expression * expr ) {
-                                        // this might be too permissive. It's possible that only particular casts are relevant.
-                                        while ( CastExpr * cast = dynamic_cast< CastExpr * >( expr ) ) {
-                                                expr = cast->arg;
-                                        }
-                                        return expr;
-                                }
-
-                                void previsit( Expression * ) {
-                                        // anything else does not qualify
-                                        isSimilar = false;
-                                }
-
-                                template<typename T>
-                                T * cast( Expression * node ) {
-                                        // all expressions need to ignore casts, so this bit has been factored out
-                                        return dynamic_cast< T * >( stripCasts( node ) );
-                                }
-
-                                // ignore casts
-                                void previsit( CastExpr * ) {}
-
-                                void previsit( MemberExpr * memExpr ) {
-                                        if ( MemberExpr * otherMember = cast< MemberExpr >( other ) ) {
-                                                if ( otherMember->member == memExpr->member ) {
-                                                        other = otherMember->aggregate;
-                                                        return;
-                                                }
-                                        }
-                                        isSimilar = false;
-                                }
-
-                                void previsit( VariableExpr * varExpr ) {
-                                        if ( VariableExpr * otherVar = cast< VariableExpr >( other ) ) {
-                                                if ( otherVar->var == varExpr->var ) {
-                                                        return;
-                                                }
-                                        }
-                                        isSimilar = false;
-                                }
-
-                                void previsit( AddressExpr * ) {
-                                        if ( AddressExpr * addrExpr = cast< AddressExpr >( other ) ) {
-                                                other = addrExpr->arg;
+                Statement * SplitExpressions::postmutate( ExprStmt * stmt ) {
+                        // wrap each top-level ExprStmt in a block so that destructors for argument and return temporaries are destroyed
+                        // in the correct places
+                        CompoundStmt * ret = new CompoundStmt( { stmt } );
+                        return ret;
+                }
+
+                void SplitExpressions::premutate( TupleAssignExpr * ) {
+                        // don't do this within TupleAssignExpr, since it is already broken up into multiple expressions
+                        visit_children = false;
+                }
+
+                // Relatively simple structural comparison for expressions, needed to determine
+                // if two expressions are "the same" (used to determine if self assignment occurs)
+                struct StructuralChecker {
+                        Expression * stripCasts( Expression * expr ) {
+                                // this might be too permissive. It's possible that only particular casts are relevant.
+                                while ( CastExpr * cast = dynamic_cast< CastExpr * >( expr ) ) {
+                                        expr = cast->arg;
+                                }
+                                return expr;
+                        }
+
+                        void previsit( Expression * ) {
+                                // anything else does not qualify
+                                isSimilar = false;
+                        }
+
+                        template<typename T>
+                        T * cast( Expression * node ) {
+                                // all expressions need to ignore casts, so this bit has been factored out
+                                return dynamic_cast< T * >( stripCasts( node ) );
+                        }
+
+                        // ignore casts
+                        void previsit( CastExpr * ) {}
+
+                        void previsit( MemberExpr * memExpr ) {
+                                if ( MemberExpr * otherMember = cast< MemberExpr >( other ) ) {
+                                        if ( otherMember->member == memExpr->member ) {
+                                                other = otherMember->aggregate;
                                                 return;
                                         }
-                                        isSimilar = false;
-                                }
-
-                                Expression * other = nullptr;
-                                bool isSimilar = true;
-                        };
-
-                        bool structurallySimilar( Expression * e1, Expression * e2 ) {
-                                PassVisitor<StructuralChecker> checker;
-                                checker.pass.other = e2;
-                                e1->accept( checker );
-                                return checker.pass.isSimilar;
-                        }
+                                }
+                                isSimilar = false;
+                        }
+
+                        void previsit( VariableExpr * varExpr ) {
+                                if ( VariableExpr * otherVar = cast< VariableExpr >( other ) ) {
+                                        if ( otherVar->var == varExpr->var ) {
+                                                return;
+                                        }
+                                }
+                                isSimilar = false;
+                        }
+
+                        void previsit( AddressExpr * ) {
+                                if ( AddressExpr * addrExpr = cast< AddressExpr >( other ) ) {
+                                        other = addrExpr->arg;
+                                        return;
+                                }
+                                isSimilar = false;
+                        }
+
+                        Expression * other = nullptr;
+                        bool isSimilar = true;
+                };
+
+                bool structurallySimilar( Expression * e1, Expression * e2 ) {
+                        PassVisitor<StructuralChecker> checker;
+                        checker.pass.other = e2;
+                        e1->accept( checker );
+                        return checker.pass.isSimilar;
                 }
 
@@ -535 +561 @@
                                         // so that the object isn't changed inside of the polymorphic function
                                         if ( ! GenPoly::needsBoxing( formal, result, impCpCtorExpr->callExpr, env ) ) return;
+                                        // xxx - leaking tmp
                                 }
                         }