Changeset 70a06f6 for src/GenPoly

Timestamp:

Apr 14, 2016, 4:13:10 PM (9 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, with_gc

Children:

356189a

Parents:

db4ecc5 (diff), 37f0da8 (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' into ctor

Conflicts:

src/CodeGen/CodeGenerator.cc
src/GenPoly/Box.cc
src/Parser/DeclarationNode.cc
src/Parser/ParseNode.h
src/Parser/parser.cc
src/Parser/parser.yy
src/SymTab/AddVisit.h
src/SymTab/Validate.cc
src/SynTree/Expression.cc
src/SynTree/Expression.h
src/SynTree/Mutator.cc
src/SynTree/Mutator.h
src/SynTree/SynTree.h
src/SynTree/Visitor.cc
src/SynTree/Visitor.h
src/libcfa/iostream.c

Location:

src/GenPoly

Files:

• Box.cc (modified) (66 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) (12 diffs)
• ScopedSet.h (added)
• ScrubTyVars.cc (modified) (2 diffs)

src/GenPoly/Box.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Rob Schluntz
-// Last Modified On : Tue Feb 09 14:39:52 2016
+// Last Modified On : Thu Apr 14 15:57:46 2016
 // Update Count     : 295
 //
@@ -30 +30 @@
 #include "FindFunction.h"
 #include "ScopedMap.h"
+#include "ScopedSet.h"
 #include "ScrubTyVars.h"
 
@@ -62 +63 @@
                 FunctionType *makeAdapterType( FunctionType *adaptee, const TyVarMap &tyVars );
 
-                /// Key for a unique concrete type; generic base type paired with type parameter list
-                struct ConcreteType {
-                        ConcreteType() : base(NULL), params() {}
-
-                        ConcreteType(AggregateDecl *_base, const std::list< Type* >& _params) : base(_base), params() { cloneAll(_params, params); }
-
-                        ConcreteType(const ConcreteType& that) : base(that.base), params() { cloneAll(that.params, params); }
+                /// Abstracts type equality for a list of parameter types
+                struct TypeList {
+                        TypeList() : params() {}
+                        TypeList( const std::list< Type* > &_params ) : params() { cloneAll(_params, params); }
+                        TypeList( std::list< Type* > &&_params ) : params( _params ) {}
+
+                        TypeList( const TypeList &that ) : params() { cloneAll(that.params, params); }
+                        TypeList( TypeList &&that ) : params( std::move( that.params ) ) {}
 
                         /// Extracts types from a list of TypeExpr*
-                        ConcreteType(AggregateDecl *_base, const std::list< TypeExpr* >& _params) : base(_base), params() {
+                        TypeList( const std::list< TypeExpr* >& _params ) : params() {
                                 for ( std::list< TypeExpr* >::const_iterator param = _params.begin(); param != _params.end(); ++param ) {
                                         params.push_back( (*param)->get_type()->clone() );
@@ -77 +79 @@
                         }
 
-                        ConcreteType& operator= (const ConcreteType& that) {
+                        TypeList& operator= ( const TypeList &that ) {
                                 deleteAll( params );
+
                                 params.clear();
-
-                                base = that.base;
                                 cloneAll( that.params, params );
 
@@ -87 +88 @@
                         }
 
-                        ~ConcreteType() { deleteAll( params ); }
-
-                        bool operator== (const ConcreteType& that) const {
-                                if ( base != that.base ) return false;
+                        TypeList& operator= ( TypeList &&that ) {
+                                deleteAll( params );
+
+                                params = std::move( that.params );
+
+                                return *this;
+                        }
+
+                        ~TypeList() { deleteAll( params ); }
+
+                        bool operator== ( const TypeList& that ) const {
+                                if ( params.size() != that.params.size() ) return false;
 
                                 SymTab::Indexer dummy;
-                                if ( params.size() != that.params.size() ) return false;
                                 for ( std::list< Type* >::const_iterator it = params.begin(), jt = that.params.begin(); it != params.end(); ++it, ++jt ) {
                                         if ( ! ResolvExpr::typesCompatible( *it, *jt, dummy ) ) return false;
@@ -100 +108 @@
                         }
 
-                        AggregateDecl *base;        ///< Base generic type
                         std::list< Type* > params;  ///< Instantiation parameters
                 };
 
-                /// Maps a concrete type to the some value, accounting for scope
-                template< typename Value >
+                /// Maps a key and a TypeList to the some value, accounting for scope
+                template< typename Key, typename Value >
                 class InstantiationMap {
-                        /// Information about a specific instantiation of a generic type
-                        struct Instantiation {
-                                ConcreteType key;  ///< Instantiation parameters for this type
-                                Value *value;      ///< Value for this instantiation
-
-                                Instantiation() : key(), value(0) {}
-                                Instantiation(const ConcreteType &_key, Value *_value) : key(_key), value(_value) {}
-                        };
-                        /// Map of generic types to instantiations of them
-                        typedef std::map< AggregateDecl*, std::vector< Instantiation > > Scope;
-
-                        std::vector< Scope > scopes;  ///< list of scopes, from outermost to innermost
+                        /// Wraps value for a specific (Key, TypeList) combination
+                        typedef std::pair< TypeList, Value* > Instantiation;
+                        /// List of TypeLists paired with their appropriate values
+                        typedef std::vector< Instantiation > ValueList;
+                        /// Underlying map type; maps keys to a linear list of corresponding TypeLists and values
+                        typedef ScopedMap< Key*, ValueList > InnerMap;
+
+                        InnerMap instantiations;  ///< instantiations
 
                 public:
                         /// Starts a new scope
-                        void beginScope() {
-                                Scope scope;
-                                scopes.push_back(scope);
-                        }
+                        void beginScope() { instantiations.beginScope(); }
 
                         /// Ends a scope
-                        void endScope() {
-                                scopes.pop_back();
-                        }
-
-                        /// Default constructor initializes with one scope
-                        InstantiationMap() { beginScope(); }
-
-//              private:
-                        /// Gets the value for the concrete instantiation of this type, assuming it has already been instantiated in the current scope.
-                        /// Returns NULL on none such.
-                        Value *lookup( AggregateDecl *generic, const std::list< TypeExpr* >& params ) {
-                                ConcreteType key(generic, params);
-                                // scan scopes from innermost out
-                                for ( typename std::vector< Scope >::const_reverse_iterator scope = scopes.rbegin(); scope != scopes.rend(); ++scope ) {
-                                        // skip scope if no instantiations of this generic type
-                                        typename Scope::const_iterator insts = scope->find( generic );
-                                        if ( insts == scope->end() ) continue;
-                                        // look through instantiations for matches to concrete type
-                                        for ( typename std::vector< Instantiation >::const_iterator inst = insts->second.begin(); inst != insts->second.end(); ++inst ) {
-                                                if ( inst->key == key ) return inst->value;
+                        void endScope() { instantiations.endScope(); }
+
+                        /// Gets the value for the (key, typeList) pair, returns NULL on none such.
+                        Value *lookup( Key *key, const std::list< TypeExpr* >& params ) const {
+                                TypeList typeList( params );
+
+                                // scan scopes for matches to the key
+                                for ( typename InnerMap::const_iterator insts = instantiations.find( key ); insts != instantiations.end(); insts = instantiations.findNext( insts, key ) ) {
+                                        for ( typename ValueList::const_reverse_iterator inst = insts->second.rbegin(); inst != insts->second.rend(); ++inst ) {
+                                                if ( inst->first == typeList ) return inst->second;
                                         }
                                 }
-                                // no matching instantiation found
+                                // no matching instantiations found
                                 return 0;
                         }
-                public:
-//                      StructDecl* lookup( StructInstType *inst, const std::list< TypeExpr* > &typeSubs ) { return (StructDecl*)lookup( inst->get_baseStruct(), typeSubs ); }
-//                      UnionDecl* lookup( UnionInstType *inst, const std::list< TypeExpr* > &typeSubs ) { return (UnionDecl*)lookup( inst->get_baseUnion(), typeSubs ); }
-
-//              private:
-                        /// Adds a value for a concrete type to the current scope
-                        void insert( AggregateDecl *generic, const std::list< TypeExpr* > &params, Value *value ) {
-                                ConcreteType key(generic, params);
-                                scopes.back()[generic].push_back( Instantiation( key, value ) );
-                        }
-//              public:
-//                      void insert( StructInstType *inst, const std::list< TypeExpr* > &typeSubs, StructDecl *decl ) { insert( inst->get_baseStruct(), typeSubs, decl ); }
-//                      void insert( UnionInstType *inst, const std::list< TypeExpr* > &typeSubs, UnionDecl *decl ) { insert( inst->get_baseUnion(), typeSubs, decl ); }
+
+                        /// Adds a value for a (key, typeList) pair to the current scope
+                        void insert( Key *key, const std::list< TypeExpr* > &params, Value *value ) {
+                                instantiations[ key ].push_back( Instantiation( TypeList( params ), value ) );
+                        }
                 };
 
@@ -178 +160 @@
                         virtual Declaration *mutate( UnionDecl *unionDecl );
                 };
-                
+
                 /// Replaces polymorphic return types with out-parameters, replaces calls to polymorphic functions with adapter calls as needed, and adds appropriate type variables to the function call
                 class Pass1 : public PolyMutator {
@@ -197 +179 @@
                         virtual void doEndScope();
                   private:
-                        /// Makes a new temporary array holding the offsets of the fields of `type`, and returns a new variable expression referencing it
-                        Expression *makeOffsetArray( StructInstType *type );
                         /// Pass the extra type parameters from polymorphic generic arguments or return types into a function application
                         void passArgTypeVars( ApplicationExpr *appExpr, Type *parmType, Type *argBaseType, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars, std::set< std::string > &seenTypes );
@@ -225 +205 @@
                         ObjectDecl *makeTemporary( Type *type );
 
-                        std::map< std::string, DeclarationWithType *> assignOps;
-                        ResolvExpr::TypeMap< DeclarationWithType > scopedAssignOps;
-                        ScopedMap< std::string, DeclarationWithType* > adapters;
+                        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
+
                         DeclarationWithType *retval;
                         bool useRetval;
@@ -233 +214 @@
                 };
 
-                /// Moves polymorphic returns in function types to pointer-type parameters, adds type size and assertion parameters to parameter lists as well
+                /// * Moves polymorphic returns in function types to pointer-type parameters
+                /// * adds type size and assertion parameters to parameter lists
                 class Pass2 : public PolyMutator {
                   public:
@@ -244 +226 @@
                         virtual Type *mutate( PointerType *pointerType );
                         virtual Type *mutate( FunctionType *funcType );
+
                   private:
                         void addAdapters( FunctionType *functionType );
@@ -253 +236 @@
                 class GenericInstantiator : public DeclMutator {
                         /// Map of (generic type, parameter list) pairs to concrete type instantiations
-                        InstantiationMap< AggregateDecl > instantiations;
+                        InstantiationMap< AggregateDecl, AggregateDecl > instantiations;
                         /// Namer for concrete types
                         UniqueName typeNamer;
@@ -278 +261 @@
                 };
 
-                /// Replaces member expressions for polymorphic types with calculated add-field-offset-and-dereference;
-                /// also fixes offsetof expressions.
-                class MemberExprFixer : public PolyMutator {
-                  public:
+                /// Replaces member and size/align/offsetof expressions on polymorphic generic types with calculated expressions.
+                /// * Replaces member expressions for polymorphic types with calculated add-field-offset-and-dereference
+                /// * Calculates polymorphic offsetof expressions from offset array
+                /// * Inserts dynamic calculation of polymorphic type layouts where needed
+                class PolyGenericCalculator : public PolyMutator {
+                public:
                         template< typename DeclClass >
                         DeclClass *handleDecl( DeclClass *decl, Type *type );
@@ -292 +277 @@
                         virtual Type *mutate( FunctionType *funcType );
                         virtual Expression *mutate( MemberExpr *memberExpr );
+                        virtual Expression *mutate( SizeofExpr *sizeofExpr );
+                        virtual Expression *mutate( AlignofExpr *alignofExpr );
                         virtual Expression *mutate( OffsetofExpr *offsetofExpr );
+                        virtual Expression *mutate( OffsetPackExpr *offsetPackExpr );
+
+                        virtual void doBeginScope();
+                        virtual void doEndScope();
+
+                private:
+                        /// Makes a new variable in the current scope with the given name, type & optional initializer
+                        ObjectDecl *makeVar( const std::string &name, Type *type, Initializer *init = 0 );
+                        /// returns true if the type has a dynamic layout; such a layout will be stored in appropriately-named local variables when the function returns
+                        bool findGeneric( Type *ty );
+                        /// 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
+                        ScopedSet< std::string > knownOffsets;          ///< Set of non-generic types for which the offset array exists in the current scope, indexed by offsetofName
                 };
 
@@ -342 +349 @@
                 Pass2 pass2;
                 GenericInstantiator instantiator;
-                MemberExprFixer memberFixer;
+                PolyGenericCalculator polyCalculator;
                 Pass3 pass3;
-                
+
                 layoutBuilder.mutateDeclarationList( translationUnit );
                 mutateTranslationUnit/*All*/( translationUnit, pass1 );
                 mutateTranslationUnit/*All*/( translationUnit, pass2 );
-//              instantiateGeneric( translationUnit );
                 instantiator.mutateDeclarationList( translationUnit );
-                mutateTranslationUnit/*All*/( translationUnit, memberFixer );
+                mutateTranslationUnit/*All*/( translationUnit, polyCalculator );
                 mutateTranslationUnit/*All*/( translationUnit, pass3 );
         }
@@ -364 +370 @@
                 return functionDecl;
         }
-        
+
         /// Get a list of type declarations that will affect a layout function
         std::list< TypeDecl* > takeOtypeOnly( std::list< TypeDecl* > &decls ) {
@@ -374 +380 @@
                         }
                 }
-                
+
                 return otypeDecls;
         }
@@ -381 +387 @@
         void addOtypeParams( FunctionType *layoutFnType, std::list< TypeDecl* > &otypeParams ) {
                 BasicType sizeAlignType( Type::Qualifiers(), BasicType::LongUnsignedInt );
-                
+
                 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;
@@ -437 +444 @@
                 return makeCond( ifCond, ifExpr );
         }
-        
+
         /// adds an expression to a compound statement
         void addExpr( CompoundStmt *stmts, Expression *expr ) {
@@ -447 +454 @@
                 stmts->get_kids().push_back( stmt );
         }
-        
+
         Declaration *LayoutFunctionBuilder::mutate( StructDecl *structDecl ) {
                 // do not generate layout function for "empty" tag structs
@@ -460 +467 @@
                 BasicType *sizeAlignType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt );
                 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
@@ -490 +497 @@
                                 addStmt( layoutDecl->get_statements(), makeAlignTo( derefVar( sizeParam ), new AlignofExpr( memberType->clone() ) ) );
                         }
-                        
+
                         // place current size in the current offset index
                         addExpr( layoutDecl->get_statements(), makeOp( "?=?", makeOp( "?[?]", new VariableExpr( offsetParam ), new ConstantExpr( Constant::from( n_members ) ) ),
@@ -498 +505 @@
                         // add member size to current size
                         addExpr( layoutDecl->get_statements(), makeOp( "?+=?", derefVar( sizeParam ), new SizeofExpr( memberType->clone() ) ) );
-                        
+
                         // take max of member alignment and global alignment
                         addStmt( layoutDecl->get_statements(), makeAssignMax( derefVar( alignParam ), new AlignofExpr( memberType->clone() ) ) );
@@ -508 +515 @@
                 return structDecl;
         }
-        
+
         Declaration *LayoutFunctionBuilder::mutate( UnionDecl *unionDecl ) {
                 // do not generate layout function for "empty" tag unions
                 if ( unionDecl->get_members().empty() ) return unionDecl;
-                
+
                 // get parameters that can change layout, exiting early if none
                 std::list< TypeDecl* > otypeParams = takeOtypeOnly( unionDecl->get_parameters() );
@@ -521 +528 @@
                 BasicType *sizeAlignType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt );
                 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
@@ -538 +545 @@
                         assert( dwt );
                         Type *memberType = dwt->get_type();
-                        
+
                         // take max member size and global size
                         addStmt( layoutDecl->get_statements(), makeAssignMax( derefVar( sizeParam ), new SizeofExpr( memberType->clone() ) ) );
-                        
+
                         // take max of member alignment and global alignment
                         addStmt( layoutDecl->get_statements(), makeAssignMax( derefVar( alignParam ), new AlignofExpr( memberType->clone() ) ) );
@@ -551 +558 @@
                 return unionDecl;
         }
-        
+
         ////////////////////////////////////////// Pass1 ////////////////////////////////////////////////////
 
@@ -612 +619 @@
                         return 0;
                 }
-                
+
                 /// returns T if the given declaration is: (*?=?)(T *, T) for some type T (return not checked, but maybe should be), NULL otherwise
                 /// Only picks assignments where neither parameter is cv-qualified
@@ -624 +631 @@
                                                 Type *paramType2 = funType->get_parameters().back()->get_type();
                                                 if ( paramType2->get_qualifiers() != defaultQualifiers ) return 0;
-                                                
+
                                                 if ( PointerType *pointerType = dynamic_cast< PointerType* >( paramType1 ) ) {
                                                         Type *baseType1 = pointerType->get_base();
@@ -653 +660 @@
 
                 DeclarationWithType *Pass1::mutate( FunctionDecl *functionDecl ) {
-                        // if this is a polymorphic assignment function, put it in the map for this scope
+                        // if this is a assignment function, put it in the map for this scope
                         if ( Type *assignedType = isAssignment( functionDecl ) ) {
                                 if ( ! dynamic_cast< TypeInstType* >( assignedType ) ) {
@@ -662 +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;
@@ -704 +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;
@@ -743 +745 @@
                 }
 
-                Expression *Pass1::makeOffsetArray( StructInstType *ty ) {
-                        std::list<Expression*> noDesignators;
-                        std::list< Declaration* > &baseMembers = ty->get_baseStruct()->get_members();
-
-                        // make a new temporary array
-                        Type *offsetType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt );
-                        std::stringstream lenGen;
-                        lenGen << baseMembers.size();
-                        ConstantExpr *lenExpr = new ConstantExpr( Constant( offsetType->clone(), lenGen.str() ) );
-                        ObjectDecl *arrayTemp = makeTemporary( new ArrayType( Type::Qualifiers(), offsetType, lenExpr, false, false ) );
-
-                        // build initializer list for temporary
-                        std::list< Initializer* > inits;
-                        for ( std::list< Declaration* >::const_iterator member = baseMembers.begin(); member != baseMembers.end(); ++member ) {
-                                DeclarationWithType *memberDecl;
-                                if ( DeclarationWithType *origMember = dynamic_cast< DeclarationWithType* >( *member ) ) {
-                                        memberDecl = origMember->clone();
-                                } else {
-                                        memberDecl = new ObjectDecl( (*member)->get_name(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, offsetType->clone(), 0 );
-                                }
-                                inits.push_back( new SingleInit( new OffsetofExpr( ty->clone(), memberDecl ), noDesignators ) );
-                        }
-                        arrayTemp->set_init( new ListInit( inits, noDesignators ) );
-
-                        // return variable pointing to temporary
-                        return new VariableExpr( arrayTemp );
-                }
-
                 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() ) );
@@ -781 +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 ) ) {
-                                                arg = appExpr->get_args().insert( arg, makeOffsetArray( argBaseStructType ) );
-                                                arg++;
+                                                // zero-length arrays are forbidden by C, so don't pass offset for empty struct
+                                                if ( ! argBaseStructType->get_baseStruct()->get_members().empty() ) {
+                                                        arg = appExpr->get_args().insert( arg, new OffsetPackExpr( argBaseStructType->clone() ) );
+                                                        arg++;
+                                                }
                                         } else {
                                                 throw SemanticError( "Cannot pass non-struct type for generic struct" );
@@ -790 +767 @@
                                 }
 
-                                seenTypes.insert( sizeName );
+                                seenTypes.insert( typeName );
                         }
                 }
@@ -826 +803 @@
                                 passArgTypeVars( appExpr, polyRetType, concRetType, arg, exprTyVars, seenTypes );
                         }
-                        
+
                         // add type information args for presently unseen types in parameter list
                         for ( ; fnParm != funcType->get_parameters().end() && fnArg != appExpr->get_args().end(); ++fnParm, ++fnArg ) {
@@ -905 +882 @@
                         assert( env );
                         Type *concrete = replaceWithConcrete( appExpr, polyType );
-                        // add out-parameter for return value   
+                        // add out-parameter for return value
                         return addRetParam( appExpr, function, concrete, arg );
                 }
@@ -932 +909 @@
                                         return;
                                 } else if ( arg->get_results().front()->get_isLvalue() ) {
-                                        // VariableExpr and MemberExpr are lvalues
-                                        arg = new AddressExpr( arg );
+                                        // VariableExpr and MemberExpr are lvalues; need to check this isn't coming from the second arg of a comma expression though (not an lvalue)
+                                        if ( CommaExpr *commaArg = dynamic_cast< CommaExpr* >( arg ) ) {
+                                                commaArg->set_arg2( new AddressExpr( commaArg->get_arg2() ) );
+                                        } else {
+                                                arg = new AddressExpr( arg );
+                                        }
                                 } else {
                                         // use type computed in unification to declare boxed variables
@@ -1028 +1009 @@
                         } // for
                 }
-
-
 
                 FunctionDecl *Pass1::makeAdapter( FunctionType *adaptee, FunctionType *realType, const std::string &mangleName, const TyVarMap &tyVars ) {
@@ -1146 +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() ) {
@@ -1173 +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 );
@@ -1179 +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() );
@@ -1242 +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() ) {
@@ -1252 +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
@@ -1267 +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
@@ -1304 +1283 @@
                         std::list< Expression *>::iterator paramBegin = appExpr->get_args().begin();
 
-                        TyVarMap exprTyVars;
+                        TyVarMap exprTyVars( (TypeDecl::Kind)-1 );
                         makeTyVarMap( function, exprTyVars );
                         ReferenceToType *polyRetType = isPolyRet( function );
@@ -1327 +1306 @@
 
                         boxParams( appExpr, function, arg, exprTyVars );
-
                         passAdapters( appExpr, function, exprTyVars );
 
@@ -1388 +1366 @@
                         return new VariableExpr( functionObj );
                 }
-                
+
                 Statement * Pass1::mutate( ReturnStmt *returnStmt ) {
                         if ( retval && returnStmt->get_expr() ) {
@@ -1407 +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() );
@@ -1429 +1407 @@
                                         std::list< TypeDecl* >::const_iterator forallIt = forallParams.begin();
                                         for ( ; tyIt != tyParams.end() && forallIt != forallParams.end(); ++tyIt, ++forallIt ) {
-                                                if ( (*forallIt)->get_kind() != TypeDecl::Any ) continue; // skip types with no assign op (ftype/dtype)
-
-                                                std::list< DeclarationWithType* > &asserts = (*forallIt)->get_assertions();
-                                                assert( ! asserts.empty() && "Type param needs assignment operator assertion" );
-                                                DeclarationWithType *actualDecl = asserts.front();
-                                                TypeInstType *actualType = isTypeInstAssignment( actualDecl );
-                                                assert( actualType && "First assertion of type with assertions should be assignment operator" );
+                                                // Add appropriate mapping to assignment expression environment
                                                 TypeExpr *formalTypeExpr = dynamic_cast< TypeExpr* >( *tyIt );
                                                 assert( formalTypeExpr && "type parameters must be type expressions" );
                                                 Type *formalType = formalTypeExpr->get_type();
-                                                assignExpr->get_env()->add( actualType->get_name(), formalType );
-                                                
+                                                assignExpr->get_env()->add( (*forallIt)->get_name(), formalType );
+
+                                                // skip types with no assign op (ftype/dtype)
+                                                if ( (*forallIt)->get_kind() != TypeDecl::Any ) continue;
+
+                                                // find assignment operator for formal type
                                                 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 );
@@ -1454 +1430 @@
                                                         }
                                                 }
-                                                
-
+
+                                                // add inferred parameter for field assignment operator to assignment expression
+                                                std::list< DeclarationWithType* > &asserts = (*forallIt)->get_assertions();
+                                                assert( ! asserts.empty() && "Type param needs assignment operator assertion" );
+                                                DeclarationWithType *actualDecl = asserts.front();
                                                 assignExpr->get_inferParams()[ actualDecl->get_uniqueId() ]
                                                         = ParamEntry( assertAssign->get_uniqueId(), assertAssign->get_type()->clone(), actualDecl->get_type()->clone(), wrapFunctionDecl( assertAssign ) );
@@ -1481 +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;
                 }
@@ -1561 +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 );
 
@@ -1588 +1567 @@
                         ObjectDecl newPtr( "", DeclarationNode::NoStorageClass, LinkageSpec::C, 0,
                                            new PointerType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) ), 0 );
-//   ObjectDecl *newFunPtr = new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) ), 0 );
                         for ( std::list< TypeDecl *>::const_iterator tyParm = funcType->get_forall().begin(); tyParm != funcType->get_forall().end(); ++tyParm ) {
                                 ObjectDecl *sizeParm, *alignParm;
@@ -1594 +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;
@@ -1616 +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 ( dynamic_cast< StructInstType* >( polyBase ) ) {
-                                                offsetParm = newPtr.clone();
-                                                offsetParm->set_name( offsetofName( polyBase ) );
-                                                last = funcType->get_parameters().insert( last, offsetParm );
-                                                ++last;
+                                        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( typeName ) );
+                                                        last = funcType->get_parameters().insert( last, offsetParm );
+                                                        ++last;
+                                                }
                                         }
 
-                                        seenTypes.insert( sizeName );
+                                        seenTypes.insert( typeName );
                                 }
                         }
@@ -1649 +1631 @@
                         mutateAll( funcType->get_parameters(), *this );
 
-                        scopeTyVars = oldtyVars;
+                        scopeTyVars.endScope();
                         return funcType;
                 }
@@ -1842 +1824 @@
                 }
 
-////////////////////////////////////////// MemberExprFixer ////////////////////////////////////////////////////
+////////////////////////////////////////// PolyGenericCalculator ////////////////////////////////////////////////////
+
+                void PolyGenericCalculator::beginTypeScope( Type *ty ) {
+                        scopeTyVars.beginScope();
+                        makeTyVarMap( ty, scopeTyVars );
+                }
+
+                void PolyGenericCalculator::endTypeScope() {
+                        scopeTyVars.endScope();
+                }
 
                 template< typename DeclClass >
-                DeclClass * MemberExprFixer::handleDecl( DeclClass *decl, Type *type ) {
-                        TyVarMap oldtyVars = scopeTyVars;
-                        makeTyVarMap( type, scopeTyVars );
+                DeclClass * PolyGenericCalculator::handleDecl( DeclClass *decl, Type *type ) {
+                        beginTypeScope( type );
+                        knownLayouts.beginScope();
+                        knownOffsets.beginScope();
 
                         DeclClass *ret = static_cast< DeclClass *>( Mutator::mutate( decl ) );
 
-                        scopeTyVars = oldtyVars;
+                        knownOffsets.endScope();
+                        knownLayouts.endScope();
+                        endTypeScope();
                         return ret;
                 }
 
-                ObjectDecl * MemberExprFixer::mutate( ObjectDecl *objectDecl ) {
+                ObjectDecl * PolyGenericCalculator::mutate( ObjectDecl *objectDecl ) {
                         return handleDecl( objectDecl, objectDecl->get_type() );
                 }
 
-                DeclarationWithType * MemberExprFixer::mutate( FunctionDecl *functionDecl ) {
+                DeclarationWithType * PolyGenericCalculator::mutate( FunctionDecl *functionDecl ) {
                         return handleDecl( functionDecl, functionDecl->get_functionType() );
                 }
 
-                TypedefDecl * MemberExprFixer::mutate( TypedefDecl *typedefDecl ) {
+                TypedefDecl * PolyGenericCalculator::mutate( TypedefDecl *typedefDecl ) {
                         return handleDecl( typedefDecl, typedefDecl->get_base() );
                 }
 
-                TypeDecl * MemberExprFixer::mutate( TypeDecl *typeDecl ) {
+                TypeDecl * PolyGenericCalculator::mutate( TypeDecl *typeDecl ) {
                         scopeTyVars[ typeDecl->get_name() ] = typeDecl->get_kind();
                         return Mutator::mutate( typeDecl );
                 }
 
-                Type * MemberExprFixer::mutate( PointerType *pointerType ) {
-                        TyVarMap oldtyVars = scopeTyVars;
-                        makeTyVarMap( pointerType, scopeTyVars );
+                Type * PolyGenericCalculator::mutate( PointerType *pointerType ) {
+                        beginTypeScope( pointerType );
 
                         Type *ret = Mutator::mutate( pointerType );
 
-                        scopeTyVars = oldtyVars;
+                        endTypeScope();
                         return ret;
                 }
 
-                Type * MemberExprFixer::mutate( FunctionType *functionType ) {
-                        TyVarMap oldtyVars = scopeTyVars;
-                        makeTyVarMap( functionType, scopeTyVars );
-
-                        Type *ret = Mutator::mutate( functionType );
-
-                        scopeTyVars = oldtyVars;
+                Type * PolyGenericCalculator::mutate( FunctionType *funcType ) {
+                        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 *polyType = isPolyType( (*fnParm)->get_type(), scopeTyVars );
+                                if ( polyType && ! dynamic_cast< TypeInstType* >( polyType ) ) {
+                                        knownLayouts.insert( mangleType( polyType ) );
+                                }
+                        }
+
+                        Type *ret = Mutator::mutate( funcType );
+
+                        endTypeScope();
                         return ret;
                 }
 
-                Statement *MemberExprFixer::mutate( DeclStmt *declStmt ) {
+                Statement *PolyGenericCalculator::mutate( DeclStmt *declStmt ) {
                         if ( ObjectDecl *objectDecl = dynamic_cast< ObjectDecl *>( declStmt->get_decl() ) ) {
-                                if ( isPolyType( objectDecl->get_type(), scopeTyVars ) ) {
+                                if ( findGeneric( objectDecl->get_type() ) ) {
                                         // change initialization of a polymorphic value object
                                         // to allocate storage with alloca
                                         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();
@@ -1931 +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;
@@ -1946 +1947 @@
                 }
 
-                Expression *MemberExprFixer::mutate( MemberExpr *memberExpr ) {
+                Expression *PolyGenericCalculator::mutate( MemberExpr *memberExpr ) {
                         // mutate, exiting early if no longer MemberExpr
                         Expression *expr = Mutator::mutate( memberExpr );
@@ -1963 +1964 @@
                         Type *objectType = hasPolyBase( objectDecl->get_type(), scopeTyVars, &tyDepth );
                         if ( ! objectType ) return memberExpr;
+                        findGeneric( objectType ); // ensure layout for this type is available
 
                         Expression *newMemberExpr = 0;
@@ -1994 +1996 @@
                 }
 
-                Expression *MemberExprFixer::mutate( OffsetofExpr *offsetofExpr ) {
+                ObjectDecl *PolyGenericCalculator::makeVar( const std::string &name, Type *type, Initializer *init ) {
+                        ObjectDecl *newObj = new ObjectDecl( name, DeclarationNode::NoStorageClass, LinkageSpec::C, 0, type, init );
+                        stmtsToAdd.push_back( new DeclStmt( noLabels, newObj ) );
+                        return newObj;
+                }
+
+                void PolyGenericCalculator::addOtypeParamsToLayoutCall( UntypedExpr *layoutCall, const std::list< Type* > &otypeParams ) {
+                        for ( std::list< Type* >::const_iterator param = otypeParams.begin(); param != otypeParams.end(); ++param ) {
+                                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 ) ) );
+                                } else {
+                                        layoutCall->get_args().push_back( new SizeofExpr( (*param)->clone() ) );
+                                        layoutCall->get_args().push_back( new AlignofExpr( (*param)->clone() ) );
+                                }
+                        }
+                }
+
+                /// returns true if any of the otype parameters have a dynamic layout and puts all otype parameters in the output list
+                bool findGenericParams( std::list< TypeDecl* > &baseParams, std::list< Expression* > &typeParams, std::list< Type* > &out ) {
+                        bool hasDynamicLayout = false;
+
+                        std::list< TypeDecl* >::const_iterator baseParam = baseParams.begin();
+                        std::list< Expression* >::const_iterator typeParam = typeParams.begin();
+                        for ( ; baseParam != baseParams.end() && typeParam != typeParams.end(); ++baseParam, ++typeParam ) {
+                                // skip non-otype parameters
+                                if ( (*baseParam)->get_kind() != TypeDecl::Any ) continue;
+                                TypeExpr *typeExpr = dynamic_cast< TypeExpr* >( *typeParam );
+                                assert( typeExpr && "all otype parameters should be type expressions" );
+
+                                Type *type = typeExpr->get_type();
+                                out.push_back( type );
+                                if ( isPolyType( type ) ) hasDynamicLayout = true;
+                        }
+                        assert( baseParam == baseParams.end() && typeParam == typeParams.end() );
+
+                        return hasDynamicLayout;
+                }
+
+                bool PolyGenericCalculator::findGeneric( Type *ty ) {
+                        if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( ty ) ) {
+                                // duplicate logic from isPolyType()
+                                if ( env ) {
+                                        if ( Type *newType = env->lookup( typeInst->get_name() ) ) {
+                                                return findGeneric( newType );
+                                        } // if
+                                } // if
+                                if ( scopeTyVars.find( typeInst->get_name() ) != scopeTyVars.end() ) {
+                                        // NOTE assumes here that getting put in the scopeTyVars included having the layout variables set
+                                        return true;
+                                }
+                                return false;
+                        } 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;
+
+                                // check if any of the type parameters have dynamic layout; if none do, this type is (or will be) monomorphized
+                                std::list< Type* > otypeParams;
+                                if ( ! findGenericParams( *structTy->get_baseParameters(), structTy->get_parameters(), otypeParams ) ) return false;
+
+                                // 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
+                                Type *layoutType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt );
+
+                                int n_members = structTy->get_baseStruct()->get_members().size();
+                                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 ) ) ) );
+                                        // 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 ) );
+
+                                        // generate call to layout function
+                                        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 ) ) );
+                                        layoutCall->get_args().push_back( new VariableExpr( offsetVar ) );
+                                        addOtypeParamsToLayoutCall( layoutCall, otypeParams );
+
+                                        stmtsToAdd.push_back( new ExprStmt( noLabels, layoutCall ) );
+                                }
+
+                                return true;
+                        } 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;
+
+                                // check if any of the type parameters have dynamic layout; if none do, this type is (or will be) monomorphized
+                                std::list< Type* > otypeParams;
+                                if ( ! findGenericParams( *unionTy->get_baseParameters(), unionTy->get_parameters(), otypeParams ) ) return false;
+
+                                // 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
+                                Type *layoutType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt );
+
+                                ObjectDecl *sizeVar = makeVar( sizeofName( typeName ), layoutType );
+                                ObjectDecl *alignVar = makeVar( alignofName( typeName ), layoutType->clone() );
+
+                                // generate call to layout function
+                                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 ) ) );
+                                addOtypeParamsToLayoutCall( layoutCall, otypeParams );
+
+                                stmtsToAdd.push_back( new ExprStmt( noLabels, layoutCall ) );
+
+                                return true;
+                        }
+
+                        return false;
+                }
+
+                Expression *PolyGenericCalculator::mutate( SizeofExpr *sizeofExpr ) {
+                        Type *ty = sizeofExpr->get_type();
+                        if ( findGeneric( ty ) ) {
+                                Expression *ret = new NameExpr( sizeofName( mangleType( ty ) ) );
+                                delete sizeofExpr;
+                                return ret;
+                        }
+                        return sizeofExpr;
+                }
+
+                Expression *PolyGenericCalculator::mutate( AlignofExpr *alignofExpr ) {
+                        Type *ty = alignofExpr->get_type();
+                        if ( findGeneric( ty ) ) {
+                                Expression *ret = new NameExpr( alignofName( mangleType( ty ) ) );
+                                delete alignofExpr;
+                                return ret;
+                        }
+                        return alignofExpr;
+                }
+
+                Expression *PolyGenericCalculator::mutate( OffsetofExpr *offsetofExpr ) {
                         // mutate, exiting early if no longer OffsetofExpr
                         Expression *expr = Mutator::mutate( offsetofExpr );
@@ -2001 +2142 @@
 
                         // only mutate expressions for polymorphic structs/unions
-                        Type *ty = isPolyType( offsetofExpr->get_type(), scopeTyVars );
-                        if ( ! ty ) return offsetofExpr;
+                        Type *ty = offsetofExpr->get_type();
+                        if ( ! findGeneric( ty ) ) return offsetofExpr;
 
                         if ( StructInstType *structType = dynamic_cast< StructInstType* >( ty ) ) {
@@ -2019 +2160 @@
                 }
 
+                Expression *PolyGenericCalculator::mutate( OffsetPackExpr *offsetPackExpr ) {
+                        StructInstType *ty = offsetPackExpr->get_type();
+
+                        Expression *ret = 0;
+                        if ( findGeneric( ty ) ) {
+                                // pull offset back from generated type information
+                                ret = new NameExpr( offsetofName( mangleType( ty ) ) );
+                        } else {
+                                std::string offsetName = offsetofName( mangleType( ty ) );
+                                if ( knownOffsets.find( offsetName ) != knownOffsets.end() ) {
+                                        // use the already-generated offsets for this type
+                                        ret = new NameExpr( offsetName );
+                                } else {
+                                        knownOffsets.insert( offsetName );
+
+                                        std::list< Declaration* > &baseMembers = ty->get_baseStruct()->get_members();
+                                        Type *offsetType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt );
+
+                                        // build initializer list for offset array
+                                        std::list< Initializer* > inits;
+                                        for ( std::list< Declaration* >::const_iterator member = baseMembers.begin(); member != baseMembers.end(); ++member ) {
+                                                DeclarationWithType *memberDecl;
+                                                if ( DeclarationWithType *origMember = dynamic_cast< DeclarationWithType* >( *member ) ) {
+                                                        memberDecl = origMember->clone();
+                                                } else {
+                                                        memberDecl = new ObjectDecl( (*member)->get_name(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, offsetType->clone(), 0 );
+                                                }
+                                                inits.push_back( new SingleInit( new OffsetofExpr( ty->clone(), memberDecl ) ) );
+                                        }
+
+                                        // build the offset array and replace the pack with a reference to it
+                                        ObjectDecl *offsetArray = makeVar( offsetName, new ArrayType( Type::Qualifiers(), offsetType, new ConstantExpr( Constant::from( baseMembers.size() ) ), false, false ),
+                                                        new ListInit( inits ) );
+                                        ret = new VariableExpr( offsetArray );
+                                }
+                        }
+
+                        delete offsetPackExpr;
+                        return ret;
+                }
+
+                void PolyGenericCalculator::doBeginScope() {
+                        knownLayouts.beginScope();
+                        knownOffsets.beginScope();
+                }
+
+                void PolyGenericCalculator::doEndScope() {
+                        knownLayouts.endScope();
+                        knownOffsets.endScope();
+                }
+
 ////////////////////////////////////////// Pass3 ////////////////////////////////////////////////////
 
                 template< typename DeclClass >
                 DeclClass * Pass3::handleDecl( DeclClass *decl, Type *type ) {
-                        TyVarMap oldtyVars = scopeTyVars;
+                        scopeTyVars.beginScope();
                         makeTyVarMap( type, scopeTyVars );
 
@@ -2029 +2221 @@
                         ScrubTyVars::scrub( decl, scopeTyVars );
 
-                        scopeTyVars = oldtyVars;
+                        scopeTyVars.endScope();
                         return ret;
                 }
@@ -2059 +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

@@ -17 +17 @@
 #define _SCOPEDMAP_H
 
+#include <cassert>
 #include <iterator>
 #include <map>
@@ -50 +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) {}
@@ -67 +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; }
@@ -81 +99 @@
                                 }
                                 --it;
-                                return *this;
+                                return prev_valid();
                         }
                         iterator& operator-- (int) { iterator tmp = *this; --(*this); return tmp; }
@@ -104 +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) {}
@@ -126 +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; }
@@ -140 +175 @@
                                 }
                                 --it;
-                                return *this;
+                                return prev_valid();
                         }
                         const_iterator& operator-- (int) { const_iterator tmp = *this; --(*this); return tmp; }
@@ -164 +199 @@
                 void endScope() {
                         scopes.pop_back();
+                        assert( ! scopes.empty() );
                 }
 
@@ -169 +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); }
@@ -188 +224 @@
                         return end();
                 }
-                const_iterator find( const Key &key ) const { return const_iterator( find( key ) ); }
+                const_iterator find( const Key &key ) const {
+                                return const_iterator( const_cast< ScopedMap< Key, Value >* >(this)->find( key ) );
+                }
                 
                 /// Finds the given key in the outermost scope inside the given scope where it occurs
@@ -200 +238 @@
                         return end();
                 }
-                const_iterator findNext( const_iterator &it, const Key &key ) const { return const_iterator( findNext( it, key ) ); }
+                const_iterator findNext( const_iterator &it, const Key &key ) const {
+                                return const_iterator( const_cast< ScopedMap< Key, Value >* >(this)->findNext( it, key ) );
+                }
 
                 /// Inserts the given key-value pair into the outermost scope
@@ -208 +248 @@
                 }
                 std::pair< iterator, bool > insert( const Key &key, const Value &value ) { return insert( std::make_pair( key, value ) ); }
-                
+
+                Value& operator[] ( const Key &key ) {
+                        iterator slot = find( key );
+                        if ( slot != end() ) return slot->second;
+                        return insert( key, Value() ).first->second;
+                }
         };
 } // namespace GenPoly

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 {