Changeset 845cedc for src/InitTweak/FixInit.cc

Timestamp:

Apr 25, 2016, 2:49:55 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:

add371c

Parents:

67b1180

Message:

don't generate copy constructor calls for arguments to intrinsic functions, copy constructors, assignment operators, and destructors, fix problem with copying result type of ImplicitCopyCtorExpr? which caused expression resolution to fail

File:

• src/InitTweak/FixInit.cc (modified) (11 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 Apr 14 17:29:21 2016
+// Last Modified On : Mon Apr 25 14:44:21 2016
 // Update Count     : 30
 //
@@ -18 +18 @@
 #include "RemoveInit.h"
 #include "ResolvExpr/Resolver.h"
+#include "ResolvExpr/typeops.h"
 #include "SynTree/Declaration.h"
 #include "SynTree/Type.h"
@@ -27 +28 @@
 #include "GenPoly/PolyMutator.h"
 
+bool ctordtorp = false;
+#define PRINT( text ) if ( ctordtorp ) { text }
+
 namespace InitTweak {
         namespace {
@@ -115 +119 @@
 
         Expression * InsertImplicitCalls::mutate( ApplicationExpr * appExpr ) {
+                appExpr = dynamic_cast< ApplicationExpr * >( Mutator::mutate( appExpr ) );
+                assert( 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;
+                        } else if ( FunctionDecl * funcDecl = dynamic_cast< FunctionDecl * > ( function->get_var() ) ) {
+                                FunctionType * ftype = funcDecl->get_functionType();
+                                if ( (funcDecl->get_name() == "?{}" || funcDecl->get_name() == "?=?") && ftype->get_parameters().size() == 2 ) {
+                                        Type * t1 = ftype->get_parameters().front()->get_type();
+                                        Type * t2 = ftype->get_parameters().back()->get_type();
+                                        PointerType * ptrType = dynamic_cast< PointerType * > ( t1 );
+                                        assert( ptrType );
+                                        if ( ResolvExpr::typesCompatible( ptrType->get_base(), t2, SymTab::Indexer() ) ) {
+                                                // optimization: don't need to copy construct in order to call a copy constructor or
+                                                // assignment operator
+                                                return appExpr;
+                                        }
+                                } else if ( funcDecl->get_name() == "^?{}" ) {
+                                        // correctness: never copy construct arguments to a destructor
+                                        return appExpr;
+                                }
                         }
                 }
+                PRINT( std::cerr << "InsertImplicitCalls: adding a wrapper " << appExpr << std::endl; )
+
                 // 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 );
         }
@@ -140 +159 @@
                 // should only be one alternative for copy ctor and dtor expressions, since
                 // all arguments are fixed (VariableExpr and already resolved expression)
+                PRINT( std::cerr << "ResolvingCtorDtor " << untyped << std::endl; )
                 ApplicationExpr * resolved = dynamic_cast< ApplicationExpr * >( ResolvExpr::findVoidExpression( untyped, *this ) );
 
@@ -151 +171 @@
                 static UniqueName retNamer("_tmp_cp_ret");
 
-                // resolve function call
-                ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( ResolvExpr::findVoidExpression( impCpCtorExpr->get_callExpr(), *this ) );
-                assert( appExpr );
-                delete impCpCtorExpr->get_callExpr();
-                impCpCtorExpr->set_callExpr( appExpr );
-
-                // Visitor::visit( impCpCtorExpr );
+                PRINT( std::cerr << "ResolveCopyCtors: " << impCpCtorExpr << std::endl; )
+                Visitor::visit( impCpCtorExpr );
+
+                ApplicationExpr * appExpr = impCpCtorExpr->get_callExpr();
 
                 // take each argument and attempt to copy construct it.
@@ -167 +184 @@
 
                         // create and resolve copy constructor
+                        PRINT( std::cerr << "makeCtorDtor for an argument" << std::endl; )
                         ApplicationExpr * cpCtor = makeCtorDtor( "?{}", tmp, arg );
 
@@ -186 +204 @@
                 // later
                 // xxx - handle multiple return values
+                ApplicationExpr * callExpr = impCpCtorExpr->get_callExpr();
                 for ( Type * result : appExpr->get_results() ) {
-                        ObjectDecl * ret = new ObjectDecl( retNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, result->clone(), new SingleInit( impCpCtorExpr->get_callExpr() ) );
+                        ObjectDecl * ret = new ObjectDecl( retNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, result->clone(), new SingleInit( callExpr ) );
                         ret->get_type()->set_isConst( false );
                         impCpCtorExpr->get_returnDecls().push_back( ret );
+                        PRINT( std::cerr << "makeCtorDtor for a return" << std::endl; )
                         impCpCtorExpr->get_dtors().push_front( makeCtorDtor( "^?{}", ret ) );
                 }
+                PRINT( std::cerr << "after Resolving: " << impCpCtorExpr << std::endl; )
         }
 
 
         Expression * FixCopyCtors::mutate( ImplicitCopyCtorExpr * impCpCtorExpr ) {
+                PRINT( std::cerr << "FixCopyCtors: " << impCpCtorExpr << std::endl; )
+
+                // assert( impCpCtorExpr->get_callExpr()->get_env() );
                 impCpCtorExpr = dynamic_cast< ImplicitCopyCtorExpr * >( Mutator::mutate( impCpCtorExpr ) );
                 assert( impCpCtorExpr );
@@ -219 +243 @@
                 // xxx - update to work with multiple return values
                 ObjectDecl * returnDecl = returnDecls.empty() ? NULL : returnDecls.front();
+                Expression * callExpr = impCpCtorExpr->get_callExpr();
+
+                PRINT( std::cerr << "Coming out the back..." << impCpCtorExpr << std::endl; )
 
                 // xxx - some of these aren't necessary, and can be removed once this is stable
@@ -225 +252 @@
                 tempDecls.clear();
                 returnDecls.clear();
+                impCpCtorExpr->set_callExpr( NULL );
+                delete impCpCtorExpr;
 
                 if ( returnDecl ) {
@@ -232 +261 @@
                 } else {
                         // add call expression - if no return values, can call directly
-                        return impCpCtorExpr->get_callExpr();
+                        assert( callExpr );
+                        return callExpr;
                 }
         }