Changeset 8024bc8 for src/InitTweak/FixInit.cc

Timestamp:

Sep 18, 2017, 11:02:23 AM (7 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:

6994d8c

Parents:

ed235b6 (diff), 5f782f7 (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/InitTweak/FixInit.cc (modified) (23 diffs)

src/InitTweak/FixInit.cc

@@ -70 +70 @@
 namespace InitTweak {
         namespace {
-                typedef std::unordered_map< Expression *, TypeSubstitution * > EnvMap;
                 typedef std::unordered_map< int, int > UnqCount;
 
-                class InsertImplicitCalls : public WithTypeSubstitution {
-                public:
+                struct InsertImplicitCalls : public WithTypeSubstitution {
                         /// 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, EnvMap & envMap );
-
-                        InsertImplicitCalls( EnvMap & envMap ) : envMap( envMap ) {}
+                        static void insert( std::list< Declaration * > & translationUnit );
 
                         Expression * postmutate( ApplicationExpr * appExpr );
-                        void premutate( StmtExpr * stmtExpr );
-
-                        // collects environments for relevant nodes
-                        EnvMap & envMap;
                 };
 
-                class ResolveCopyCtors final : public SymTab::Indexer {
-                public:
+                struct ResolveCopyCtors final : public WithIndexer, public WithShortCircuiting, public WithTypeSubstitution {
                         /// generate temporary ObjectDecls for each argument and return value of each ImplicitCopyCtorExpr,
                         /// 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, const EnvMap & envMap, UnqCount & unqCount );
-
-                        typedef SymTab::Indexer Parent;
-                        using Parent::visit;
-
-                        ResolveCopyCtors( const EnvMap & envMap, UnqCount & unqCount ) : envMap( envMap ), unqCount( unqCount ) {}
-
-                        virtual void visit( ImplicitCopyCtorExpr * impCpCtorExpr ) override;
-                        virtual void visit( UniqueExpr * unqExpr ) override;
-                        virtual void visit( StmtExpr * stmtExpr ) override;
+                        static void resolveImplicitCalls( std::list< Declaration * > & translationUnit, UnqCount & unqCount );
+
+                        ResolveCopyCtors( UnqCount & unqCount ) : unqCount( unqCount ) {}
+
+                        void postvisit( ImplicitCopyCtorExpr * impCpCtorExpr );
+                        void postvisit( StmtExpr * stmtExpr );
+                        void previsit( UniqueExpr * unqExpr );
+                        void postvisit( UniqueExpr * unqExpr );
 
                         /// create and resolve ctor/dtor expression: fname(var, [cpArg])
@@ -111 +100 @@
                         void destructRet( ObjectDecl * ret, ImplicitCopyCtorExpr * impCpCtorExpr );
 
-                        TypeSubstitution * env;
-                        const EnvMap & envMap;
                         UnqCount & unqCount; // count the number of times each unique expr ID appears
+                        std::unordered_set< int > vars;
                 };
 
@@ -238 +226 @@
                 };
 
-                class GenStructMemberCalls final : public SymTab::Indexer {
-                  public:
-                        typedef Indexer Parent;
+                struct GenStructMemberCalls final : public WithGuards, public WithShortCircuiting, public WithIndexer {
                         /// generate default/copy ctor and dtor calls for user-defined struct ctor/dtors
                         /// for any member that is missing a corresponding ctor/dtor call.
@@ -246 +232 @@
                         static void generate( std::list< Declaration * > & translationUnit );
 
-                        using Parent::visit;
-
-                        virtual void visit( FunctionDecl * funcDecl ) override;
-
-                        virtual void visit( MemberExpr * memberExpr ) override;
-                        virtual void visit( ApplicationExpr * appExpr ) override;
+                        void previsit( FunctionDecl * funcDecl );
+                        void postvisit( FunctionDecl * funcDecl );
+
+                        void previsit( MemberExpr * memberExpr );
+                        void previsit( ApplicationExpr * appExpr );
 
                         SemanticError errors;
@@ -295 +280 @@
                 InitTweak::fixGlobalInit( translationUnit, filename, inLibrary );
 
-                EnvMap envMap;
                 UnqCount unqCount;
 
-                InsertImplicitCalls::insert( translationUnit, envMap );
-                ResolveCopyCtors::resolveImplicitCalls( translationUnit, envMap, unqCount );
+                InsertImplicitCalls::insert( translationUnit );
+                ResolveCopyCtors::resolveImplicitCalls( translationUnit, unqCount );
                 InsertDtors::insert( translationUnit );
                 FixInit::fixInitializers( translationUnit );
@@ -318 +302 @@
 
         namespace {
-                void InsertImplicitCalls::insert( std::list< Declaration * > & translationUnit, EnvMap & envMap ) {
-                        PassVisitor<InsertImplicitCalls> inserter( envMap );
+                void InsertImplicitCalls::insert( std::list< Declaration * > & translationUnit ) {
+                        PassVisitor<InsertImplicitCalls> inserter;
                         mutateAll( translationUnit, inserter );
                 }
 
-                void ResolveCopyCtors::resolveImplicitCalls( std::list< Declaration * > & translationUnit, const EnvMap & envMap, UnqCount & unqCount ) {
-                        ResolveCopyCtors resolver( envMap, unqCount );
+                void ResolveCopyCtors::resolveImplicitCalls( std::list< Declaration * > & translationUnit, UnqCount & unqCount ) {
+                        PassVisitor<ResolveCopyCtors> resolver( unqCount );
                         acceptAll( translationUnit, resolver );
                 }
@@ -360 +344 @@
 
                 void GenStructMemberCalls::generate( std::list< Declaration * > & translationUnit ) {
-                        GenStructMemberCalls warner;
+                        PassVisitor<GenStructMemberCalls> warner;
                         acceptAll( translationUnit, warner );
                 }
@@ -398 +382 @@
                         // 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 into the envMap so that it is easy to find.
+                        // Move the type substitution to the new top-level, if it is attached to the appExpr.
                         // 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
-                        // calls can be resolved. Normally this is what PolyMutator is for, but the pass that resolves
-                        // copy constructor calls must be an Indexer. We could alternatively make a PolyIndexer which
-                        // saves the environment, or compute the types of temporaries here, but it's much simpler to
-                        // save the environment here, and more cohesive to compute temporary variables and resolve copy
-                        // constructor calls together.
+                        // calls can be resolved.
                         assert( env );
-                        envMap[expr] = env;
+                        std::swap( expr->env, appExpr->env );
                         return expr;
-                }
-
-                void InsertImplicitCalls::premutate( StmtExpr * stmtExpr ) {
-                        assert( env );
-                        envMap[stmtExpr] = env;
                 }
 
@@ -431 +406 @@
                         // (VariableExpr and already resolved expression)
                         CP_CTOR_PRINT( std::cerr << "ResolvingCtorDtor " << untyped << std::endl; )
-                        Expression * resolved = ResolvExpr::findVoidExpression( untyped, *this );
+                        Expression * resolved = ResolvExpr::findVoidExpression( untyped, indexer );
                         assert( resolved );
                         if ( resolved->get_env() ) {
@@ -480 +455 @@
                 }
 
-                void ResolveCopyCtors::visit( ImplicitCopyCtorExpr *impCpCtorExpr ) {
+                void ResolveCopyCtors::postvisit( ImplicitCopyCtorExpr *impCpCtorExpr ) {
                         CP_CTOR_PRINT( std::cerr << "ResolveCopyCtors: " << impCpCtorExpr << std::endl; )
-                        Parent::visit( impCpCtorExpr );
-                        env = envMap.at(impCpCtorExpr);
-                        assert( env );
 
                         ApplicationExpr * appExpr = impCpCtorExpr->get_callExpr();
@@ -513 +485 @@
                 }
 
-                void ResolveCopyCtors::visit( StmtExpr * stmtExpr ) {
-                        Parent::visit( stmtExpr );
-                        env = envMap.at(stmtExpr);
+                void ResolveCopyCtors::postvisit( StmtExpr * stmtExpr ) {
+                        assert( env );
                         assert( stmtExpr->get_result() );
                         Type * result = stmtExpr->get_result();
@@ -537 +508 @@
                                 stmtExpr->get_dtors().push_front( makeCtorDtor( "^?{}", ret ) );
                         } // if
-
-                }
-
-                void ResolveCopyCtors::visit( UniqueExpr * unqExpr ) {
-                        static std::unordered_set< int > vars;
+                }
+
+                void ResolveCopyCtors::previsit( UniqueExpr * unqExpr ) {
                         unqCount[ unqExpr->get_id() ]++;  // count the number of unique expressions for each ID
                         if ( vars.count( unqExpr->get_id() ) ) {
                                 // xxx - hack to prevent double-handling of unique exprs, otherwise too many temporary variables and destructors are generated
+                                visit_children = false;
+                        }
+                }
+
+                void ResolveCopyCtors::postvisit( UniqueExpr * unqExpr ) {
+                        if ( vars.count( unqExpr->get_id() ) ) {
+                                // xxx - hack to prevent double-handling of unique exprs, otherwise too many temporary variables and destructors are generated
                                 return;
                         }
 
-                        Parent::visit( unqExpr );
                         // it should never be necessary to wrap a void-returning expression in a UniqueExpr - if this assumption changes, this needs to be rethought
                         assert( unqExpr->get_result() );
@@ -585 +560 @@
 
                         // xxx - update to work with multiple return values
-                        ObjectDecl * returnDecl = returnDecls.empty() ? NULL : returnDecls.front();
+                        ObjectDecl * returnDecl = returnDecls.empty() ? nullptr : returnDecls.front();
                         Expression * callExpr = impCpCtorExpr->get_callExpr();
 
@@ -594 +569 @@
                         tempDecls.clear();
                         returnDecls.clear();
-                        impCpCtorExpr->set_callExpr( NULL );
-                        impCpCtorExpr->set_env( NULL );
+                        impCpCtorExpr->set_callExpr( nullptr );
+                        std::swap( impCpCtorExpr->env, callExpr->env );
+                        assert( impCpCtorExpr->env == nullptr );
                         delete impCpCtorExpr;
 
@@ -978 +954 @@
                 }
 
-                void GenStructMemberCalls::visit( FunctionDecl * funcDecl ) {
-                        ValueGuard< FunctionDecl * > oldFunction( funcDecl );
-                        ValueGuard< std::set< DeclarationWithType * > > oldUnhandled( unhandled );
-                        ValueGuard< std::map< DeclarationWithType *, CodeLocation > > oldUsedUninit( usedUninit );
-                        ValueGuard< ObjectDecl * > oldThisParam( thisParam );
-                        ValueGuard< bool > oldIsCtor( isCtor );
-                        ValueGuard< StructDecl * > oldStructDecl( structDecl );
+                void GenStructMemberCalls::previsit( FunctionDecl * funcDecl ) {
+                        GuardValue( funcDecl );
+                        GuardValue( unhandled );
+                        GuardValue( usedUninit );
+                        GuardValue( thisParam );
+                        GuardValue( isCtor );
+                        GuardValue( structDecl );
                         errors = SemanticError();  // clear previous errors
 
@@ -1010 +986 @@
                                 }
                         }
-                        Parent::visit( function );
-
+                }
+
+                void addIds( SymTab::Indexer & indexer, const std::list< DeclarationWithType * > & decls ) {
+                        for ( auto d : decls ) {
+                                indexer.addId( d );
+                        }
+                }
+
+                void addTypes( SymTab::Indexer & indexer, const std::list< TypeDecl * > & tds ) {
+                        for ( auto td : tds ) {
+                                indexer.addType( td );
+                                addIds( indexer, td->assertions );
+                        }
+                }
+
+                void GenStructMemberCalls::postvisit( FunctionDecl * funcDecl ) {
                         // remove the unhandled objects from usedUninit, because a call is inserted
                         // to handle them - only objects that are later constructed are used uninitialized.
@@ -1032 +1022 @@
                         if ( ! unhandled.empty() ) {
                                 // need to explicitly re-add function parameters to the indexer in order to resolve copy constructors
-                                enterScope();
-                                maybeAccept( function->get_functionType(), *this );
+                                auto guard = makeFuncGuard( [this]() { indexer.enterScope(); }, [this]() { indexer.leaveScope(); } );
+                                addTypes( indexer, function->type->forall );
+                                addIds( indexer, function->type->returnVals );
+                                addIds( indexer, function->type->parameters );
 
                                 // need to iterate through members in reverse in order for
@@ -1063 +1055 @@
                                                 Statement * callStmt = stmt.front();
 
-                                                MutatingResolver resolver( *this );
+                                                MutatingResolver resolver( indexer );
                                                 try {
                                                         callStmt->acceptMutator( resolver );
@@ -1077 +1069 @@
                                         }
                                 }
-                                leaveScope();
                         }
                         if (! errors.isEmpty()) {
@@ -1107 +1098 @@
                 }
 
-                void GenStructMemberCalls::visit( ApplicationExpr * appExpr ) {
-                        if ( ! checkWarnings( function ) ) return;
+                void GenStructMemberCalls::previsit( ApplicationExpr * appExpr ) {
+                        if ( ! checkWarnings( function ) ) {
+                                visit_children = false;
+                                return;
+                        }
 
                         std::string fname = getFunctionName( appExpr );
@@ -1127 +1121 @@
                                 }
                         }
-                        Parent::visit( appExpr );
-                }
-
-                void GenStructMemberCalls::visit( MemberExpr * memberExpr ) {
-                        if ( ! checkWarnings( function ) ) return;
-                        if ( ! isCtor ) return;
+                }
+
+                void GenStructMemberCalls::previsit( MemberExpr * memberExpr ) {
+                        if ( ! checkWarnings( function ) || ! isCtor ) {
+                                visit_children = false;
+                                return;
+                        }
 
                         if ( isThisExpression( memberExpr->get_aggregate(), thisParam ) ) {
@@ -1140 +1135 @@
                                 }
                         }
-                        Parent::visit( memberExpr );
                 }
 
@@ -1161 +1155 @@
                         // in generated code. If this changes, add mutate methods for entities with
                         // scope and call {enter,leave}Scope explicitly.
-                        objectDecl->accept( indexer );
+                        indexer.addId( objectDecl );
                         return objectDecl;
                 }