Changeset 1048b31 for src/GenPoly/Box.cc

Timestamp:

May 2, 2016, 3:28:16 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:

1b7ea43

Parents:

1f6e009 (diff), e945826 (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 global-init

File:

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

src/GenPoly/Box.cc

@@ -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 ) );
+                        }
                 };
 
@@ -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;
                 
@@ -348 +355 @@
                 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 );
         }
@@ -384 +390 @@
                 for ( std::list< TypeDecl* >::const_iterator param = otypeParams.begin(); param != otypeParams.end(); ++param ) {
                         TypeInstType paramType( Type::Qualifiers(), (*param)->get_name(), *param );
-                        layoutFnType->get_parameters().push_back( new ObjectDecl( sizeofName( &paramType ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignType.clone(), 0 ) );
-                        layoutFnType->get_parameters().push_back( new ObjectDecl( alignofName( &paramType ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignType.clone(), 0 ) );
+                        std::string paramName = mangleType( &paramType );
+                        layoutFnType->get_parameters().push_back( new ObjectDecl( sizeofName( paramName ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignType.clone(), 0 ) );
+                        layoutFnType->get_parameters().push_back( new ObjectDecl( alignofName( paramName ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignType.clone(), 0 ) );
                 }
         }
 
         /// Builds a layout function declaration
-        FunctionDecl *buildLayoutFunctionDecl( const std::string &typeName, unsigned int functionNesting, FunctionType *layoutFnType ) {
+        FunctionDecl *buildLayoutFunctionDecl( AggregateDecl *typeDecl, unsigned int functionNesting, FunctionType *layoutFnType ) {
                 // Routines at global scope marked "static" to prevent multiple definitions is separate translation units
                 // because each unit generates copies of the default routines for each aggregate.
                 FunctionDecl *layoutDecl = new FunctionDecl(
-                        "__layoutof_" + typeName, functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static, LinkageSpec::AutoGen, layoutFnType, new CompoundStmt( noLabels ), true, false );
+                        layoutofName( typeDecl ), functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static, LinkageSpec::AutoGen, layoutFnType, new CompoundStmt( noLabels ), true, false );
                 layoutDecl->fixUniqueId();
                 return layoutDecl;
@@ -461 +468 @@
                 PointerType *sizeAlignOutType = new PointerType( Type::Qualifiers(), sizeAlignType );
                 
-                ObjectDecl *sizeParam = new ObjectDecl( "__sizeof_" + structDecl->get_name(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType, 0 );
+                ObjectDecl *sizeParam = new ObjectDecl( sizeofName( structDecl->get_name() ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType, 0 );
                 layoutFnType->get_parameters().push_back( sizeParam );
-                ObjectDecl *alignParam = new ObjectDecl( "__alignof_" + structDecl->get_name(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 );
+                ObjectDecl *alignParam = new ObjectDecl( alignofName( structDecl->get_name() ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 );
                 layoutFnType->get_parameters().push_back( alignParam );
-                ObjectDecl *offsetParam = new ObjectDecl( "__offsetof_" + structDecl->get_name(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 );
+                ObjectDecl *offsetParam = new ObjectDecl( offsetofName( structDecl->get_name() ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 );
                 layoutFnType->get_parameters().push_back( offsetParam );
                 addOtypeParams( layoutFnType, otypeParams );
 
                 // build function decl
-                FunctionDecl *layoutDecl = buildLayoutFunctionDecl( structDecl->get_name(), functionNesting, layoutFnType );
+                FunctionDecl *layoutDecl = buildLayoutFunctionDecl( structDecl, functionNesting, layoutFnType );
 
                 // calculate struct layout in function body
@@ -522 +529 @@
                 PointerType *sizeAlignOutType = new PointerType( Type::Qualifiers(), sizeAlignType );
                 
-                ObjectDecl *sizeParam = new ObjectDecl( "__sizeof_" + unionDecl->get_name(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType, 0 );
+                ObjectDecl *sizeParam = new ObjectDecl( sizeofName( unionDecl->get_name() ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType, 0 );
                 layoutFnType->get_parameters().push_back( sizeParam );
-                ObjectDecl *alignParam = new ObjectDecl( "__alignof_" + unionDecl->get_name(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 );
+                ObjectDecl *alignParam = new ObjectDecl( alignofName( unionDecl->get_name() ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 );
                 layoutFnType->get_parameters().push_back( alignParam );
                 addOtypeParams( layoutFnType, otypeParams );
 
                 // build function decl
-                FunctionDecl *layoutDecl = buildLayoutFunctionDecl( unionDecl->get_name(), functionNesting, layoutFnType );
+                FunctionDecl *layoutDecl = buildLayoutFunctionDecl( unionDecl, functionNesting, layoutFnType );
 
                 // calculate union layout in function body
@@ -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< 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 ) ) );
-                        }
-                        arrayTemp->set_init( new ListInit( inits ) );
-
-                        // 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() ) );
@@ -780 +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" );
@@ -789 +767 @@
                                 }
 
-                                seenTypes.insert( sizeName );
+                                seenTypes.insert( typeName );
                         }
                 }
@@ -931 +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
@@ -1027 +1009 @@
                         } // for
                 }
-
-
 
                 FunctionDecl *Pass1::makeAdapter( FunctionType *adaptee, FunctionType *realType, const std::string &mangleName, const TyVarMap &tyVars ) {
@@ -1145 +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() ) {
@@ -1172 +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 );
@@ -1178 +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() );
@@ -1241 +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() ) {
@@ -1251 +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
@@ -1266 +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
@@ -1303 +1283 @@
                         std::list< Expression *>::iterator paramBegin = appExpr->get_args().begin();
 
-                        TyVarMap exprTyVars;
+                        TyVarMap exprTyVars( (TypeDecl::Kind)-1 );
                         makeTyVarMap( function, exprTyVars );
                         ReferenceToType *polyRetType = isPolyRet( function );
@@ -1326 +1306 @@
 
                         boxParams( appExpr, function, arg, exprTyVars );
-
                         passAdapters( appExpr, function, exprTyVars );
 
@@ -1406 +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() );
@@ -1428 +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 );
@@ -1453 +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 ) );
@@ -1480 +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;
                 }
@@ -1560 +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 );
 
@@ -1587 +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;
@@ -1593 +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;
@@ -1615 +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 );
                                 }
                         }
@@ -1648 +1631 @@
                         mutateAll( funcType->get_parameters(), *this );
 
-                        scopeTyVars = oldtyVars;
+                        scopeTyVars.endScope();
                         return funcType;
                 }
@@ -1841 +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();
@@ -1930 +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;
@@ -1945 +1947 @@
                 }
                 
-                Expression *MemberExprFixer::mutate( MemberExpr *memberExpr ) {
+                Expression *PolyGenericCalculator::mutate( MemberExpr *memberExpr ) {
                         // mutate, exiting early if no longer MemberExpr
                         Expression *expr = Mutator::mutate( memberExpr );
@@ -1962 +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;
@@ -1993 +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 );
@@ -2000 +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 ) ) {
                                 // replace offsetof expression by index into offset array
@@ -2018 +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 );
 
@@ -2028 +2221 @@
                         ScrubTyVars::scrub( decl, scopeTyVars );
 
-                        scopeTyVars = oldtyVars;
+                        scopeTyVars.endScope();
                         return ret;
                 }
@@ -2058 +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;
                 }