Changes in / [b7fd9daf:1622af5]

Location:

src

Files:

• AST/Convert.cpp (modified) (1 diff)
• AST/Copy.hpp (modified) (2 diffs)
• AST/Expr.hpp (modified) (1 diff)
• Tuples/TupleExpansionNew.cpp (modified) (2 diffs)
• Tuples/Tuples.h (modified) (1 diff)
• main.cc (modified) (2 diffs)

src/AST/Convert.cpp

@@ -1041 +1041 @@
 
         const ast::Expr * visit( const ast::StmtExpr * node ) override final {
+                auto stmts = node->stmts;
+                // disable sharing between multiple StmtExprs explicitly.
+                // this should no longer be true.
+
                 auto rslt = new StmtExpr(
-                        get<CompoundStmt>().accept1(node->stmts)
+                        get<CompoundStmt>().accept1(stmts)
                 );
 
                 rslt->returnDecls = get<ObjectDecl>().acceptL(node->returnDecls);
                 rslt->dtors       = get<Expression>().acceptL(node->dtors);
-
-                // is this even used after convert?
-                //if (tmp->resultExpr) {
-                //      // this MUST be found by children visit
-                //      rslt->resultExpr  = strict_dynamic_cast<ExprStmt *>(readonlyCache.at(tmp->resultExpr));
-                //}
+                if (node->resultExpr) {
+                        // this MUST be found by children visit
+                        rslt->resultExpr  = strict_dynamic_cast<ExprStmt *>(readonlyCache.at(node->resultExpr));
+                }
 
                 auto expr = visitBaseExpr( node, rslt );

src/AST/Copy.hpp

@@ -88 +88 @@
         }
 
-        void postvisit( const StmtExpr * node ) {
-                readonlyInsert( &node->resultExpr );
-        }
-
         void postvisit( const MemberExpr * node ) {
                 readonlyInsert( &node->member );
@@ -126 +122 @@
 node_t * deepCopy( const node_t * localRoot ) {
         Pass< DeepCopyCore > dc;
-        node_t const * newRoot = strict_dynamic_cast<node_t const*>(localRoot->accept( dc ));
+        node_t const * newRoot = localRoot->accept( dc );
         dc.core.readonlyUpdates();
         return const_cast< node_t * >( newRoot );

src/AST/Expr.hpp

@@ -767 +767 @@
 
 /// An expression which must only be evaluated once
-class 
-UniqueExpr final : public Expr {
+class UniqueExpr final : public Expr {
         static unsigned long long nextId;
 public:

src/Tuples/TupleExpansionNew.cpp

@@ -21 +21 @@
                 void previsit( const ast::UntypedMemberExpr * ) { visit_children = false; }
         const ast::Expr * postvisit( const ast::UntypedMemberExpr * memberExpr );
-        };
-        struct UniqueExprExpander final : public ast::WithDeclsToAdd<> {
-                const ast::Expr * postvisit( const ast::UniqueExpr * unqExpr );
-                std::map< int, ast::ptr<ast::Expr> > decls; // not vector, because order added may not be increasing order
         };
 } // namespace
@@ -70 +66 @@
         }
 } // namespace
-
-void expandUniqueExpr( ast::TranslationUnit & translationUnit ) {
-        ast::Pass< UniqueExprExpander >::run( translationUnit );
-}
-
-namespace {
-        const ast::Expr * UniqueExprExpander::postvisit( const ast::UniqueExpr * unqExpr ) {
-                const CodeLocation loc = unqExpr->location;
-                const int id = unqExpr->id;
-
-                // on first time visiting a unique expr with a particular ID, generate the expression that replaces all UniqueExprs with that ID,
-                // and lookup on subsequent hits. This ensures that all unique exprs with the same ID reference the same variable.
-                if ( ! decls.count( id ) ) {
-                        ast::ptr< ast::Expr > assignUnq;
-                        const ast::VariableExpr * var = unqExpr->var;
-                        if ( unqExpr->object ) {
-                                // an object was generated to represent this unique expression -- it should be added to the list of declarations now
-                                declsToAddBefore.push_back( unqExpr->object.as< ast::Decl >() );
-                                // deep copy required due to unresolved issues with UniqueExpr
-                                assignUnq = ast::UntypedExpr::createAssign( loc, var, unqExpr->expr );
-                        } else {
-                                const auto commaExpr = unqExpr->expr.strict_as< ast::CommaExpr >();
-                                assignUnq = commaExpr->arg1;
-                        }
-                        auto finished = new ast::ObjectDecl( loc, toString( "_unq", id, "_finished_" ), new ast::BasicType( ast::BasicType::Kind::Bool ),
-                                new ast::SingleInit( loc, ast::ConstantExpr::from_int( loc, 0 ) ), {}, ast::Linkage::Cforall );
-                        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.
-                        auto assignFinished = ast::UntypedExpr::createAssign( loc, new ast::VariableExpr( loc, finished ),
-                                ast::ConstantExpr::from_int( loc, 1 ) );
-                        auto condExpr = new ast::ConditionalExpr( loc, new ast::VariableExpr( loc, finished ), var,
-                                new ast::CommaExpr( loc, new ast::CommaExpr( loc, assignUnq, assignFinished ), var ) );
-                        condExpr->result = var->result;
-                        condExpr->env = unqExpr->env;
-                        decls[id] = condExpr;
-                }
-                //delete unqExpr;
-                return ast::deepCopy(decls[id].get());
-        }
-} // namespace
 } // namespace Tuples

src/Tuples/Tuples.h

@@ -46 +46 @@
         /// replaces UniqueExprs with a temporary variable and one call
         void expandUniqueExpr( std::list< Declaration * > & translationUnit );
-        void expandUniqueExpr( ast::TranslationUnit & translationUnit );
 
         /// returns VoidType if any of the expressions have Voidtype, otherwise TupleType of the Expression result types

src/main.cc

@@ -381 +381 @@
                         PASS( "Fix Init", InitTweak::fix(transUnit, buildingLibrary()));
 
-                        // fix ObjectDecl - replaces ConstructorInit nodes
-                        if ( ctorinitp ) {
-                                dump( move( transUnit ) );
-                                return EXIT_SUCCESS;
-                        } // if
-
-                        // Currently not working due to unresolved issues with UniqueExpr
-                        PASS( "Expand Unique Expr", Tuples::expandUniqueExpr( transUnit ) ); // xxx - is this the right place for this? want to expand ASAP so tha, sequent passes don't need to worry about double-visiting a unique expr - needs to go after InitTweak::fix so that copy constructed return declarations are reused
                         translationUnit = convert( move( transUnit ) );
                 } else {
@@ -443 +435 @@
 
                         PASS( "Fix Init", InitTweak::fix( translationUnit, buildingLibrary() ) );
-
-                        // fix ObjectDecl - replaces ConstructorInit nodes
-                        if ( ctorinitp ) {
-                                dump ( translationUnit );
-                                return EXIT_SUCCESS;
-                        } // if
-
-                        PASS( "Expand Unique Expr", Tuples::expandUniqueExpr( translationUnit ) ); // xxx - is this the right place for this? want to expand ASAP so tha, sequent passes don't need to worry about double-visiting a unique expr - needs to go after InitTweak::fix so that copy constructed return declarations are reused
                 }
+
+                // fix ObjectDecl - replaces ConstructorInit nodes
+                if ( ctorinitp ) {
+                        dump ( translationUnit );
+                        return EXIT_SUCCESS;
+                } // if
+
+                PASS( "Expand Unique Expr", Tuples::expandUniqueExpr( translationUnit ) ); // xxx - is this the right place for this? want to expand ASAP so tha, sequent passes don't need to worry about double-visiting a unique expr - needs to go after InitTweak::fix so that copy constructed return declarations are reused
 
                 PASS( "Translate Tries" , ControlStruct::translateTries( translationUnit ) );