Changeset dd33c1f for src/GenPoly

Timestamp:

Jul 26, 2022, 2:17:49 PM (2 years ago)

Author:

Fangren Yu <f37yu@…>

Branches:

ADT, ast-experimental, master, pthread-emulation

Children:

1b97cc87

Parents:

4c48be0 (diff), 3992098 (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

Location:

src/GenPoly

Files:

• Specialize.h (modified) (2 diffs)
• SpecializeNew.cpp (modified) (11 diffs)

src/GenPoly/Specialize.h

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// Specialize.h -- 
+// Specialize.h -- Generate thunks to specialize polymorphic functions.
 //
 // Author           : Richard C. Bilson
@@ -17 +17 @@
 
 #include <list>  // for list
-#include "AST/TranslationUnit.hpp"
 
 class Declaration;
+namespace ast {
+        class TranslationUnit;
+}
 
 namespace GenPoly {

src/GenPoly/SpecializeNew.cpp

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// SpecializeNew.cpp --
+// SpecializeNew.cpp -- Generate thunks to specialize polymorphic functions.
 //
 // Author           : Andrew Beach
@@ -201 +201 @@
                         *formal, *actual, getInferredParams( expr ) );
         }
-        //for ( auto pair : group_iterate( formal->params, mut->args ) ) {
-        //      const ast::ptr<ast::Type> & formal = std::get<0>( pair );
-        //      ast::ptr<ast::Expr> & actual = std::get<1>( pair );
-        //      *actual = doSpecialization( (*actual)->location, *formal, *actual, getInferredParams( expr ) );
-        //}
         return mut;
 }
@@ -227 +222 @@
 }
 
-// Restructures the arguments to match the structure of the formal parameters
-// of the actual function. [begin, end) are the exploded arguments.
-template<typename Iterator, typename OutIterator>
-void structureArg( const CodeLocation & location, const ast::Type * type,
-                Iterator & begin, Iterator end, OutIterator out ) {
-        if ( auto tuple = dynamic_cast<const ast::TupleType *>( type ) ) {
-                std::vector<ast::ptr<ast::Expr>> exprs;
-                for ( const ast::Type * t : *tuple ) {
-                        structureArg( location, t, begin, end, std::back_inserter( exprs ) );
-                }
-                *out++ = new ast::TupleExpr( location, std::move( exprs ) );
-        } else {
-                assertf( begin != end, "reached the end of the arguments while structuring" );
-                *out++ = *begin++;
-        }
-}
-
-#if 0
+// Restructures arguments to match the structure of the formal parameters
+// of the actual function. Returns the next structured argument.
 template<typename Iterator>
 const ast::Expr * structureArg(
                 const CodeLocation& location, const ast::ptr<ast::Type> & type,
                 Iterator & begin, const Iterator & end ) {
-        if ( auto tuple = type->as<ast::TupleType>() ) {
+        if ( auto tuple = type.as<ast::TupleType>() ) {
                 std::vector<ast::ptr<ast::Expr>> exprs;
                 for ( const ast::Type * t : *tuple ) {
@@ -260 +239 @@
         }
 }
-#endif
 
 namespace {
@@ -291 +269 @@
                 // Must replace only occurrences of type variables
                 // that occure free in the thunk's type.
-                //ast::TypeSubstitution::ApplyResult<ast::FunctionType>
-                //      typeSubs->applyFree( newType );
                 auto result = typeSubs->applyFree( newType );
                 newType = result.node.release();
@@ -300 +276 @@
         using DeclVector = std::vector<ast::ptr<ast::TypeDecl>>;
 
-        //const std::string & thunkName = thunkNamer.newName();
-        //UniqueName paramNamer(thunkName + "Param");
         UniqueName paramNamer( paramPrefix );
 
-        //auto toParamDecl = [&location, &paramNamer]( const ast::Type * type ) {
-        //      return new ast::ObjectDecl(
-        //              location, paramNamer.newName(), ast::deepCopy( type ) );
-        //};
-
         // Create new thunk with same signature as formal type.
-
-        // std::map<const ast::TypeDecl *, std::pair<int, int>> typeMap;
         ast::Pass<TypeInstFixer> fixer;
         for (const auto & kv : newType->forall) {
                 if (fixer.core.typeMap.count(kv->base)) {
-                        std::cerr << location << ' ' << kv->base->name << ' ' << kv->expr_id << '_' << kv->formal_usage << ',' 
-                        << fixer.core.typeMap[kv->base].first << '_' << fixer.core.typeMap[kv->base].second << std::endl;
+                        std::cerr << location << ' ' << kv->base->name
+                                << ' ' << kv->expr_id << '_' << kv->formal_usage
+                                << ',' << fixer.core.typeMap[kv->base].first
+                                << '_' << fixer.core.typeMap[kv->base].second << std::endl;
                         assertf(false, "multiple formals in specialize");
                 }
@@ -322 +291 @@
                         fixer.core.typeMap[kv->base] = std::make_pair(kv->expr_id, kv->formal_usage);
                 }
-        } 
+        }
 
         ast::CompoundStmt * thunkBody = new ast::CompoundStmt( location );
@@ -345 +314 @@
                 );
 
-        // thunkFunc->accept(fixer);
         thunkFunc->fixUniqueId();
-
-
 
         // Thunks may be generated and not used, avoid them.
@@ -375 +341 @@
                 // Name each thunk parameter and explode it.
                 // These are then threaded back into the actual function call.
-                //param->name = paramNamer.newName();
                 ast::DeclWithType * mutParam = ast::mutate( param.get() );
-                // - Should be renamed earlier. -
-                //mutParam->name = paramNamer.newName();
                 explodeSimple( location, new ast::VariableExpr( location, mutParam ),
                         std::back_inserter( args ) );
@@ -388 +351 @@
                 argBegin = args.begin(), argEnd = args.end();
         for ( const auto & actualArg : actualType->params ) {
-                structureArg( location, actualArg.get(), argBegin, argEnd,
-                        std::back_inserter( app->args ) );
+                app->args.push_back(
+                        structureArg( location, actualArg.get(), argBegin, argEnd ) );
         }
         assertf( argBegin == argEnd, "Did not structure all arguments." );
@@ -469 +432 @@
         // Create thunks for the inferred parameters.
         // This is not needed for intrinsic calls, because they aren't
-        // actually passed
-        //
-        // need to handle explicit params before inferred params so that
-        // explicit params do not recieve a changed set of inferParams (and
-        // change them again) alternatively, if order starts to matter then
-        // copy appExpr's inferParams and pass them to handleExplicitParams.
+        // actually passed to the function. It needs to handle explicit params
+        // before inferred params so that explicit params do not recieve a
+        // changed set of inferParams (and change them again).
+        // Alternatively, if order starts to matter then copy expr's inferParams
+        // and pass them to handleExplicitParams.
         ast::ApplicationExpr * mut = handleExplicitParams( expr );
         if ( !mut->inferred.hasParams() ) {