Changeset 3f7e12cb for src/GenPoly/Specialize.cc

Timestamp:

Nov 8, 2017, 5:43:33 PM (8 years ago)

Author:

Aaron Moss <a3moss@…>

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:

954908d

Parents:

78315272 (diff), e35f30a (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' of plg.uwaterloo.ca:software/cfa/cfa-cc

File:

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

src/GenPoly/Specialize.cc

@@ -22 +22 @@
 #include <utility>                       // for pair
 
+#include "Common/PassVisitor.h"
 #include "Common/SemanticError.h"        // for SemanticError
 #include "Common/UniqueName.h"           // for UniqueName
@@ -28 +29 @@
 #include "InitTweak/InitTweak.h"         // for isIntrinsicCallExpr
 #include "Parser/LinkageSpec.h"          // for C
-#include "PolyMutator.h"                 // for PolyMutator
 #include "ResolvExpr/FindOpenVars.h"     // for findOpenVars
 #include "ResolvExpr/TypeEnvironment.h"  // for OpenVarSet, AssertionSet
@@ -43 +43 @@
 
 namespace GenPoly {
-        class Specialize final : public PolyMutator {
-          public:
-                using PolyMutator::mutate;
-                virtual Expression * mutate( ApplicationExpr *applicationExpr ) override;
-                virtual Expression * mutate( AddressExpr *castExpr ) override;
-                virtual Expression * mutate( CastExpr *castExpr ) override;
-                // virtual Expression * mutate( LogicalExpr *logicalExpr );
-                // virtual Expression * mutate( ConditionalExpr *conditionalExpr );
-                // virtual Expression * mutate( CommaExpr *commaExpr );
+        struct Specialize final : public WithTypeSubstitution, public WithStmtsToAdd, public WithVisitorRef<Specialize> {
+                Expression * postmutate( ApplicationExpr *applicationExpr );
+                Expression * postmutate( CastExpr *castExpr );
 
                 void handleExplicitParams( ApplicationExpr *appExpr );
                 Expression * createThunkFunction( FunctionType *funType, Expression *actual, InferredParams *inferParams );
-                Expression * doSpecialization( Type *formalType, Expression *actual, InferredParams *inferParams = nullptr );
+                Expression * doSpecialization( Type *formalType, Expression *actual, InferredParams *inferParams );
 
                 std::string paramPrefix = "_p";
@@ -72 +66 @@
                                 if ( ! boundType ) continue;
                                 if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( boundType ) ) {
+                                        // bound to another type variable
                                         if ( closedVars.find( typeInst->get_name() ) == closedVars.end() ) {
+                                                // bound to a closed variable => must specialize
                                                 return true;
                                         } // if
                                 } else {
+                                        // variable is bound to a concrete type => must specialize
                                         return true;
                                 } // if
                         } // for
+                        // none of the type variables are bound
                         return false;
                 } else {
+                        // no env
                         return false;
                 } // if
@@ -136 +135 @@
                         if ( functionParameterSize( fftype ) != functionParameterSize( aftype ) ) return false;
                         // tuple-parameter sizes are the same, but actual parameter sizes differ - must tuple specialize
-                        if ( fftype->get_parameters().size() != aftype->get_parameters().size() ) return true;
+                        if ( fftype->parameters.size() != aftype->parameters.size() ) return true;
                         // total parameter size can be the same, while individual parameters can have different structure
-                        for ( auto params : group_iterate( fftype->get_parameters(), aftype->get_parameters() ) ) {
+                        for ( auto params : group_iterate( fftype->parameters, aftype->parameters ) ) {
                                 DeclarationWithType * formal = std::get<0>(params);
                                 DeclarationWithType * actual = std::get<1>(params);
@@ -152 +151 @@
 
         Expression * Specialize::doSpecialization( Type *formalType, Expression *actual, InferredParams *inferParams ) {
-                assertf( actual->has_result(), "attempting to specialize an untyped expression" );
+                assertf( actual->result, "attempting to specialize an untyped expression" );
                 if ( needsSpecialization( formalType, actual->get_result(), env ) ) {
                         if ( FunctionType *funType = getFunctionType( formalType ) ) {
-                                ApplicationExpr *appExpr;
-                                VariableExpr *varExpr;
-                                if ( ( appExpr = dynamic_cast<ApplicationExpr*>( actual ) ) ) {
+                                if ( ApplicationExpr * appExpr = dynamic_cast<ApplicationExpr*>( actual ) ) {
                                         return createThunkFunction( funType, appExpr->get_function(), inferParams );
-                                } else if ( ( varExpr = dynamic_cast<VariableExpr*>( actual ) ) ) {
+                                } else if ( VariableExpr * varExpr = dynamic_cast<VariableExpr*>( actual ) ) {
                                         return createThunkFunction( funType, varExpr, inferParams );
                                 } else {
@@ -204 +201 @@
         }
 
-        struct EnvTrimmer : public Visitor {
+        struct EnvTrimmer {
                 TypeSubstitution * env, * newEnv;
                 EnvTrimmer( TypeSubstitution * env, TypeSubstitution * newEnv ) : env( env ), newEnv( newEnv ){}
-                virtual void visit( TypeDecl * tyDecl ) {
+                void previsit( TypeDecl * tyDecl ) {
                         // transfer known bindings for seen type variables
-                        if ( Type * t = env->lookup( tyDecl->get_name() ) ) {
-                                newEnv->add( tyDecl->get_name(), t );
+                        if ( Type * t = env->lookup( tyDecl->name ) ) {
+                                newEnv->add( tyDecl->name, t );
                         }
                 }
@@ -219 +216 @@
                 if ( env ) {
                         TypeSubstitution * newEnv = new TypeSubstitution();
-                        EnvTrimmer trimmer( env, newEnv );
+                        PassVisitor<EnvTrimmer> trimmer( env, newEnv );
                         expr->accept( trimmer );
                         return newEnv;
@@ -277 +274 @@
                 std::string oldParamPrefix = paramPrefix;
                 paramPrefix += "p";
-                // save stmtsToAdd in oldStmts
+                // save stmtsToAddBefore in oldStmts
                 std::list< Statement* > oldStmts;
-                oldStmts.splice( oldStmts.end(), stmtsToAdd );
-                mutate( appExpr );
+                oldStmts.splice( oldStmts.end(), stmtsToAddBefore );
+                appExpr->acceptMutator( *visitor );
                 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 );
+                thunkFunc->statements->kids.splice( thunkFunc->statements->kids.end(), stmtsToAddBefore );
+                // restore oldStmts into stmtsToAddBefore
+                stmtsToAddBefore.splice( stmtsToAddBefore.end(), oldStmts );
 
                 // add return (or valueless expression) to the thunk
                 Statement *appStmt;
-                if ( funType->get_returnVals().empty() ) {
+                if ( funType->returnVals.empty() ) {
                         appStmt = new ExprStmt( noLabels, appExpr );
                 } else {
                         appStmt = new ReturnStmt( noLabels, appExpr );
                 } // if
-                thunkFunc->get_statements()->get_kids().push_back( appStmt );
+                thunkFunc->statements->kids.push_back( appStmt );
 
                 // add thunk definition to queue of statements to add
-                stmtsToAdd.push_back( new DeclStmt( noLabels, thunkFunc ) );
+                stmtsToAddBefore.push_back( new DeclStmt( noLabels, thunkFunc ) );
                 // return address of thunk function as replacement expression
                 return new AddressExpr( new VariableExpr( thunkFunc ) );
@@ -304 +301 @@
         void Specialize::handleExplicitParams( ApplicationExpr *appExpr ) {
                 // create thunks for the explicit parameters
-                assert( appExpr->get_function()->has_result() );
-                FunctionType *function = getFunctionType( appExpr->get_function()->get_result() );
+                assert( appExpr->function->result );
+                FunctionType *function = getFunctionType( appExpr->function->result );
                 assert( function );
                 std::list< DeclarationWithType* >::iterator formal;
                 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() );
-                }
-        }
-
-        Expression * Specialize::mutate( ApplicationExpr *appExpr ) {
-                appExpr->get_function()->acceptMutator( *this );
-                mutateAll( appExpr->get_args(), *this );
-
+                        *actual = doSpecialization( (*formal)->get_type(), *actual, &appExpr->get_inferParams() );
+                }
+        }
+
+        Expression * Specialize::postmutate( ApplicationExpr *appExpr ) {
                 if ( ! InitTweak::isIntrinsicCallExpr( appExpr ) ) {
                         // create thunks for the inferred parameters
@@ -331 +325 @@
         }
 
-        Expression * Specialize::mutate( AddressExpr *addrExpr ) {
-                addrExpr->get_arg()->acceptMutator( *this );
-                assert( addrExpr->has_result() );
-                addrExpr->set_arg( doSpecialization( addrExpr->get_result(), addrExpr->get_arg() ) );
-                return addrExpr;
-        }
-
-        Expression * Specialize::mutate( CastExpr *castExpr ) {
-                castExpr->get_arg()->acceptMutator( *this );
-                if ( castExpr->get_result()->isVoid() ) {
+        Expression * Specialize::postmutate( CastExpr *castExpr ) {
+                if ( castExpr->result->isVoid() ) {
                         // can't specialize if we don't have a return value
                         return castExpr;
                 }
-                Expression *specialized = doSpecialization( castExpr->get_result(), castExpr->get_arg() );
-                if ( specialized != castExpr->get_arg() ) {
+                Expression *specialized = doSpecialization( castExpr->result, castExpr->arg, &castExpr->inferParams );
+                if ( specialized != castExpr->arg ) {
                         // assume here that the specialization incorporates the cast
                         return specialized;
@@ -353 +339 @@
         }
 
-        // Removing these for now. Richard put these in for some reason, but it's not clear why.
-        // In particular, copy constructors produce a comma expression, and with this code the parts
-        // of that comma expression are not specialized, which causes problems.
-
-        // Expression * Specialize::mutate( LogicalExpr *logicalExpr ) {
-        //      return logicalExpr;
-        // }
-
-        // Expression * Specialize::mutate( ConditionalExpr *condExpr ) {
-        //      return condExpr;
-        // }
-
-        // Expression * Specialize::mutate( CommaExpr *commaExpr ) {
-        //      return commaExpr;
-        // }
-
         void convertSpecializations( std::list< Declaration* >& translationUnit ) {
-                Specialize spec;
+                PassVisitor<Specialize> spec;
                 mutateAll( translationUnit, spec );
         }