Changeset 28e58fd for src/Tuples/TupleExpansion.cc

Timestamp:

Aug 25, 2017, 10:38:34 AM (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, with_gc

Children:

800d275

Parents:

af08051 (diff), 3eab308c (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

File:

• src/Tuples/TupleExpansion.cc (modified) (15 diffs)

src/Tuples/TupleExpansion.cc

@@ -37 +37 @@
 namespace Tuples {
         namespace {
-                class MemberTupleExpander final : public Mutator {
-                public:
+                struct MemberTupleExpander final : public Mutator {
                         typedef Mutator Parent;
                         using Parent::mutate;
@@ -45 +44 @@
                 };
 
-                class UniqueExprExpander final : public GenPoly::DeclMutator {
-                public:
-                        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
@@ -61 +56 @@
                 };
 
-                class TupleAssignExpander : public Mutator {
-                public:
-                        typedef Mutator Parent;
-                        using Parent::mutate;
-
-                        virtual Expression * mutate( TupleAssignExpr * tupleExpr );
+                struct TupleAssignExpander {
+                        Expression * postmutate( TupleAssignExpr * tupleExpr );
                 };
 
@@ -79 +70 @@
                 };
 
-                class TupleIndexExpander {
-                public:
+                struct TupleIndexExpander {
                         Expression * postmutate( TupleIndexExpr * tupleExpr );
                 };
 
-                class TupleExprExpander final : public Mutator {
-                public:
-                        typedef Mutator Parent;
-                        using Parent::mutate;
-
-                        virtual Expression * mutate( TupleExpr * tupleExpr ) override;
+                struct TupleExprExpander final {
+                        Expression * postmutate( TupleExpr * tupleExpr );
                 };
         }
@@ -99 +85 @@
 
         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 );
 
@@ -113 +99 @@
                 mutateAll( translationUnit, idxExpander );
 
-                TupleExprExpander exprExpander;
+                PassVisitor<TupleExprExpander> exprExpander;
                 mutateAll( translationUnit, exprExpander );
         }
@@ -146 +132 @@
                         // 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() ) {
@@ -164 +150 @@
         }
 
-        Expression * UniqueExprExpander::mutate( UniqueExpr * unqExpr ) {
-                unqExpr = safe_dynamic_cast< UniqueExpr * > ( Parent::mutate( unqExpr ) );
+        Expression * UniqueExprExpander::postmutate( UniqueExpr * unqExpr ) {
                 const int id = unqExpr->get_id();
 
@@ -175 +160 @@
                         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
@@ -189 +174 @@
                         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.
@@ -203 +188 @@
         }
 
-        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 );
@@ -238 +222 @@
                 for ( auto p : group_iterate( tupleType->get_types(), decl->get_parameters() ) ) {
                         Type * t = std::get<0>(p);
-                        TypeDecl * td = std::get<1>(p);
                         newType->get_parameters().push_back( new TypeExpr( t->clone() ) );
-                        if ( env ) {
-                                // add bindings to the type environment.
-                                // xxx - This may not be sufficient, it may be necessary to rename type variables on StructInstType?
-                                env->add( td->get_name(), t->clone() );
-                        }
                 }
                 delete tupleType;
@@ -293 +271 @@
         }
 
-        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();
@@ -342 +318 @@
                 class ImpurityDetector : public Visitor {
                 public:
+                        ImpurityDetector( bool ignoreUnique ) : ignoreUnique( ignoreUnique ) {}
+
                         typedef Visitor Parent;
                         virtual void visit( ApplicationExpr * appExpr ) {
@@ -355 +333 @@
                                 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;