Changeset 9f10c4b8 for src/Tuples

Timestamp:

Aug 22, 2017, 5:31:27 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:

d104b02

Parents:

1ae06fa

Message:

Add maybeImpureIgnoreUnique and convert tuple passes to use PassVisitor?

Location:

src/Tuples

Files:

• TupleExpansion.cc (modified) (13 diffs)
• Tuples.h (modified) (1 diff)

src/Tuples/TupleExpansion.cc

@@ -41 +41 @@
                 };
 
-                struct UniqueExprExpander final : public GenPoly::DeclMutator {
-                        typedef GenPoly::DeclMutator Parent;
-                        using Parent::mutate;
-
-                        virtual Expression * mutate( UniqueExpr * unqExpr ) override;
+                struct UniqueExprExpander final : public WithDeclsToAdd {
+                        Expression * postmutate( UniqueExpr * unqExpr );
 
                         std::map< int, Expression * > decls; // not vector, because order added may not be increasing order
@@ -56 +53 @@
                 };
 
-                struct TupleAssignExpander : public Mutator {
-                        typedef Mutator Parent;
-                        using Parent::mutate;
-
-                        virtual Expression * mutate( TupleAssignExpr * tupleExpr );
+                struct TupleAssignExpander {
+                        Expression * postmutate( TupleAssignExpr * tupleExpr );
                 };
 
@@ -77 +71 @@
                 };
 
-                struct TupleExprExpander final : public Mutator {
-                        typedef Mutator Parent;
-                        using Parent::mutate;
-
-                        virtual Expression * mutate( TupleExpr * tupleExpr ) override;
+                struct TupleExprExpander final {
+                        Expression * postmutate( TupleExpr * tupleExpr );
                 };
         }
@@ -91 +82 @@
 
         void expandUniqueExpr( std::list< Declaration * > & translationUnit ) {
-                UniqueExprExpander unqExpander;
-                unqExpander.mutateDeclarationList( translationUnit );
+                PassVisitor<UniqueExprExpander> unqExpander;
+                mutateAll( translationUnit, unqExpander );
         }
 
         void expandTuples( std::list< Declaration * > & translationUnit ) {
-                TupleAssignExpander assnExpander;
+                PassVisitor<TupleAssignExpander> assnExpander;
                 mutateAll( translationUnit, assnExpander );
 
@@ -105 +96 @@
                 mutateAll( translationUnit, idxExpander );
 
-                TupleExprExpander exprExpander;
+                PassVisitor<TupleExprExpander> exprExpander;
                 mutateAll( translationUnit, exprExpander );
         }
@@ -138 +129 @@
                         // aggregate expressions which might be impure must be wrapped in unique expressions
                         // xxx - if there's a member-tuple expression nested in the aggregate, this currently generates the wrong code if a UniqueExpr is not used, and it's purely an optimization to remove the UniqueExpr
-                        // if ( Tuples::maybeImpure( memberExpr->get_aggregate() ) ) aggr = new UniqueExpr( aggr );
+                        // if ( Tuples::maybeImpureIgnoreUnique( memberExpr->get_aggregate() ) ) aggr = new UniqueExpr( aggr );
                         aggr = new UniqueExpr( aggr );
                         for ( Expression *& expr : tupleExpr->get_exprs() ) {
@@ -156 +147 @@
         }
 
-        Expression * UniqueExprExpander::mutate( UniqueExpr * unqExpr ) {
-                unqExpr = safe_dynamic_cast< UniqueExpr * > ( Parent::mutate( unqExpr ) );
+        Expression * UniqueExprExpander::postmutate( UniqueExpr * unqExpr ) {
                 const int id = unqExpr->get_id();
 
@@ -167 +157 @@
                         if ( unqExpr->get_object() ) {
                                 // an object was generated to represent this unique expression -- it should be added to the list of declarations now
-                                addDeclaration( unqExpr->get_object() );
+                                declsToAddBefore.push_back( unqExpr->get_object() );
                                 unqExpr->set_object( nullptr );
                                 // steal the expr from the unqExpr
@@ -181 +171 @@
                         ObjectDecl * finished = new ObjectDecl( toString( "_unq", id, "_finished_" ), Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new BasicType( Type::Qualifiers(), BasicType::Bool ),
                                                                                                         new SingleInit( new ConstantExpr( Constant::from_int( 0 ) ) ) );
-                        addDeclaration( finished );
+                        declsToAddBefore.push_back( finished );
                         // (finished ? _unq_expr_N : (_unq_expr_N = <unqExpr->get_expr()>, finished = 1, _unq_expr_N))
                         // This pattern ensures that each unique expression is evaluated once, regardless of evaluation order of the generated C code.
@@ -195 +185 @@
         }
 
-        Expression * TupleAssignExpander::mutate( TupleAssignExpr * assnExpr ) {
-                assnExpr = safe_dynamic_cast< TupleAssignExpr * >( Parent::mutate( assnExpr ) );
+        Expression * TupleAssignExpander::postmutate( TupleAssignExpr * assnExpr ) {
                 StmtExpr * ret = assnExpr->get_stmtExpr();
                 assnExpr->set_stmtExpr( nullptr );
@@ -279 +268 @@
         }
 
-        Expression * TupleExprExpander::mutate( TupleExpr * tupleExpr ) {
-                // recursively expand sub-tuple-expressions
-                tupleExpr = safe_dynamic_cast<TupleExpr *>(Parent::mutate(tupleExpr));
+        Expression * TupleExprExpander::postmutate( TupleExpr * tupleExpr ) {
                 Type * result = tupleExpr->get_result();
                 std::list< Expression * > exprs = tupleExpr->get_exprs();
@@ -328 +315 @@
                 class ImpurityDetector : public Visitor {
                 public:
+                        ImpurityDetector( bool ignoreUnique ) : ignoreUnique( ignoreUnique ) {}
+
                         typedef Visitor Parent;
                         virtual void visit( ApplicationExpr * appExpr ) {
@@ -341 +330 @@
                                 maybeImpure = true;
                         }
-                        virtual void visit( __attribute__((unused)) UntypedExpr * untypedExpr ) { maybeImpure = true; }
+                        virtual void visit( UntypedExpr * ) { maybeImpure = true; }
+                        virtual void visit( UniqueExpr * unq ) {
+                                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.
+                                        return;
+                                }
+                                maybeAccept( unq->expr, *this );
+                        }
+
                         bool maybeImpure = false;
+                        bool ignoreUnique;
                 };
         } // namespace
 
         bool maybeImpure( Expression * expr ) {
-                ImpurityDetector detector;
+                ImpurityDetector detector( false );
+                expr->accept( detector );
+                return detector.maybeImpure;
+        }
+
+        bool maybeImpureIgnoreUnique( Expression * expr ) {
+                ImpurityDetector detector( true );
                 expr->accept( detector );
                 return detector.maybeImpure;

src/Tuples/Tuples.h

@@ -46 +46 @@
         /// returns true if the expression may contain side-effects.
         bool maybeImpure( Expression * expr );
+
+        /// returns true if the expression may contain side-effect, ignoring the presence of unique expressions.
+        bool maybeImpureIgnoreUnique( Expression * expr );
 } // namespace Tuples