Changeset 86ad276 for src/Tuples

Timestamp:

Dec 5, 2017, 1:36:23 PM (8 years ago)

Author:

Thierry Delisle <tdelisle@…>

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, stuck-waitfor-destruct, with_gc

Children:

12d2dc8

Parents:

f3b9efc (diff), 5da9d6a (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

Location:

src/Tuples

Files:

• TupleAssignment.cc (modified) (16 diffs)
• TupleExpansion.cc (modified) (3 diffs)

src/Tuples/TupleAssignment.cc

@@ -23 +23 @@
 
 #include "CodeGen/OperatorTable.h"
+#include "Common/PassVisitor.h"
 #include "Common/UniqueName.h"             // for UniqueName
 #include "Common/utility.h"                // for zipWith
@@ -61 +62 @@
                 struct Matcher {
                   public:
-                        Matcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList& lhs, const 
+                        Matcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList& lhs, const
                                 ResolvExpr::AltList& rhs );
                         virtual ~Matcher() {}
@@ -75 +76 @@
                 struct MassAssignMatcher : public Matcher {
                   public:
-                        MassAssignMatcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList& lhs, 
+                        MassAssignMatcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList& lhs,
                                 const ResolvExpr::AltList& rhs ) : Matcher(spotter, lhs, rhs) {}
                         virtual void match( std::list< Expression * > &out );
@@ -82 +83 @@
                 struct MultipleAssignMatcher : public Matcher {
                   public:
-                        MultipleAssignMatcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList& lhs, 
+                        MultipleAssignMatcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList& lhs,
                                 const ResolvExpr::AltList& rhs ) : Matcher(spotter, lhs, rhs) {}
                         virtual void match( std::list< Expression * > &out );
@@ -119 +120 @@
         }
 
-        void handleTupleAssignment( ResolvExpr::AlternativeFinder & currentFinder, UntypedExpr * expr, 
+        void handleTupleAssignment( ResolvExpr::AlternativeFinder & currentFinder, UntypedExpr * expr,
                                 std::vector<ResolvExpr::AlternativeFinder> &args ) {
                 TupleAssignSpotter spotter( currentFinder );
@@ -128 +129 @@
                 : currentFinder(f) {}
 
-        void TupleAssignSpotter::spot( UntypedExpr * expr, 
+        void TupleAssignSpotter::spot( UntypedExpr * expr,
                         std::vector<ResolvExpr::AlternativeFinder> &args ) {
                 if (  NameExpr *op = dynamic_cast< NameExpr * >(expr->get_function()) ) {
@@ -137 +138 @@
                                 if ( args.size() == 0 ) return;
 
-                                // if an assignment only takes 1 argument, that's odd, but maybe someone wrote 
+                                // if an assignment only takes 1 argument, that's odd, but maybe someone wrote
                                 // the function, in which case AlternativeFinder will handle it normally
                                 if ( args.size() == 1 && CodeGen::isAssignment( fname ) ) return;
@@ -146 +147 @@
                                         if ( ! refToTuple(lhsAlt.expr) ) continue;
 
-                                        // explode is aware of casts - ensure every LHS expression is sent into explode 
+                                        // explode is aware of casts - ensure every LHS expression is sent into explode
                                         // with a reference cast
-                                        // xxx - this seems to change the alternatives before the normal 
+                                        // xxx - this seems to change the alternatives before the normal
                                         //  AlternativeFinder flow; maybe this is desired?
                                         if ( ! dynamic_cast<CastExpr*>( lhsAlt.expr ) ) {
-                                                lhsAlt.expr = new CastExpr( lhsAlt.expr, 
-                                                                new ReferenceType( Type::Qualifiers(), 
+                                                lhsAlt.expr = new CastExpr( lhsAlt.expr,
+                                                                new ReferenceType( Type::Qualifiers(),
                                                                         lhsAlt.expr->get_result()->clone() ) );
                                         }
@@ -160 +161 @@
                                         explode( lhsAlt, currentFinder.get_indexer(), back_inserter(lhs), true );
                                         for ( ResolvExpr::Alternative& alt : lhs ) {
-                                                // each LHS value must be a reference - some come in with a cast expression, 
+                                                // each LHS value must be a reference - some come in with a cast expression,
                                                 // if not just cast to reference here
                                                 if ( ! dynamic_cast<ReferenceType*>( alt.expr->get_result() ) ) {
-                                                        alt.expr = new CastExpr( alt.expr, 
-                                                                new ReferenceType( Type::Qualifiers(), 
+                                                        alt.expr = new CastExpr( alt.expr,
+                                                                new ReferenceType( Type::Qualifiers(),
                                                                         alt.expr->get_result()->clone() ) );
                                                 }
@@ -178 +179 @@
                                                 // TODO build iterative version of this instead of using combos
                                                 std::vector< ResolvExpr::AltList > rhsAlts;
-                                                combos( std::next(args.begin(), 1), args.end(), 
+                                                combos( std::next(args.begin(), 1), args.end(),
                                                         std::back_inserter( rhsAlts ) );
                                                 for ( const ResolvExpr::AltList& rhsAlt : rhsAlts ) {
                                                         // multiple assignment
                                                         ResolvExpr::AltList rhs;
-                                                        explode( rhsAlt, currentFinder.get_indexer(), 
+                                                        explode( rhsAlt, currentFinder.get_indexer(),
                                                                 std::back_inserter(rhs), true );
                                                         matcher.reset( new MultipleAssignMatcher( *this, lhs, rhs ) );
@@ -193 +194 @@
                                                         if ( isTuple(rhsAlt.expr) ) {
                                                                 // multiple assignment
-                                                                explode( rhsAlt, currentFinder.get_indexer(),  
+                                                                explode( rhsAlt, currentFinder.get_indexer(),
                                                                         std::back_inserter(rhs), true );
                                                                 matcher.reset( new MultipleAssignMatcher( *this, lhs, rhs ) );
@@ -222 +223 @@
                 ResolvExpr::AltList current;
                 // now resolve new assignments
-                for ( std::list< Expression * >::iterator i = new_assigns.begin(); 
+                for ( std::list< Expression * >::iterator i = new_assigns.begin();
                                 i != new_assigns.end(); ++i ) {
                         PRINT(
@@ -229 +230 @@
                         )
 
-                        ResolvExpr::AlternativeFinder finder{ currentFinder.get_indexer(), 
+                        ResolvExpr::AlternativeFinder finder{ currentFinder.get_indexer(),
                                 currentFinder.get_environ() };
                         try {
@@ -253 +254 @@
                 // xxx -- was push_front
                 currentFinder.get_alternatives().push_back( ResolvExpr::Alternative(
-                        new TupleAssignExpr(solved_assigns, matcher->tmpDecls), matcher->compositeEnv, 
+                        new TupleAssignExpr(solved_assigns, matcher->tmpDecls), matcher->compositeEnv,
                         ResolvExpr::sumCost( current ) + matcher->baseCost ) );
         }
 
-        TupleAssignSpotter::Matcher::Matcher( TupleAssignSpotter &spotter, 
-                const ResolvExpr::AltList &lhs, const ResolvExpr::AltList &rhs ) 
-        : lhs(lhs), rhs(rhs), spotter(spotter), 
+        TupleAssignSpotter::Matcher::Matcher( TupleAssignSpotter &spotter,
+                const ResolvExpr::AltList &lhs, const ResolvExpr::AltList &rhs )
+        : lhs(lhs), rhs(rhs), spotter(spotter),
           baseCost( ResolvExpr::sumCost( lhs ) + ResolvExpr::sumCost( rhs ) ) {
                 simpleCombineEnvironments( lhs.begin(), lhs.end(), compositeEnv );
@@ -277 +278 @@
         // xxx - maybe this should happen in alternative finder for every StmtExpr?
         // xxx - it's possible that these environments could contain some useful information. Maybe the right thing to do is aggregate the environments and pass the aggregate back to be added into the compositeEnv
-        struct EnvRemover : public Visitor {
-                virtual void visit( ExprStmt * stmt ) {
-                        delete stmt->get_expr()->get_env();
-                        stmt->get_expr()->set_env( nullptr );
-                        Visitor::visit( stmt );
+        struct EnvRemover {
+                void previsit( ExprStmt * stmt ) {
+                        delete stmt->expr->env;
+                        stmt->expr->env = nullptr;
                 }
         };
@@ -293 +293 @@
                         ret->set_init( ctorInit );
                         ResolvExpr::resolveCtorInit( ctorInit, spotter.currentFinder.get_indexer() ); // resolve ctor/dtors for the new object
-                        EnvRemover rm; // remove environments from subexpressions of StmtExprs
+                        PassVisitor<EnvRemover> rm; // remove environments from subexpressions of StmtExprs
                         ctorInit->accept( rm );
                 }

src/Tuples/TupleExpansion.cc

@@ -315 +315 @@
         namespace {
                 /// determines if impurity (read: side-effects) may exist in a piece of code. Currently gives a very crude approximation, wherein any function call expression means the code may be impure
-                class ImpurityDetector : public Visitor {
-                public:
+                struct ImpurityDetector : public WithShortCircuiting {
                         ImpurityDetector( bool ignoreUnique ) : ignoreUnique( ignoreUnique ) {}
 
-                        typedef Visitor Parent;
-                        virtual void visit( ApplicationExpr * appExpr ) {
+                        void previsit( ApplicationExpr * appExpr ) {
+                                visit_children = false;
                                 if ( DeclarationWithType * function = InitTweak::getFunction( appExpr ) ) {
                                         if ( function->get_linkage() == LinkageSpec::Intrinsic ) {
                                                 if ( function->get_name() == "*?" || function->get_name() == "?[?]" ) {
                                                         // intrinsic dereference, subscript are pure, but need to recursively look for impurity
-                                                        Parent::visit( appExpr );
+                                                        visit_children = true;
                                                         return;
                                                 }
@@ -332 +331 @@
                                 maybeImpure = true;
                         }
-                        virtual void visit( UntypedExpr * ) { maybeImpure = true; }
-                        virtual void visit( UniqueExpr * unq ) {
+                        void previsit( UntypedExpr * ) { maybeImpure = true; visit_children = false; }
+                        void previsit( UniqueExpr * ) {
                                 if ( ignoreUnique ) {
                                         // bottom out at unique expression.
                                         // The existence of a unique expression doesn't change the purity of an expression.
                                         // That is, even if the wrapped expression is impure, the wrapper protects the rest of the expression.
+                                        visit_children = false;
                                         return;
                                 }
-                                maybeAccept( unq->expr, *this );
                         }
 
@@ -349 +348 @@
 
         bool maybeImpure( Expression * expr ) {
-                ImpurityDetector detector( false );
+                PassVisitor<ImpurityDetector> detector( false );
                 expr->accept( detector );
-                return detector.maybeImpure;
+                return detector.pass.maybeImpure;
         }
 
         bool maybeImpureIgnoreUnique( Expression * expr ) {
-                ImpurityDetector detector( true );
+                PassVisitor<ImpurityDetector> detector( true );
                 expr->accept( detector );
-                return detector.maybeImpure;
+                return detector.pass.maybeImpure;
         }
 } // namespace Tuples