Changes in src/GenPoly/Box.cc [03c56f6:0b1ca47]

File:

• src/GenPoly/Box.cc (modified) (17 diffs)

src/GenPoly/Box.cc

@@ -68 +68 @@
                 /// Adds layout-generation functions to polymorphic types.
                 class LayoutFunctionBuilder final : public WithDeclsToAdd, public WithVisitorRef<LayoutFunctionBuilder>, public WithShortCircuiting {
+                        // Current level of nested functions:
+                        unsigned int functionNesting = 0;
                 public:
+                        void previsit( FunctionDecl *functionDecl );
                         void previsit( StructDecl *structDecl );
                         void previsit( UnionDecl *unionDecl );
@@ -234 +237 @@
         ////////////////////////////////// LayoutFunctionBuilder ////////////////////////////////////////////
 
+        void LayoutFunctionBuilder::previsit( FunctionDecl *functionDecl ) {
+                visit_children = false;
+                maybeAccept( functionDecl->get_functionType(), *visitor );
+                ++functionNesting;
+                maybeAccept( functionDecl->get_statements(), *visitor );
+                --functionNesting;
+        }
+
         /// Get a list of type declarations that will affect a layout function
         std::list< TypeDecl* > takeOtypeOnly( std::list< TypeDecl* > &decls ) {
@@ -260 +271 @@
 
         /// Builds a layout function declaration
-        FunctionDecl *buildLayoutFunctionDecl( AggregateDecl *typeDecl, bool isInFunction, FunctionType *layoutFnType ) {
+        FunctionDecl *buildLayoutFunctionDecl( AggregateDecl *typeDecl, unsigned int functionNesting, FunctionType *layoutFnType ) {
                 // Routines at global scope marked "static" to prevent multiple definitions is separate translation units
                 // because each unit generates copies of the default routines for each aggregate.
                 FunctionDecl *layoutDecl = new FunctionDecl( layoutofName( typeDecl ),
-                                                                                                         isInFunction ? Type::StorageClasses() : Type::StorageClasses( Type::Static ),
+                                                                                                         functionNesting > 0 ? Type::StorageClasses() : Type::StorageClasses( Type::Static ),
                                                                                                          LinkageSpec::AutoGen, layoutFnType, new CompoundStmt(),
                                                                                                          std::list< Attribute * >(), Type::FuncSpecifiers( Type::Inline ) );
@@ -336 +347 @@
 
                 // build function decl
-                FunctionDecl *layoutDecl = buildLayoutFunctionDecl( structDecl, isInFunction(), layoutFnType );
+                FunctionDecl *layoutDecl = buildLayoutFunctionDecl( structDecl, functionNesting, layoutFnType );
 
                 // calculate struct layout in function body
@@ -343 +354 @@
                 addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( sizeParam ), new ConstantExpr( Constant::from_ulong( 0 ) ) ) );
                 addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( alignParam ), new ConstantExpr( Constant::from_ulong( 1 ) ) ) );
-                for ( auto index_member : enumerate( structDecl->members ) ) {
-                        DeclarationWithType *dwt = dynamic_cast< DeclarationWithType * >( index_member.val );
+                unsigned long n_members = 0;
+                bool firstMember = true;
+                for ( Declaration* member : structDecl->get_members() ) {
+                        DeclarationWithType *dwt = dynamic_cast< DeclarationWithType * >( member );
                         assert( dwt );
                         Type *memberType = dwt->get_type();
 
-                        if ( 0 < index_member.idx ) {
+                        if ( firstMember ) {
+                                firstMember = false;
+                        } else {
                                 // make sure all members after the first (automatically aligned at 0) are properly padded for alignment
                                 addStmt( layoutDecl->get_statements(), makeAlignTo( derefVar( sizeParam ), new AlignofExpr( memberType->clone() ) ) );
@@ -354 +369 @@
 
                         // place current size in the current offset index
-                        addExpr( layoutDecl->get_statements(), makeOp( "?=?", makeOp( "?[?]", new VariableExpr( offsetParam ), new ConstantExpr( Constant::from_ulong( index_member.idx ) ) ),
+                        addExpr( layoutDecl->get_statements(), makeOp( "?=?", makeOp( "?[?]", new VariableExpr( offsetParam ), new ConstantExpr( Constant::from_ulong( n_members ) ) ),
                                                                               derefVar( sizeParam ) ) );
+                        ++n_members;
 
                         // add member size to current size
@@ -390 +406 @@
 
                 // build function decl
-                FunctionDecl *layoutDecl = buildLayoutFunctionDecl( unionDecl, isInFunction(), layoutFnType );
+                FunctionDecl *layoutDecl = buildLayoutFunctionDecl( unionDecl, functionNesting, layoutFnType );
 
                 // calculate union layout in function body
@@ -550 +566 @@
                                 if ( tyParam.second.isComplete ) {
                                         Type *concrete = env->lookup( tyParam.first );
-                                        // If there is an unbound type variable, it should have detected already.
-                                        assertf( concrete, "Unbound type variable: %s in: %s",
-                                                toCString( tyParam.first ), toCString( *env ) );
-
-                                        arg = appExpr->get_args().insert( arg, new SizeofExpr( concrete->clone() ) );
-                                        arg++;
-                                        arg = appExpr->get_args().insert( arg, new AlignofExpr( concrete->clone() ) );
-                                        arg++;
+                                        if ( concrete ) {
+                                                arg = appExpr->get_args().insert( arg, new SizeofExpr( concrete->clone() ) );
+                                                arg++;
+                                                arg = appExpr->get_args().insert( arg, new AlignofExpr( concrete->clone() ) );
+                                                arg++;
+                                        } else {
+                                                // xxx - should this be an assertion?
+                                                SemanticError( appExpr, toString( *env, "\nunbound type variable: ", tyParam.first, " in application " ) );
+                                        } // if
                                 } // if
                         } // for
@@ -621 +638 @@
 
                 void Pass1::replaceParametersWithConcrete( ApplicationExpr *appExpr, std::list< Expression* >& params ) {
-                        for ( Expression * const param : params ) {
-                                TypeExpr *paramType = dynamic_cast< TypeExpr* >( param );
+                        for ( std::list< Expression* >::iterator param = params.begin(); param != params.end(); ++param ) {
+                                TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
                                 assertf(paramType, "Aggregate parameters should be type expressions");
                                 paramType->set_type( replaceWithConcrete( appExpr, paramType->get_type(), false ) );
@@ -675 +692 @@
                 }
 
-                // find instances of polymorphic type parameters
-                struct PolyFinder {
-                        const TyVarMap * tyVars = nullptr;
-                        bool found = false;
-
-                        void previsit( TypeInstType * t ) {
-                                if ( isPolyType( t, *tyVars ) ) {
-                                        found = true;
-                                }
-                        }
-                };
-
-                // true if there is an instance of a polymorphic type parameter in t
-                bool hasPolymorphism( Type * t, const TyVarMap &tyVars ) {
-                        PassVisitor<PolyFinder> finder;
-                        finder.pass.tyVars = &tyVars;
-                        maybeAccept( t, finder );
-                        return finder.pass.found;
-                }
-
-                /// cast parameters to polymorphic functions so that types are replaced with
-                /// void * if they are type parameters in the formal type.
-                /// this gets rid of warnings from gcc.
-                void addCast( Expression *&actual, Type *formal, const TyVarMap &tyVars ) {
-                        // type contains polymorphism, but isn't exactly a polytype, in which case it
-                        // has some real actual type (e.g. unsigned int) and casting to void * is wrong
-                        if ( hasPolymorphism( formal, tyVars ) && ! isPolyType( formal, tyVars ) ) {
-                                Type * newType = formal->clone();
-                                newType = ScrubTyVars::scrub( newType, tyVars );
-                                actual = new CastExpr( actual, newType );
-                        } // if
-                }
-
                 void Pass1::boxParam( Type *param, Expression *&arg, const TyVarMap &exprTyVars ) {
                         assertf( arg->result, "arg does not have result: %s", toString( arg ).c_str() );
-                        addCast( arg, param, exprTyVars );
                         if ( ! needsBoxing( param, arg->result, exprTyVars, env ) ) return;
 
@@ -741 +724 @@
                 }
 
+                // find instances of polymorphic type parameters
+                struct PolyFinder {
+                        const TyVarMap * tyVars = nullptr;
+                        bool found = false;
+
+                        void previsit( TypeInstType * t ) {
+                                if ( isPolyType( t, *tyVars ) ) {
+                                        found = true;
+                                }
+                        }
+                };
+
+                // true if there is an instance of a polymorphic type parameter in t
+                bool hasPolymorphism( Type * t, const TyVarMap &tyVars ) {
+                        PassVisitor<PolyFinder> finder;
+                        finder.pass.tyVars = &tyVars;
+                        maybeAccept( t, finder );
+                        return finder.pass.found;
+                }
+
+                /// cast parameters to polymorphic functions so that types are replaced with
+                /// void * if they are type parameters in the formal type.
+                /// this gets rid of warnings from gcc.
+                void addCast( Expression *&actual, Type *formal, const TyVarMap &tyVars ) {
+                        // type contains polymorphism, but isn't exactly a polytype, in which case it
+                        // has some real actual type (e.g. unsigned int) and casting to void * is wrong
+                        if ( hasPolymorphism( formal, tyVars ) && ! isPolyType( formal, tyVars ) ) {
+                                Type * newType = formal->clone();
+                                newType = ScrubTyVars::scrub( newType, tyVars );
+                                actual = new CastExpr( actual, newType );
+                        } // if
+                }
+
                 void Pass1::boxParams( ApplicationExpr *appExpr, FunctionType *function, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars ) {
-                        for ( DeclarationWithType * param : function->parameters ) {
-                                assertf( arg != appExpr->args.end(), "boxParams: missing argument for param %s to %s in %s", toString( param ).c_str(), toString( function ).c_str(), toString( appExpr ).c_str() );
-                                boxParam( param->get_type(), *arg, exprTyVars );
-                                ++arg;
+                        for ( std::list< DeclarationWithType *>::const_iterator param = function->get_parameters().begin(); param != function->parameters.end(); ++param, ++arg ) {
+                                assertf( arg != appExpr->args.end(), "boxParams: missing argument for param %s to %s in %s", toString( *param ).c_str(), toString( function ).c_str(), toString( appExpr ).c_str() );
+                                addCast( *arg, (*param)->get_type(), exprTyVars );
+                                boxParam( (*param)->get_type(), *arg, exprTyVars );
                         } // for
                 }
@@ -751 +767 @@
                 void Pass1::addInferredParams( ApplicationExpr *appExpr, FunctionType *functionType, std::list< Expression *>::iterator &arg, const TyVarMap &tyVars ) {
                         std::list< Expression *>::iterator cur = arg;
-                        for ( TypeDecl * const tyVar : functionType->forall ) {
-                                for ( DeclarationWithType * const assert : tyVar->assertions ) {
-                                        InferredParams::const_iterator inferParam = appExpr->inferParams.find( assert->get_uniqueId() );
-                                        assertf( inferParam != appExpr->inferParams.end(), "addInferredParams missing inferred parameter: %s in: %s", toString( assert ).c_str(), toString( appExpr ).c_str() );
+                        for ( Type::ForallList::iterator tyVar = functionType->get_forall().begin(); tyVar != functionType->get_forall().end(); ++tyVar ) {
+                                for ( std::list< DeclarationWithType *>::iterator assert = (*tyVar)->assertions.begin(); assert != (*tyVar)->assertions.end(); ++assert ) {
+                                        InferredParams::const_iterator inferParam = appExpr->inferParams.find( (*assert)->get_uniqueId() );
+                                        assertf( inferParam != appExpr->inferParams.end(), "addInferredParams missing inferred parameter: %s in: %s", toString( *assert ).c_str(), toString( appExpr ).c_str() );
                                         Expression *newExpr = inferParam->second.expr->clone();
-                                        boxParam( assert->get_type(), newExpr, tyVars );
+                                        addCast( newExpr, (*assert)->get_type(), tyVars );
+                                        boxParam( (*assert)->get_type(), newExpr, tyVars );
                                         appExpr->get_args().insert( cur, newExpr );
                                 } // for
@@ -786 +803 @@
                         assert( param );
                         assert( arg );
-                        if ( isPolyType( realParam->get_type(), tyVars )
-                                        && ! isPolyType( arg->get_type() ) ) {
-                                UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
-                                deref->args.push_back( new CastExpr( new VariableExpr( param ), new PointerType( Type::Qualifiers(), arg->get_type()->clone() ) ) );
-                                deref->result = arg->get_type()->clone();
-                                return deref;
+                        if ( isPolyType( realParam->get_type(), tyVars ) ) {
+                                if ( ! isPolyType( arg->get_type() ) ) {
+                                        UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
+                                        deref->args.push_back( new CastExpr( new VariableExpr( param ), new PointerType( Type::Qualifiers(), arg->get_type()->clone() ) ) );
+                                        deref->result = arg->get_type()->clone();
+                                        return deref;
+                                } // if
                         } // if
                         return new VariableExpr( param );
@@ -1127 +1145 @@
                 }
 
-                bool isPolyDeref( UntypedExpr * expr, TyVarMap const & scopeTyVars, TypeSubstitution const * env ) {
+                Expression * Pass1::postmutate( UntypedExpr *expr ) {
                         if ( expr->result && isPolyType( expr->result, scopeTyVars, env ) ) {
                                 if ( NameExpr *name = dynamic_cast< NameExpr *>( expr->function ) ) {
                                         if ( name->name == "*?" ) {
-                                                return true;
+                                                Expression *ret = expr->args.front();
+                                                expr->args.clear();
+                                                delete expr;
+                                                return ret;
                                         } // if
                                 } // if
                         } // if
-                        return false;
-                }
-
-                Expression * Pass1::postmutate( UntypedExpr *expr ) {
-                        if ( isPolyDeref( expr, scopeTyVars, env ) ) {
-                                Expression *ret = expr->args.front();
-                                expr->args.clear();
-                                delete expr;
-                                return ret;
-                        }
                         return expr;
                 }
@@ -1154 +1165 @@
                         bool needs = false;
                         if ( UntypedExpr *expr = dynamic_cast< UntypedExpr *>( addrExpr->arg ) ) {
-                                if ( isPolyDeref( expr, scopeTyVars, env ) ) {
-                                        if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( expr->args.front() ) ) {
-                                                assert( appExpr->function->result );
-                                                FunctionType *function = getFunctionType( appExpr->function->result );
-                                                assert( function );
-                                                needs = needsAdapter( function, scopeTyVars );
+                                if ( expr->result && isPolyType( expr->result, scopeTyVars, env ) ) {
+                                        if ( NameExpr *name = dynamic_cast< NameExpr *>( expr->function ) ) {
+                                                if ( name->name == "*?" ) {
+                                                        if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( expr->args.front() ) ) {
+                                                                assert( appExpr->function->result );
+                                                                FunctionType *function = getFunctionType( appExpr->function->result );
+                                                                assert( function );
+                                                                needs = needsAdapter( function, scopeTyVars );
+                                                        } // if
+                                                } // if
                                         } // if
                                 } // if
@@ -1211 +1226 @@
                         std::list< DeclarationWithType *> &paramList = functionType->parameters;
                         std::list< FunctionType *> functions;
-                        for ( DeclarationWithType * const arg : functionType->parameters ) {
+                        for (  DeclarationWithType * const arg : functionType->parameters ) {
                                 Type *orig = arg->get_type();
                                 findAndReplaceFunction( orig, functions, scopeTyVars, needsAdapter );
@@ -1432 +1447 @@
 
                         if(!expect_func_type) {
+                                GuardAction( [this]() {
+                                        knownLayouts.endScope();
+                                        knownOffsets.endScope();
+                                });
                                 // If this is the first function type we see
                                 // Then it's the type of the declaration and we care about it
-                                GuardScope( *this );
+                                knownLayouts.beginScope();
+                                knownOffsets.beginScope();
                         }