Changeset 092528b for src/InitTweak

Timestamp:

Jan 23, 2017, 2:36:49 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:

0bfaf80

Parents:

207c7e1d

Message:

fix copy constructing/destructing qualified argument/return temporaries

Location:

src/InitTweak

Files:

• FixInit.cc (modified) (7 diffs)
• GenInit.cc (modified) (1 diff)
• GenInit.h (modified) (1 diff)

src/InitTweak/FixInit.cc

@@ -21 +21 @@
 #include <unordered_set>
 #include "InitTweak.h"
+#include "GenInit.h"
 #include "FixInit.h"
 #include "FixGlobalInit.h"
@@ -86 +87 @@
                         /// create and resolve ctor/dtor expression: fname(var, [cpArg])
                         Expression * makeCtorDtor( const std::string & fname, ObjectDecl * var, Expression * cpArg = NULL );
-                        Expression * makeCtorDtor( const std::string & fname, Expression * thisArg, Expression * cpArg = NULL );
                         /// true if type does not need to be copy constructed to ensure correctness
                         bool skipCopyConstruct( Type * type );
                         void copyConstructArg( Expression *& arg, ImplicitCopyCtorExpr * impCpCtorExpr );
-                        void destructRet( Expression * ret, ImplicitCopyCtorExpr * impCpCtorExpr );
+                        void destructRet( ObjectDecl * ret, ImplicitCopyCtorExpr * impCpCtorExpr );
 
                         TypeSubstitution * env;
@@ -398 +398 @@
                 Expression * ResolveCopyCtors::makeCtorDtor( const std::string & fname, ObjectDecl * var, Expression * cpArg ) {
                         assert( var );
-                        return makeCtorDtor( fname, new AddressExpr( new VariableExpr( var ) ), cpArg );
-                }
-
-                Expression * ResolveCopyCtors::makeCtorDtor( const std::string & fname, Expression * thisArg, Expression * cpArg ) {
-                        assert( thisArg );
-                        UntypedExpr * untyped = new UntypedExpr( new NameExpr( fname ) );
-                        untyped->get_args().push_back( thisArg );
-                        if (cpArg) untyped->get_args().push_back( cpArg->clone() );
+                        // arrays are not copy constructed, so this should always be an ExprStmt
+                        ImplicitCtorDtorStmt * stmt = genCtorDtor( fname, var, cpArg );
+                        ExprStmt * exprStmt = safe_dynamic_cast< ExprStmt * >( stmt->get_callStmt() );
+                        Expression * untyped = exprStmt->get_expr();
 
                         // resolve copy constructor
@@ -420 +416 @@
                         } // if
 
-                        delete untyped;
+                        delete stmt;
                         return resolved;
                 }
@@ -456 +452 @@
                 }
 
-                void ResolveCopyCtors::destructRet( Expression * ret, ImplicitCopyCtorExpr * impCpCtorExpr ) {
-                        impCpCtorExpr->get_dtors().push_front( makeCtorDtor( "^?{}", new AddressExpr( ret ) ) );
+                void ResolveCopyCtors::destructRet( ObjectDecl * ret, ImplicitCopyCtorExpr * impCpCtorExpr ) {
+                        impCpCtorExpr->get_dtors().push_front( makeCtorDtor( "^?{}", ret ) );
                 }
 
@@ -487 +483 @@
                                 if ( ! result->get_isLvalue() ) {
                                         // destructing lvalue returns is bad because it can cause multiple destructor calls to the same object - the returned object is not a temporary
-                                        destructRet( new VariableExpr( ret ), impCpCtorExpr );
+                                        destructRet( ret, impCpCtorExpr );
                                 }
                         } // for
@@ -515 +511 @@
                                 last->set_expr( makeCtorDtor( "?{}", ret, last->get_expr() ) );
 
-                                stmtExpr->get_dtors().push_front( makeCtorDtor( "^?{}", new AddressExpr( new VariableExpr( ret ) ) ) );
+                                stmtExpr->get_dtors().push_front( makeCtorDtor( "^?{}", ret ) );
                         } // if
 

src/InitTweak/GenInit.cc

@@ -247 +247 @@
                         managedTypes.insert( SymTab::Mangler::mangle( type->get_base() ) );
                 }
+        }
+
+        ImplicitCtorDtorStmt * genCtorDtor( const std::string & fname, ObjectDecl * objDecl, Expression * arg ) {
+                // call into genImplicitCall from Autogen.h to generate calls to ctor/dtor
+                assertf( objDecl, "genCtorDtor passed null objDecl" );
+                std::list< Statement * > stmts;
+                InitExpander srcParam( maybeClone( arg ) );
+                SymTab::genImplicitCall( srcParam, new VariableExpr( objDecl ), fname, back_inserter( stmts ), objDecl );
+                assert( stmts.size() <= 1 );
+                return stmts.size() == 1 ? safe_dynamic_cast< ImplicitCtorDtorStmt * >( stmts.front() ) : nullptr;
         }
 

src/InitTweak/GenInit.h

@@ -28 +28 @@
         void genInit( std::list< Declaration * > & translationUnit );
 
+  /// generates a single ctor/dtor statement using objDecl as the 'this' parameter and arg as the optional argument
+  ImplicitCtorDtorStmt * genCtorDtor( const std::string & fname, ObjectDecl * objDecl, Expression * arg = nullptr );
+
         /// creates an appropriate ConstructorInit node which contains a constructor, destructor, and C-initializer
         ConstructorInit * genCtorInit( ObjectDecl * objDecl );