Changeset 6840e7c for src/InitTweak

Timestamp:

Oct 19, 2017, 12:01:04 PM (8 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, arm-eh, ast-experimental, cleanup-dtors, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

837ce06

Parents:

b96ec83 (diff), a15b72c (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' into cleanup-dtors

Location:

src/InitTweak

Files:

• FixInit.cc (modified) (20 diffs)
• GenInit.cc (modified) (10 diffs)
• GenInit.h (modified) (2 diffs)
• InitTweak.cc (modified) (6 diffs)
• InitTweak.h (modified) (2 diffs)

src/InitTweak/FixInit.cc

@@ -94 +94 @@
                         /// 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 );
 
@@ -259 +259 @@
 
                 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
@@ -288 +289 @@
                         for ( std::list< Declaration * >::iterator i = translationUnit.begin(); i != translationUnit.end(); ++i ) {
                                 try {
-                                        *i = maybeMutate( *i, fixer );
+                                        maybeMutate( *i, fixer );
                                         translationUnit.splice( i, fixer.pass.staticDtorDecls );
                                 } catch( SemanticError &e ) {
@@ -322 +323 @@
 
                 Expression * InsertImplicitCalls::postmutate( ApplicationExpr * appExpr ) {
-                        assert( appExpr );
-
                         if ( VariableExpr * function = dynamic_cast< VariableExpr * > ( appExpr->get_function() ) ) {
-                                if ( LinkageSpec::isBuiltin( function->get_var()->get_linkage() ) ) {
+                                if ( function->var->linkage.is_builtin ) {
                                         // optimization: don't need to copy construct in order to call intrinsic functions
                                         return appExpr;
@@ -331 +330 @@
                                         FunctionType * ftype = dynamic_cast< FunctionType * >( GenPoly::getFunctionType( funcDecl->get_type() ) );
                                         assertf( ftype, "Function call without function type: %s", toString( funcDecl ).c_str() );
-                                        if ( CodeGen::isConstructor( funcDecl->get_name() ) && ftype->get_parameters().size() == 2 ) {
-                                                Type * t1 = getPointerBase( ftype->get_parameters().front()->get_type() );
-                                                Type * t2 = ftype->get_parameters().back()->get_type();
+                                        if ( CodeGen::isConstructor( funcDecl->get_name() ) && ftype->parameters.size() == 2 ) {
+                                                Type * t1 = getPointerBase( ftype->parameters.front()->get_type() );
+                                                Type * t2 = ftype->parameters.back()->get_type();
                                                 assert( t1 );
 
@@ -366 +365 @@
                         ImplicitCtorDtorStmt * stmt = genCtorDtor( fname, var, cpArg );
                         ExprStmt * exprStmt = strict_dynamic_cast< ExprStmt * >( stmt->get_callStmt() );
-                        Expression * untyped = exprStmt->get_expr();
+                        Expression * resolved = exprStmt->expr;
+                        exprStmt->expr = nullptr; // take ownership of expr
 
                         // resolve copy constructor
                         // should only be one alternative for copy ctor and dtor expressions, since all arguments are fixed
                         // (VariableExpr and already resolved expression)
-                        CP_CTOR_PRINT( std::cerr << "ResolvingCtorDtor " << untyped << std::endl; )
-                        Expression * resolved = ResolvExpr::findVoidExpression( untyped, indexer );
+                        CP_CTOR_PRINT( std::cerr << "ResolvingCtorDtor " << resolved << std::endl; )
+                        ResolvExpr::findVoidExpression( resolved, indexer );
                         assert( resolved );
                         if ( resolved->get_env() ) {
@@ -380 +380 @@
                                 resolved->set_env( nullptr );
                         } // if
-
                         delete stmt;
                         return resolved;
                 }
 
-                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->has_result() );
-                        Type * result = arg->get_result();
+                        assert( arg->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 );
@@ -406 +406 @@
                                 // 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;
+                                }
                         }
 
@@ -416 +419 @@
                         // 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 ) );
                 }
 
@@ -427 +430 @@
                         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
 
@@ -437 +450 @@
                         // 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");
@@ -443 +456 @@
                                 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 ) ) {
@@ -551 +564 @@
                                 Expression * retExpr = new CommaExpr( assign, new VariableExpr( returnDecl ) );
                                 // move env from callExpr to retExpr
-                                retExpr->set_env( callExpr->get_env() );
-                                callExpr->set_env( nullptr );
+                                std::swap( retExpr->env, callExpr->env );
                                 return retExpr;
                         } else {
@@ -754 +766 @@
                                                 if ( ctorStmt && (ctorCall = isIntrinsicCallExpr( ctorStmt->expr )) && ctorCall->get_args().size() == 2 ) {
                                                         // clean up intrinsic copy constructor calls by making them into SingleInits
-                                                        objDecl->init = new SingleInit( ctorCall->args.back() );
+                                                        Expression * ctorArg = ctorCall->args.back();
+                                                        std::swap( ctorArg->env, ctorCall->env );
+                                                        objDecl->init = new SingleInit( ctorArg );
+
                                                         ctorCall->args.pop_back();
                                                 } else {
@@ -822 +837 @@
                         GuardValue( labelVars );
                         labelVars.clear();
+                        // LabelFinder does not recurse into FunctionDecl, so need to visit
+                        // its children manually.
                         maybeAccept( funcDecl->type, finder );
                         maybeAccept( funcDecl->statements, finder );
@@ -1079 +1096 @@
                 }
 
-                DeclarationWithType * MutatingResolver::mutate( ObjectDecl *objectDecl ) {
+                DeclarationWithType * MutatingResolver::mutate( ObjectDecl * objectDecl ) {
                         // add object to the indexer assumes that there will be no name collisions
                         // in generated code. If this changes, add mutate methods for entities with
@@ -1087 +1104 @@
                 }
 
-                Expression* MutatingResolver::mutate( UntypedExpr *untypedExpr ) {
-                        return strict_dynamic_cast< ApplicationExpr * >( ResolvExpr::findVoidExpression( untypedExpr, indexer ) );
+                Expression * MutatingResolver::mutate( UntypedExpr * untypedExpr ) {
+                        Expression * newExpr = untypedExpr;
+                        ResolvExpr::findVoidExpression( newExpr, indexer );
+                        return newExpr;
                 }
 
@@ -1094 +1113 @@
                         static UniqueName tempNamer( "_tmp_ctor_expr" );
                         // xxx - is the size check necessary?
-                        assert( ctorExpr->has_result() && ctorExpr->get_result()->size() == 1 );
+                        assert( ctorExpr->result && ctorExpr->get_result()->size() == 1 );
 
                         // xxx - ideally we would reuse the temporary generated from the copy constructor passes from within firstArg if it exists and not generate a temporary if it's unnecessary.
@@ -1113 +1132 @@
 
                         // resolve assignment and dispose of new env
-                        Expression * resolvedAssign = ResolvExpr::findVoidExpression( assign, indexer );
-                        delete resolvedAssign->env;
-                        resolvedAssign->env = nullptr;
-                        delete assign;
+                        ResolvExpr::findVoidExpression( assign, indexer );
+                        delete assign->env;
+                        assign->env = nullptr;
 
                         // for constructor expr:
@@ -1125 +1143 @@
                         //   T & tmp;
                         //   &tmp = &x, ?{}(tmp), tmp
-                        CommaExpr * commaExpr = new CommaExpr( resolvedAssign, new CommaExpr( callExpr, new VariableExpr( tmp ) ) );
+                        CommaExpr * commaExpr = new CommaExpr( assign, new CommaExpr( callExpr, new VariableExpr( tmp ) ) );
                         commaExpr->set_env( env );
                         return commaExpr;

src/InitTweak/GenInit.cc

@@ -85 +85 @@
                 // should not have a ConstructorInit generated.
 
-                bool isManaged( ObjectDecl * objDecl ) const ; // determine if object is managed
-                bool isManaged( Type * type ) const; // determine if type is managed
-                void handleDWT( DeclarationWithType * dwt ); // add type to managed if ctor/dtor
-                GenPoly::ScopedSet< std::string > managedTypes;
+                ManagedTypes managedTypes;
                 bool inFunction = false;
         };
@@ -129 +126 @@
                 // hands off if the function returns a reference - we don't want to allocate a temporary if a variable's address
                 // is being returned
-                if ( returnStmt->get_expr() && returnVals.size() == 1 && isConstructable( returnVals.front()->get_type() ) ) {
+                if ( returnStmt->expr && returnVals.size() == 1 && isConstructable( returnVals.front()->get_type() ) ) {
                         // explicitly construct the return value using the return expression and the retVal object
-                        assertf( returnVals.front()->get_name() != "", "Function %s has unnamed return value\n", funcName.c_str() );
-
-                        stmtsToAddBefore.push_back( genCtorDtor( "?{}", dynamic_cast< ObjectDecl *>( returnVals.front() ), returnStmt->get_expr() ) );
+                        assertf( returnVals.front()->name != "", "Function %s has unnamed return value\n", funcName.c_str() );
+
+                        ObjectDecl * retVal = strict_dynamic_cast< ObjectDecl * >( returnVals.front() );
+                        if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( returnStmt->expr ) ) {
+                                // return statement has already been mutated - don't need to do it again
+                                if ( varExpr->var == retVal ) return;
+                        }
+                        stmtsToAddBefore.push_back( genCtorDtor( "?{}", retVal, returnStmt->get_expr() ) );
 
                         // return the retVal object
-                        returnStmt->set_expr( new VariableExpr( returnVals.front() ) );
+                        returnStmt->expr = new VariableExpr( returnVals.front() );
                 } // if
         }
@@ -199 +201 @@
         }
 
-        bool CtorDtor::isManaged( Type * type ) const {
+        bool ManagedTypes::isManaged( Type * type ) const {
                 // references are never constructed
                 if ( dynamic_cast< ReferenceType * >( type ) ) return false;
@@ -215 +217 @@
         }
 
-        bool CtorDtor::isManaged( ObjectDecl * objDecl ) const {
+        bool ManagedTypes::isManaged( ObjectDecl * objDecl ) const {
                 Type * type = objDecl->get_type();
                 while ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) {
@@ -223 +225 @@
         }
 
-        void CtorDtor::handleDWT( DeclarationWithType * dwt ) {
+        void ManagedTypes::handleDWT( DeclarationWithType * dwt ) {
                 // if this function is a user-defined constructor or destructor, mark down the type as "managed"
                 if ( ! LinkageSpec::isOverridable( dwt->get_linkage() ) && CodeGen::isCtorDtor( dwt->get_name() ) ) {
@@ -233 +235 @@
                 }
         }
+
+        void ManagedTypes::handleStruct( StructDecl * aggregateDecl ) {
+                // don't construct members, but need to take note if there is a managed member,
+                // because that means that this type is also managed
+                for ( Declaration * member : aggregateDecl->get_members() ) {
+                        if ( ObjectDecl * field = dynamic_cast< ObjectDecl * >( member ) ) {
+                                if ( isManaged( field ) ) {
+                                        StructInstType inst( Type::Qualifiers(), aggregateDecl );
+                                        managedTypes.insert( SymTab::Mangler::mangle( &inst ) );
+                                        break;
+                                }
+                        }
+                }
+        }
+
+        void ManagedTypes::beginScope() { managedTypes.beginScope(); }
+        void ManagedTypes::endScope() { managedTypes.endScope(); }
 
         ImplicitCtorDtorStmt * genCtorDtor( const std::string & fname, ObjectDecl * objDecl, Expression * arg ) {
@@ -277 +296 @@
 
         void CtorDtor::previsit( ObjectDecl * objDecl ) {
-                handleDWT( objDecl );
+                managedTypes.handleDWT( objDecl );
                 // hands off if @=, extern, builtin, etc.
                 // even if unmanaged, try to construct global or static if initializer is not constexpr, since this is not legal C
-                if ( tryConstruct( objDecl ) && ( isManaged( objDecl ) || ((! inFunction || objDecl->get_storageClasses().is_static ) && ! isConstExpr( objDecl->get_init() ) ) ) ) {
+                if ( tryConstruct( objDecl ) && ( managedTypes.isManaged( objDecl ) || ((! inFunction || objDecl->get_storageClasses().is_static ) && ! isConstExpr( objDecl->get_init() ) ) ) ) {
                         // constructed objects cannot be designated
                         if ( isDesignated( objDecl->get_init() ) ) throw SemanticError( "Cannot include designations in the initializer for a managed Object. If this is really what you want, then initialize with @=.\n", objDecl );
@@ -295 +314 @@
                 inFunction = true;
 
-                handleDWT( functionDecl );
+                managedTypes.handleDWT( functionDecl );
 
                 GuardScope( managedTypes );
@@ -301 +320 @@
                 for ( auto & tyDecl : functionDecl->get_functionType()->get_forall() ) {
                         for ( DeclarationWithType *& assertion : tyDecl->get_assertions() ) {
-                                handleDWT( assertion );
+                                managedTypes.handleDWT( assertion );
                         }
                 }
@@ -311 +330 @@
                 visit_children = false; // do not try to construct and destruct aggregate members
 
-                // don't construct members, but need to take note if there is a managed member,
-                // because that means that this type is also managed
-                for ( Declaration * member : aggregateDecl->get_members() ) {
-                        if ( ObjectDecl * field = dynamic_cast< ObjectDecl * >( member ) ) {
-                                if ( isManaged( field ) ) {
-                                        StructInstType inst( Type::Qualifiers(), aggregateDecl );
-                                        managedTypes.insert( SymTab::Mangler::mangle( &inst ) );
-                                        break;
-                                }
-                        }
-                }
+                managedTypes.handleStruct( aggregateDecl );
         }
 

src/InitTweak/GenInit.h

@@ -16 +16 @@
 #pragma once
 
-#include <list>               // for list
-#include <string>             // for string
+#include <list>                // for list
+#include <string>              // for string
 
-#include "SynTree/SynTree.h"  // for Visitor Nodes
+#include "SynTree/SynTree.h"   // for Visitor Nodes
+
+#include "GenPoly/ScopedSet.h" // for ScopedSet
 
 namespace InitTweak {
@@ -33 +35 @@
         /// creates an appropriate ConstructorInit node which contains a constructor, destructor, and C-initializer
         ConstructorInit * genCtorInit( ObjectDecl * objDecl );
+
+        class ManagedTypes {
+        public:
+                bool isManaged( ObjectDecl * objDecl ) const ; // determine if object is managed
+                bool isManaged( Type * type ) const; // determine if type is managed
+
+                void handleDWT( DeclarationWithType * dwt ); // add type to managed if ctor/dtor
+                void handleStruct( StructDecl * aggregateDecl ); // add type to managed if child is managed
+
+                void beginScope();
+                void endScope();
+        private:
+                GenPoly::ScopedSet< std::string > managedTypes;
+        };
 } // namespace
 

src/InitTweak/InitTweak.cc

@@ -168 +168 @@
                 deleteAll( indices );
                 indices.clear();
+        }
+
+        bool InitExpander::addReference() {
+                bool added = false;
+                for ( Expression *& expr : cur ) {
+                        expr = new AddressExpr( expr );
+                        added = true;
+                }
+                return added;
         }
 
@@ -270 +279 @@
         }
 
-        Type * getThisType( FunctionType * ftype ) {
-                assertf( ftype, "getThisType: nullptr ftype" );
-                ObjectDecl * thisParam = getThisParam( ftype );
+        Type * getTypeofThis( FunctionType * ftype ) {
+                assertf( ftype, "getTypeofThis: nullptr ftype" );
+                ObjectDecl * thisParam = getParamThis( ftype );
                 ReferenceType * refType = strict_dynamic_cast< ReferenceType * >( thisParam->type );
                 return refType->base;
         }
 
-        ObjectDecl * getThisParam( FunctionType * ftype ) {
-                assertf( ftype, "getThisParam: nullptr ftype" );
+        ObjectDecl * getParamThis( FunctionType * ftype ) {
+                assertf( ftype, "getParamThis: nullptr ftype" );
                 auto & params = ftype->parameters;
-                assertf( ! params.empty(), "getThisParam: ftype with 0 parameters: %s", toString( ftype ).c_str() );
+                assertf( ! params.empty(), "getParamThis: ftype with 0 parameters: %s", toString( ftype ).c_str() );
                 return strict_dynamic_cast< ObjectDecl * >( params.front() );
         }
@@ -353 +362 @@
                         assert( expr );
                         if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( expr ) ) {
-                                return varExpr->get_var();
+                                return varExpr->var;
                         } else if ( MemberExpr * memberExpr = dynamic_cast< MemberExpr * >( expr ) ) {
-                                return memberExpr->get_member();
+                                return memberExpr->member;
                         } else if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) {
-                                return getCalledFunction( castExpr->get_arg() );
+                                return getCalledFunction( castExpr->arg );
                         } else if ( UntypedExpr * untypedExpr = dynamic_cast< UntypedExpr * >( expr ) ) {
                                 return handleDerefCalledFunction( untypedExpr );
@@ -363 +372 @@
                                 return handleDerefCalledFunction( appExpr );
                         } else if ( AddressExpr * addrExpr = dynamic_cast< AddressExpr * >( expr ) ) {
-                                return getCalledFunction( addrExpr->get_arg() );
+                                return getCalledFunction( addrExpr->arg );
+                        } else if ( CommaExpr * commaExpr = dynamic_cast< CommaExpr * >( expr ) ) {
+                                return getCalledFunction( commaExpr->arg2 );
                         }
                         return nullptr;
@@ -578 +589 @@
         FunctionDecl * isCopyFunction( Declaration * decl, const std::string & fname ) {
                 FunctionDecl * function = dynamic_cast< FunctionDecl * >( decl );
-                if ( ! function ) return 0;
-                if ( function->get_name() != fname ) return 0;
-                FunctionType * ftype = function->get_functionType();
-                if ( ftype->get_parameters().size() != 2 ) return 0;
+                if ( ! function ) return nullptr;
+                if ( function->name != fname ) return nullptr;
+                FunctionType * ftype = function->type;
+                if ( ftype->parameters.size() != 2 ) return nullptr;
 
                 Type * t1 = getPointerBase( ftype->get_parameters().front()->get_type() );
-                Type * t2 = ftype->get_parameters().back()->get_type();
+                Type * t2 = ftype->parameters.back()->get_type();
                 assert( t1 );
 
@@ -604 +615 @@
         }
         FunctionDecl * isDefaultConstructor( Declaration * decl ) {
-                if ( isConstructor( decl->get_name() ) ) {
+                if ( isConstructor( decl->name ) ) {
                         if ( FunctionDecl * func = dynamic_cast< FunctionDecl * >( decl ) ) {
-                                if ( func->get_functionType()->get_parameters().size() == 1 ) {
+                                if ( func->type->parameters.size() == 1 ) {
                                         return func;
                                 }

src/InitTweak/InitTweak.h

@@ -31 +31 @@
 
         /// returns the base type of the first parameter to a constructor/destructor/assignment function
-        Type * getThisType( FunctionType * ftype );
+        Type * getTypeofThis( FunctionType * ftype );
 
         /// returns the first parameter of a constructor/destructor/assignment function
-        ObjectDecl * getThisParam( FunctionType * ftype );
+        ObjectDecl * getParamThis( FunctionType * ftype );
 
         /// transform Initializer into an argument list that can be passed to a call expression
@@ -105 +105 @@
                 void addArrayIndex( Expression * index, Expression * dimension );
                 void clearArrayIndices();
+                bool addReference();
 
                 class ExpanderImpl;