Changeset 31f379c for src/InitTweak

Timestamp:

Dec 13, 2016, 6:16:21 PM (8 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:

cce9429

Parents:

d5556a3

Message:

add copy constructor code for StmtExpr?, fix usage of environments in FixInit?

File:

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

src/InitTweak/FixInit.cc ¶

@@ -49 +49 @@
 namespace InitTweak {
         namespace {
+                typedef std::unordered_map< Expression *, TypeSubstitution * > EnvMap;
+
                 class InsertImplicitCalls final : public GenPoly::PolyMutator {
                 public:
                         /// wrap function application expressions as ImplicitCopyCtorExpr nodes so that it is easy to identify which
                         /// function calls need their parameters to be copy constructed
-                        static void insert( std::list< Declaration * > & translationUnit );
-
-                        using GenPoly::PolyMutator::mutate;
+                        static void insert( std::list< Declaration * > & translationUnit, EnvMap & envMap );
+
+                        InsertImplicitCalls( EnvMap & envMap ) : envMap( envMap ) {}
+                        typedef GenPoly::PolyMutator Parent;
+                        using Parent::mutate;
                         virtual Expression * mutate( ApplicationExpr * appExpr ) override;
+                        virtual Expression * mutate( StmtExpr * stmtExpr ) override;
+
+                        // collects environments for relevant nodes
+                        EnvMap & envMap;
                 };
 
@@ -64 +72 @@
                         /// generate/resolve copy construction expressions for each, and generate/resolve destructors for both
                         /// arguments and return value temporaries
-                        static void resolveImplicitCalls( std::list< Declaration * > & translationUnit );
+                        static void resolveImplicitCalls( std::list< Declaration * > & translationUnit, const EnvMap & envMap );
 
                         typedef SymTab::Indexer Parent;
                         using Parent::visit;
 
+                        ResolveCopyCtors( const EnvMap & envMap ) : envMap( envMap ) {}
+
                         virtual void visit( ImplicitCopyCtorExpr * impCpCtorExpr ) override;
-                        virtual void visit( UniqueExpr * unqExpr );
+                        virtual void visit( UniqueExpr * unqExpr ) override;
+                        virtual void visit( StmtExpr * stmtExpr ) override;
 
                         /// create and resolve ctor/dtor expression: fname(var, [cpArg])
@@ -79 +90 @@
                         void copyConstructArg( Expression *& arg, ImplicitCopyCtorExpr * impCpCtorExpr );
                         void destructRet( Expression * ret, ImplicitCopyCtorExpr * impCpCtorExpr );
-                private:
+
                         TypeSubstitution * env;
+                        const EnvMap & envMap;
                 };
 
@@ -174 +186 @@
                         static void fixInitializers( std::list< Declaration * > &translationUnit );
 
-                        using GenPoly::PolyMutator::mutate;
+                        typedef GenPoly::PolyMutator Parent;
+                        using Parent::mutate;
                         virtual DeclarationWithType * mutate( ObjectDecl *objDecl ) override;
 
@@ -186 +199 @@
                         static void fixCopyCtors( std::list< Declaration * > &translationUnit );
 
-                        using GenPoly::PolyMutator::mutate;
+                        typedef GenPoly::PolyMutator Parent;
+                        using Parent::mutate;
                         virtual Expression * mutate( ImplicitCopyCtorExpr * impCpCtorExpr ) override;
                         virtual Expression * mutate( UniqueExpr * unqExpr ) override;
+                        virtual Expression * mutate( StmtExpr * stmtExpr ) override;
                 };
 
@@ -248 +263 @@
                 InitTweak::fixGlobalInit( translationUnit, filename, inLibrary );
 
-
-                InsertImplicitCalls::insert( translationUnit );
-                ResolveCopyCtors::resolveImplicitCalls( translationUnit );
+                EnvMap envMap;
+
+                InsertImplicitCalls::insert( translationUnit, envMap );
+                ResolveCopyCtors::resolveImplicitCalls( translationUnit, envMap );
                 InsertDtors::insert( translationUnit );
                 FixInit::fixInitializers( translationUnit );
@@ -269 +285 @@
 
         namespace {
-                void InsertImplicitCalls::insert( std::list< Declaration * > & translationUnit ) {
-                        InsertImplicitCalls inserter;
+                void InsertImplicitCalls::insert( std::list< Declaration * > & translationUnit, EnvMap & envMap ) {
+                        InsertImplicitCalls inserter( envMap );
                         mutateAll( translationUnit, inserter );
                 }
 
-                void ResolveCopyCtors::resolveImplicitCalls( std::list< Declaration * > & translationUnit ) {
-                        ResolveCopyCtors resolver;
+                void ResolveCopyCtors::resolveImplicitCalls( std::list< Declaration * > & translationUnit, const EnvMap & envMap ) {
+                        ResolveCopyCtors resolver( envMap );
                         acceptAll( translationUnit, resolver );
                 }
@@ -326 +342 @@
 
                 Expression * InsertImplicitCalls::mutate( ApplicationExpr * appExpr ) {
-                        appExpr = dynamic_cast< ApplicationExpr * >( Mutator::mutate( appExpr ) );
+                        appExpr = dynamic_cast< ApplicationExpr * >( Parent::mutate( appExpr ) );
                         assert( appExpr );
 
@@ -339 +355 @@
                                                 Type * t1 = ftype->get_parameters().front()->get_type();
                                                 Type * t2 = ftype->get_parameters().back()->get_type();
-                                                PointerType * ptrType = dynamic_cast< PointerType * > ( t1 );
-                                                assert( ptrType );
+                                                PointerType * ptrType = safe_dynamic_cast< PointerType * > ( t1 );
 
                                                 if ( ResolvExpr::typesCompatible( ptrType->get_base(), t2, SymTab::Indexer() ) ) {
@@ -357 +372 @@
                         // wrap each function call so that it is easy to identify nodes that have to be copy constructed
                         ImplicitCopyCtorExpr * expr = new ImplicitCopyCtorExpr( appExpr );
-                        // save the type substitution onto the new node so that it is easy to find.
+                        // save the type substitution into the envMap so that it is easy to find.
                         // Ensure it is not deleted with the ImplicitCopyCtorExpr by removing it before deletion.
                         // The substitution is needed to obtain the type of temporary variables so that copy constructor
@@ -366 +381 @@
                         // constructor calls together.
                         assert( env );
-                        expr->set_env( env );
+                        envMap[expr] = env;
                         return expr;
+                }
+
+                Expression * InsertImplicitCalls::mutate( StmtExpr * stmtExpr ) {
+                        assert( env );
+                        envMap[stmtExpr] = env;
+                        return Parent::mutate( stmtExpr );
                 }
 
@@ -392 +413 @@
                         assert( resolved );
                         if ( resolved->get_env() ) {
+                                // Extract useful information and discard new environments. Keeping them causes problems in PolyMutator passes.
                                 env->add( *resolved->get_env() );
+                                delete resolved->get_env();
+                                resolved->set_env( nullptr );
                         } // if
 
@@ -401 +425 @@
                 void ResolveCopyCtors::copyConstructArg( Expression *& arg, ImplicitCopyCtorExpr * impCpCtorExpr ) {
                         static UniqueName tempNamer("_tmp_cp");
-                        CP_CTOR_PRINT( std::cerr << "Type Substitution: " << *impCpCtorExpr->get_env() << std::endl; )
+                        assert( env );
+                        CP_CTOR_PRINT( std::cerr << "Type Substitution: " << *env << std::endl; )
                         assert( arg->has_result() );
                         Type * result = arg->get_result();
@@ -408 +433 @@
                         // type may involve type variables, so apply type substitution to get temporary variable's actual type
                         result = result->clone();
-                        impCpCtorExpr->get_env()->apply( result );
+                        env->apply( result );
                         ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, result, 0 );
                         tmp->get_type()->set_isConst( false );
@@ -437 +462 @@
                         CP_CTOR_PRINT( std::cerr << "ResolveCopyCtors: " << impCpCtorExpr << std::endl; )
                         Parent::visit( impCpCtorExpr );
-                        env = impCpCtorExpr->get_env(); // xxx - maybe we really should just have a PolyIndexer...
+                        env = envMap.at(impCpCtorExpr);
+                        assert( env );
 
                         ApplicationExpr * appExpr = impCpCtorExpr->get_callExpr();
@@ -448 +474 @@
                         // each return value from the call needs to be connected with an ObjectDecl at the call site, which is
                         // initialized with the return value and is destructed later
-                        // xxx - handle multiple return values
-                        ApplicationExpr * callExpr = impCpCtorExpr->get_callExpr();
-                        // xxx - is this right? callExpr may not have the right environment, because it was attached at a higher
-                        // level. Trying to pass that environment along.
-                        callExpr->set_env( impCpCtorExpr->get_env()->clone() );
+                        // xxx - handle named return values?
                         Type * result = appExpr->get_result();
                         if ( ! result->isVoid() ) {
                                 static UniqueName retNamer("_tmp_cp_ret");
                                 result = result->clone();
-                                impCpCtorExpr->get_env()->apply( result );
+                                env->apply( result );
                                 ObjectDecl * ret = new ObjectDecl( retNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, result, 0 );
                                 ret->get_type()->set_isConst( false );
@@ -468 +490 @@
                         } // for
                         CP_CTOR_PRINT( std::cerr << "after Resolving: " << impCpCtorExpr << std::endl; )
+                }
+
+                void ResolveCopyCtors::visit( StmtExpr * stmtExpr ) {
+                        Parent::visit( stmtExpr );
+                        env = envMap.at(stmtExpr);
+                        assert( stmtExpr->get_result() );
+                        Type * result = stmtExpr->get_result();
+                        if ( ! result->isVoid() ) {
+                                static UniqueName retNamer("_tmp_stmtexpr_ret");
+
+                                // create variable that will hold the result of the stmt expr
+                                result = result->clone();
+                                env->apply( result );
+                                ObjectDecl * ret = new ObjectDecl( retNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, result, 0 );
+                                ret->get_type()->set_isConst( false );
+                                stmtExpr->get_returnDecls().push_front( ret );
+
+                                // must have a non-empty body, otherwise it wouldn't have a result
+                                CompoundStmt * body = stmtExpr->get_statements();
+                                assert( ! body->get_kids().empty() );
+                                // must be an ExprStmt, otherwise it wouldn't have a result
+                                ExprStmt * last = safe_dynamic_cast< ExprStmt * >( body->get_kids().back() );
+                                last->set_expr( makeCtorDtor( "?{}", ret, last->get_expr() ) );
+
+                                stmtExpr->get_dtors().push_front( makeCtorDtor( "^?{}", new AddressExpr( new VariableExpr( ret ) ) ) );
+                        } // if
+
                 }
 
@@ -492 +541 @@
                 }
 
-
                 Expression * FixCopyCtors::mutate( ImplicitCopyCtorExpr * impCpCtorExpr ) {
                         CP_CTOR_PRINT( std::cerr << "FixCopyCtors: " << impCpCtorExpr << std::endl; )
 
-                        impCpCtorExpr = dynamic_cast< ImplicitCopyCtorExpr * >( Mutator::mutate( impCpCtorExpr ) );
-                        assert( impCpCtorExpr );
-
+                        impCpCtorExpr = safe_dynamic_cast< ImplicitCopyCtorExpr * >( Parent::mutate( impCpCtorExpr ) );
                         std::list< ObjectDecl * > & tempDecls = impCpCtorExpr->get_tempDecls();
                         std::list< ObjectDecl * > & returnDecls = impCpCtorExpr->get_returnDecls();
@@ -558 +604 @@
                                         retExpr = UntypedExpr::createDeref( retExpr );
                                 } // if
-                                retExpr->set_env( env->clone() );
+                                // move env from callExpr to retExpr
+                                retExpr->set_env( callExpr->get_env() );
+                                callExpr->set_env( nullptr );
                                 return retExpr;
                         } else {
@@ -565 +613 @@
                 }
 
+                Expression * FixCopyCtors::mutate( StmtExpr * stmtExpr ) {
+                        stmtExpr = safe_dynamic_cast< StmtExpr * >( Parent::mutate( stmtExpr ) );
+                        assert( stmtExpr->get_result() );
+                        Type * result = stmtExpr->get_result();
+                        if ( ! result->isVoid() ) {
+                                for ( ObjectDecl * obj : stmtExpr->get_returnDecls() ) {
+                                        stmtsToAdd.push_back( new DeclStmt( noLabels, obj ) );
+                                } // for
+                                // add destructors after current statement
+                                for ( Expression * dtor : stmtExpr->get_dtors() ) {
+                                        stmtsToAddAfter.push_back( new ExprStmt( noLabels, dtor ) );
+                                } // for
+                                // must have a non-empty body, otherwise it wouldn't have a result
+                                CompoundStmt * body = stmtExpr->get_statements();
+                                assert( ! body->get_kids().empty() );
+                                assert( ! stmtExpr->get_returnDecls().empty() );
+                                body->get_kids().push_back( new ExprStmt( noLabels, new VariableExpr( stmtExpr->get_returnDecls().front() ) ) );
+                        }
+                        stmtExpr->get_returnDecls().clear();
+                        stmtExpr->get_dtors().clear();
+                        return stmtExpr;
+                }
+
                 Expression * FixCopyCtors::mutate( UniqueExpr * unqExpr ) {
                         static std::unordered_map< int, UniqueExpr * > unqMap;
                         static std::unordered_set< int > addDeref;
                         // has to be done to clean up ImplicitCopyCtorExpr nodes, even when this node was skipped in previous passes
-                        unqExpr = safe_dynamic_cast< UniqueExpr * >( Parent::mutate( unqExpr ) );
                         if ( unqMap.count( unqExpr->get_id() ) ) {
                                 // take data from other UniqueExpr to ensure consistency
@@ -582 +652 @@
                                 return unqExpr;
                         }
+                        unqExpr = safe_dynamic_cast< UniqueExpr * >( Parent::mutate( unqExpr ) ); // stmtexprs contained should not be separately fixed, so this must occur after the lookup
                         unqMap[unqExpr->get_id()] = unqExpr;
                         if ( UntypedExpr * deref = dynamic_cast< UntypedExpr * >( unqExpr->get_expr() ) ) {
@@ -599 +670 @@
                         // first recursively handle pieces of ObjectDecl so that they aren't missed by other visitors when the init
                         // is removed from the ObjectDecl
-                        objDecl = dynamic_cast< ObjectDecl * >( Mutator::mutate( objDecl ) );
-
+                        objDecl = dynamic_cast< ObjectDecl * >( Parent::mutate( objDecl ) );
                         if ( ConstructorInit * ctorInit = dynamic_cast< ConstructorInit * >( objDecl->get_init() ) ) {
                                 // a decision should have been made by the resolver, so ctor and init are not both non-NULL