Changeset ae1b9ea

Timestamp:

Oct 19, 2017, 11:15:36 AM (7 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:

a365e0d

Parents:

aabc60c

git-author:

Rob Schluntz <rschlunt@…> (10/17/17 17:10:04)

git-committer:

Rob Schluntz <rschlunt@…> (10/19/17 11:15:36)

Message:

Always copy construct arguments that require boxing

Location:

src

Files:

• GenPoly/Box.cc (modified) (1 diff)
• GenPoly/GenPoly.cc (modified) (1 diff)
• GenPoly/GenPoly.h (modified) (1 diff)
• InitTweak/FixInit.cc (modified) (8 diffs)

src/GenPoly/Box.cc

@@ -715 +715 @@
                 void Pass1::boxParam( Type *param, Expression *&arg, const TyVarMap &exprTyVars ) {
                         assertf( arg->result, "arg does not have result: %s", toString( arg ).c_str() );
-                        if ( isPolyType( param, exprTyVars ) ) {
-                                Type * newType = arg->get_result()->clone();
+                        if ( ! needsBoxing( param, arg->result, exprTyVars, env ) ) return;
+
+                        if ( arg->result->get_lvalue() ) {
+                                // argument expression may be CFA lvalue, but not C lvalue -- apply generalizedLvalue transformations.
+                                // if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( arg ) ) {
+                                //      if ( dynamic_cast<ArrayType *>( varExpr->var->get_type() ) ){
+                                //              // temporary hack - don't box arrays, because &arr is not the same as &arr[0]
+                                //              return;
+                                //      }
+                                // }
+                                arg =  generalizedLvalue( new AddressExpr( arg ) );
+                                if ( ! ResolvExpr::typesCompatible( param, arg->get_result(), SymTab::Indexer() ) ) {
+                                        // silence warnings by casting boxed parameters when the actual type does not match up with the formal type.
+                                        arg = new CastExpr( arg, param->clone() );
+                                }
+                        } else {
+                                // use type computed in unification to declare boxed variables
+                                Type * newType = param->clone();
                                 if ( env ) env->apply( newType );
-                                std::unique_ptr<Type> manager( newType );
-                                if ( isPolyType( newType ) ) {
-                                        // if the argument's type is polymorphic, we don't need to box again!
-                                        return;
-                                } else if ( arg->get_result()->get_lvalue() ) {
-                                        // argument expression may be CFA lvalue, but not C lvalue -- apply generalizedLvalue transformations.
-                                        // if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( arg ) ) {
-                                        //      if ( dynamic_cast<ArrayType *>( varExpr->var->get_type() ) ){
-                                        //              // temporary hack - don't box arrays, because &arr is not the same as &arr[0]
-                                        //              return;
-                                        //      }
-                                        // }
-                                        arg =  generalizedLvalue( new AddressExpr( arg ) );
-                                        if ( ! ResolvExpr::typesCompatible( param, arg->get_result(), SymTab::Indexer() ) ) {
-                                                // silence warnings by casting boxed parameters when the actual type does not match up with the formal type.
-                                                arg = new CastExpr( arg, param->clone() );
-                                        }
-                                } else {
-                                        // use type computed in unification to declare boxed variables
-                                        Type * newType = param->clone();
-                                        if ( env ) env->apply( newType );
-                                        ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, newType, 0 );
-                                        newObj->get_type()->get_qualifiers() = Type::Qualifiers(); // TODO: is this right???
-                                        stmtsToAddBefore.push_back( new DeclStmt( noLabels, newObj ) );
-                                        UntypedExpr *assign = new UntypedExpr( new NameExpr( "?=?" ) ); // TODO: why doesn't this just use initialization syntax?
-                                        assign->get_args().push_back( new VariableExpr( newObj ) );
-                                        assign->get_args().push_back( arg );
-                                        stmtsToAddBefore.push_back( new ExprStmt( noLabels, assign ) );
-                                        arg = new AddressExpr( new VariableExpr( newObj ) );
-                                } // if
+                                ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, newType, 0 );
+                                newObj->get_type()->get_qualifiers() = Type::Qualifiers(); // TODO: is this right???
+                                stmtsToAddBefore.push_back( new DeclStmt( noLabels, newObj ) );
+                                UntypedExpr *assign = new UntypedExpr( new NameExpr( "?=?" ) ); // TODO: why doesn't this just use initialization syntax?
+                                assign->get_args().push_back( new VariableExpr( newObj ) );
+                                assign->get_args().push_back( arg );
+                                stmtsToAddBefore.push_back( new ExprStmt( noLabels, assign ) );
+                                arg = new AddressExpr( new VariableExpr( newObj ) );
                         } // if
                 }

src/GenPoly/GenPoly.cc

@@ -432 +432 @@
         }
 
+        bool needsBoxing( Type * param, Type * arg, const TyVarMap &exprTyVars, TypeSubstitution * env ) {
+                // is parameter is not polymorphic, don't need to box
+                if ( ! isPolyType( param, exprTyVars ) ) return false;
+                Type * newType = arg->clone();
+                if ( env ) env->apply( newType );
+                std::unique_ptr<Type> manager( newType );
+                // if the argument's type is polymorphic, we don't need to box again!
+                return ! isPolyType( newType );
+        }
+
+        bool needsBoxing( Type * param, Type * arg, ApplicationExpr * appExpr, TypeSubstitution * env ) {
+                FunctionType * function = getFunctionType( appExpr->function->result );
+                assertf( function, "ApplicationExpr has non-function type: %s", toString( appExpr->function->result ).c_str() );
+                TyVarMap exprTyVars( TypeDecl::Data{} );
+                makeTyVarMap( function, exprTyVars );
+                return needsBoxing( param, arg, exprTyVars, env );
+        }
+
         void addToTyVarMap( TypeDecl * tyVar, TyVarMap &tyVarMap ) {
                 // xxx - should this actually be insert?

src/GenPoly/GenPoly.h

@@ -80 +80 @@
         bool typesPolyCompatible( Type *aty, Type *bty );
 
+        /// true if arg requires boxing given exprTyVars
+        bool needsBoxing( Type * param, Type * arg, const TyVarMap &exprTyVars, TypeSubstitution * env );
+
+        /// true if arg requires boxing in the call to appExpr
+        bool needsBoxing( Type * param, Type * arg, ApplicationExpr * appExpr, TypeSubstitution * env );
+
         /// Adds the type variable `tyVar` to `tyVarMap`
         void addToTyVarMap( TypeDecl * tyVar, TyVarMap &tyVarMap );

src/InitTweak/FixInit.cc

@@ -93 +93 @@
                         /// true if type does not need to be copy constructed to ensure correctness
                         bool skipCopyConstruct( Type * type );
-                        void copyConstructArg( Expression *& arg, ImplicitCopyCtorExpr * impCpCtorExpr );
+                        void copyConstructArg( Expression *& arg, ImplicitCopyCtorExpr * impCpCtorExpr, Type * formal );
                         void destructRet( ObjectDecl * ret, ImplicitCopyCtorExpr * impCpCtorExpr );
 
@@ -260 +260 @@
 
                 GenStructMemberCalls::generate( translationUnit );
+
                 // xxx - ctor expansion currently has to be after FixCopyCtors, because there is currently a
                 // hack in the way untyped assignments are generated, where the first argument cannot have
@@ -384 +385 @@
                 }
 
-                void ResolveCopyCtors::copyConstructArg( Expression *& arg, ImplicitCopyCtorExpr * impCpCtorExpr ) {
+                void ResolveCopyCtors::copyConstructArg( Expression *& arg, ImplicitCopyCtorExpr * impCpCtorExpr, Type * formal ) {
                         static UniqueName tempNamer("_tmp_cp");
                         assert( env );
                         CP_CTOR_PRINT( std::cerr << "Type Substitution: " << *env << std::endl; )
                         assert( arg->result );
-                        Type * result = arg->get_result();
+                        Type * result = arg->result;
                         if ( skipCopyConstruct( result ) ) return; // skip certain non-copyable types
 
-                        // type may involve type variables, so apply type substitution to get temporary variable's actual type
+                        // type may involve type variables, so apply type substitution to get temporary variable's actual type.
+                        // Use applyFree so that types bound in function pointers are not substituted, e.g. in forall(dtype T) void (*)(T).
                         result = result->clone();
-                        env->apply( result );
+                        env->applyFree( result );
                         ObjectDecl * tmp = ObjectDecl::newObject( "__tmp", result, nullptr );
                         tmp->get_type()->set_const( false );
@@ -405 +407 @@
                                 // 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 * >( appExpr->get_function() );
-                                assert( function );
-                                if ( function->get_var()->get_linkage() == LinkageSpec::Intrinsic ) return;
+                                VariableExpr * function = strict_dynamic_cast< VariableExpr * >( appExpr->function );
+                                if ( function->var->linkage == LinkageSpec::Intrinsic ) {
+                                        // arguments that need to be boxed need a temporary regardless of whether the copy constructor is intrinsic,
+                                        // so that the object isn't changed inside of the polymorphic function
+                                        if ( ! GenPoly::needsBoxing( formal, result, impCpCtorExpr->callExpr, env ) ) return;
+                                }
                         }
 
@@ -415 +420 @@
                         // replace argument to function call with temporary
                         arg = new CommaExpr( cpCtor, new VariableExpr( tmp ) );
-                        impCpCtorExpr->get_tempDecls().push_back( tmp );
-                        impCpCtorExpr->get_dtors().push_front( makeCtorDtor( "^?{}", tmp ) );
+                        impCpCtorExpr->tempDecls.push_back( tmp );
+                        impCpCtorExpr->dtors.push_front( makeCtorDtor( "^?{}", tmp ) );
                 }
 
@@ -426 +431 @@
                         CP_CTOR_PRINT( std::cerr << "ResolveCopyCtors: " << impCpCtorExpr << std::endl; )
 
-                        ApplicationExpr * appExpr = impCpCtorExpr->get_callExpr();
+                        ApplicationExpr * appExpr = impCpCtorExpr->callExpr;
 
                         // take each argument and attempt to copy construct it.
-                        for ( Expression * & arg : appExpr->get_args() ) {
-                                copyConstructArg( arg, impCpCtorExpr );
+                        FunctionType * ftype = GenPoly::getFunctionType( appExpr->function->result );
+                        assert( ftype );
+                        auto & params = ftype->parameters;
+                        auto iter = params.begin();
+                        for ( Expression * & arg : appExpr->args ) {
+                                Type * formal = nullptr;
+                                if ( iter != params.end() ) {
+                                        DeclarationWithType * param = *iter++;
+                                        formal = param->get_type();
+                                }
+
+                                copyConstructArg( arg, impCpCtorExpr, formal );
                         } // for
 
@@ -436 +451 @@
                         // initialized with the return value and is destructed later
                         // xxx - handle named return values?
-                        Type * result = appExpr->get_result();
+                        Type * result = appExpr->result;
                         if ( ! result->isVoid() ) {
                                 static UniqueName retNamer("_tmp_cp_ret");
@@ -442 +457 @@
                                 env->apply( result );
                                 ObjectDecl * ret = ObjectDecl::newObject( retNamer.newName(), result, nullptr );
-                                ret->get_type()->set_const( false );
-                                impCpCtorExpr->get_returnDecls().push_back( ret );
+                                ret->type->set_const( false );
+                                impCpCtorExpr->returnDecls.push_back( ret );
                                 CP_CTOR_PRINT( std::cerr << "makeCtorDtor for a return" << std::endl; )
                                 if ( ! dynamic_cast< ReferenceType * >( result ) ) {