Changeset 278e162 for src

Timestamp:

Oct 23, 2023, 11:13:00 AM (2 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

master

Children:

cb94e41

Parents:

4d2d7e27 (diff), abb04a4 (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

Files:

• CodeTools/DeclStats.cc (modified) (1 diff)
• GenPoly/BoxNew.cpp (modified) (16 diffs)
• GenPoly/GenPoly.cc (modified) (2 diffs)
• GenPoly/GenPoly.h (modified) (1 diff)
• GenPoly/SpecializeNew.cpp (modified) (1 diff)

src/CodeTools/DeclStats.cc

@@ -25 +25 @@
 #include "Common/PassVisitor.h"
 #include "Common/VectorMap.h"      // for VectorMap
-#include "GenPoly/GenPoly.h"       // for hasPolyBase
 #include "SynTree/LinkageSpec.h"   // for ::NoOfSpecs, Spec
 #include "SynTree/Declaration.h"   // for FunctionDecl, TypeDecl, Declaration

src/GenPoly/BoxNew.cpp

@@ -39 +39 @@
 
 namespace {
-
-/// Common field of several sub-passes of box.
-struct BoxPass {
-        TypeVarMap scopeTypeVars;
-        BoxPass() : scopeTypeVars( ast::TypeData() ) {}
-};
-
-// TODO: Could this be a common helper somewhere?
-ast::FunctionType * makeFunctionType( ast::FunctionDecl const * decl ) {
-        ast::FunctionType * type = new ast::FunctionType(
-                decl->type->isVarArgs, decl->type->qualifiers
-        );
-        for ( auto type_param : decl->type_params ) {
-                type->forall.emplace_back( new ast::TypeInstType( type_param ) );
-        }
-        for ( auto assertion : decl->assertions ) {
-                type->assertions.emplace_back( new ast::VariableExpr(
-                        assertion->location, assertion ) );
-        }
-        for ( auto param : decl->params ) {
-                type->params.emplace_back( param->get_type() );
-        }
-        for ( auto retval : decl->returns ) {
-                type->returns.emplace_back( retval->get_type() );
-        }
-        return type;
-}
 
 // --------------------------------------------------------------------------
@@ -359 +332 @@
 /// * Adds appropriate type variables to the function calls.
 struct CallAdapter final :
-                public BoxPass,
                 public ast::WithConstTypeSubstitution,
                 public ast::WithGuards,
@@ -438 +410 @@
                 CodeLocation const & location, ast::Type const * type );
 
-        /// Set of adapter functions in the current scope.
+        TypeVarMap scopeTypeVars;
         ScopedMap< std::string, ast::DeclWithType const * > adapters;
         std::map< ast::ApplicationExpr const *, ast::Expr const * > retVals;
@@ -659 +631 @@
         ptrdiff_t initArgCount = mutExpr->args.size();
 
-        TypeVarMap exprTypeVars = { ast::TypeData() };
+        TypeVarMap exprTypeVars;
         // TODO: Should this take into account the variables already bound in
         // scopeTypeVars ([ex] remove them from exprTypeVars)?
@@ -1410 +1382 @@
 
 ast::FunctionDecl const * DeclAdapter::previsit( ast::FunctionDecl const * decl ) {
-        TypeVarMap localTypeVars = { ast::TypeData() };
+        TypeVarMap localTypeVars;
         makeTypeVarMap( decl, localTypeVars );
 
@@ -1441 +1413 @@
                         layoutParams.emplace_back( alignParam );
                 }
-                // TODO: These should possibly all be gone.
-                // More all assertions into parameter list.
-                for ( ast::ptr<ast::DeclWithType> & assert : mutParam->assertions ) {
-                        // Assertion parameters may not be used in body,
-                        // pass along with unused attribute.
-                        assert.get_and_mutate()->attributes.push_back(
-                                new ast::Attribute( "unused" ) );
-                        inferredParams.push_back( assert );
-                }
-                mutParam->assertions.clear();
+                // Assertions should be stored in the main list.
+                assert( mutParam->assertions.empty() );
                 typeParam = mutParam;
         }
-        // TODO: New version of inner loop.
         for ( ast::ptr<ast::DeclWithType> & assert : mutDecl->assertions ) {
                 // Assertion parameters may not be used in body,
@@ -1468 +1431 @@
         spliceBegin( mutDecl->params, layoutParams );
         addAdapters( mutDecl, localTypeVars );
+
+        // Now have to update the type to match the declaration.
+        ast::FunctionType * type = new ast::FunctionType(
+                mutDecl->type->isVarArgs, mutDecl->type->qualifiers );
+        for ( auto type_param : mutDecl->type_params ) {
+                type->forall.emplace_back( new ast::TypeInstType( type_param ) );
+        }
+        for ( auto param : mutDecl->params ) {
+                type->params.emplace_back( param->get_type() );
+        }
+        for ( auto retval : mutDecl->returns ) {
+                type->returns.emplace_back( retval->get_type() );
+        }
+        mutDecl->type = type;
 
         return mutDecl;
@@ -1501 +1478 @@
                 }
         }
-        // TODO: Can this be updated as we go along?
-        mutDecl->type = makeFunctionType( mutDecl );
         return mutDecl;
 }
@@ -1558 +1533 @@
         assertf( it != adapters.end(), "Could not correct floating node." );
         return ast::mutate_field( expr, &ast::VariableExpr::var, it->second );
-
 }
 
@@ -1570 +1544 @@
 /// * Inserts dynamic calculation of polymorphic type layouts where needed.
 struct PolyGenericCalculator final :
-                public BoxPass,
                 public ast::WithConstTypeSubstitution,
                 public ast::WithDeclsToAdd<>,
@@ -1615 +1588 @@
         /// C sizeof().
         ast::Expr const * genSizeof( CodeLocation const &, ast::Type const * );
-
         /// Enters a new scope for type-variables,
         /// adding the type variables from the provided type.
         void beginTypeScope( ast::Type const * );
 
+        /// The type variables and polymorphic parameters currently in scope.
+        TypeVarMap scopeTypeVars;
         /// Set of generic type layouts known in the current scope,
         /// indexed by sizeofName.
@@ -1668 +1642 @@
                 ast::TypeDecl const * decl ) {
         ast::Type const * base = decl->base;
-        if ( nullptr == base) return decl;
+        if ( nullptr == base ) return decl;
 
         // Add size/align variables for opaque type declarations.
@@ -1693 +1667 @@
         alignDecl->accept( *visitor );
 
-        // Can't use [makeVar], because it inserts into stmtsToAdd and TypeDecls
-        // can occur at global scope.
+        // A little trick to replace this with two declarations.
+        // Adding after makes sure that there is no conflict with adding stmts.
         declsToAddAfter.push_back( alignDecl );
-        // replace with sizeDecl.
         return sizeDecl;
 }
@@ -1721 +1694 @@
 
         // Change initialization of a polymorphic value object to allocate via a
-        // variable-length-array (alloca was previouly used, but it cannot be
-        // safely used in loops).
+        // variable-length-array (alloca cannot be safely used in loops).
         ast::ObjectDecl * newBuf = new ast::ObjectDecl( decl->location,
                 bufNamer.newName(),
@@ -2210 +2182 @@
 /// * Strips fields from generic structure declarations.
 struct Eraser final :
-                public BoxPass,
                 public ast::WithGuards {
         void guardTypeVarMap( ast::Type const * type ) {
@@ -2225 +2196 @@
         void previsit( ast::PointerType const * type );
         void previsit( ast::FunctionType const * type );
+public:
+        TypeVarMap scopeTypeVars;
 };
 

src/GenPoly/GenPoly.cc

@@ -273 +273 @@
         if ( func->returns.empty() ) return nullptr;
 
-        TypeVarMap forallTypes = { ast::TypeData() };
+        TypeVarMap forallTypes;
         makeTypeVarMap( func, forallTypes );
         return isDynType( func->returns.front(), forallTypes );
@@ -801 +801 @@
         const ast::FunctionType * function = getFunctionType( expr->func->result );
         assertf( function, "ApplicationExpr has non-function type: %s", toString( expr->func->result ).c_str() );
-        TypeVarMap exprTyVars = { ast::TypeData() };
+        TypeVarMap exprTyVars;
         makeTypeVarMap( function, exprTyVars );
         return needsBoxing( param, arg, exprTyVars, subst );

src/GenPoly/GenPoly.h

@@ -33 +33 @@
 
         typedef ErasableScopedMap< std::string, TypeDecl::Data > TyVarMap;
-        using TypeVarMap = ErasableScopedMap< ast::TypeEnvKey, ast::TypeData >;
+        struct TypeVarMap : public ErasableScopedMap<ast::TypeEnvKey, ast::TypeData> {
+                TypeVarMap() : ErasableScopedMap( ast::TypeData() ) {}
+        };
 
         /// Replaces a TypeInstType by its referrent in the environment, if applicable

src/GenPoly/SpecializeNew.cpp

@@ -81 +81 @@
 }
 
-// The number of elements in a type if it is a flattened tuple.
-size_t flatTupleSize( const ast::Type * type ) {
-        if ( auto tuple = dynamic_cast<const ast::TupleType *>( type ) ) {
-                size_t sum = 0;
-                for ( auto t : *tuple ) {
-                        sum += flatTupleSize( t );
-                }
-                return sum;
-        } else {
-                return 1;
-        }
+// The number of elements in a list, if all tuples had been flattened.
+size_t flatTypeListSize( const std::vector<ast::ptr<ast::Type>> & types ) {
+        size_t sum = 0;
+        for ( const ast::ptr<ast::Type> & type : types ) {
+                if ( const ast::TupleType * tuple = type.as<ast::TupleType>() ) {
+                        sum += flatTypeListSize( tuple->types );
+                } else {
+                        sum += 1;
+                }
+        }
+        return sum;
 }
 
 // Find the total number of components in a parameter list.
 size_t functionParameterSize( const ast::FunctionType * type ) {
-        size_t sum = 0;
-        for ( auto param : type->params ) {
-                sum += flatTupleSize( param );
-        }
-        return sum;
+        return flatTypeListSize( type->params );
 }