Changeset db4ecc5 for src/InitTweak/FixInit.cc

Timestamp:

Apr 14, 2016, 3:22:42 PM (8 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, ctor, deferred_resn, demangler, enum, forall-pointer-decay, gc_noraii, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

70a06f6

Parents:

7eabc25

Message:

add ImplicitCopyCtorExpr? node, implicit copy constructors are inserted into the right places (but there is room for elision)

File:

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

src/InitTweak/FixInit.cc

@@ -10 +10 @@
 // Created On       : Wed Jan 13 16:29:30 2016
 // Last Modified By : Rob Schluntz
-// Last Modified On : Thu Mar 31 13:54:58 2016
+// Last Modified On : Thu Apr 14 15:19:11 2016
 // Update Count     : 30
 //
@@ -17 +17 @@
 #include <list>
 #include "RemoveInit.h"
+#include "ResolvExpr/Resolver.h"
 #include "SynTree/Declaration.h"
 #include "SynTree/Type.h"
@@ -23 +24 @@
 #include "SynTree/Initializer.h"
 #include "SynTree/Mutator.h"
+#include "SymTab/Indexer.h"
 #include "GenPoly/PolyMutator.h"
 
@@ -31 +33 @@
         }
 
+        class InsertImplicitCalls : public Mutator {
+        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 );
+
+                virtual Expression * mutate( ApplicationExpr * appExpr );
+        };
+
+        class ResolveCopyCtors : public SymTab::Indexer {
+        public:
+                /// 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 );
+
+                virtual void visit( ImplicitCopyCtorExpr * impCpCtorExpr );
+
+                /// create and resolve ctor/dtor expression: fname(var, [cpArg])
+                ApplicationExpr * makeCtorDtor( const std::string & fname, ObjectDecl * var, Expression * cpArg = NULL );
+        };
+
         class FixInit : public GenPoly::PolyMutator {
           public:
+                /// expand each object declaration to use its constructor after it is declared.
+                /// insert destructor calls at the appropriate places
                 static void fixInitializers( std::list< Declaration * > &translationUnit );
 
-                virtual ObjectDecl * mutate( ObjectDecl *objDecl );
+                virtual DeclarationWithType * mutate( ObjectDecl *objDecl );
 
                 virtual CompoundStmt * mutate( CompoundStmt * compoundStmt );
@@ -46 +73 @@
         };
 
+        class FixCopyCtors : public GenPoly::PolyMutator {
+          public:
+                /// expand ImplicitCopyCtorExpr nodes into the temporary declarations, copy constructors,
+                /// call expression, and destructors
+                static void fixCopyCtors( std::list< Declaration * > &translationUnit );
+
+                virtual Expression * mutate( ImplicitCopyCtorExpr * impCpCtorExpr );
+
+          private:
+                // stack of list of statements - used to differentiate scopes
+                std::list< std::list< Statement * > > dtorStmts;
+        };
+
         void fix( std::list< Declaration * > & translationUnit ) {
+                InsertImplicitCalls::insert( translationUnit );
+                ResolveCopyCtors::resolveImplicitCalls( translationUnit );
                 FixInit::fixInitializers( translationUnit );
+                // FixCopyCtors must happen after FixInit, so that destructors are placed correctly
+                FixCopyCtors::fixCopyCtors( translationUnit );
+        }
+
+        void InsertImplicitCalls::insert( std::list< Declaration * > & translationUnit ) {
+                InsertImplicitCalls inserter;
+                mutateAll( translationUnit, inserter );
+        }
+
+        void ResolveCopyCtors::resolveImplicitCalls( std::list< Declaration * > & translationUnit ) {
+                ResolveCopyCtors resolver;
+                acceptAll( translationUnit, resolver );
         }
 
@@ -55 +109 @@
         }
 
-        ObjectDecl *FixInit::mutate( ObjectDecl *objDecl ) {
+        void FixCopyCtors::fixCopyCtors( std::list< Declaration * > & translationUnit ) {
+                FixCopyCtors fixer;
+                mutateAll( translationUnit, fixer );
+        }
+
+        Expression * InsertImplicitCalls::mutate( ApplicationExpr * appExpr ) {
+                if ( VariableExpr * function = dynamic_cast< VariableExpr * > ( appExpr->get_function() ) ) {
+                        if ( function->get_var()->get_linkage() == LinkageSpec::Intrinsic ) {
+                                // optimization: don't need to copy construct in order to call intrinsic functions
+                                return appExpr;
+                        } else if ( FunctionDecl * func = dynamic_cast< FunctionDecl * > ( function->get_var() ) ) {
+                                // if (  )
+                                // // optimization: don't need to copy construct in order to call a copy constructor
+                                // return appExpr;
+                        }
+                }
+                // wrap each function call so that it is easy to identify nodes that have to be copy constructed
+                appExpr = dynamic_cast< ApplicationExpr * >( Mutator::mutate( appExpr ) );
+                assert( appExpr );
+                return new ImplicitCopyCtorExpr( appExpr );
+        }
+
+        ApplicationExpr * ResolveCopyCtors::makeCtorDtor( const std::string & fname, ObjectDecl * var, Expression * cpArg ) {
+                assert( var );
+                UntypedExpr * untyped = new UntypedExpr( new NameExpr( fname ) );
+                untyped->get_args().push_back( new AddressExpr( new VariableExpr( var ) ) );
+                if (cpArg) untyped->get_args().push_back( cpArg );
+
+                // resolve copy constructor
+                // should only be one alternative for copy ctor and dtor expressions, since
+                // all arguments are fixed (VariableExpr and already resolved expression)
+                ApplicationExpr * resolved = dynamic_cast< ApplicationExpr * >( ResolvExpr::findVoidExpression( untyped, *this ) );
+
+                assert( resolved );
+                delete untyped;
+                return resolved;
+        }
+
+        void ResolveCopyCtors::visit( ImplicitCopyCtorExpr *impCpCtorExpr ) {
+                static UniqueName tempNamer("_tmp_cp");
+                static UniqueName retNamer("_tmp_cp_ret");
+
+                // resolve function call
+                Expression * newExpr = ResolvExpr::findVoidExpression( impCpCtorExpr->get_callExpr(), *this );
+                delete impCpCtorExpr->get_callExpr();
+                ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( newExpr );
+                assert( appExpr );
+                impCpCtorExpr->set_callExpr( appExpr );
+
+                // take each argument and attempt to copy construct it.
+                for ( Expression * & arg : appExpr->get_args() ) {
+                        // xxx - need to handle tuple arguments
+                        assert( ! arg->get_results().empty() );
+                        ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, arg->get_results().front()->clone(), 0 );
+
+                        // create and resolve copy constructor
+                        ApplicationExpr * cpCtor = makeCtorDtor( "?{}", tmp, arg );
+
+                        // if the chosen constructor is intrinsic, the copy is unnecessary, so
+                        // don't create the temporary and don't call the copy constructor
+                        VariableExpr * function = dynamic_cast< VariableExpr * >( cpCtor->get_function() );
+                        assert( function );
+                        if ( function->get_var()->get_linkage() != LinkageSpec::Intrinsic ) {
+                                // replace argument to function call with temporary
+                                arg = new VariableExpr( tmp );
+                                impCpCtorExpr->get_tempDecls().push_back( tmp );
+                                impCpCtorExpr->get_copyCtors().push_back( cpCtor );
+                                impCpCtorExpr->get_dtors().push_front( makeCtorDtor( "^?{}", tmp ) );
+                        }
+                }
+
+                // 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
+                for ( Type * result : appExpr->get_results() ) {
+                        ObjectDecl * ret = new ObjectDecl( retNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, result->clone(), new SingleInit( impCpCtorExpr->get_callExpr() ) );
+                        impCpCtorExpr->get_returnDecls().push_back( ret );
+                        impCpCtorExpr->get_dtors().push_front( makeCtorDtor( "^?{}", ret ) );
+                }
+        }
+
+
+        Expression * FixCopyCtors::mutate( ImplicitCopyCtorExpr * impCpCtorExpr ) {
+                impCpCtorExpr = dynamic_cast< ImplicitCopyCtorExpr * >( Mutator::mutate( impCpCtorExpr ) );
+                assert( impCpCtorExpr );
+                std::cerr << "Running FixCopyCtors on implicit copy ctor..." << std::endl;
+
+                std::list< Expression * > & copyCtors = impCpCtorExpr->get_copyCtors();
+                std::list< ObjectDecl * > & tempDecls = impCpCtorExpr->get_tempDecls();
+                std::list< ObjectDecl * > & returnDecls = impCpCtorExpr->get_returnDecls();
+                std::list< Expression * > & dtors = impCpCtorExpr->get_dtors();
+
+                // add all temporary declarations and their constructors
+                for ( ObjectDecl * obj : tempDecls ) {
+                        assert( ! copyCtors.empty() );
+                        stmtsToAdd.push_back( new DeclStmt( noLabels, obj ) );
+                        stmtsToAdd.push_back( new ExprStmt( noLabels, copyCtors.front() ) );
+                        copyCtors.pop_front();
+                }
+
+                // add destructors after current statement
+                for ( Expression * dtor : dtors ) {
+                        stmtsToAddAfter.push_back( new ExprStmt( noLabels, dtor ) );
+                }
+
+                // xxx - update to work with multiple return values
+                ObjectDecl * returnDecl = returnDecls.empty() ? NULL : returnDecls.front();
+
+                // xxx - some of these aren't necessary, and can be removed once this is stable
+                copyCtors.clear();
+                dtors.clear();
+                tempDecls.clear();
+                returnDecls.clear();
+
+                if ( returnDecl ) {
+                        // call is currently attached to first returnDecl
+                        stmtsToAdd.push_back( new DeclStmt( noLabels, returnDecl ) );
+                        return new VariableExpr( returnDecl );
+                } else {
+                        // add call expression - if no return values, can call directly
+                        return impCpCtorExpr->get_callExpr();
+                }
+        }
+
+        DeclarationWithType *FixInit::mutate( ObjectDecl *objDecl ) {
+                // 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 ) );
+
                 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
@@ -170 +353 @@
                         insertDtors( list->begin(), list->end(), back_inserter( stmtsToAdd ) );
                 }
-                return returnStmt;
+                return Mutator::mutate( returnStmt );
         }
 
@@ -189 +372 @@
                                 assert( false );
                 }
-                return branchStmt;
+                return Mutator::mutate( branchStmt );
         }