Changes in src/GenPoly/Box.cc [aa19ccf:8a34677]

File:

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

src/GenPoly/Box.cc

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