Changes in src/GenPoly/Specialize.cc [6c3a988f:b3b2077]

File:

• src/GenPoly/Specialize.cc (modified) (10 diffs)

src/GenPoly/Specialize.cc

@@ -32 +32 @@
 #include "Common/utility.h"
 #include "InitTweak/InitTweak.h"
-#include "Tuples/Tuples.h"
 
 namespace GenPoly {
-        class Specializer;
-        class Specialize final : public PolyMutator {
-                friend class Specializer;
+        const std::list<Label> noLabels;
+
+        class Specialize : public PolyMutator {
           public:
-                using PolyMutator::mutate;
-                virtual Expression * mutate( ApplicationExpr *applicationExpr ) override;
-                virtual Expression * mutate( AddressExpr *castExpr ) override;
-                virtual Expression * mutate( CastExpr *castExpr ) override;
+                Specialize( std::string paramPrefix = "_p" );
+
+                virtual Expression * mutate( ApplicationExpr *applicationExpr );
+                virtual Expression * mutate( AddressExpr *castExpr );
+                virtual Expression * mutate( CastExpr *castExpr );
                 // virtual Expression * mutate( LogicalExpr *logicalExpr );
                 // virtual Expression * mutate( ConditionalExpr *conditionalExpr );
                 // virtual Expression * mutate( CommaExpr *commaExpr );
 
-                Specializer * specializer = nullptr;
+          private:
+                Expression *createThunkFunction( FunctionType *funType, Expression *actual, InferredParams *inferParams = 0 );
+                Expression *doSpecialization( Type *formalType, Expression *actual, InferredParams *inferParams = 0 );
                 void handleExplicitParams( ApplicationExpr *appExpr );
+
+                UniqueName thunkNamer;
+                std::string paramPrefix;
         };
 
-        class Specializer {
-          public:
-                Specializer( Specialize & spec ) : spec( spec ), env( spec.env ), stmtsToAdd( spec.stmtsToAdd ) {}
-                virtual bool needsSpecialization( Type * formalType, Type * actualType, TypeSubstitution * env ) = 0;
-                virtual Expression *createThunkFunction( FunctionType *funType, Expression *actual, InferredParams *inferParams ) = 0;
-                virtual Expression *doSpecialization( Type *formalType, Expression *actual, InferredParams *inferParams = 0 );
-
-          protected:
-                Specialize & spec;
-                std::string paramPrefix = "_p";
-                TypeSubstitution *& env;
-                std::list< Statement * > & stmtsToAdd;
-        };
-
-        // for normal polymorphic -> monomorphic function conversion
-        class PolySpecializer : public Specializer {
-          public:
-                PolySpecializer( Specialize & spec ) : Specializer( spec ) {}
-                virtual bool needsSpecialization( Type * formalType, Type * actualType, TypeSubstitution * env ) override;
-                virtual Expression *createThunkFunction( FunctionType *funType, Expression *actual, InferredParams *inferParams ) override;
-        };
-
-        // // for tuple -> non-tuple function conversion
-        class TupleSpecializer : public Specializer {
-          public:
-                TupleSpecializer( Specialize & spec ) : Specializer( spec ) {}
-                virtual bool needsSpecialization( Type * formalType, Type * actualType, TypeSubstitution * env ) override;
-                virtual Expression *createThunkFunction( FunctionType *funType, Expression *actual, InferredParams *inferParams ) override;
-        };
+        void convertSpecializations( std::list< Declaration* >& translationUnit ) {
+                Specialize specializer;
+                mutateAll( translationUnit, specializer );
+        }
+
+        Specialize::Specialize( std::string paramPrefix )
+                : thunkNamer( "_thunk" ), paramPrefix( paramPrefix ) {
+        }
 
         /// Looks up open variables in actual type, returning true if any of them are bound in the environment or formal type.
-        bool PolySpecializer::needsSpecialization( Type *formalType, Type *actualType, TypeSubstitution *env ) {
+        bool needsSpecialization( Type *formalType, Type *actualType, TypeSubstitution *env ) {
                 if ( env ) {
                         using namespace ResolvExpr;
@@ -107 +91 @@
 
         /// Generates a thunk that calls `actual` with type `funType` and returns its address
-        Expression * PolySpecializer::createThunkFunction( FunctionType *funType, Expression *actual, InferredParams *inferParams ) {
-                static UniqueName thunkNamer( "_thunk" );
-
+        Expression * Specialize::createThunkFunction( FunctionType *funType, Expression *actual, InferredParams *inferParams ) {
                 FunctionType *newType = funType->clone();
                 if ( env ) {
+                        TypeSubstitution newEnv( *env );
                         // it is important to replace only occurrences of type variables that occur free in the
                         // thunk's type
-                        env->applyFree( newType );
+                        newEnv.applyFree( newType );
                 } // if
                 // create new thunk with same signature as formal type (C linkage, empty body)
@@ -141 +124 @@
                 std::list< Statement* > oldStmts;
                 oldStmts.splice( oldStmts.end(), stmtsToAdd );
-                spec.handleExplicitParams( appExpr );
+                handleExplicitParams( appExpr );
                 paramPrefix = oldParamPrefix;
                 // write any statements added for recursive specializations into the thunk body
@@ -163 +146 @@
         }
 
-        Expression * Specializer::doSpecialization( Type *formalType, Expression *actual, InferredParams *inferParams ) {
+        Expression * Specialize::doSpecialization( Type *formalType, Expression *actual, InferredParams *inferParams ) {
                 assertf( actual->has_result(), "attempting to specialize an untyped expression" );
                 if ( needsSpecialization( formalType, actual->get_result(), env ) ) {
-                        if ( FunctionType *funType = getFunctionType( formalType ) ) {
+                        FunctionType *funType;
+                        if ( ( funType = getFunctionType( formalType ) ) ) {
                                 ApplicationExpr *appExpr;
                                 VariableExpr *varExpr;
@@ -185 +169 @@
         }
 
-        bool TupleSpecializer::needsSpecialization( Type *formalType, Type *actualType, TypeSubstitution *env ) {
-                if ( FunctionType * ftype = getFunctionType( formalType ) ) {
-                        return ftype->isTtype();
-                }
-                return false;
-        }
-
-        /// restructures arg to match the structure of a single formal parameter. Assumes that atomic types are compatible (as the Resolver should have ensured this)
-        template< typename OutIterator >
-        void matchOneFormal( Expression * arg, unsigned & idx, Type * formal, OutIterator out ) {
-                if ( TupleType * tupleType = dynamic_cast< TupleType * >( formal ) ) {
-                        std::list< Expression * > exprs;
-                        for ( Type * t : *tupleType ) {
-                                matchOneFormal( arg, idx, t, back_inserter( exprs ) );
-                        }
-                        *out++ = new TupleExpr( exprs );
-                } else {
-                        *out++ = new TupleIndexExpr( arg->clone(), idx++ );
-                }
-        }
-
-        /// restructures the ttype argument to match the structure of the formal parameters of the actual function.
-        // [begin, end) are the formal parameters.
-        // args is the list of arguments currently given to the actual function, the last of which needs to be restructured.
-        template< typename Iterator, typename OutIterator >
-        void fixLastArg( Expression * last, Iterator begin, Iterator end, OutIterator out ) {
-                // safe_dynamic_cast for the assertion
-                safe_dynamic_cast< TupleType * >( last->get_result() );
-                unsigned idx = 0;
-                for ( ; begin != end; ++begin ) {
-                        DeclarationWithType * formal = *begin;
-                        Type * formalType = formal->get_type();
-                        matchOneFormal( last, idx, formalType, out );
-                }
-                delete last;
-        }
-
-        Expression * TupleSpecializer::createThunkFunction( FunctionType *funType, Expression *actual, InferredParams *inferParams ) {
-                static UniqueName thunkNamer( "_tupleThunk" );
-
-                FunctionType *newType = funType->clone();
-                if ( env ) {
-                        // it is important to replace only occurrences of type variables that occur free in the
-                        // thunk's type
-                        env->applyFree( newType );
-                } // if
-                // create new thunk with same signature as formal type (C linkage, empty body)
-                FunctionDecl *thunkFunc = new FunctionDecl( thunkNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, newType, new CompoundStmt( noLabels ), false, false );
-                thunkFunc->fixUniqueId();
-
-                // thunks may be generated and not used - silence warning with attribute
-                thunkFunc->get_attributes().push_back( new Attribute( "unused" ) );
-
-                // thread thunk parameters into call to actual function, naming thunk parameters as we go
-                UniqueName paramNamer( paramPrefix );
-                ApplicationExpr *appExpr = new ApplicationExpr( actual );
-
-                FunctionType * actualType = getFunctionType( actual->get_result() )->clone();
-                if ( env ) {
-                        // need to apply the environment to the actual function's type, since it may itself be polymorphic
-                        env->apply( actualType );
-                }
-                std::unique_ptr< FunctionType > actualTypeManager( actualType ); // for RAII
-                std::list< DeclarationWithType * >::iterator actualBegin = actualType->get_parameters().begin();
-                std::list< DeclarationWithType * >::iterator actualEnd = actualType->get_parameters().end();
-                std::list< DeclarationWithType * >::iterator formalBegin = funType->get_parameters().begin();
-                std::list< DeclarationWithType * >::iterator formalEnd = funType->get_parameters().end();
-
-                Expression * last = nullptr;
-                for ( DeclarationWithType* param : thunkFunc->get_functionType()->get_parameters() ) {
-                        // walk the parameters to the actual function alongside the parameters to the thunk to find the location where the ttype parameter begins to satisfy parameters in the actual function.
-                        param->set_name( paramNamer.newName() );
-                        assertf( formalBegin != formalEnd, "Reached end of formal parameters before finding ttype parameter" );
-                        if ( Tuples::isTtype((*formalBegin)->get_type()) ) {
-                                last = new VariableExpr( param );
-                                break;
-                        }
-                        assertf( actualBegin != actualEnd, "reached end of actual function's arguments before finding ttype parameter" );
-                        ++actualBegin;
-                        ++formalBegin;
-
-                        appExpr->get_args().push_back( new VariableExpr( param ) );
-                } // for
-                assert( last );
-                fixLastArg( last, actualBegin, actualEnd, back_inserter( appExpr->get_args() ) );
-                appExpr->set_env( maybeClone( env ) );
-                if ( inferParams ) {
-                        appExpr->get_inferParams() = *inferParams;
-                } // if
-
-                // handle any specializations that may still be present
-                std::string oldParamPrefix = paramPrefix;
-                paramPrefix += "p";
-                // save stmtsToAdd in oldStmts
-                std::list< Statement* > oldStmts;
-                oldStmts.splice( oldStmts.end(), stmtsToAdd );
-                spec.mutate( appExpr );
-                paramPrefix = oldParamPrefix;
-                // write any statements added for recursive specializations into the thunk body
-                thunkFunc->get_statements()->get_kids().splice( thunkFunc->get_statements()->get_kids().end(), stmtsToAdd );
-                // restore oldStmts into stmtsToAdd
-                stmtsToAdd.splice( stmtsToAdd.end(), oldStmts );
-
-                // add return (or valueless expression) to the thunk
-                Statement *appStmt;
-                if ( funType->get_returnVals().empty() ) {
-                        appStmt = new ExprStmt( noLabels, appExpr );
-                } else {
-                        appStmt = new ReturnStmt( noLabels, appExpr );
-                } // if
-                thunkFunc->get_statements()->get_kids().push_back( appStmt );
-
-                // add thunk definition to queue of statements to add
-                stmtsToAdd.push_back( new DeclStmt( noLabels, thunkFunc ) );
-                // return address of thunk function as replacement expression
-                return new AddressExpr( new VariableExpr( thunkFunc ) );
-        }
-
         void Specialize::handleExplicitParams( ApplicationExpr *appExpr ) {
                 // create thunks for the explicit parameters
@@ -311 +177 @@
                 std::list< Expression* >::iterator actual;
                 for ( formal = function->get_parameters().begin(), actual = appExpr->get_args().begin(); formal != function->get_parameters().end() && actual != appExpr->get_args().end(); ++formal, ++actual ) {
-                        *actual = specializer->doSpecialization( (*formal )->get_type(), *actual, &appExpr->get_inferParams() );
+                        *actual = doSpecialization( (*formal )->get_type(), *actual, &appExpr->get_inferParams() );
                 }
         }
@@ -323 +189 @@
                         // don't need to do this for intrinsic calls, because they aren't actually passed
                         for ( InferredParams::iterator inferParam = appExpr->get_inferParams().begin(); inferParam != appExpr->get_inferParams().end(); ++inferParam ) {
-                                inferParam->second.expr = specializer->doSpecialization( inferParam->second.formalType, inferParam->second.expr, inferParam->second.inferParams.get() );
+                                inferParam->second.expr = doSpecialization( inferParam->second.formalType, inferParam->second.expr, &appExpr->get_inferParams() );
                         }
+
                         handleExplicitParams( appExpr );
                 }
+
                 return appExpr;
         }
@@ -333 +201 @@
                 addrExpr->get_arg()->acceptMutator( *this );
                 assert( addrExpr->has_result() );
-                addrExpr->set_arg( specializer->doSpecialization( addrExpr->get_result(), addrExpr->get_arg() ) );
+                addrExpr->set_arg( doSpecialization( addrExpr->get_result(), addrExpr->get_arg() ) );
                 return addrExpr;
         }
@@ -343 +211 @@
                         return castExpr;
                 }
-                Expression *specialized = specializer->doSpecialization( castExpr->get_result(), castExpr->get_arg() );
+                Expression *specialized = doSpecialization( castExpr->get_result(), castExpr->get_arg() );
                 if ( specialized != castExpr->get_arg() ) {
                         // assume here that the specialization incorporates the cast
@@ -367 +235 @@
         //      return commaExpr;
         // }
-
-        void convertSpecializations( std::list< Declaration* >& translationUnit ) {
-                Specialize spec;
-
-                TupleSpecializer tupleSpec( spec );
-                spec.specializer = &tupleSpec;
-                mutateAll( translationUnit, spec );
-
-                PolySpecializer polySpec( spec );
-                spec.specializer = &polySpec;
-                mutateAll( translationUnit, spec );
-        }
 } // namespace GenPoly