Changeset 626dbc10

Timestamp:

Dec 21, 2016, 3:12:19 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:

b940dc71

Parents:

e33f321

git-author:

Rob Schluntz <rschlunt@…> (12/21/16 15:07:41)

git-committer:

Rob Schluntz <rschlunt@…> (12/21/16 15:12:19)

Message:

major refactoring of specialization code, added code to generate thunks for ttype functions, move specialize pass to before tuple expansion

Location:

src

Files:

• GenPoly/Specialize.cc (modified) (11 diffs)
• main.cc (modified) (8 diffs)

src/GenPoly/Specialize.cc ¶

@@ -34 +34 @@
 
 namespace GenPoly {
-        const std::list<Label> noLabels;
-
+        class Specializer;
         class Specialize final : public PolyMutator {
+                friend class Specializer;
           public:
-                Specialize( std::string paramPrefix = "_p" );
-
                 using PolyMutator::mutate;
                 virtual Expression * mutate( ApplicationExpr *applicationExpr ) override;
@@ -48 +46 @@
                 // virtual Expression * mutate( CommaExpr *commaExpr );
 
-          private:
-                Expression *createThunkFunction( FunctionType *funType, Expression *actual, InferredParams *inferParams = 0 );
-                Expression *doSpecialization( Type *formalType, Expression *actual, InferredParams *inferParams = 0 );
+                Specializer * specializer = nullptr;
                 void handleExplicitParams( ApplicationExpr *appExpr );
-
-                UniqueName thunkNamer;
-                std::string paramPrefix;
         };
 
-        void convertSpecializations( std::list< Declaration* >& translationUnit ) {
-                Specialize specializer;
-                mutateAll( translationUnit, specializer );
-        }
-
-        Specialize::Specialize( std::string paramPrefix )
-                : thunkNamer( "_thunk" ), paramPrefix( 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;
+        };
 
         /// Looks up open variables in actual type, returning true if any of them are bound in the environment or formal type.
-        bool needsSpecialization( Type *formalType, Type *actualType, TypeSubstitution *env ) {
+        bool PolySpecializer::needsSpecialization( Type *formalType, Type *actualType, TypeSubstitution *env ) {
                 if ( env ) {
                         using namespace ResolvExpr;
@@ -92 +106 @@
 
         /// Generates a thunk that calls `actual` with type `funType` and returns its address
-        Expression * Specialize::createThunkFunction( FunctionType *funType, Expression *actual, InferredParams *inferParams ) {
+        Expression * PolySpecializer::createThunkFunction( FunctionType *funType, Expression *actual, InferredParams *inferParams ) {
+                static UniqueName thunkNamer( "_thunk" );
+
                 FunctionType *newType = funType->clone();
                 if ( env ) {
@@ -125 +141 @@
                 std::list< Statement* > oldStmts;
                 oldStmts.splice( oldStmts.end(), stmtsToAdd );
-                handleExplicitParams( appExpr );
+                spec.handleExplicitParams( appExpr );
                 paramPrefix = oldParamPrefix;
                 // write any statements added for recursive specializations into the thunk body
@@ -147 +163 @@
         }
 
-        Expression * Specialize::doSpecialization( Type *formalType, Expression *actual, InferredParams *inferParams ) {
+        Expression * Specializer::doSpecialization( Type *formalType, Expression *actual, InferredParams *inferParams ) {
                 assertf( actual->has_result(), "attempting to specialize an untyped expression" );
                 if ( needsSpecialization( formalType, actual->get_result(), env ) ) {
@@ -170 +186 @@
         }
 
+        bool TupleSpecializer::needsSpecialization( Type *formalType, Type *actualType, TypeSubstitution *env ) {
+                // std::cerr << "asking if type needs tuple spec: " << formalType << std::endl;
+                if ( FunctionType * ftype = getFunctionType( formalType ) ) {
+                        return ftype->isTtype();
+                }
+                return false;
+        }
+
+        template< typename Iterator >
+        void fixLastArg( std::list< Expression * > & args, Iterator begin, Iterator end ) {
+                assertf( ! args.empty(), "Somehow args to tuple function are empty" ); // xxx - it's quite possible this will trigger for the nullary case...
+                Expression * last = args.back();
+                // safe_dynamic_cast for the assertion
+                safe_dynamic_cast< TupleType * >( last->get_result() ); // xxx - it's quite possible this will trigger for the unary case...
+                args.pop_back(); // replace last argument in the call with
+                unsigned idx = 0;
+                for ( ; begin != end; ++begin ) {
+                        // DeclarationWithType * formal = *begin;
+                        // Type * formalType = formal->get_type();
+                        args.push_back( new TupleIndexExpr( last->clone(), idx++ ) );
+                }
+                delete last;
+        }
+
+        Expression * TupleSpecializer::createThunkFunction( FunctionType *funType, Expression *actual, InferredParams *inferParams ) {
+                static UniqueName thunkNamer( "_tupleThunk" );
+                // std::cerr << "creating tuple thunk for " << funType << std::endl;
+
+                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
+                        newEnv.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 );
+                // std::cerr << actual << std::endl;
+
+                FunctionType * actualType = getFunctionType( actual->get_result() );
+                std::list< DeclarationWithType * >::iterator begin = actualType->get_parameters().begin();
+                std::list< DeclarationWithType * >::iterator end = actualType->get_parameters().end();
+
+                for ( DeclarationWithType* param : thunkFunc->get_functionType()->get_parameters() ) {
+                        ++begin;
+                        assert( begin != end );
+
+                        // std::cerr << "thunk param: " << param << std::endl;
+                        // last param will always be a tuple type... expand it into the actual type(?)
+                        param->set_name( paramNamer.newName() );
+                        appExpr->get_args().push_back( new VariableExpr( param ) );
+                } // for
+                fixLastArg( appExpr->get_args(), --begin, end );
+                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.handleExplicitParams( 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 );
+
+                // std::cerr << "thunkFunc is: " << thunkFunc << std::endl;
+
+                // 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
@@ -178 +290 @@
                 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 = doSpecialization( (*formal )->get_type(), *actual, &appExpr->get_inferParams() );
+                        *actual = specializer->doSpecialization( (*formal )->get_type(), *actual, &appExpr->get_inferParams() );
                 }
         }
@@ -190 +302 @@
                         // 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 = doSpecialization( inferParam->second.formalType, inferParam->second.expr, &appExpr->get_inferParams() );
+                                inferParam->second.expr = specializer->doSpecialization( inferParam->second.formalType, inferParam->second.expr, &appExpr->get_inferParams() );
                         }
-
                         handleExplicitParams( appExpr );
                 }
-
                 return appExpr;
         }
@@ -202 +312 @@
                 addrExpr->get_arg()->acceptMutator( *this );
                 assert( addrExpr->has_result() );
-                addrExpr->set_arg( doSpecialization( addrExpr->get_result(), addrExpr->get_arg() ) );
+                addrExpr->set_arg( specializer->doSpecialization( addrExpr->get_result(), addrExpr->get_arg() ) );
                 return addrExpr;
         }
@@ -212 +322 @@
                         return castExpr;
                 }
-                Expression *specialized = doSpecialization( castExpr->get_result(), castExpr->get_arg() );
+                Expression *specialized = specializer->doSpecialization( castExpr->get_result(), castExpr->get_arg() );
                 if ( specialized != castExpr->get_arg() ) {
                         // assume here that the specialization incorporates the cast
@@ -236 +346 @@
         //      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
 

src/main.cc ¶

@@ -69 +69 @@
         symtabp = false,
         treep = false,
+        tuplep = false,
         validp = false,
         errorp = false,
@@ -266 +267 @@
                 OPTPRINT( "expandUniqueExpr" ); // xxx - is this the right place for this? want to expand ASAP so that subsequent passes don't need to worry about double-visiting a unique expr - needs to go after InitTweak::fix so that copy constructed return declarations are reused
                 Tuples::expandUniqueExpr( translationUnit );
+
+                OPTPRINT( "convertSpecializations" ) // needs to happen before tuple types are expanded
+                GenPoly::convertSpecializations( translationUnit );
+
                 OPTPRINT( "expandTuples" ); // xxx - is this the right place for this?
                 Tuples::expandTuples( translationUnit );
+                if ( tuplep ) {
+                        dump( translationUnit );
+                        return 0;
+                }
 
                 OPTPRINT("instantiateGenerics")
@@ -273 +282 @@
                 OPTPRINT( "copyParams" );
                 GenPoly::copyParams( translationUnit );
-                OPTPRINT( "convertSpecializations" )
-                GenPoly::convertSpecializations( translationUnit );
                 OPTPRINT( "convertLvalue" )
                 GenPoly::convertLvalue( translationUnit );
@@ -327 +334 @@
 
 void parse_cmdline( int argc, char * argv[], const char *& filename ) {
-        enum { Ast, Bbox, Bresolver, CtorInitFix, Expr, ExprAlt, Grammar, LibCFA, Nopreamble, Parse, Prototypes, Resolver, Symbol, Tree, Validate, };
+        enum { Ast, Bbox, Bresolver, CtorInitFix, Expr, ExprAlt, Grammar, LibCFA, Nopreamble, Parse, Prototypes, Resolver, Symbol, Tree, TupleExpansion, Validate, };
 
         static struct option long_opts[] = {
@@ -344 +351 @@
                 { "symbol", no_argument, 0, Symbol },
                 { "tree", no_argument, 0, Tree },
+                { "tuple-expansion", no_argument, 0, TupleExpansion },
                 { "validate", no_argument, 0, Validate },
                 { 0, 0, 0, 0 }
@@ -352 +360 @@
 
         int c;
-        while ( (c = getopt_long( argc, argv, "abBcefglnpqrstvyzD:F:", long_opts, &long_index )) != -1 ) {
+        while ( (c = getopt_long( argc, argv, "abBcefglnpqrstTvyzD:F:", long_opts, &long_index )) != -1 ) {
                 switch ( c ) {
                   case Ast:
@@ -362 +370 @@
                         bresolvep = true;
                         break;
-                  case 'B':                                                                             // print before resolver steps
+                  case 'B':                                                                             // print before box steps
                         bboxp = true;
                         break;
@@ -408 +416 @@
                   case 't':                                                                             // build in tree
                         treep = true;
+                        break;
+                  case TupleExpansion:
+                  case 'T':                                                                             // print after tuple expansion
+                        tuplep = true;
                         break;
                   case 'v':                                                                             // dump AST after decl validation pass