Changes in src/GenPoly/BoxNew.cpp [e14d169:0bf0b978]

File:

• src/GenPoly/BoxNew.cpp (modified) (16 diffs)

src/GenPoly/BoxNew.cpp

@@ -376 +376 @@
         ast::Expr const * postvisit( ast::AddressExpr const * expr );
         ast::ReturnStmt const * previsit( ast::ReturnStmt const * stmt );
+        void previsit( ast::PointerType const * type );
+        void previsit( ast::FunctionType const * type );
 
         void beginScope();
@@ -384 +386 @@
         // return value.
 
-        /// Passes extra layout arguments for sized polymorphic type parameters.
+        /// Pass the extra type parameters from polymorphic generic arguments or
+        /// return types into a function application.
+        ast::vector<ast::Expr>::iterator passArgTypeVars(
+                ast::ApplicationExpr * expr, ast::Type const * parmType,
+                ast::Type const * argBaseType, ast::vector<ast::Expr>::iterator arg,
+                const TypeVarMap & exprTyVars, std::set<std::string> & seenTypes );
+        /// Passes extra type parameters into a polymorphic function application.
         ast::vector<ast::Expr>::iterator passTypeVars(
                 ast::ApplicationExpr * expr,
-                ast::FunctionType const * funcType );
+                ast::Type const * polyRetType,
+                ast::FunctionType const * funcType,
+                const TypeVarMap & exprTyVars );
         /// Wraps a function application with a new temporary for the
         /// out-parameter return value.
@@ -551 +561 @@
 
 ast::FunctionDecl const * CallAdapter::previsit( ast::FunctionDecl const * decl ) {
-        // Prevent type declaration information from leaking out.
+        if ( nullptr == decl->stmts ) {
+                // This may keep TypeDecls we don't ever want from sneaking in.
+                // Not visiting child nodes might just be faster.
+                GuardScope( scopeTypeVars );
+                return decl;
+        }
+
         GuardScope( scopeTypeVars );
-
-        if ( nullptr == decl->stmts ) {
-                return decl;
-        }
-
         GuardValue( retval );
 
@@ -684 +695 @@
 
         assert( typeSubs );
+        ast::Type const * concRetType = replaceWithConcrete( dynRetType, *typeSubs );
+        // Used to use dynRetType instead of concRetType; this changed so that
+        // the correct type parameters are passed for return types (it should be
+        // the concrete type's parameters, not the formal type's).
         ast::vector<ast::Expr>::iterator argIt =
-                passTypeVars( mutExpr, function );
+                passTypeVars( mutExpr, concRetType, function, exprTypeVars );
         addInferredParams( mutExpr, argIt, function, exprTypeVars );
 
@@ -763 +778 @@
 }
 
+void CallAdapter::previsit( ast::PointerType const * type ) {
+        GuardScope( scopeTypeVars );
+        makeTypeVarMap( type, scopeTypeVars );
+}
+
+void CallAdapter::previsit( ast::FunctionType const * type ) {
+        GuardScope( scopeTypeVars );
+        makeTypeVarMap( type, scopeTypeVars );
+}
+
 void CallAdapter::beginScope() {
         adapters.beginScope();
@@ -787 +812 @@
 }
 
+// arg is an in/out parameter that matches the return value.
+ast::vector<ast::Expr>::iterator CallAdapter::passArgTypeVars(
+                ast::ApplicationExpr * expr, ast::Type const * paramType,
+                ast::Type const * argBaseType, ast::vector<ast::Expr>::iterator arg,
+                const TypeVarMap & exprTypeVars, std::set<std::string> & seenTypes ) {
+        ast::Type const * polyType = isPolyType( paramType, exprTypeVars );
+        if ( !polyType || dynamic_cast<ast::TypeInstType const *>( polyType ) ) {
+                return arg;
+        }
+
+        std::string typeName = Mangle::mangleType( polyType );
+        if ( seenTypes.count( typeName ) ) return arg;
+
+        arg = expr->args.insert( arg,
+                new ast::SizeofExpr( expr->location, ast::deepCopy( argBaseType ) )
+        );
+        arg++;
+        arg = expr->args.insert( arg,
+                new ast::AlignofExpr( expr->location, ast::deepCopy( argBaseType ) )
+        );
+        arg++;
+        if ( dynamic_cast<ast::StructInstType const *>( polyType ) ) {
+                auto argBaseStructType =
+                                dynamic_cast<ast::StructInstType const *>( argBaseType );
+                if ( nullptr == argBaseStructType ) {
+                        SemanticError( expr,
+                                "Cannot pass non-structure type for generic struct: " );
+                }
+
+                // Zero-length arrays are forbidden by C, so don't pass
+                // offset for empty structure.
+                if ( !argBaseStructType->base->members.empty() ) {
+                        arg = expr->args.insert( arg,
+                                new ast::OffsetPackExpr(
+                                        expr->location,
+                                        ast::deepCopy( argBaseStructType ) )
+                        );
+                        arg++;
+                }
+        }
+
+        seenTypes.insert( typeName );
+        return arg;
+}
+
 ast::vector<ast::Expr>::iterator CallAdapter::passTypeVars(
                 ast::ApplicationExpr * expr,
-                ast::FunctionType const * function ) {
+                ast::Type const * polyRetType,
+                ast::FunctionType const * function,
+                const TypeVarMap & exprTypeVars ) {
         assert( typeSubs );
         ast::vector<ast::Expr>::iterator arg = expr->args.begin();
@@ -808 +880 @@
                         new ast::AlignofExpr( expr->location, ast::deepCopy( concrete ) ) );
                 arg++;
+        }
+
+        // Add size/align for generic types to parameter list.
+        if ( !expr->func->result ) return arg;
+        ast::FunctionType const * funcType = getFunctionType( expr->func->result );
+        assert( funcType );
+
+        // This iterator points at first original argument.
+        ast::vector<ast::Expr>::const_iterator funcArg;
+        // Names for generic types we've seen.
+        std::set<std::string> seenTypes;
+
+        // A polymorphic return type may need to be added to the argument list.
+        if ( polyRetType ) {
+                assert( typeSubs );
+                auto concRetType = replaceWithConcrete( polyRetType, *typeSubs );
+                // TODO: This write-back may not be correct.
+                arg = passArgTypeVars( expr, polyRetType, concRetType,
+                                arg, exprTypeVars, seenTypes );
+                // Skip the return parameter in the argument list.
+                funcArg = arg + 1;
+        } else {
+                funcArg = arg;
+        }
+
+        // TODO:
+        // I believe this is (starts as) the number of original arguments to the
+        // function with the args before funcArg all being inserted.
+        ptrdiff_t argsToPass = std::distance( funcArg, expr->args.cend() );
+
+        // Add type information args for presently unseen types in parameter list.
+        ast::vector<ast::Type>::const_iterator funcParam = funcType->params.begin();
+        // assert( funcType->params.size() == argsToPass );
+        for ( ; funcParam != funcType->params.end() && 0 < argsToPass
+                        ; ++funcParam, --argsToPass ) {
+                assert( 0 < argsToPass );
+                assert( argsToPass <= (ptrdiff_t)expr->args.size() );
+                ptrdiff_t index = expr->args.size() - argsToPass;
+                ast::Type const * argType = expr->args[index]->result;
+                if ( nullptr == argType ) continue;
+                arg = passArgTypeVars( expr, *funcParam, argType,
+                                arg, exprTypeVars, seenTypes );
         }
         return arg;
@@ -1409 +1523 @@
 }
 
+ast::ObjectDecl * makePtr(
+                CodeLocation const & location, std::string const & name ) {
+        return new ast::ObjectDecl( location, name,
+                new ast::PointerType( makeSizeAlignType() ),
+                nullptr, ast::Storage::Classes(), ast::Linkage::C, nullptr );
+}
+
 ast::FunctionDecl const * DeclAdapter::previsit( ast::FunctionDecl const * decl ) {
         TypeVarMap localTypeVars = { ast::TypeData() };
@@ -1463 +1584 @@
         mutDecl->assertions.clear();
 
+        // Add size/align for generic parameter types to parameter list.
+        std::set<std::string> seenTypes;
+        ast::vector<ast::DeclWithType> otypeParams;
+        for ( ast::ptr<ast::DeclWithType> & funcParam : mutDecl->params ) {
+                ast::Type const * polyType = isPolyType( funcParam->get_type(), localTypeVars );
+                if ( !polyType || dynamic_cast<ast::TypeInstType const *>( polyType ) ) {
+                        continue;
+                }
+                std::string typeName = Mangle::mangleType( polyType );
+                if ( seenTypes.count( typeName ) ) continue;
+                seenTypes.insert( typeName );
+
+                auto sizeParam = makeObj( funcParam->location, sizeofName( typeName ) );
+                otypeParams.emplace_back( sizeParam );
+
+                auto alignParam = makeObj( funcParam->location, alignofName( typeName ) );
+                otypeParams.emplace_back( alignParam );
+
+                // Zero-length arrays are illegal in C, so empty structs have no
+                // offset array.
+                if ( auto * polyStruct =
+                                dynamic_cast<ast::StructInstType const *>( polyType ) ;
+                                polyStruct && !polyStruct->base->members.empty() ) {
+                        auto offsetParam = makePtr( funcParam->location, offsetofName( typeName ) );
+                        otypeParams.emplace_back( offsetParam );
+                }
+        }
+
         // Prepend each argument group. From last group to first. addAdapters
         // does do the same, it just does it itself and see all other parameters.
         spliceBegin( mutDecl->params, inferredParams );
+        spliceBegin( mutDecl->params, otypeParams );
         spliceBegin( mutDecl->params, layoutParams );
         addAdapters( mutDecl, localTypeVars );
@@ -1578 +1728 @@
         PolyGenericCalculator();
 
+        void previsit( ast::ObjectDecl const * decl );
         void previsit( ast::FunctionDecl const * decl );
         void previsit( ast::TypedefDecl const * decl );
@@ -1584 +1735 @@
         ast::StructDecl const * previsit( ast::StructDecl const * decl );
         ast::UnionDecl const * previsit( ast::UnionDecl const * decl );
+        void previsit( ast::PointerType const * type );
+        void previsit( ast::FunctionType const * type );
         ast::DeclStmt const * previsit( ast::DeclStmt const * stmt );
         ast::Expr const * postvisit( ast::MemberExpr const * expr );
@@ -1619 +1772 @@
         /// adding the type variables from the provided type.
         void beginTypeScope( ast::Type const * );
+        /// Enters a new scope for known layouts and offsets, and queues exit calls.
+        void beginGenericScope();
 
         /// Set of generic type layouts known in the current scope,
@@ -1630 +1785 @@
         /// If the argument of an AddressExpr is MemberExpr, it is stored here.
         ast::MemberExpr const * addrMember = nullptr;
+        /// Used to avoid recursing too deep in type declarations.
+        bool expect_func_type = false;
 };
 
@@ -1651 +1808 @@
 }
 
+void PolyGenericCalculator::previsit( ast::ObjectDecl const * decl ) {
+        beginTypeScope( decl->type );
+}
+
 void PolyGenericCalculator::previsit( ast::FunctionDecl const * decl ) {
-        GuardScope( *this );
+        beginGenericScope();
         beginTypeScope( decl->type );
+
+        // TODO: Going though dec->params does not work for some reason.
+        for ( ast::ptr<ast::Type> const & funcParam : decl->type->params ) {
+                // Condition here duplicates that in `DeclAdapter::previsit( FunctionDecl const * )`
+                ast::Type const * polyType = isPolyType( funcParam, scopeTypeVars );
+                if ( polyType && !dynamic_cast<ast::TypeInstType const *>( polyType ) ) {
+                        knownLayouts.insert( Mangle::mangleType( polyType ) );
+                }
+        }
 }
 
@@ -1714 +1884 @@
 }
 
+void PolyGenericCalculator::previsit( ast::PointerType const * type ) {
+        beginTypeScope( type );
+}
+
+void PolyGenericCalculator::previsit( ast::FunctionType const * type ) {
+        beginTypeScope( type );
+
+        GuardValue( expect_func_type );
+        GuardScope( *this );
+
+        // The other functions type we will see in this scope are probably
+        // function parameters they don't help us with the layout and offsets so
+        // don't mark them as known in this scope.
+        expect_func_type = false;
+
+        // Make sure that any type information passed into the function is
+        // accounted for.
+        for ( ast::ptr<ast::Type> const & funcParam : type->params ) {
+                // Condition here duplicates that in `DeclAdapter::previsit( FunctionDecl const * )`
+                ast::Type const * polyType = isPolyType( funcParam, scopeTypeVars );
+                if ( polyType && !dynamic_cast<ast::TypeInstType const *>( polyType ) ) {
+                        knownLayouts.insert( Mangle::mangleType( polyType ) );
+                }
+        }
+}
+
+//void PolyGenericCalculator::previsit( ast::DeclStmt const * stmt ) {
 ast::DeclStmt const * PolyGenericCalculator::previsit( ast::DeclStmt const * stmt ) {
         ast::ObjectDecl const * decl = stmt->decl.as<ast::ObjectDecl>();
@@ -2203 +2400 @@
 }
 
+void PolyGenericCalculator::beginGenericScope() {
+        GuardScope( *this );
+        // We expect the first function type see to be the type relating to this
+        // scope but any further type is probably some unrelated function pointer
+        // keep track of whrich is the first.
+        GuardValue( expect_func_type ) = true;
+}
+
 // --------------------------------------------------------------------------
-/// Removes unneeded or incorrect type information.
+/// No common theme found.
 /// * Replaces initialization of polymorphic values with alloca.
 /// * Replaces declaration of dtype/ftype with appropriate void expression.