Changeset 37f0da8 for src/GenPoly

Timestamp:

Apr 14, 2016, 3:23:53 PM (10 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, ctor, deferred_resn, demangler, enum, forall-pointer-decay, gc_noraii, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, string, with_gc

Children:

0f9e4403, 347c42f, 70a06f6

Parents:

37218fc (diff), baba5d8 (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:/u/cforall/software/cfa/cfa-cc

Location:

src/GenPoly

Files:

• Box.cc (modified) (44 diffs)
• ErasableScopedMap.h (added)
• FindFunction.cc (modified) (3 diffs)
• GenPoly.cc (modified) (3 diffs)
• GenPoly.h (modified) (3 diffs)
• Lvalue.cc (modified) (3 diffs)
• PolyMutator.cc (modified) (1 diff)
• ScopedMap.h (modified) (7 diffs)
• ScopedSet.h (modified) (7 diffs)
• ScrubTyVars.cc (modified) (2 diffs)

src/GenPoly/Box.cc

@@ -205 +205 @@
                         ObjectDecl *makeTemporary( Type *type );
 
-                        std::map< std::string, DeclarationWithType *> assignOps;     ///< Currently known type variable assignment operators
+                        ScopedMap< std::string, DeclarationWithType *> assignOps;    ///< Currently known type variable assignment operators
                         ResolvExpr::TypeMap< DeclarationWithType > scopedAssignOps;  ///< Currently known assignment operators
                         ScopedMap< std::string, DeclarationWithType* > adapters;     ///< Set of adapter functions in the current scope
@@ -292 +292 @@
                         /// adds type parameters to the layout call; will generate the appropriate parameters if needed
                         void addOtypeParamsToLayoutCall( UntypedExpr *layoutCall, const std::list< Type* > &otypeParams );
+
+                        /// Enters a new scope for type-variables, adding the type variables from ty
+                        void beginTypeScope( Type *ty );
+                        /// Exits the type-variable scope
+                        void endTypeScope();
                         
                         ScopedSet< std::string > knownLayouts;          ///< Set of generic type layouts known in the current scope, indexed by sizeofName
@@ -385 +390 @@
                 for ( std::list< TypeDecl* >::const_iterator param = otypeParams.begin(); param != otypeParams.end(); ++param ) {
                         TypeInstType paramType( Type::Qualifiers(), (*param)->get_name(), *param );
-                        layoutFnType->get_parameters().push_back( new ObjectDecl( sizeofName( &paramType ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignType.clone(), 0 ) );
-                        layoutFnType->get_parameters().push_back( new ObjectDecl( alignofName( &paramType ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignType.clone(), 0 ) );
+                        std::string paramName = mangleType( &paramType );
+                        layoutFnType->get_parameters().push_back( new ObjectDecl( sizeofName( paramName ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignType.clone(), 0 ) );
+                        layoutFnType->get_parameters().push_back( new ObjectDecl( alignofName( paramName ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignType.clone(), 0 ) );
                 }
         }
 
         /// Builds a layout function declaration
-        FunctionDecl *buildLayoutFunctionDecl( const std::string &typeName, unsigned int functionNesting, 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(
-                        "__layoutof_" + typeName, functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static, LinkageSpec::AutoGen, layoutFnType, new CompoundStmt( noLabels ), true, false );
+                        layoutofName( typeDecl ), functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static, LinkageSpec::AutoGen, layoutFnType, new CompoundStmt( noLabels ), true, false );
                 layoutDecl->fixUniqueId();
                 return layoutDecl;
@@ -462 +468 @@
                 PointerType *sizeAlignOutType = new PointerType( Type::Qualifiers(), sizeAlignType );
                 
-                ObjectDecl *sizeParam = new ObjectDecl( "__sizeof_" + structDecl->get_name(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType, 0 );
+                ObjectDecl *sizeParam = new ObjectDecl( sizeofName( structDecl->get_name() ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType, 0 );
                 layoutFnType->get_parameters().push_back( sizeParam );
-                ObjectDecl *alignParam = new ObjectDecl( "__alignof_" + structDecl->get_name(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 );
+                ObjectDecl *alignParam = new ObjectDecl( alignofName( structDecl->get_name() ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 );
                 layoutFnType->get_parameters().push_back( alignParam );
-                ObjectDecl *offsetParam = new ObjectDecl( "__offsetof_" + structDecl->get_name(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 );
+                ObjectDecl *offsetParam = new ObjectDecl( offsetofName( structDecl->get_name() ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 );
                 layoutFnType->get_parameters().push_back( offsetParam );
                 addOtypeParams( layoutFnType, otypeParams );
 
                 // build function decl
-                FunctionDecl *layoutDecl = buildLayoutFunctionDecl( structDecl->get_name(), functionNesting, layoutFnType );
+                FunctionDecl *layoutDecl = buildLayoutFunctionDecl( structDecl, functionNesting, layoutFnType );
 
                 // calculate struct layout in function body
@@ -523 +529 @@
                 PointerType *sizeAlignOutType = new PointerType( Type::Qualifiers(), sizeAlignType );
                 
-                ObjectDecl *sizeParam = new ObjectDecl( "__sizeof_" + unionDecl->get_name(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType, 0 );
+                ObjectDecl *sizeParam = new ObjectDecl( sizeofName( unionDecl->get_name() ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType, 0 );
                 layoutFnType->get_parameters().push_back( sizeParam );
-                ObjectDecl *alignParam = new ObjectDecl( "__alignof_" + unionDecl->get_name(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 );
+                ObjectDecl *alignParam = new ObjectDecl( alignofName( unionDecl->get_name() ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 );
                 layoutFnType->get_parameters().push_back( alignParam );
                 addOtypeParams( layoutFnType, otypeParams );
 
                 // build function decl
-                FunctionDecl *layoutDecl = buildLayoutFunctionDecl( unionDecl->get_name(), functionNesting, layoutFnType );
+                FunctionDecl *layoutDecl = buildLayoutFunctionDecl( unionDecl, functionNesting, layoutFnType );
 
                 // calculate union layout in function body
@@ -663 +669 @@
                         if ( functionDecl->get_statements() ) {         // empty routine body ?
                                 doBeginScope();
-                                TyVarMap oldtyVars = scopeTyVars;
-                                std::map< std::string, DeclarationWithType *> oldassignOps = assignOps;
+                                scopeTyVars.beginScope();
+                                assignOps.beginScope();
                                 DeclarationWithType *oldRetval = retval;
                                 bool oldUseRetval = useRetval;
@@ -705 +711 @@
                                 functionDecl->set_statements( functionDecl->get_statements()->acceptMutator( *this ) );
 
-                                scopeTyVars = oldtyVars;
-                                assignOps = oldassignOps;
-                                // std::cerr << "end FunctionDecl: ";
-                                // for ( TyVarMap::iterator i = scopeTyVars.begin(); i != scopeTyVars.end(); ++i ) {
-                                //      std::cerr << i->first << " ";
-                                // }
-                                // std::cerr << "\n";
+                                scopeTyVars.endScope();
+                                assignOps.endScope();
                                 retval = oldRetval;
                                 useRetval = oldUseRetval;
@@ -745 +746 @@
 
                 void Pass1::passArgTypeVars( ApplicationExpr *appExpr, Type *parmType, Type *argBaseType, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars, std::set< std::string > &seenTypes ) {
-                        Type *polyBase = hasPolyBase( parmType, exprTyVars );
-                        if ( polyBase && ! dynamic_cast< TypeInstType* >( polyBase ) ) {
-                                std::string sizeName = sizeofName( polyBase );
-                                if ( seenTypes.count( sizeName ) ) return;
+                        Type *polyType = isPolyType( parmType, exprTyVars );
+                        if ( polyType && ! dynamic_cast< TypeInstType* >( polyType ) ) {
+                                std::string typeName = mangleType( polyType );
+                                if ( seenTypes.count( typeName ) ) return;
 
                                 arg = appExpr->get_args().insert( arg, new SizeofExpr( argBaseType->clone() ) );
@@ -754 +755 @@
                                 arg = appExpr->get_args().insert( arg, new AlignofExpr( argBaseType->clone() ) );
                                 arg++;
-                                if ( dynamic_cast< StructInstType* >( polyBase ) ) {
+                                if ( dynamic_cast< StructInstType* >( polyType ) ) {
                                         if ( StructInstType *argBaseStructType = dynamic_cast< StructInstType* >( argBaseType ) ) {
                                                 // zero-length arrays are forbidden by C, so don't pass offset for empty struct
@@ -766 +767 @@
                                 }
 
-                                seenTypes.insert( sizeName );
+                                seenTypes.insert( typeName );
                         }
                 }
@@ -1124 +1125 @@
                                 addAssign->get_args().push_back( appExpr->get_args().front() );
                         } // if
-                        addAssign->get_args().push_back( new NameExpr( sizeofName( polyType ) ) );
+                        addAssign->get_args().push_back( new NameExpr( sizeofName( mangleType( polyType ) ) ) );
                         addAssign->get_results().front() = appExpr->get_results().front()->clone();
                         if ( appExpr->get_env() ) {
@@ -1151 +1152 @@
                                                         UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) );
                                                         multiply->get_args().push_back( appExpr->get_args().back() );
-                                                        multiply->get_args().push_back( new NameExpr( sizeofName( baseType1 ) ) );
+                                                        multiply->get_args().push_back( new SizeofExpr( baseType1->clone() ) );
                                                         ret->get_args().push_back( appExpr->get_args().front() );
                                                         ret->get_args().push_back( multiply );
@@ -1157 +1158 @@
                                                         UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) );
                                                         multiply->get_args().push_back( appExpr->get_args().front() );
-                                                        multiply->get_args().push_back( new NameExpr( sizeofName( baseType2 ) ) );
+                                                        multiply->get_args().push_back( new SizeofExpr( baseType2->clone() ) );
                                                         ret->get_args().push_back( multiply );
                                                         ret->get_args().push_back( appExpr->get_args().back() );
@@ -1220 +1221 @@
                                                         UntypedExpr *divide = new UntypedExpr( new NameExpr( "?/?" ) );
                                                         divide->get_args().push_back( appExpr );
-                                                        divide->get_args().push_back( new NameExpr( sizeofName( baseType1 ) ) );
+                                                        divide->get_args().push_back( new SizeofExpr( baseType1->clone() ) );
                                                         divide->get_results().push_front( appExpr->get_results().front()->clone() );
                                                         if ( appExpr->get_env() ) {
@@ -1230 +1231 @@
                                                         UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) );
                                                         multiply->get_args().push_back( appExpr->get_args().back() );
-                                                        multiply->get_args().push_back( new NameExpr( sizeofName( baseType1 ) ) );
+                                                        multiply->get_args().push_back( new SizeofExpr( baseType1->clone() ) );
                                                         appExpr->get_args().back() = multiply;
                                                 } else if ( baseType2 ) {
                                                         UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) );
                                                         multiply->get_args().push_back( appExpr->get_args().front() );
-                                                        multiply->get_args().push_back( new NameExpr( sizeofName( baseType2 ) ) );
+                                                        multiply->get_args().push_back( new SizeofExpr( baseType2->clone() ) );
                                                         appExpr->get_args().front() = multiply;
                                                 } // if
@@ -1245 +1246 @@
                                                         UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) );
                                                         multiply->get_args().push_back( appExpr->get_args().back() );
-                                                        multiply->get_args().push_back( new NameExpr( sizeofName( baseType ) ) );
+                                                        multiply->get_args().push_back( new SizeofExpr( baseType->clone() ) );
                                                         appExpr->get_args().back() = multiply;
                                                 } // if
@@ -1282 +1283 @@
                         std::list< Expression *>::iterator paramBegin = appExpr->get_args().begin();
 
-                        TyVarMap exprTyVars;
+                        TyVarMap exprTyVars( (TypeDecl::Kind)-1 );
                         makeTyVarMap( function, exprTyVars );
                         ReferenceToType *polyRetType = isPolyRet( function );
@@ -1305 +1306 @@
 
                         boxParams( appExpr, function, arg, exprTyVars );
-
                         passAdapters( appExpr, function, exprTyVars );
 
@@ -1385 +1385 @@
                                 if ( TypeInstType *typeInst = dynamic_cast< TypeInstType *>( retval->get_type() ) ) {
                                         // find assignment operator for type variable
-                                        std::map< std::string, DeclarationWithType *>::const_iterator assignIter = assignOps.find( typeInst->get_name() );
+                                        ScopedMap< std::string, DeclarationWithType *>::const_iterator assignIter = assignOps.find( typeInst->get_name() );
                                         if ( assignIter == assignOps.end() ) {
                                                 throw SemanticError( "Attempt to return dtype or ftype object in ", returnStmt->get_expr() );
@@ -1419 +1419 @@
                                                 DeclarationWithType *assertAssign = 0;
                                                 if ( TypeInstType *formalTypeInstType = dynamic_cast< TypeInstType* >( formalType ) ) {
-                                                        std::map< std::string, DeclarationWithType *>::const_iterator assertAssignIt = assignOps.find( formalTypeInstType->get_name() );
+                                                        ScopedMap< std::string, DeclarationWithType *>::const_iterator assertAssignIt = assignOps.find( formalTypeInstType->get_name() );
                                                         if ( assertAssignIt == assignOps.end() ) {
                                                                 throw SemanticError( "No assignment operation found for ", formalTypeInstType );
@@ -1460 +1460 @@
 
                 Type * Pass1::mutate( PointerType *pointerType ) {
-                        TyVarMap oldtyVars = scopeTyVars;
+                        scopeTyVars.beginScope();
                         makeTyVarMap( pointerType, scopeTyVars );
 
                         Type *ret = Mutator::mutate( pointerType );
 
-                        scopeTyVars = oldtyVars;
+                        scopeTyVars.endScope();
                         return ret;
                 }
 
                 Type * Pass1::mutate( FunctionType *functionType ) {
-                        TyVarMap oldtyVars = scopeTyVars;
+                        scopeTyVars.beginScope();
                         makeTyVarMap( functionType, scopeTyVars );
 
                         Type *ret = Mutator::mutate( functionType );
 
-                        scopeTyVars = oldtyVars;
+                        scopeTyVars.endScope();
                         return ret;
                 }
@@ -1540 +1540 @@
 
                 Type * Pass2::mutate( PointerType *pointerType ) {
-                        TyVarMap oldtyVars = scopeTyVars;
+                        scopeTyVars.beginScope();
                         makeTyVarMap( pointerType, scopeTyVars );
 
                         Type *ret = Mutator::mutate( pointerType );
 
-                        scopeTyVars = oldtyVars;
+                        scopeTyVars.endScope();
                         return ret;
                 }
 
                 Type *Pass2::mutate( FunctionType *funcType ) {
-                        TyVarMap oldtyVars = scopeTyVars;
+                        scopeTyVars.beginScope();
                         makeTyVarMap( funcType, scopeTyVars );
 
@@ -1572 +1572 @@
                                 if ( (*tyParm)->get_kind() == TypeDecl::Any ) {
                                         TypeInstType parmType( Type::Qualifiers(), (*tyParm)->get_name(), *tyParm );
+                                        std::string parmName = mangleType( &parmType );
 
                                         sizeParm = newObj.clone();
-                                        sizeParm->set_name( sizeofName( &parmType ) );
+                                        sizeParm->set_name( sizeofName( parmName ) );
                                         last = funcType->get_parameters().insert( last, sizeParm );
                                         ++last;
 
                                         alignParm = newObj.clone();
-                                        alignParm->set_name( alignofName( &parmType ) );
+                                        alignParm->set_name( alignofName( parmName ) );
                                         last = funcType->get_parameters().insert( last, alignParm );
                                         ++last;
@@ -1594 +1595 @@
                         std::set< std::string > seenTypes; // sizeofName for generic types we've seen
                         for ( std::list< DeclarationWithType* >::const_iterator fnParm = last; fnParm != funcType->get_parameters().end(); ++fnParm ) {
-                                Type *polyBase = hasPolyBase( (*fnParm)->get_type(), scopeTyVars );
-                                if ( polyBase && ! dynamic_cast< TypeInstType* >( polyBase ) ) {
-                                        std::string sizeName = sizeofName( polyBase );
-                                        if ( seenTypes.count( sizeName ) ) continue;
+                                Type *polyType = isPolyType( (*fnParm)->get_type(), scopeTyVars );
+                                if ( polyType && ! dynamic_cast< TypeInstType* >( polyType ) ) {
+                                        std::string typeName = mangleType( polyType );
+                                        if ( seenTypes.count( typeName ) ) continue;
 
                                         ObjectDecl *sizeParm, *alignParm, *offsetParm;
                                         sizeParm = newObj.clone();
-                                        sizeParm->set_name( sizeName );
+                                        sizeParm->set_name( sizeofName( typeName ) );
                                         last = funcType->get_parameters().insert( last, sizeParm );
                                         ++last;
 
                                         alignParm = newObj.clone();
-                                        alignParm->set_name( alignofName( polyBase ) );
+                                        alignParm->set_name( alignofName( typeName ) );
                                         last = funcType->get_parameters().insert( last, alignParm );
                                         ++last;
 
-                                        if ( StructInstType *polyBaseStruct = dynamic_cast< StructInstType* >( polyBase ) ) {
+                                        if ( StructInstType *polyBaseStruct = dynamic_cast< StructInstType* >( polyType ) ) {
                                                 // NOTE zero-length arrays are illegal in C, so empty structs have no offset array
                                                 if ( ! polyBaseStruct->get_baseStruct()->get_members().empty() ) {
                                                         offsetParm = newPtr.clone();
-                                                        offsetParm->set_name( offsetofName( polyBase ) );
+                                                        offsetParm->set_name( offsetofName( typeName ) );
                                                         last = funcType->get_parameters().insert( last, offsetParm );
                                                         ++last;
@@ -1620 +1621 @@
                                         }
 
-                                        seenTypes.insert( sizeName );
+                                        seenTypes.insert( typeName );
                                 }
                         }
@@ -1630 +1631 @@
                         mutateAll( funcType->get_parameters(), *this );
 
-                        scopeTyVars = oldtyVars;
+                        scopeTyVars.endScope();
                         return funcType;
                 }
@@ -1823 +1824 @@
                 }
 
-////////////////////////////////////////// MemberExprFixer ////////////////////////////////////////////////////
+////////////////////////////////////////// PolyGenericCalculator ////////////////////////////////////////////////////
+
+                void PolyGenericCalculator::beginTypeScope( Type *ty ) {
+                        scopeTyVars.beginScope();
+                        makeTyVarMap( ty, scopeTyVars );
+                }
+
+                void PolyGenericCalculator::endTypeScope() {
+                        scopeTyVars.endScope();
+                }
 
                 template< typename DeclClass >
                 DeclClass * PolyGenericCalculator::handleDecl( DeclClass *decl, Type *type ) {
-                        TyVarMap oldtyVars = scopeTyVars;
-                        makeTyVarMap( type, scopeTyVars );
+                        beginTypeScope( type );
+                        knownLayouts.beginScope();
+                        knownOffsets.beginScope();
 
                         DeclClass *ret = static_cast< DeclClass *>( Mutator::mutate( decl ) );
 
-                        scopeTyVars = oldtyVars;
+                        knownOffsets.endScope();
+                        knownLayouts.endScope();
+                        endTypeScope();
                         return ret;
                 }
@@ -1854 +1867 @@
 
                 Type * PolyGenericCalculator::mutate( PointerType *pointerType ) {
-                        TyVarMap oldtyVars = scopeTyVars;
-                        makeTyVarMap( pointerType, scopeTyVars );
+                        beginTypeScope( pointerType );
 
                         Type *ret = Mutator::mutate( pointerType );
 
-                        scopeTyVars = oldtyVars;
+                        endTypeScope();
                         return ret;
                 }
 
                 Type * PolyGenericCalculator::mutate( FunctionType *funcType ) {
-                        TyVarMap oldtyVars = scopeTyVars;
-                        makeTyVarMap( funcType, scopeTyVars );
+                        beginTypeScope( funcType );
 
                         // make sure that any type information passed into the function is accounted for
                         for ( std::list< DeclarationWithType* >::const_iterator fnParm = funcType->get_parameters().begin(); fnParm != funcType->get_parameters().end(); ++fnParm ) {
                                 // condition here duplicates that in Pass2::mutate( FunctionType* )
-                                Type *polyBase = hasPolyBase( (*fnParm)->get_type(), scopeTyVars );
-                                if ( polyBase && ! dynamic_cast< TypeInstType* >( polyBase ) ) {
-                                        knownLayouts.insert( sizeofName( polyBase ) );
+                                Type *polyType = isPolyType( (*fnParm)->get_type(), scopeTyVars );
+                                if ( polyType && ! dynamic_cast< TypeInstType* >( polyType ) ) {
+                                        knownLayouts.insert( mangleType( polyType ) );
                                 }
                         }
@@ -1878 +1889 @@
                         Type *ret = Mutator::mutate( funcType );
 
-                        scopeTyVars = oldtyVars;
+                        endTypeScope();
                         return ret;
                 }
@@ -1889 +1900 @@
                                         Type *declType = objectDecl->get_type();
                                         UntypedExpr *alloc = new UntypedExpr( new NameExpr( "__builtin_alloca" ) );
-                                        alloc->get_args().push_back( new NameExpr( sizeofName( declType ) ) );
+                                        alloc->get_args().push_back( new NameExpr( sizeofName( mangleType( declType ) ) ) );
 
                                         delete objectDecl->get_init();
@@ -1921 +1932 @@
                         ConstantExpr *fieldIndex = new ConstantExpr( Constant( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), offset_namer.str() ) );
                         UntypedExpr *fieldOffset = new UntypedExpr( new NameExpr( "?[?]" ) );
-                        fieldOffset->get_args().push_back( new NameExpr( offsetofName( objectType ) ) );
+                        fieldOffset->get_args().push_back( new NameExpr( offsetofName( mangleType( objectType ) ) ) );
                         fieldOffset->get_args().push_back( fieldIndex );
                         return fieldOffset;
@@ -1995 +2006 @@
                                 if ( findGeneric( *param ) ) {
                                         // push size/align vars for a generic parameter back
-                                        layoutCall->get_args().push_back( new NameExpr( sizeofName( *param ) ) );
-                                        layoutCall->get_args().push_back( new NameExpr( alignofName( *param ) ) );
+                                        std::string paramName = mangleType( *param );
+                                        layoutCall->get_args().push_back( new NameExpr( sizeofName( paramName ) ) );
+                                        layoutCall->get_args().push_back( new NameExpr( alignofName( paramName ) ) );
                                 } else {
                                         layoutCall->get_args().push_back( new SizeofExpr( (*param)->clone() ) );
@@ -2040 +2052 @@
                         } else if ( StructInstType *structTy = dynamic_cast< StructInstType* >( ty ) ) {
                                 // check if this type already has a layout generated for it
-                                std::string sizeName = sizeofName( ty );
-                                if ( knownLayouts.find( sizeName ) != knownLayouts.end() ) return true;
+                                std::string typeName = mangleType( ty );
+                                if ( knownLayouts.find( typeName ) != knownLayouts.end() ) return true;
 
                                 // check if any of the type parameters have dynamic layout; if none do, this type is (or will be) monomorphized
@@ -2048 +2060 @@
 
                                 // insert local variables for layout and generate call to layout function
-                                knownLayouts.insert( sizeName );  // done early so as not to interfere with the later addition of parameters to the layout call
+                                knownLayouts.insert( typeName );  // done early so as not to interfere with the later addition of parameters to the layout call
                                 Type *layoutType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt );
 
@@ -2054 +2066 @@
                                 if ( n_members == 0 ) {
                                         // all empty structs have the same layout - size 1, align 1
-                                        makeVar( sizeName, layoutType, new SingleInit( new ConstantExpr( Constant::from( (unsigned long)1 ) ) ) );
-                                        makeVar( alignofName( ty ), layoutType->clone(), new SingleInit( new ConstantExpr( Constant::from( (unsigned long)1 ) ) ) );
+                                        makeVar( sizeofName( typeName ), layoutType, new SingleInit( new ConstantExpr( Constant::from( (unsigned long)1 ) ) ) );
+                                        makeVar( alignofName( typeName ), layoutType->clone(), new SingleInit( new ConstantExpr( Constant::from( (unsigned long)1 ) ) ) );
                                         // NOTE zero-length arrays are forbidden in C, so empty structs have no offsetof array
                                 } else {
-                                        ObjectDecl *sizeVar = makeVar( sizeName, layoutType );
-                                        ObjectDecl *alignVar = makeVar( alignofName( ty ), layoutType->clone() );
-                                        ObjectDecl *offsetVar = makeVar( offsetofName( ty ), new ArrayType( Type::Qualifiers(), layoutType->clone(), new ConstantExpr( Constant::from( n_members ) ), false, false ) );
+                                        ObjectDecl *sizeVar = makeVar( sizeofName( typeName ), layoutType );
+                                        ObjectDecl *alignVar = makeVar( alignofName( typeName ), layoutType->clone() );
+                                        ObjectDecl *offsetVar = makeVar( offsetofName( typeName ), new ArrayType( Type::Qualifiers(), layoutType->clone(), new ConstantExpr( Constant::from( n_members ) ), false, false ) );
 
                                         // generate call to layout function
-                                        UntypedExpr *layoutCall = new UntypedExpr( new NameExpr( "__layoutof_" + structTy->get_baseStruct()->get_name() ) );
+                                        UntypedExpr *layoutCall = new UntypedExpr( new NameExpr( layoutofName( structTy->get_baseStruct() ) ) );
                                         layoutCall->get_args().push_back( new AddressExpr( new VariableExpr( sizeVar ) ) );
                                         layoutCall->get_args().push_back( new AddressExpr( new VariableExpr( alignVar ) ) );
@@ -2075 +2087 @@
                         } else if ( UnionInstType *unionTy = dynamic_cast< UnionInstType* >( ty ) ) {
                                 // check if this type already has a layout generated for it
-                                std::string sizeName = sizeofName( ty );
-                                if ( knownLayouts.find( sizeName ) != knownLayouts.end() ) return true;
+                                std::string typeName = mangleType( ty );
+                                if ( knownLayouts.find( typeName ) != knownLayouts.end() ) return true;
 
                                 // check if any of the type parameters have dynamic layout; if none do, this type is (or will be) monomorphized
@@ -2083 +2095 @@
 
                                 // insert local variables for layout and generate call to layout function
-                                knownLayouts.insert( sizeName );  // done early so as not to interfere with the later addition of parameters to the layout call
+                                knownLayouts.insert( typeName );  // done early so as not to interfere with the later addition of parameters to the layout call
                                 Type *layoutType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt );
 
-                                ObjectDecl *sizeVar = makeVar( sizeName, layoutType );
-                                ObjectDecl *alignVar = makeVar( alignofName( ty ), layoutType->clone() );
+                                ObjectDecl *sizeVar = makeVar( sizeofName( typeName ), layoutType );
+                                ObjectDecl *alignVar = makeVar( alignofName( typeName ), layoutType->clone() );
 
                                 // generate call to layout function
-                                UntypedExpr *layoutCall = new UntypedExpr( new NameExpr( "__layoutof_" + unionTy->get_baseUnion()->get_name() ) );
+                                UntypedExpr *layoutCall = new UntypedExpr( new NameExpr( layoutofName( unionTy->get_baseUnion() ) ) );
                                 layoutCall->get_args().push_back( new AddressExpr( new VariableExpr( sizeVar ) ) );
                                 layoutCall->get_args().push_back( new AddressExpr( new VariableExpr( alignVar ) ) );
@@ -2106 +2118 @@
                         Type *ty = sizeofExpr->get_type();
                         if ( findGeneric( ty ) ) {
-                                Expression *ret = new NameExpr( sizeofName( ty ) );
+                                Expression *ret = new NameExpr( sizeofName( mangleType( ty ) ) );
                                 delete sizeofExpr;
                                 return ret;
@@ -2116 +2128 @@
                         Type *ty = alignofExpr->get_type();
                         if ( findGeneric( ty ) ) {
-                                Expression *ret = new NameExpr( alignofName( ty ) );
+                                Expression *ret = new NameExpr( alignofName( mangleType( ty ) ) );
                                 delete alignofExpr;
                                 return ret;
@@ -2154 +2166 @@
                         if ( findGeneric( ty ) ) {
                                 // pull offset back from generated type information
-                                ret = new NameExpr( offsetofName( ty ) );
+                                ret = new NameExpr( offsetofName( mangleType( ty ) ) );
                         } else {
-                                std::string offsetName = offsetofName( ty );
+                                std::string offsetName = offsetofName( mangleType( ty ) );
                                 if ( knownOffsets.find( offsetName ) != knownOffsets.end() ) {
                                         // use the already-generated offsets for this type
@@ -2196 +2208 @@
                 void PolyGenericCalculator::doEndScope() {
                         knownLayouts.endScope();
-                        knownOffsets.beginScope();
+                        knownOffsets.endScope();
                 }
 
@@ -2203 +2215 @@
                 template< typename DeclClass >
                 DeclClass * Pass3::handleDecl( DeclClass *decl, Type *type ) {
-                        TyVarMap oldtyVars = scopeTyVars;
+                        scopeTyVars.beginScope();
                         makeTyVarMap( type, scopeTyVars );
 
@@ -2209 +2221 @@
                         ScrubTyVars::scrub( decl, scopeTyVars );
 
-                        scopeTyVars = oldtyVars;
+                        scopeTyVars.endScope();
                         return ret;
                 }
@@ -2239 +2251 @@
 
                 Type * Pass3::mutate( PointerType *pointerType ) {
-                        TyVarMap oldtyVars = scopeTyVars;
+                        scopeTyVars.beginScope();
                         makeTyVarMap( pointerType, scopeTyVars );
 
                         Type *ret = Mutator::mutate( pointerType );
 
-                        scopeTyVars = oldtyVars;
+                        scopeTyVars.endScope();
                         return ret;
                 }
 
                 Type * Pass3::mutate( FunctionType *functionType ) {
-                        TyVarMap oldtyVars = scopeTyVars;
+                        scopeTyVars.beginScope();
                         makeTyVarMap( functionType, scopeTyVars );
 
                         Type *ret = Mutator::mutate( functionType );
 
-                        scopeTyVars = oldtyVars;
+                        scopeTyVars.endScope();
                         return ret;
                 }

src/GenPoly/FindFunction.cc

@@ -55 +55 @@
                         TyVarMap::iterator var = tyVars.find( (*i)->get_name() );
                         if ( var != tyVars.end() ) {
-                                tyVars.erase( var );
+                                tyVars.erase( var->first );
                         } // if
                 } // for
@@ -61 +61 @@
 
         Type * FindFunction::mutate( FunctionType *functionType ) {
-                TyVarMap oldTyVars = tyVars;
+                tyVars.beginScope();
                 handleForall( functionType->get_forall() );
                 mutateAll( functionType->get_returnVals(), *this );
@@ -72 +72 @@
                         } // if
                 } // if
-                tyVars = oldTyVars;
+                tyVars.endScope();
                 return ret;
         }
 
         Type * FindFunction::mutate( PointerType *pointerType ) {
-                TyVarMap oldTyVars = tyVars;
+                tyVars.beginScope();
                 handleForall( pointerType->get_forall() );
                 Type *ret = Mutator::mutate( pointerType );
-                tyVars = oldTyVars;
+                tyVars.endScope();
                 return ret;
         }

src/GenPoly/GenPoly.cc

@@ -16 +16 @@
 #include "GenPoly.h"
 
-#include "SymTab/Mangler.h"
 #include "SynTree/Expression.h"
 #include "SynTree/Type.h"
@@ -38 +37 @@
         ReferenceToType *isPolyRet( FunctionType *function ) {
                 if ( ! function->get_returnVals().empty() ) {
-                        TyVarMap forallTypes;
+                        TyVarMap forallTypes( (TypeDecl::Kind)-1 );
                         makeTyVarMap( function, forallTypes );
                         return (ReferenceToType*)isPolyType( function->get_returnVals().front()->get_type(), forallTypes );
@@ -218 +217 @@
         }
 
-        std::string sizeofName( Type *ty ) {
-                return std::string( "_sizeof_" ) + SymTab::Mangler::mangleType( ty );
-        }
-
-        std::string alignofName( Type *ty ) {
-                return std::string( "_alignof_" ) + SymTab::Mangler::mangleType( ty );
-        }
-
-        std::string offsetofName( Type* ty ) {
-                return std::string( "_offsetof_" ) + SymTab::Mangler::mangleType( ty );
-        }
-
 } // namespace GenPoly
 

src/GenPoly/GenPoly.h

@@ -17 +17 @@
 #define GENPOLY_H
 
-#include <map>
 #include <string>
 #include <iostream>
 #include <utility>
+
+#include "ErasableScopedMap.h"
+
+#include "SymTab/Mangler.h"
 
 #include "SynTree/Declaration.h"
@@ -27 +30 @@
 
 namespace GenPoly {
-        typedef std::map< std::string, TypeDecl::Kind > TyVarMap;
+        typedef ErasableScopedMap< std::string, TypeDecl::Kind > TyVarMap;
 
         /// A function needs an adapter if it returns a polymorphic value or if any of its
@@ -69 +72 @@
         void printTyVarMap( std::ostream &os, const TyVarMap &tyVarMap );
 
-        /// Gets the name of the sizeof parameter for the type
-        std::string sizeofName( Type *ty );
+        /// Gets the mangled name of this type; alias for SymTab::Mangler::mangleType().
+        inline std::string mangleType( Type *ty ) { return SymTab::Mangler::mangleType( ty ); }
+        
+        /// Gets the name of the sizeof parameter for the type, given its mangled name
+        inline std::string sizeofName( const std::string &name ) { return std::string( "_sizeof_" ) + name; }
 
-        /// Gets the name of the alignof parameter for the type
-        std::string alignofName( Type *ty );
+        /// Gets the name of the alignof parameter for the type, given its mangled name
+        inline std::string alignofName( const std::string &name ) { return std::string( "_alignof_" ) + name; }
 
-        /// Gets the name of the offsetof parameter for the type
-        std::string offsetofName( Type *ty );
+        /// Gets the name of the offsetof parameter for the type, given its mangled name
+        inline std::string offsetofName( const std::string &name ) { return std::string( "_offsetof_" ) + name; }
+
+        /// Gets the name of the layout function for a given aggregate type, given its declaration
+        inline std::string layoutofName( AggregateDecl *decl ) { return std::string( "_layoutof_" ) + decl->get_name(); }
+        
 } // namespace GenPoly
 

src/GenPoly/Lvalue.cc

@@ -17 +17 @@
 
 #include "Lvalue.h"
+
+#include "GenPoly.h"
 
 #include "SynTree/Declaration.h"
@@ -63 +65 @@
 
         namespace {
-                bool isLvalueRet( FunctionType *function ) {
-                        if ( ! function->get_returnVals().empty() ) {
-                                return function->get_returnVals().front()->get_type()->get_isLvalue();
-                        } else {
-                                return false;
-                        } // if
+                Type* isLvalueRet( FunctionType *function ) {
+                        if ( function->get_returnVals().empty() ) return 0;
+                        Type *ty = function->get_returnVals().front()->get_type();
+                        return ty->get_isLvalue() ? ty : 0;
                 }
 
@@ -107 +107 @@
                         assert( function );
 
-                        std::string typeName;
-                        if ( isLvalueRet( function ) && ! isIntrinsicApp( appExpr ) ) {
+                        Type *funType = isLvalueRet( function );
+                        if ( funType && ! isIntrinsicApp( appExpr ) ) {
+                                Expression *expr = appExpr;
+                                Type *appType = appExpr->get_results().front();
+                                if ( isPolyType( funType ) && ! isPolyType( appType ) ) {
+                                        // make sure cast for polymorphic type is inside dereference
+                                        expr = new CastExpr( appExpr, new PointerType( Type::Qualifiers(), appType->clone() ) );
+                                }
                                 UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
-                                deref->get_results().push_back( appExpr->get_results().front() );
-                                appExpr->get_results().front() = new PointerType( Type::Qualifiers(), deref->get_results().front()->clone() );
-                                deref->get_args().push_back( appExpr );
+                                deref->get_results().push_back( appType->clone() );
+                                appExpr->get_results().front() = new PointerType( Type::Qualifiers(), appType );
+                                deref->get_args().push_back( expr );
                                 return deref;
                         } else {

src/GenPoly/PolyMutator.cc

@@ -27 +27 @@
         }
 
-        PolyMutator::PolyMutator() : env( 0 ) {
-        }
+        PolyMutator::PolyMutator() : scopeTyVars( (TypeDecl::Kind)-1 ), env( 0 ) {}
 
         void PolyMutator::mutateStatementList( std::list< Statement* > &statements ) {

src/GenPoly/ScopedMap.h

@@ -51 +51 @@
                         typedef typename scope_list::size_type size_type;
 
+                        /// Checks if this iterator points to a valid item
+                        bool is_valid() const {
+                                return it != (*scopes)[i].end();
+                        }
+
+                        /// Increments on invalid
+                        iterator& next_valid() {
+                                if ( ! is_valid() ) { ++(*this); }
+                                return *this;
+                        }
+
+                        /// Decrements on invalid
+                        iterator& prev_valid() {
+                                if ( ! is_valid() ) { --(*this); }
+                                return *this;
+                        }
+
                         iterator(scope_list const &_scopes, const wrapped_iterator &_it, size_type _i)
                                 : scopes(&_scopes), it(_it), i(_i) {}
@@ -68 +85 @@
                                         --i;
                                         it = (*scopes)[i].begin();
-                                        return *this;
-                                }
-                                ++it;
-                                return *this;
+                                } else {
+                                        ++it;
+                                }
+                                return next_valid();
                         }
                         iterator& operator++ (int) { iterator tmp = *this; ++(*this); return tmp; }
@@ -82 +99 @@
                                 }
                                 --it;
-                                return *this;
+                                return prev_valid();
                         }
                         iterator& operator-- (int) { iterator tmp = *this; --(*this); return tmp; }
@@ -105 +122 @@
                         typedef typename scope_list::size_type size_type;
 
+                        /// Checks if this iterator points to a valid item
+                        bool is_valid() const {
+                                return it != (*scopes)[i].end();
+                        }
+
+                        /// Increments on invalid
+                        const_iterator& next_valid() {
+                                if ( ! is_valid() ) { ++(*this); }
+                                return *this;
+                        }
+
+                        /// Decrements on invalid
+                        const_iterator& prev_valid() {
+                                if ( ! is_valid() ) { --(*this); }
+                                return *this;
+                        }
+
                         const_iterator(scope_list const &_scopes, const wrapped_const_iterator &_it, size_type _i)
                                 : scopes(&_scopes), it(_it), i(_i) {}
@@ -127 +161 @@
                                         --i;
                                         it = (*scopes)[i].begin();
-                                        return *this;
-                                }
-                                ++it;
-                                return *this;
+                                } else {
+                                        ++it;
+                                }
+                                return next_valid();
                         }
                         const_iterator& operator++ (int) { const_iterator tmp = *this; ++(*this); return tmp; }
@@ -141 +175 @@
                                 }
                                 --it;
-                                return *this;
+                                return prev_valid();
                         }
                         const_iterator& operator-- (int) { const_iterator tmp = *this; --(*this); return tmp; }
@@ -171 +205 @@
                 ScopedMap() { beginScope(); }
 
-                iterator begin() { return iterator(scopes, scopes.back().begin(), scopes.size()-1); }
-                const_iterator begin() const { return const_iterator(scopes, scopes.back().begin(), scopes.size()-1); }
-                const_iterator cbegin() const { return const_iterator(scopes, scopes.back().begin(), scopes.size()-1); }
+                iterator begin() { return iterator(scopes, scopes.back().begin(), scopes.size()-1).next_valid(); }
+                const_iterator begin() const { return const_iterator(scopes, scopes.back().begin(), scopes.size()-1).next_valid(); }
+                const_iterator cbegin() const { return const_iterator(scopes, scopes.back().begin(), scopes.size()-1).next_valid(); }
                 iterator end() { return iterator(scopes, scopes[0].end(), 0); }
                 const_iterator end() const { return const_iterator(scopes, scopes[0].end(), 0); }

src/GenPoly/ScopedSet.h

@@ -48 +48 @@
                         typedef typename scope_list::size_type size_type;
 
+                        /// Checks if this iterator points to a valid item
+                        bool is_valid() const {
+                                return it != (*scopes)[i].end();
+                        }
+
+                        /// Increments on invalid
+                        iterator& next_valid() {
+                                if ( ! is_valid() ) { ++(*this); }
+                                return *this;
+                        }
+
+                        /// Decrements on invalid
+                        iterator& prev_valid() {
+                                if ( ! is_valid() ) { --(*this); }
+                                return *this;
+                        }
+
                         iterator(scope_list const &_scopes, const wrapped_iterator &_it, size_type _i)
                                 : scopes(&_scopes), it(_it), i(_i) {}
@@ -65 +82 @@
                                         --i;
                                         it = (*scopes)[i].begin();
-                                        return *this;
-                                }
-                                ++it;
-                                return *this;
+                                } else {
+                                        ++it;
+                                }
+                                return next_valid();
                         }
                         iterator& operator++ (int) { iterator tmp = *this; ++(*this); return tmp; }
@@ -79 +96 @@
                                 }
                                 --it;
-                                return *this;
+                                return prev_valid();
                         }
                         iterator& operator-- (int) { iterator tmp = *this; --(*this); return tmp; }
@@ -102 +119 @@
                         typedef typename scope_list::size_type size_type;
 
+                        /// Checks if this iterator points to a valid item
+                        bool is_valid() const {
+                                return it != (*scopes)[i].end();
+                        }
+
+                        /// Increments on invalid
+                        const_iterator& next_valid() {
+                                if ( ! is_valid() ) { ++(*this); }
+                                return *this;
+                        }
+
+                        /// Decrements on invalid
+                        const_iterator& prev_valid() {
+                                if ( ! is_valid() ) { --(*this); }
+                                return *this;
+                        }
+
                         const_iterator(scope_list const &_scopes, const wrapped_const_iterator &_it, size_type _i)
                                 : scopes(&_scopes), it(_it), i(_i) {}
@@ -124 +158 @@
                                         --i;
                                         it = (*scopes)[i].begin();
-                                        return *this;
-                                }
-                                ++it;
-                                return *this;
+                                } else {
+                                        ++it;
+                                }
+                                return next_valid();
                         }
                         const_iterator& operator++ (int) { const_iterator tmp = *this; ++(*this); return tmp; }
@@ -138 +172 @@
                                 }
                                 --it;
-                                return *this;
+                                return prev_valid();
                         }
                         const_iterator& operator-- (int) { const_iterator tmp = *this; --(*this); return tmp; }
@@ -167 +201 @@
                 ScopedSet() { beginScope(); }
 
-                iterator begin() { return iterator(scopes, scopes.back().begin(), scopes.size()-1); }
-                const_iterator begin() const { return const_iterator(scopes, scopes.back().begin(), scopes.size()-1); }
-                const_iterator cbegin() const { return const_iterator(scopes, scopes.back().begin(), scopes.size()-1); }
+                iterator begin() { return iterator(scopes, scopes.back().begin(), scopes.size()-1).next_valid(); }
+                const_iterator begin() const { return const_iterator(scopes, scopes.back().begin(), scopes.size()-1).next_valid(); }
+                const_iterator cbegin() const { return const_iterator(scopes, scopes.back().begin(), scopes.size()-1).next_valid(); }
                 iterator end() { return iterator(scopes, scopes[0].end(), 0); }
                 const_iterator end() const { return const_iterator(scopes, scopes[0].end(), 0); }

src/GenPoly/ScrubTyVars.cc

@@ -64 +64 @@
                 // sizeof( T ) => _sizeof_T parameter, which is the size of T
                 if ( Type *polyType = isPolyType( szeof->get_type() ) ) {
-                        Expression *expr = new NameExpr( sizeofName( polyType ) );
+                        Expression *expr = new NameExpr( sizeofName( mangleType( polyType ) ) );
                         return expr;
                 } else {
@@ -74 +74 @@
                 // alignof( T ) => _alignof_T parameter, which is the alignment of T
                 if ( Type *polyType = isPolyType( algnof->get_type() ) ) {
-                        Expression *expr = new NameExpr( alignofName( polyType ) );
+                        Expression *expr = new NameExpr( alignofName( mangleType( polyType ) ) );
                         return expr;
                 } else {