source: src/GenPoly/Box.cc @ 2edd80ae

aaron-thesisarm-ehcleanup-dtorsdeferred_resndemanglerjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-exprnew-envno_listpersistent-indexerresolv-newwith_gc
Last change on this file since 2edd80ae was 2edd80ae, checked in by Aaron Moss <a3moss@…>, 4 years ago

Fixes #29

  • Property mode set to 100644
File size: 87.2 KB
Line 
1//
2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
3//
4// The contents of this file are covered under the licence agreement in the
5// file "LICENCE" distributed with Cforall.
6//
7// Box.cc --
8//
9// Author           : Richard C. Bilson
10// Created On       : Mon May 18 07:44:20 2015
11// Last Modified By : Peter A. Buhr
12// Last Modified On : Wed Jun 21 15:49:59 2017
13// Update Count     : 346
14//
15
16#include <algorithm>
17#include <iterator>
18#include <list>
19#include <map>
20#include <set>
21#include <stack>
22#include <string>
23#include <utility>
24#include <vector>
25#include <cassert>
26
27#include "Box.h"
28#include "DeclMutator.h"
29#include "PolyMutator.h"
30#include "FindFunction.h"
31#include "ScopedSet.h"
32#include "ScrubTyVars.h"
33
34#include "Parser/ParseNode.h"
35
36#include "SynTree/Attribute.h"
37#include "SynTree/Constant.h"
38#include "SynTree/Declaration.h"
39#include "SynTree/Expression.h"
40#include "SynTree/Initializer.h"
41#include "SynTree/Mutator.h"
42#include "SynTree/Statement.h"
43#include "SynTree/Type.h"
44#include "SynTree/TypeSubstitution.h"
45
46#include "ResolvExpr/TypeEnvironment.h"
47#include "ResolvExpr/TypeMap.h"
48#include "ResolvExpr/typeops.h"
49
50#include "SymTab/Indexer.h"
51#include "SymTab/Mangler.h"
52
53#include "Common/ScopedMap.h"
54#include "Common/SemanticError.h"
55#include "Common/UniqueName.h"
56#include "Common/utility.h"
57
58#include "InitTweak/InitTweak.h"
59
60#include <ext/functional> // temporary
61
62namespace GenPoly {
63        namespace {
64                FunctionType *makeAdapterType( FunctionType *adaptee, const TyVarMap &tyVars );
65
66                /// Adds layout-generation functions to polymorphic types
67                class LayoutFunctionBuilder final : public DeclMutator {
68                        unsigned int functionNesting;  // current level of nested functions
69                public:
70                        LayoutFunctionBuilder() : functionNesting( 0 ) {}
71
72                        using DeclMutator::mutate;
73                        virtual DeclarationWithType *mutate( FunctionDecl *functionDecl ) override;
74                        virtual Declaration *mutate( StructDecl *structDecl ) override;
75                        virtual Declaration *mutate( UnionDecl *unionDecl ) override;
76                };
77
78                /// 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
79                class Pass1 final : public PolyMutator {
80                  public:
81                        Pass1();
82
83                        using PolyMutator::mutate;
84                        virtual Expression *mutate( ApplicationExpr *appExpr ) override;
85                        virtual Expression *mutate( AddressExpr *addrExpr ) override;
86                        virtual Expression *mutate( UntypedExpr *expr ) override;
87                        virtual DeclarationWithType* mutate( FunctionDecl *functionDecl ) override;
88                        virtual TypeDecl *mutate( TypeDecl *typeDecl ) override;
89                        virtual Expression *mutate( CommaExpr *commaExpr ) override;
90                        virtual Expression *mutate( ConditionalExpr *condExpr ) override;
91                        virtual Statement * mutate( ReturnStmt *returnStmt ) override;
92                        virtual Type *mutate( PointerType *pointerType ) override;
93                        virtual Type * mutate( FunctionType *functionType ) override;
94
95                        virtual void doBeginScope() override;
96                        virtual void doEndScope() override;
97                  private:
98                        /// Pass the extra type parameters from polymorphic generic arguments or return types into a function application
99                        void passArgTypeVars( ApplicationExpr *appExpr, Type *parmType, Type *argBaseType, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars, std::set< std::string > &seenTypes );
100                        /// passes extra type parameters into a polymorphic function application
101                        void passTypeVars( ApplicationExpr *appExpr, Type *polyRetType, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars );
102                        /// wraps a function application with a new temporary for the out-parameter return value
103                        Expression *addRetParam( ApplicationExpr *appExpr, Type *retType, std::list< Expression *>::iterator &arg );
104                        /// Replaces all the type parameters of a generic type with their concrete equivalents under the current environment
105                        void replaceParametersWithConcrete( ApplicationExpr *appExpr, std::list< Expression* >& params );
106                        /// Replaces a polymorphic type with its concrete equivalant under the current environment (returns itself if concrete).
107                        /// If `doClone` is set to false, will not clone interior types
108                        Type *replaceWithConcrete( ApplicationExpr *appExpr, Type *type, bool doClone = true );
109                        /// wraps a function application returning a polymorphic type with a new temporary for the out-parameter return value
110                        Expression *addDynRetParam( ApplicationExpr *appExpr, Type *polyType, std::list< Expression *>::iterator &arg );
111                        Expression *applyAdapter( ApplicationExpr *appExpr, FunctionType *function, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars );
112                        void boxParam( Type *formal, Expression *&arg, const TyVarMap &exprTyVars );
113                        void boxParams( ApplicationExpr *appExpr, FunctionType *function, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars );
114                        void addInferredParams( ApplicationExpr *appExpr, FunctionType *functionType, std::list< Expression *>::iterator &arg, const TyVarMap &tyVars );
115                        /// Stores assignment operators from assertion list in local map of assignment operations
116                        void passAdapters( ApplicationExpr *appExpr, FunctionType *functionType, const TyVarMap &exprTyVars );
117                        FunctionDecl *makeAdapter( FunctionType *adaptee, FunctionType *realType, const std::string &mangleName, const TyVarMap &tyVars );
118                        /// Replaces intrinsic operator functions with their arithmetic desugaring
119                        Expression *handleIntrinsics( ApplicationExpr *appExpr );
120                        /// Inserts a new temporary variable into the current scope with an auto-generated name
121                        ObjectDecl *makeTemporary( Type *type );
122
123                        ScopedMap< std::string, DeclarationWithType* > adapters;     ///< Set of adapter functions in the current scope
124
125                        std::map< ApplicationExpr *, Expression * > retVals;
126
127                        DeclarationWithType *retval;
128                        UniqueName tempNamer;
129                };
130
131                /// * Moves polymorphic returns in function types to pointer-type parameters
132                /// * adds type size and assertion parameters to parameter lists
133                class Pass2 final : public PolyMutator {
134                  public:
135                        template< typename DeclClass >
136                        DeclClass *handleDecl( DeclClass *decl );
137                        template< typename AggDecl >
138                        AggDecl * handleAggDecl( AggDecl * aggDecl );
139
140                        typedef PolyMutator Parent;
141                        using Parent::mutate;
142                        virtual DeclarationWithType *mutate( FunctionDecl *functionDecl ) override;
143                        virtual ObjectDecl *mutate( ObjectDecl *objectDecl ) override;
144                        virtual StructDecl *mutate( StructDecl *structDecl ) override;
145                        virtual UnionDecl *mutate( UnionDecl *unionDecl ) override;
146                        virtual TypeDecl *mutate( TypeDecl *typeDecl ) override;
147                        virtual TypedefDecl *mutate( TypedefDecl *typedefDecl ) override;
148                        virtual Type *mutate( PointerType *pointerType ) override;
149                        virtual Type *mutate( FunctionType *funcType ) override;
150
151                  private:
152                        void addAdapters( FunctionType *functionType );
153
154                        std::map< UniqueId, std::string > adapterName;
155                };
156
157                /// Replaces member and size/align/offsetof expressions on polymorphic generic types with calculated expressions.
158                /// * Replaces member expressions for polymorphic types with calculated add-field-offset-and-dereference
159                /// * Calculates polymorphic offsetof expressions from offset array
160                /// * Inserts dynamic calculation of polymorphic type layouts where needed
161                class PolyGenericCalculator final : public PolyMutator {
162                public:
163                        typedef PolyMutator Parent;
164                        using Parent::mutate;
165
166                        PolyGenericCalculator();
167
168                        template< typename DeclClass >
169                        DeclClass *handleDecl( DeclClass *decl, Type *type );
170                        virtual DeclarationWithType *mutate( FunctionDecl *functionDecl ) override;
171                        virtual ObjectDecl *mutate( ObjectDecl *objectDecl ) override;
172                        virtual TypedefDecl *mutate( TypedefDecl *objectDecl ) override;
173                        virtual TypeDecl *mutate( TypeDecl *objectDecl ) override;
174                        virtual Statement *mutate( DeclStmt *declStmt ) override;
175                        virtual Type *mutate( PointerType *pointerType ) override;
176                        virtual Type *mutate( FunctionType *funcType ) override;
177                        virtual Expression *mutate( MemberExpr *memberExpr ) override;
178                        virtual Expression *mutate( SizeofExpr *sizeofExpr ) override;
179                        virtual Expression *mutate( AlignofExpr *alignofExpr ) override;
180                        virtual Expression *mutate( OffsetofExpr *offsetofExpr ) override;
181                        virtual Expression *mutate( OffsetPackExpr *offsetPackExpr ) override;
182
183                        virtual void doBeginScope() override;
184                        virtual void doEndScope() override;
185
186                private:
187                        /// Makes a new variable in the current scope with the given name, type & optional initializer
188                        ObjectDecl *makeVar( const std::string &name, Type *type, Initializer *init = 0 );
189                        /// returns true if the type has a dynamic layout; such a layout will be stored in appropriately-named local variables when the function returns
190                        bool findGeneric( Type *ty );
191                        /// adds type parameters to the layout call; will generate the appropriate parameters if needed
192                        void addOtypeParamsToLayoutCall( UntypedExpr *layoutCall, const std::list< Type* > &otypeParams );
193
194                        /// Enters a new scope for type-variables, adding the type variables from ty
195                        void beginTypeScope( Type *ty );
196                        /// Exits the type-variable scope
197                        void endTypeScope();
198
199                        ScopedSet< std::string > knownLayouts;          ///< Set of generic type layouts known in the current scope, indexed by sizeofName
200                        ScopedSet< std::string > knownOffsets;          ///< Set of non-generic types for which the offset array exists in the current scope, indexed by offsetofName
201                        UniqueName bufNamer;                           ///< Namer for VLA buffers
202                };
203
204                /// Replaces initialization of polymorphic values with alloca, declaration of dtype/ftype with appropriate void expression, sizeof expressions of polymorphic types with the proper variable, and strips fields from generic struct declarations.
205                class Pass3 final : public PolyMutator {
206                  public:
207                        template< typename DeclClass >
208                        DeclClass *handleDecl( DeclClass *decl, Type *type );
209
210                        using PolyMutator::mutate;
211                        virtual DeclarationWithType *mutate( FunctionDecl *functionDecl ) override;
212                        virtual Declaration *mutate( StructDecl *structDecl ) override;
213                        virtual Declaration *mutate( UnionDecl *unionDecl ) override;
214                        virtual ObjectDecl *mutate( ObjectDecl *objectDecl ) override;
215                        virtual TypedefDecl *mutate( TypedefDecl *objectDecl ) override;
216                        virtual TypeDecl *mutate( TypeDecl *objectDecl ) override;
217                        virtual Type *mutate( PointerType *pointerType ) override;
218                        virtual Type *mutate( FunctionType *funcType ) override;
219                  private:
220                };
221
222        } // anonymous namespace
223
224        /// version of mutateAll with special handling for translation unit so you can check the end of the prelude when debugging
225        template< typename MutatorType >
226        inline void mutateTranslationUnit( std::list< Declaration* > &translationUnit, MutatorType &mutator ) {
227                bool seenIntrinsic = false;
228                SemanticError errors;
229                for ( typename std::list< Declaration* >::iterator i = translationUnit.begin(); i != translationUnit.end(); ++i ) {
230                        try {
231                                if ( *i ) {
232                                        if ( (*i)->get_linkage() == LinkageSpec::Intrinsic ) {
233                                                seenIntrinsic = true;
234                                        } else if ( seenIntrinsic ) {
235                                                seenIntrinsic = false; // break on this line when debugging for end of prelude
236                                        }
237
238                                        *i = dynamic_cast< Declaration* >( (*i)->acceptMutator( mutator ) );
239                                        assert( *i );
240                                } // if
241                        } catch( SemanticError &e ) {
242                                e.set_location( (*i)->location );
243                                errors.append( e );
244                        } // try
245                } // for
246                if ( ! errors.isEmpty() ) {
247                        throw errors;
248                } // if
249        }
250
251        void box( std::list< Declaration *>& translationUnit ) {
252                LayoutFunctionBuilder layoutBuilder;
253                Pass1 pass1;
254                Pass2 pass2;
255                PolyGenericCalculator polyCalculator;
256                Pass3 pass3;
257
258                layoutBuilder.mutateDeclarationList( translationUnit );
259                mutateTranslationUnit/*All*/( translationUnit, pass1 );
260                mutateTranslationUnit/*All*/( translationUnit, pass2 );
261                mutateTranslationUnit/*All*/( translationUnit, polyCalculator );
262                mutateTranslationUnit/*All*/( translationUnit, pass3 );
263        }
264
265        ////////////////////////////////// LayoutFunctionBuilder ////////////////////////////////////////////
266
267        DeclarationWithType *LayoutFunctionBuilder::mutate( FunctionDecl *functionDecl ) {
268                functionDecl->set_functionType( maybeMutate( functionDecl->get_functionType(), *this ) );
269                ++functionNesting;
270                functionDecl->set_statements( maybeMutate( functionDecl->get_statements(), *this ) );
271                --functionNesting;
272                return functionDecl;
273        }
274
275        /// Get a list of type declarations that will affect a layout function
276        std::list< TypeDecl* > takeOtypeOnly( std::list< TypeDecl* > &decls ) {
277                std::list< TypeDecl * > otypeDecls;
278
279                for ( std::list< TypeDecl* >::const_iterator decl = decls.begin(); decl != decls.end(); ++decl ) {
280                        if ( (*decl)->isComplete() ) {
281                                otypeDecls.push_back( *decl );
282                        }
283                }
284
285                return otypeDecls;
286        }
287
288        /// Adds parameters for otype layout to a function type
289        void addOtypeParams( FunctionType *layoutFnType, std::list< TypeDecl* > &otypeParams ) {
290                BasicType sizeAlignType( Type::Qualifiers(), BasicType::LongUnsignedInt );
291
292                for ( std::list< TypeDecl* >::const_iterator param = otypeParams.begin(); param != otypeParams.end(); ++param ) {
293                        TypeInstType paramType( Type::Qualifiers(), (*param)->get_name(), *param );
294                        std::string paramName = mangleType( &paramType );
295                        layoutFnType->get_parameters().push_back( new ObjectDecl( sizeofName( paramName ), Type::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignType.clone(), 0 ) );
296                        layoutFnType->get_parameters().push_back( new ObjectDecl( alignofName( paramName ), Type::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignType.clone(), 0 ) );
297                }
298        }
299
300        /// Builds a layout function declaration
301        FunctionDecl *buildLayoutFunctionDecl( AggregateDecl *typeDecl, unsigned int functionNesting, FunctionType *layoutFnType ) {
302                // Routines at global scope marked "static" to prevent multiple definitions is separate translation units
303                // because each unit generates copies of the default routines for each aggregate.
304                FunctionDecl *layoutDecl = new FunctionDecl( layoutofName( typeDecl ),
305                                                                                                         functionNesting > 0 ? Type::StorageClasses() : Type::StorageClasses( Type::Static ),
306                                                                                                         LinkageSpec::AutoGen, layoutFnType, new CompoundStmt( noLabels ),
307                                                                                                         std::list< Attribute * >(), Type::FuncSpecifiers( Type::Inline ) );
308                layoutDecl->fixUniqueId();
309                return layoutDecl;
310        }
311
312        /// Makes a unary operation
313        Expression *makeOp( const std::string &name, Expression *arg ) {
314                UntypedExpr *expr = new UntypedExpr( new NameExpr( name ) );
315                expr->get_args().push_back( arg );
316                return expr;
317        }
318
319        /// Makes a binary operation
320        Expression *makeOp( const std::string &name, Expression *lhs, Expression *rhs ) {
321                UntypedExpr *expr = new UntypedExpr( new NameExpr( name ) );
322                expr->get_args().push_back( lhs );
323                expr->get_args().push_back( rhs );
324                return expr;
325        }
326
327        /// Returns the dereference of a local pointer variable
328        Expression *derefVar( ObjectDecl *var ) {
329                return makeOp( "*?", new VariableExpr( var ) );
330        }
331
332        /// makes an if-statement with a single-expression if-block and no then block
333        Statement *makeCond( Expression *cond, Expression *ifPart ) {
334                return new IfStmt( noLabels, cond, new ExprStmt( noLabels, ifPart ), 0 );
335        }
336
337        /// makes a statement that assigns rhs to lhs if lhs < rhs
338        Statement *makeAssignMax( Expression *lhs, Expression *rhs ) {
339                return makeCond( makeOp( "?<?", lhs, rhs ), makeOp( "?=?", lhs->clone(), rhs->clone() ) );
340        }
341
342        /// makes a statement that aligns lhs to rhs (rhs should be an integer power of two)
343        Statement *makeAlignTo( Expression *lhs, Expression *rhs ) {
344                // check that the lhs is zeroed out to the level of rhs
345                Expression *ifCond = makeOp( "?&?", lhs, makeOp( "?-?", rhs, new ConstantExpr( Constant::from_ulong( 1 ) ) ) );
346                // if not aligned, increment to alignment
347                Expression *ifExpr = makeOp( "?+=?", lhs->clone(), makeOp( "?-?", rhs->clone(), ifCond->clone() ) );
348                return makeCond( ifCond, ifExpr );
349        }
350
351        /// adds an expression to a compound statement
352        void addExpr( CompoundStmt *stmts, Expression *expr ) {
353                stmts->get_kids().push_back( new ExprStmt( noLabels, expr ) );
354        }
355
356        /// adds a statement to a compound statement
357        void addStmt( CompoundStmt *stmts, Statement *stmt ) {
358                stmts->get_kids().push_back( stmt );
359        }
360
361        Declaration *LayoutFunctionBuilder::mutate( StructDecl *structDecl ) {
362                // do not generate layout function for "empty" tag structs
363                if ( structDecl->get_members().empty() ) return structDecl;
364
365                // get parameters that can change layout, exiting early if none
366                std::list< TypeDecl* > otypeParams = takeOtypeOnly( structDecl->get_parameters() );
367                if ( otypeParams.empty() ) return structDecl;
368
369                // build layout function signature
370                FunctionType *layoutFnType = new FunctionType( Type::Qualifiers(), false );
371                BasicType *sizeAlignType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt );
372                PointerType *sizeAlignOutType = new PointerType( Type::Qualifiers(), sizeAlignType );
373
374                ObjectDecl *sizeParam = new ObjectDecl( sizeofName( structDecl->get_name() ), Type::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignOutType, 0 );
375                layoutFnType->get_parameters().push_back( sizeParam );
376                ObjectDecl *alignParam = new ObjectDecl( alignofName( structDecl->get_name() ), Type::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 );
377                layoutFnType->get_parameters().push_back( alignParam );
378                ObjectDecl *offsetParam = new ObjectDecl( offsetofName( structDecl->get_name() ), Type::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 );
379                layoutFnType->get_parameters().push_back( offsetParam );
380                addOtypeParams( layoutFnType, otypeParams );
381
382                // build function decl
383                FunctionDecl *layoutDecl = buildLayoutFunctionDecl( structDecl, functionNesting, layoutFnType );
384
385                // calculate struct layout in function body
386
387                // initialize size and alignment to 0 and 1 (will have at least one member to re-edit size)
388                addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( sizeParam ), new ConstantExpr( Constant::from_ulong( 0 ) ) ) );
389                addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( alignParam ), new ConstantExpr( Constant::from_ulong( 1 ) ) ) );
390                unsigned long n_members = 0;
391                bool firstMember = true;
392                for ( std::list< Declaration* >::const_iterator member = structDecl->get_members().begin(); member != structDecl->get_members().end(); ++member ) {
393                        DeclarationWithType *dwt = dynamic_cast< DeclarationWithType * >( *member );
394                        assert( dwt );
395                        Type *memberType = dwt->get_type();
396
397                        if ( firstMember ) {
398                                firstMember = false;
399                        } else {
400                                // make sure all members after the first (automatically aligned at 0) are properly padded for alignment
401                                addStmt( layoutDecl->get_statements(), makeAlignTo( derefVar( sizeParam ), new AlignofExpr( memberType->clone() ) ) );
402                        }
403
404                        // place current size in the current offset index
405                        addExpr( layoutDecl->get_statements(), makeOp( "?=?", makeOp( "?[?]", new VariableExpr( offsetParam ), new ConstantExpr( Constant::from_ulong( n_members ) ) ),
406                                                                              derefVar( sizeParam ) ) );
407                        ++n_members;
408
409                        // add member size to current size
410                        addExpr( layoutDecl->get_statements(), makeOp( "?+=?", derefVar( sizeParam ), new SizeofExpr( memberType->clone() ) ) );
411
412                        // take max of member alignment and global alignment
413                        addStmt( layoutDecl->get_statements(), makeAssignMax( derefVar( alignParam ), new AlignofExpr( memberType->clone() ) ) );
414                }
415                // make sure the type is end-padded to a multiple of its alignment
416                addStmt( layoutDecl->get_statements(), makeAlignTo( derefVar( sizeParam ), derefVar( alignParam ) ) );
417
418                addDeclarationAfter( layoutDecl );
419                return structDecl;
420        }
421
422        Declaration *LayoutFunctionBuilder::mutate( UnionDecl *unionDecl ) {
423                // do not generate layout function for "empty" tag unions
424                if ( unionDecl->get_members().empty() ) return unionDecl;
425
426                // get parameters that can change layout, exiting early if none
427                std::list< TypeDecl* > otypeParams = takeOtypeOnly( unionDecl->get_parameters() );
428                if ( otypeParams.empty() ) return unionDecl;
429
430                // build layout function signature
431                FunctionType *layoutFnType = new FunctionType( Type::Qualifiers(), false );
432                BasicType *sizeAlignType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt );
433                PointerType *sizeAlignOutType = new PointerType( Type::Qualifiers(), sizeAlignType );
434
435                ObjectDecl *sizeParam = new ObjectDecl( sizeofName( unionDecl->get_name() ), Type::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignOutType, 0 );
436                layoutFnType->get_parameters().push_back( sizeParam );
437                ObjectDecl *alignParam = new ObjectDecl( alignofName( unionDecl->get_name() ), Type::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 );
438                layoutFnType->get_parameters().push_back( alignParam );
439                addOtypeParams( layoutFnType, otypeParams );
440
441                // build function decl
442                FunctionDecl *layoutDecl = buildLayoutFunctionDecl( unionDecl, functionNesting, layoutFnType );
443
444                // calculate union layout in function body
445                addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( sizeParam ), new ConstantExpr( Constant::from_ulong( 1 ) ) ) );
446                addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( alignParam ), new ConstantExpr( Constant::from_ulong( 1 ) ) ) );
447                for ( std::list< Declaration* >::const_iterator member = unionDecl->get_members().begin(); member != unionDecl->get_members().end(); ++member ) {
448                        DeclarationWithType *dwt = dynamic_cast< DeclarationWithType * >( *member );
449                        assert( dwt );
450                        Type *memberType = dwt->get_type();
451
452                        // take max member size and global size
453                        addStmt( layoutDecl->get_statements(), makeAssignMax( derefVar( sizeParam ), new SizeofExpr( memberType->clone() ) ) );
454
455                        // take max of member alignment and global alignment
456                        addStmt( layoutDecl->get_statements(), makeAssignMax( derefVar( alignParam ), new AlignofExpr( memberType->clone() ) ) );
457                }
458                // make sure the type is end-padded to a multiple of its alignment
459                addStmt( layoutDecl->get_statements(), makeAlignTo( derefVar( sizeParam ), derefVar( alignParam ) ) );
460
461                addDeclarationAfter( layoutDecl );
462                return unionDecl;
463        }
464
465        ////////////////////////////////////////// Pass1 ////////////////////////////////////////////////////
466
467        namespace {
468                std::string makePolyMonoSuffix( FunctionType * function, const TyVarMap &tyVars ) {
469                        std::stringstream name;
470
471                        // NOTE: this function previously used isPolyObj, which failed to produce
472                        // the correct thing in some situations. It's not clear to me why this wasn't working.
473
474                        // if the return type or a parameter type involved polymorphic types, then the adapter will need
475                        // to take those polymorphic types as pointers. Therefore, there can be two different functions
476                        // with the same mangled name, so we need to further mangle the names.
477                        for ( std::list< DeclarationWithType *>::iterator retval = function->get_returnVals().begin(); retval != function->get_returnVals().end(); ++retval ) {
478                                if ( isPolyType( (*retval)->get_type(), tyVars ) ) {
479                                        name << "P";
480                                } else {
481                                        name << "M";
482                                }
483                        }
484                        name << "_";
485                        std::list< DeclarationWithType *> &paramList = function->get_parameters();
486                        for ( std::list< DeclarationWithType *>::iterator arg = paramList.begin(); arg != paramList.end(); ++arg ) {
487                                if ( isPolyType( (*arg)->get_type(), tyVars ) ) {
488                                        name << "P";
489                                } else {
490                                        name << "M";
491                                }
492                        } // for
493                        return name.str();
494                }
495
496                std::string mangleAdapterName( FunctionType * function, const TyVarMap &tyVars ) {
497                        return SymTab::Mangler::mangle( function ) + makePolyMonoSuffix( function, tyVars );
498                }
499
500                std::string makeAdapterName( const std::string &mangleName ) {
501                        return "_adapter" + mangleName;
502                }
503
504                Pass1::Pass1() : tempNamer( "_temp" ) {}
505
506                DeclarationWithType *Pass1::mutate( FunctionDecl *functionDecl ) {
507                        if ( functionDecl->get_statements() ) {         // empty routine body ?
508                                // std::cerr << "mutating function: " << functionDecl->get_mangleName() << std::endl;
509                                doBeginScope();
510                                scopeTyVars.beginScope();
511
512                                DeclarationWithType *oldRetval = retval;
513
514                                // process polymorphic return value
515                                retval = nullptr;
516                                if ( isDynRet( functionDecl->get_functionType() ) && functionDecl->get_linkage() != LinkageSpec::C ) {
517                                        retval = functionDecl->get_functionType()->get_returnVals().front();
518
519                                        // give names to unnamed return values
520                                        if ( retval->get_name() == "" ) {
521                                                retval->set_name( "_retparm" );
522                                                retval->set_linkage( LinkageSpec::C );
523                                        } // if
524                                } // if
525
526                                FunctionType *functionType = functionDecl->get_functionType();
527                                makeTyVarMap( functionDecl->get_functionType(), scopeTyVars );
528
529                                std::list< DeclarationWithType *> &paramList = functionType->get_parameters();
530                                std::list< FunctionType *> functions;
531                                for ( Type::ForallList::iterator tyVar = functionType->get_forall().begin(); tyVar != functionType->get_forall().end(); ++tyVar ) {
532                                        for ( std::list< DeclarationWithType *>::iterator assert = (*tyVar)->get_assertions().begin(); assert != (*tyVar)->get_assertions().end(); ++assert ) {
533                                                findFunction( (*assert)->get_type(), functions, scopeTyVars, needsAdapter );
534                                        } // for
535                                } // for
536                                for ( std::list< DeclarationWithType *>::iterator arg = paramList.begin(); arg != paramList.end(); ++arg ) {
537                                        findFunction( (*arg)->get_type(), functions, scopeTyVars, needsAdapter );
538                                } // for
539
540                                for ( std::list< FunctionType *>::iterator funType = functions.begin(); funType != functions.end(); ++funType ) {
541                                        std::string mangleName = mangleAdapterName( *funType, scopeTyVars );
542                                        if ( adapters.find( mangleName ) == adapters.end() ) {
543                                                std::string adapterName = makeAdapterName( mangleName );
544                                                adapters.insert( std::pair< std::string, DeclarationWithType *>( mangleName, new ObjectDecl( adapterName, Type::StorageClasses(), LinkageSpec::C, nullptr, new PointerType( Type::Qualifiers(), makeAdapterType( *funType, scopeTyVars ) ), nullptr ) ) );
545                                        } // if
546                                } // for
547
548                                functionDecl->set_statements( functionDecl->get_statements()->acceptMutator( *this ) );
549
550                                scopeTyVars.endScope();
551                                retval = oldRetval;
552                                doEndScope();
553                                // std::cerr << "end function: " << functionDecl->get_mangleName() << std::endl;
554                        } // if
555                        return functionDecl;
556                }
557
558                TypeDecl *Pass1::mutate( TypeDecl *typeDecl ) {
559                        addToTyVarMap( typeDecl, scopeTyVars );
560                        return Mutator::mutate( typeDecl );
561                }
562
563                Expression *Pass1::mutate( CommaExpr *commaExpr ) {
564                        // Attempting to find application expressions that were mutated by the copy constructor passes
565                        // to use an explicit return variable, so that the variable can be reused as a parameter to the
566                        // call rather than creating a new temp variable. Previously this step was an optimization, but
567                        // with the introduction of tuples and UniqueExprs, it is necessary to ensure that they use the same variable.
568                        // Essentially, looking for pattern: (x=f(...), x)
569                        // To compound the issue, the right side can be *x, etc. because of lvalue-returning functions
570                        if ( UntypedExpr * assign = dynamic_cast< UntypedExpr * >( commaExpr->get_arg1() ) ) {
571                                if ( InitTweak::isAssignment( InitTweak::getFunctionName( assign ) ) ) {
572                                        assert( assign->get_args().size() == 2 );
573                                        if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * > ( assign->get_args().back() ) ) {
574                                                // first argument is assignable, so it must be an lvalue, so it should be legal to take its address.
575                                                retVals[appExpr] = assign->get_args().front();
576                                        }
577                                }
578                        }
579
580                        commaExpr->set_arg1( maybeMutate( commaExpr->get_arg1(), *this ) );
581                        commaExpr->set_arg2( maybeMutate( commaExpr->get_arg2(), *this ) );
582                        return commaExpr;
583                }
584
585                Expression *Pass1::mutate( ConditionalExpr *condExpr ) {
586                        condExpr->set_arg1( maybeMutate( condExpr->get_arg1(), *this ) );
587                        condExpr->set_arg2( maybeMutate( condExpr->get_arg2(), *this ) );
588                        condExpr->set_arg3( maybeMutate( condExpr->get_arg3(), *this ) );
589                        return condExpr;
590
591                }
592
593                void Pass1::passArgTypeVars( ApplicationExpr *appExpr, Type *parmType, Type *argBaseType, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars, std::set< std::string > &seenTypes ) {
594                        Type *polyType = isPolyType( parmType, exprTyVars );
595                        if ( polyType && ! dynamic_cast< TypeInstType* >( polyType ) ) {
596                                std::string typeName = mangleType( polyType );
597                                if ( seenTypes.count( typeName ) ) return;
598
599                                arg = appExpr->get_args().insert( arg, new SizeofExpr( argBaseType->clone() ) );
600                                arg++;
601                                arg = appExpr->get_args().insert( arg, new AlignofExpr( argBaseType->clone() ) );
602                                arg++;
603                                if ( dynamic_cast< StructInstType* >( polyType ) ) {
604                                        if ( StructInstType *argBaseStructType = dynamic_cast< StructInstType* >( argBaseType ) ) {
605                                                // zero-length arrays are forbidden by C, so don't pass offset for empty struct
606                                                if ( ! argBaseStructType->get_baseStruct()->get_members().empty() ) {
607                                                        arg = appExpr->get_args().insert( arg, new OffsetPackExpr( argBaseStructType->clone() ) );
608                                                        arg++;
609                                                }
610                                        } else {
611                                                throw SemanticError( "Cannot pass non-struct type for generic struct" );
612                                        }
613                                }
614
615                                seenTypes.insert( typeName );
616                        }
617                }
618
619                void Pass1::passTypeVars( ApplicationExpr *appExpr, Type *polyRetType, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars ) {
620                        // pass size/align for type variables
621                        for ( TyVarMap::const_iterator tyParm = exprTyVars.begin(); tyParm != exprTyVars.end(); ++tyParm ) {
622                                ResolvExpr::EqvClass eqvClass;
623                                assert( env );
624                                if ( tyParm->second.isComplete ) {
625                                        Type *concrete = env->lookup( tyParm->first );
626                                        if ( concrete ) {
627                                                arg = appExpr->get_args().insert( arg, new SizeofExpr( concrete->clone() ) );
628                                                arg++;
629                                                arg = appExpr->get_args().insert( arg, new AlignofExpr( concrete->clone() ) );
630                                                arg++;
631                                        } else {
632                                                // xxx - should this be an assertion?
633                                                std::string x = env ? toString( *env ) : "missing env";
634                                                throw SemanticError( x + "\n" + "unbound type variable: " + tyParm->first + " in application ", appExpr );
635                                        } // if
636                                } // if
637                        } // for
638
639                        // add size/align for generic types to parameter list
640                        if ( ! appExpr->get_function()->has_result() ) return;
641                        FunctionType *funcType = getFunctionType( appExpr->get_function()->get_result() );
642                        assert( funcType );
643
644                        std::list< DeclarationWithType* >::const_iterator fnParm = funcType->get_parameters().begin();
645                        std::list< Expression* >::const_iterator fnArg = arg;
646                        std::set< std::string > seenTypes; ///< names for generic types we've seen
647
648                        // a polymorphic return type may need to be added to the argument list
649                        if ( polyRetType ) {
650                                Type *concRetType = replaceWithConcrete( appExpr, polyRetType );
651                                passArgTypeVars( appExpr, polyRetType, concRetType, arg, exprTyVars, seenTypes );
652                                ++fnArg; // skip the return parameter in the argument list
653                        }
654
655                        // add type information args for presently unseen types in parameter list
656                        for ( ; fnParm != funcType->get_parameters().end() && fnArg != appExpr->get_args().end(); ++fnParm, ++fnArg ) {
657                                if ( ! (*fnArg)->get_result() ) continue;
658                                Type * argType = (*fnArg)->get_result();
659                                passArgTypeVars( appExpr, (*fnParm)->get_type(), argType, arg, exprTyVars, seenTypes );
660                        }
661                }
662
663                ObjectDecl *Pass1::makeTemporary( Type *type ) {
664                        ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, type, 0 );
665                        stmtsToAdd.push_back( new DeclStmt( noLabels, newObj ) );
666                        return newObj;
667                }
668
669                Expression *Pass1::addRetParam( ApplicationExpr *appExpr, Type *retType, std::list< Expression *>::iterator &arg ) {
670                        // Create temporary to hold return value of polymorphic function and produce that temporary as a result
671                        // using a comma expression.
672                        assert( retType );
673
674                        Expression * paramExpr = nullptr;
675                        // try to use existing return value parameter if it exists, otherwise create a new temporary
676                        if ( retVals.count( appExpr ) ) {
677                                paramExpr = retVals[appExpr]->clone();
678                        } else {
679                                ObjectDecl *newObj = makeTemporary( retType->clone() );
680                                paramExpr = new VariableExpr( newObj );
681                        }
682                        Expression * retExpr = paramExpr->clone();
683
684                        // If the type of the temporary is not polymorphic, box temporary by taking its address;
685                        // otherwise the temporary is already boxed and can be used directly.
686                        if ( ! isPolyType( paramExpr->get_result(), scopeTyVars, env ) ) {
687                                paramExpr = new AddressExpr( paramExpr );
688                        } // if
689                        arg = appExpr->get_args().insert( arg, paramExpr ); // add argument to function call
690                        arg++;
691                        // Build a comma expression to call the function and emulate a normal return.
692                        CommaExpr *commaExpr = new CommaExpr( appExpr, retExpr );
693                        commaExpr->set_env( appExpr->get_env() );
694                        appExpr->set_env( 0 );
695                        return commaExpr;
696                }
697
698                void Pass1::replaceParametersWithConcrete( ApplicationExpr *appExpr, std::list< Expression* >& params ) {
699                        for ( std::list< Expression* >::iterator param = params.begin(); param != params.end(); ++param ) {
700                                TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
701                                assertf(paramType, "Aggregate parameters should be type expressions");
702                                paramType->set_type( replaceWithConcrete( appExpr, paramType->get_type(), false ) );
703                        }
704                }
705
706                Type *Pass1::replaceWithConcrete( ApplicationExpr *appExpr, Type *type, bool doClone ) {
707                        if ( TypeInstType *typeInst = dynamic_cast< TypeInstType * >( type ) ) {
708                                Type *concrete = env->lookup( typeInst->get_name() );
709                                if ( concrete == 0 ) {
710                                        return typeInst;
711                                        // xxx - should this be an assertion?
712//                                      std::string x = env ? toString( *env ) : "missing env";
713//                                      throw SemanticError( x + "\n" + "Unbound type variable " + typeInst->get_name() + " in ", appExpr );
714                                } // if
715                                return concrete;
716                        } else if ( StructInstType *structType = dynamic_cast< StructInstType* >( type ) ) {
717                                if ( doClone ) {
718                                        structType = structType->clone();
719                                }
720                                replaceParametersWithConcrete( appExpr, structType->get_parameters() );
721                                return structType;
722                        } else if ( UnionInstType *unionType = dynamic_cast< UnionInstType* >( type ) ) {
723                                if ( doClone ) {
724                                        unionType = unionType->clone();
725                                }
726                                replaceParametersWithConcrete( appExpr, unionType->get_parameters() );
727                                return unionType;
728                        }
729                        return type;
730                }
731
732                Expression *Pass1::addDynRetParam( ApplicationExpr *appExpr, Type *dynType, std::list< Expression *>::iterator &arg ) {
733                        assert( env );
734                        Type *concrete = replaceWithConcrete( appExpr, dynType );
735                        // add out-parameter for return value
736                        return addRetParam( appExpr, concrete, arg );
737                }
738
739                Expression *Pass1::applyAdapter( ApplicationExpr *appExpr, FunctionType *function, std::list< Expression *>::iterator &arg, const TyVarMap &tyVars ) {
740                        Expression *ret = appExpr;
741//                      if ( ! function->get_returnVals().empty() && isPolyType( function->get_returnVals().front()->get_type(), tyVars ) ) {
742                        if ( isDynRet( function, tyVars ) ) {
743                                ret = addRetParam( appExpr, function->get_returnVals().front()->get_type(), arg );
744                        } // if
745                        std::string mangleName = mangleAdapterName( function, tyVars );
746                        std::string adapterName = makeAdapterName( mangleName );
747
748                        // cast adaptee to void (*)(), since it may have any type inside a polymorphic function
749                        Type * adapteeType = new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) );
750                        appExpr->get_args().push_front( new CastExpr( appExpr->get_function(), adapteeType ) );
751                        appExpr->set_function( new NameExpr( adapterName ) ); // xxx - result is never set on NameExpr
752
753                        return ret;
754                }
755
756                void Pass1::boxParam( Type *param, Expression *&arg, const TyVarMap &exprTyVars ) {
757                        assert( arg->has_result() );
758                        if ( isPolyType( param, exprTyVars ) ) {
759                                if ( isPolyType( arg->get_result() ) ) {
760                                        // if the argument's type is polymorphic, we don't need to box again!
761                                        return;
762                                } else if ( arg->get_result()->get_lvalue() ) {
763                                        // VariableExpr and MemberExpr are lvalues; need to check this isn't coming from the second arg of a comma expression though (not an lvalue)
764                                        // xxx - need to test that this code is still reachable
765                                        if ( CommaExpr *commaArg = dynamic_cast< CommaExpr* >( arg ) ) {
766                                                commaArg->set_arg2( new AddressExpr( commaArg->get_arg2() ) );
767                                        } else {
768                                                arg = new AddressExpr( arg );
769                                        }
770                                        if ( ! ResolvExpr::typesCompatible( param, arg->get_result(), SymTab::Indexer() ) ) {
771                                                // silence warnings by casting boxed parameters when the actual type does not match up with the formal type.
772                                                arg = new CastExpr( arg, param->clone() );
773                                        }
774                                } else {
775                                        // use type computed in unification to declare boxed variables
776                                        Type * newType = param->clone();
777                                        if ( env ) env->apply( newType );
778                                        ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, newType, 0 );
779                                        newObj->get_type()->get_qualifiers() = Type::Qualifiers(); // TODO: is this right???
780                                        stmtsToAdd.push_back( new DeclStmt( noLabels, newObj ) );
781                                        UntypedExpr *assign = new UntypedExpr( new NameExpr( "?=?" ) );
782                                        assign->get_args().push_back( new VariableExpr( newObj ) );
783                                        assign->get_args().push_back( arg );
784                                        stmtsToAdd.push_back( new ExprStmt( noLabels, assign ) );
785                                        arg = new AddressExpr( new VariableExpr( newObj ) );
786                                } // if
787                        } // if
788                }
789
790                /// cast parameters to polymorphic functions so that types are replaced with
791                /// void * if they are type parameters in the formal type.
792                /// this gets rid of warnings from gcc.
793                void addCast( Expression *&actual, Type *formal, const TyVarMap &tyVars ) {
794                        if ( getFunctionType( formal ) ) {
795                                Type * newType = formal->clone();
796                                newType = ScrubTyVars::scrub( newType, tyVars );
797                                actual = new CastExpr( actual, newType );
798                        } // if
799                }
800
801                void Pass1::boxParams( ApplicationExpr *appExpr, FunctionType *function, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars ) {
802                        for ( std::list< DeclarationWithType *>::const_iterator param = function->get_parameters().begin(); param != function->get_parameters().end(); ++param, ++arg ) {
803                                assertf( arg != appExpr->get_args().end(), "boxParams: missing argument for param %s to %s in %s", toString( *param ).c_str(), toString( function ).c_str(), toString( appExpr ).c_str() );
804                                addCast( *arg, (*param)->get_type(), exprTyVars );
805                                boxParam( (*param)->get_type(), *arg, exprTyVars );
806                        } // for
807                }
808
809                void Pass1::addInferredParams( ApplicationExpr *appExpr, FunctionType *functionType, std::list< Expression *>::iterator &arg, const TyVarMap &tyVars ) {
810                        std::list< Expression *>::iterator cur = arg;
811                        for ( Type::ForallList::iterator tyVar = functionType->get_forall().begin(); tyVar != functionType->get_forall().end(); ++tyVar ) {
812                                for ( std::list< DeclarationWithType *>::iterator assert = (*tyVar)->get_assertions().begin(); assert != (*tyVar)->get_assertions().end(); ++assert ) {
813                                        InferredParams::const_iterator inferParam = appExpr->get_inferParams().find( (*assert)->get_uniqueId() );
814                                        if ( inferParam == appExpr->get_inferParams().end() ) {
815                                                std::cerr << "looking for assertion: " << (*assert) << std::endl << appExpr << std::endl;
816                                        }
817                                        assertf( inferParam != appExpr->get_inferParams().end(), "NOTE: Explicit casts of polymorphic functions to compatible monomorphic functions are currently unsupported" );
818                                        Expression *newExpr = inferParam->second.expr->clone();
819                                        addCast( newExpr, (*assert)->get_type(), tyVars );
820                                        boxParam( (*assert)->get_type(), newExpr, tyVars );
821                                        appExpr->get_args().insert( cur, newExpr );
822                                } // for
823                        } // for
824                }
825
826                void makeRetParm( FunctionType *funcType ) {
827                        DeclarationWithType *retParm = funcType->get_returnVals().front();
828
829                        // make a new parameter that is a pointer to the type of the old return value
830                        retParm->set_type( new PointerType( Type::Qualifiers(), retParm->get_type() ) );
831                        funcType->get_parameters().push_front( retParm );
832
833                        // we don't need the return value any more
834                        funcType->get_returnVals().clear();
835                }
836
837                FunctionType *makeAdapterType( FunctionType *adaptee, const TyVarMap &tyVars ) {
838                        // actually make the adapter type
839                        FunctionType *adapter = adaptee->clone();
840//                      if ( ! adapter->get_returnVals().empty() && isPolyType( adapter->get_returnVals().front()->get_type(), tyVars ) ) {
841                        if ( isDynRet( adapter, tyVars ) ) {
842                                makeRetParm( adapter );
843                        } // if
844                        adapter->get_parameters().push_front( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) ), 0 ) );
845                        return adapter;
846                }
847
848                Expression *makeAdapterArg( DeclarationWithType *param, DeclarationWithType *arg, DeclarationWithType *realParam, const TyVarMap &tyVars ) {
849                        assert( param );
850                        assert( arg );
851                        if ( isPolyType( realParam->get_type(), tyVars ) ) {
852                                if ( ! isPolyType( arg->get_type() ) ) {
853                                        UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
854                                        deref->get_args().push_back( new CastExpr( new VariableExpr( param ), new PointerType( Type::Qualifiers(), arg->get_type()->clone() ) ) );
855                                        deref->set_result( arg->get_type()->clone() );
856                                        return deref;
857                                } // if
858                        } // if
859                        return new VariableExpr( param );
860                }
861
862                void addAdapterParams( ApplicationExpr *adapteeApp, std::list< DeclarationWithType *>::iterator arg, std::list< DeclarationWithType *>::iterator param, std::list< DeclarationWithType *>::iterator paramEnd, std::list< DeclarationWithType *>::iterator realParam, const TyVarMap &tyVars ) {
863                        UniqueName paramNamer( "_p" );
864                        for ( ; param != paramEnd; ++param, ++arg, ++realParam ) {
865                                if ( (*param)->get_name() == "" ) {
866                                        (*param)->set_name( paramNamer.newName() );
867                                        (*param)->set_linkage( LinkageSpec::C );
868                                } // if
869                                adapteeApp->get_args().push_back( makeAdapterArg( *param, *arg, *realParam, tyVars ) );
870                        } // for
871                }
872
873                FunctionDecl *Pass1::makeAdapter( FunctionType *adaptee, FunctionType *realType, const std::string &mangleName, const TyVarMap &tyVars ) {
874                        FunctionType *adapterType = makeAdapterType( adaptee, tyVars );
875                        adapterType = ScrubTyVars::scrub( adapterType, tyVars );
876                        DeclarationWithType *adapteeDecl = adapterType->get_parameters().front();
877                        adapteeDecl->set_name( "_adaptee" );
878                        ApplicationExpr *adapteeApp = new ApplicationExpr( new CastExpr( new VariableExpr( adapteeDecl ), new PointerType( Type::Qualifiers(), realType ) ) );
879                        Statement *bodyStmt;
880
881                        Type::ForallList::iterator tyArg = realType->get_forall().begin();
882                        Type::ForallList::iterator tyParam = adapterType->get_forall().begin();
883                        Type::ForallList::iterator realTyParam = adaptee->get_forall().begin();
884                        for ( ; tyParam != adapterType->get_forall().end(); ++tyArg, ++tyParam, ++realTyParam ) {
885                                assert( tyArg != realType->get_forall().end() );
886                                std::list< DeclarationWithType *>::iterator assertArg = (*tyArg)->get_assertions().begin();
887                                std::list< DeclarationWithType *>::iterator assertParam = (*tyParam)->get_assertions().begin();
888                                std::list< DeclarationWithType *>::iterator realAssertParam = (*realTyParam)->get_assertions().begin();
889                                for ( ; assertParam != (*tyParam)->get_assertions().end(); ++assertArg, ++assertParam, ++realAssertParam ) {
890                                        assert( assertArg != (*tyArg)->get_assertions().end() );
891                                        adapteeApp->get_args().push_back( makeAdapterArg( *assertParam, *assertArg, *realAssertParam, tyVars ) );
892                                } // for
893                        } // for
894
895                        std::list< DeclarationWithType *>::iterator arg = realType->get_parameters().begin();
896                        std::list< DeclarationWithType *>::iterator param = adapterType->get_parameters().begin();
897                        std::list< DeclarationWithType *>::iterator realParam = adaptee->get_parameters().begin();
898                        param++;                // skip adaptee parameter in the adapter type
899                        if ( realType->get_returnVals().empty() ) {
900                                // void return
901                                addAdapterParams( adapteeApp, arg, param, adapterType->get_parameters().end(), realParam, tyVars );
902                                bodyStmt = new ExprStmt( noLabels, adapteeApp );
903//                      } else if ( isPolyType( adaptee->get_returnVals().front()->get_type(), tyVars ) ) {
904                        } else if ( isDynType( adaptee->get_returnVals().front()->get_type(), tyVars ) ) {
905                                // return type T
906                                if ( (*param)->get_name() == "" ) {
907                                        (*param)->set_name( "_ret" );
908                                        (*param)->set_linkage( LinkageSpec::C );
909                                } // if
910                                UntypedExpr *assign = new UntypedExpr( new NameExpr( "?=?" ) );
911                                UntypedExpr *deref = UntypedExpr::createDeref( new CastExpr( new VariableExpr( *param++ ), new PointerType( Type::Qualifiers(), realType->get_returnVals().front()->get_type()->clone() ) ) );
912                                assign->get_args().push_back( deref );
913                                addAdapterParams( adapteeApp, arg, param, adapterType->get_parameters().end(), realParam, tyVars );
914                                assign->get_args().push_back( adapteeApp );
915                                bodyStmt = new ExprStmt( noLabels, assign );
916                        } else {
917                                // adapter for a function that returns a monomorphic value
918                                addAdapterParams( adapteeApp, arg, param, adapterType->get_parameters().end(), realParam, tyVars );
919                                bodyStmt = new ReturnStmt( noLabels, adapteeApp );
920                        } // if
921                        CompoundStmt *adapterBody = new CompoundStmt( noLabels );
922                        adapterBody->get_kids().push_back( bodyStmt );
923                        std::string adapterName = makeAdapterName( mangleName );
924                        return new FunctionDecl( adapterName, Type::StorageClasses(), LinkageSpec::C, adapterType, adapterBody );
925                }
926
927                void Pass1::passAdapters( ApplicationExpr * appExpr, FunctionType * functionType, const TyVarMap & exprTyVars ) {
928                        // collect a list of function types passed as parameters or implicit parameters (assertions)
929                        std::list< DeclarationWithType *> &paramList = functionType->get_parameters();
930                        std::list< FunctionType *> functions;
931                        for ( Type::ForallList::iterator tyVar = functionType->get_forall().begin(); tyVar != functionType->get_forall().end(); ++tyVar ) {
932                                for ( std::list< DeclarationWithType *>::iterator assert = (*tyVar)->get_assertions().begin(); assert != (*tyVar)->get_assertions().end(); ++assert ) {
933                                        findFunction( (*assert)->get_type(), functions, exprTyVars, needsAdapter );
934                                } // for
935                        } // for
936                        for ( std::list< DeclarationWithType *>::iterator arg = paramList.begin(); arg != paramList.end(); ++arg ) {
937                                findFunction( (*arg)->get_type(), functions, exprTyVars, needsAdapter );
938                        } // for
939
940                        // parameter function types for which an appropriate adapter has been generated.  we cannot use the types
941                        // after applying substitutions, since two different parameter types may be unified to the same type
942                        std::set< std::string > adaptersDone;
943
944                        for ( std::list< FunctionType *>::iterator funType = functions.begin(); funType != functions.end(); ++funType ) {
945                                FunctionType *originalFunction = (*funType)->clone();
946                                FunctionType *realFunction = (*funType)->clone();
947                                std::string mangleName = SymTab::Mangler::mangle( realFunction );
948
949                                // only attempt to create an adapter or pass one as a parameter if we haven't already done so for this
950                                // pre-substitution parameter function type.
951                                if ( adaptersDone.find( mangleName ) == adaptersDone.end() ) {
952                                        adaptersDone.insert( adaptersDone.begin(), mangleName );
953
954                                        // apply substitution to type variables to figure out what the adapter's type should look like
955                                        assert( env );
956                                        env->apply( realFunction );
957                                        mangleName = SymTab::Mangler::mangle( realFunction );
958                                        mangleName += makePolyMonoSuffix( originalFunction, exprTyVars );
959
960                                        typedef ScopedMap< std::string, DeclarationWithType* >::iterator AdapterIter;
961                                        AdapterIter adapter = adapters.find( mangleName );
962                                        if ( adapter == adapters.end() ) {
963                                                // adapter has not been created yet in the current scope, so define it
964                                                FunctionDecl *newAdapter = makeAdapter( *funType, realFunction, mangleName, exprTyVars );
965                                                std::pair< AdapterIter, bool > answer = adapters.insert( std::pair< std::string, DeclarationWithType *>( mangleName, newAdapter ) );
966                                                adapter = answer.first;
967                                                stmtsToAdd.push_back( new DeclStmt( noLabels, newAdapter ) );
968                                        } // if
969                                        assert( adapter != adapters.end() );
970
971                                        // add the appropriate adapter as a parameter
972                                        appExpr->get_args().push_front( new VariableExpr( adapter->second ) );
973                                } // if
974                        } // for
975                } // passAdapters
976
977                Expression *makeIncrDecrExpr( ApplicationExpr *appExpr, Type *polyType, bool isIncr ) {
978                        NameExpr *opExpr;
979                        if ( isIncr ) {
980                                opExpr = new NameExpr( "?+=?" );
981                        } else {
982                                opExpr = new NameExpr( "?-=?" );
983                        } // if
984                        UntypedExpr *addAssign = new UntypedExpr( opExpr );
985                        if ( AddressExpr *address = dynamic_cast< AddressExpr *>( appExpr->get_args().front() ) ) {
986                                addAssign->get_args().push_back( address->get_arg() );
987                        } else {
988                                addAssign->get_args().push_back( appExpr->get_args().front() );
989                        } // if
990                        addAssign->get_args().push_back( new NameExpr( sizeofName( mangleType( polyType ) ) ) );
991                        addAssign->set_result( appExpr->get_result()->clone() );
992                        if ( appExpr->get_env() ) {
993                                addAssign->set_env( appExpr->get_env() );
994                                appExpr->set_env( 0 );
995                        } // if
996                        appExpr->get_args().clear();
997                        delete appExpr;
998                        return addAssign;
999                }
1000
1001                Expression *Pass1::handleIntrinsics( ApplicationExpr *appExpr ) {
1002                        if ( VariableExpr *varExpr = dynamic_cast< VariableExpr *>( appExpr->get_function() ) ) {
1003                                if ( varExpr->get_var()->get_linkage() == LinkageSpec::Intrinsic ) {
1004                                        if ( varExpr->get_var()->get_name() == "?[?]" ) {
1005                                                assert( appExpr->has_result() );
1006                                                assert( appExpr->get_args().size() == 2 );
1007                                                Type *baseType1 = isPolyPtr( appExpr->get_args().front()->get_result(), scopeTyVars, env );
1008                                                Type *baseType2 = isPolyPtr( appExpr->get_args().back()->get_result(), scopeTyVars, env );
1009                                                assert( ! baseType1 || ! baseType2 ); // the arguments cannot both be polymorphic pointers
1010                                                UntypedExpr *ret = 0;
1011                                                if ( baseType1 || baseType2 ) { // one of the arguments is a polymorphic pointer
1012                                                        ret = new UntypedExpr( new NameExpr( "?+?" ) );
1013                                                } // if
1014                                                if ( baseType1 ) {
1015                                                        UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) );
1016                                                        multiply->get_args().push_back( appExpr->get_args().back() );
1017                                                        multiply->get_args().push_back( new SizeofExpr( baseType1->clone() ) );
1018                                                        ret->get_args().push_back( appExpr->get_args().front() );
1019                                                        ret->get_args().push_back( multiply );
1020                                                } else if ( baseType2 ) {
1021                                                        UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) );
1022                                                        multiply->get_args().push_back( appExpr->get_args().front() );
1023                                                        multiply->get_args().push_back( new SizeofExpr( baseType2->clone() ) );
1024                                                        ret->get_args().push_back( multiply );
1025                                                        ret->get_args().push_back( appExpr->get_args().back() );
1026                                                } // if
1027                                                if ( baseType1 || baseType2 ) {
1028                                                        ret->set_result( appExpr->get_result()->clone() );
1029                                                        if ( appExpr->get_env() ) {
1030                                                                ret->set_env( appExpr->get_env() );
1031                                                                appExpr->set_env( 0 );
1032                                                        } // if
1033                                                        appExpr->get_args().clear();
1034                                                        delete appExpr;
1035                                                        return ret;
1036                                                } // if
1037                                        } else if ( varExpr->get_var()->get_name() == "*?" ) {
1038                                                assert( appExpr->has_result() );
1039                                                assert( ! appExpr->get_args().empty() );
1040                                                if ( isPolyType( appExpr->get_result(), scopeTyVars, env ) ) {
1041                                                        Expression *ret = appExpr->get_args().front();
1042                                                        delete ret->get_result();
1043                                                        ret->set_result( appExpr->get_result()->clone() );
1044                                                        if ( appExpr->get_env() ) {
1045                                                                ret->set_env( appExpr->get_env() );
1046                                                                appExpr->set_env( 0 );
1047                                                        } // if
1048                                                        appExpr->get_args().clear();
1049                                                        delete appExpr;
1050                                                        return ret;
1051                                                } // if
1052                                        } else if ( varExpr->get_var()->get_name() == "?++" || varExpr->get_var()->get_name() == "?--" ) {
1053                                                assert( appExpr->has_result() );
1054                                                assert( appExpr->get_args().size() == 1 );
1055                                                if ( Type *baseType = isPolyPtr( appExpr->get_result(), scopeTyVars, env ) ) {
1056                                                        Type *tempType = appExpr->get_result()->clone();
1057                                                        if ( env ) {
1058                                                                env->apply( tempType );
1059                                                        } // if
1060                                                        ObjectDecl *newObj = makeTemporary( tempType );
1061                                                        VariableExpr *tempExpr = new VariableExpr( newObj );
1062                                                        UntypedExpr *assignExpr = new UntypedExpr( new NameExpr( "?=?" ) );
1063                                                        assignExpr->get_args().push_back( tempExpr->clone() );
1064                                                        if ( AddressExpr *address = dynamic_cast< AddressExpr *>( appExpr->get_args().front() ) ) {
1065                                                                assignExpr->get_args().push_back( address->get_arg()->clone() );
1066                                                        } else {
1067                                                                assignExpr->get_args().push_back( appExpr->get_args().front()->clone() );
1068                                                        } // if
1069                                                        CommaExpr *firstComma = new CommaExpr( assignExpr, makeIncrDecrExpr( appExpr, baseType, varExpr->get_var()->get_name() == "?++" ) );
1070                                                        return new CommaExpr( firstComma, tempExpr );
1071                                                } // if
1072                                        } else if ( varExpr->get_var()->get_name() == "++?" || varExpr->get_var()->get_name() == "--?" ) {
1073                                                assert( appExpr->has_result() );
1074                                                assert( appExpr->get_args().size() == 1 );
1075                                                if ( Type *baseType = isPolyPtr( appExpr->get_result(), scopeTyVars, env ) ) {
1076                                                        return makeIncrDecrExpr( appExpr, baseType, varExpr->get_var()->get_name() == "++?" );
1077                                                } // if
1078                                        } else if ( varExpr->get_var()->get_name() == "?+?" || varExpr->get_var()->get_name() == "?-?" ) {
1079                                                assert( appExpr->has_result() );
1080                                                assert( appExpr->get_args().size() == 2 );
1081                                                Type *baseType1 = isPolyPtr( appExpr->get_args().front()->get_result(), scopeTyVars, env );
1082                                                Type *baseType2 = isPolyPtr( appExpr->get_args().back()->get_result(), scopeTyVars, env );
1083                                                if ( baseType1 && baseType2 ) {
1084                                                        UntypedExpr *divide = new UntypedExpr( new NameExpr( "?/?" ) );
1085                                                        divide->get_args().push_back( appExpr );
1086                                                        divide->get_args().push_back( new SizeofExpr( baseType1->clone() ) );
1087                                                        divide->set_result( appExpr->get_result()->clone() );
1088                                                        if ( appExpr->get_env() ) {
1089                                                                divide->set_env( appExpr->get_env() );
1090                                                                appExpr->set_env( 0 );
1091                                                        } // if
1092                                                        return divide;
1093                                                } else if ( baseType1 ) {
1094                                                        UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) );
1095                                                        multiply->get_args().push_back( appExpr->get_args().back() );
1096                                                        multiply->get_args().push_back( new SizeofExpr( baseType1->clone() ) );
1097                                                        appExpr->get_args().back() = multiply;
1098                                                } else if ( baseType2 ) {
1099                                                        UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) );
1100                                                        multiply->get_args().push_back( appExpr->get_args().front() );
1101                                                        multiply->get_args().push_back( new SizeofExpr( baseType2->clone() ) );
1102                                                        appExpr->get_args().front() = multiply;
1103                                                } // if
1104                                        } else if ( varExpr->get_var()->get_name() == "?+=?" || varExpr->get_var()->get_name() == "?-=?" ) {
1105                                                assert( appExpr->has_result() );
1106                                                assert( appExpr->get_args().size() == 2 );
1107                                                Type *baseType = isPolyPtr( appExpr->get_result(), scopeTyVars, env );
1108                                                if ( baseType ) {
1109                                                        UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) );
1110                                                        multiply->get_args().push_back( appExpr->get_args().back() );
1111                                                        multiply->get_args().push_back( new SizeofExpr( baseType->clone() ) );
1112                                                        appExpr->get_args().back() = multiply;
1113                                                } // if
1114                                        } // if
1115                                        return appExpr;
1116                                } // if
1117                        } // if
1118                        return 0;
1119                }
1120
1121                Expression *Pass1::mutate( ApplicationExpr *appExpr ) {
1122                        // std::cerr << "mutate appExpr: " << InitTweak::getFunctionName( appExpr ) << std::endl;
1123                        // for ( TyVarMap::iterator i = scopeTyVars.begin(); i != scopeTyVars.end(); ++i ) {
1124                        //      std::cerr << i->first << " ";
1125                        // }
1126                        // std::cerr << "\n";
1127                        appExpr->get_function()->acceptMutator( *this );
1128                        mutateAll( appExpr->get_args(), *this );
1129
1130                        assert( appExpr->get_function()->has_result() );
1131                        PointerType *pointer = safe_dynamic_cast< PointerType *>( appExpr->get_function()->get_result() );
1132                        FunctionType *function = safe_dynamic_cast< FunctionType *>( pointer->get_base() );
1133
1134                        if ( Expression *newExpr = handleIntrinsics( appExpr ) ) {
1135                                return newExpr;
1136                        } // if
1137
1138                        Expression *ret = appExpr;
1139
1140                        std::list< Expression *>::iterator arg = appExpr->get_args().begin();
1141                        std::list< Expression *>::iterator paramBegin = appExpr->get_args().begin();
1142
1143                        TyVarMap exprTyVars( TypeDecl::Data{} );
1144                        makeTyVarMap( function, exprTyVars ); // xxx - should this take into account the variables already bound in scopeTyVars (i.e. remove them from exprTyVars?)
1145                        ReferenceToType *dynRetType = isDynRet( function, exprTyVars );
1146
1147                        // std::cerr << function << std::endl;
1148                        // std::cerr << "scopeTyVars: ";
1149                        // printTyVarMap( std::cerr, scopeTyVars );
1150                        // std::cerr << "exprTyVars: ";
1151                        // printTyVarMap( std::cerr, exprTyVars );
1152                        // std::cerr << "env: " << *env << std::endl;
1153                        // std::cerr << needsAdapter( function, scopeTyVars ) << ! needsAdapter( function, exprTyVars) << std::endl;
1154
1155                        // NOTE: addDynRetParam needs to know the actual (generated) return type so it can make a temp variable, so pass the result type from the appExpr
1156                        // passTypeVars needs to know the program-text return type (i.e. the distinction between _conc_T30 and T3(int))
1157                        // concRetType may not be a good name in one or both of these places. A more appropriate name change is welcome.
1158                        if ( dynRetType ) {
1159                                // std::cerr << "dynRetType: " << dynRetType << std::endl;
1160                                Type *concRetType = appExpr->get_result()->isVoid() ? nullptr : appExpr->get_result();
1161                                ret = addDynRetParam( appExpr, concRetType, arg ); // xxx - used to use dynRetType instead of concRetType
1162                        } else if ( needsAdapter( function, scopeTyVars ) && ! needsAdapter( function, exprTyVars) ) { // xxx - exprTyVars is used above...?
1163                                // xxx - the ! needsAdapter check may be incorrect. It seems there is some situation where an adapter is applied where it shouldn't be, and this fixes it for some cases. More investigation is needed.
1164
1165                                // std::cerr << "needs adapter: ";
1166                                // printTyVarMap( std::cerr, scopeTyVars );
1167                                // std::cerr << *env << std::endl;
1168                                // change the application so it calls the adapter rather than the passed function
1169                                ret = applyAdapter( appExpr, function, arg, scopeTyVars );
1170                        } // if
1171                        arg = appExpr->get_args().begin();
1172
1173                        Type *concRetType = replaceWithConcrete( appExpr, dynRetType );
1174                        passTypeVars( appExpr, concRetType, arg, exprTyVars ); // xxx - used to use dynRetType instead of concRetType; this changed so that the correct type paramaters are passed for return types (it should be the concrete type's parameters, not the formal type's)
1175                        addInferredParams( appExpr, function, arg, exprTyVars );
1176
1177                        arg = paramBegin;
1178
1179                        boxParams( appExpr, function, arg, exprTyVars );
1180                        passAdapters( appExpr, function, exprTyVars );
1181
1182                        return ret;
1183                }
1184
1185                Expression *Pass1::mutate( UntypedExpr *expr ) {
1186                        if ( expr->has_result() && isPolyType( expr->get_result(), scopeTyVars, env ) ) {
1187                                if ( NameExpr *name = dynamic_cast< NameExpr *>( expr->get_function() ) ) {
1188                                        if ( name->get_name() == "*?" ) {
1189                                                Expression *ret = expr->get_args().front();
1190                                                expr->get_args().clear();
1191                                                delete expr;
1192                                                return ret->acceptMutator( *this );
1193                                        } // if
1194                                } // if
1195                        } // if
1196                        return PolyMutator::mutate( expr );
1197                }
1198
1199                Expression *Pass1::mutate( AddressExpr *addrExpr ) {
1200                        assert( addrExpr->get_arg()->has_result() && ! addrExpr->get_arg()->get_result()->isVoid() );
1201
1202                        bool needs = false;
1203                        if ( UntypedExpr *expr = dynamic_cast< UntypedExpr *>( addrExpr->get_arg() ) ) {
1204                                if ( expr->has_result() && isPolyType( expr->get_result(), scopeTyVars, env ) ) {
1205                                        if ( NameExpr *name = dynamic_cast< NameExpr *>( expr->get_function() ) ) {
1206                                                if ( name->get_name() == "*?" ) {
1207                                                        if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( expr->get_args().front() ) ) {
1208                                                                assert( appExpr->get_function()->has_result() );
1209                                                                PointerType *pointer = safe_dynamic_cast< PointerType *>( appExpr->get_function()->get_result() );
1210                                                                FunctionType *function = safe_dynamic_cast< FunctionType *>( pointer->get_base() );
1211                                                                needs = needsAdapter( function, scopeTyVars );
1212                                                        } // if
1213                                                } // if
1214                                        } // if
1215                                } // if
1216                        } // if
1217                        // isPolyType check needs to happen before mutating addrExpr arg, so pull it forward
1218                        // out of the if condition.
1219                        bool polytype = isPolyType( addrExpr->get_arg()->get_result(), scopeTyVars, env );
1220                        addrExpr->set_arg( mutateExpression( addrExpr->get_arg() ) );
1221                        if ( polytype || needs ) {
1222                                Expression *ret = addrExpr->get_arg();
1223                                delete ret->get_result();
1224                                ret->set_result( addrExpr->get_result()->clone() );
1225                                addrExpr->set_arg( 0 );
1226                                delete addrExpr;
1227                                return ret;
1228                        } else {
1229                                return addrExpr;
1230                        } // if
1231                }
1232
1233                Statement * Pass1::mutate( ReturnStmt *returnStmt ) {
1234                        if ( retval && returnStmt->get_expr() ) {
1235                                assert( returnStmt->get_expr()->has_result() && ! returnStmt->get_expr()->get_result()->isVoid() );
1236                                delete returnStmt->get_expr();
1237                                returnStmt->set_expr( 0 );
1238                        } else {
1239                                returnStmt->set_expr( mutateExpression( returnStmt->get_expr() ) );
1240                        } // if
1241                        return returnStmt;
1242                }
1243
1244                Type * Pass1::mutate( PointerType *pointerType ) {
1245                        scopeTyVars.beginScope();
1246                        makeTyVarMap( pointerType, scopeTyVars );
1247
1248                        Type *ret = Mutator::mutate( pointerType );
1249
1250                        scopeTyVars.endScope();
1251                        return ret;
1252                }
1253
1254                Type * Pass1::mutate( FunctionType *functionType ) {
1255                        scopeTyVars.beginScope();
1256                        makeTyVarMap( functionType, scopeTyVars );
1257
1258                        Type *ret = Mutator::mutate( functionType );
1259
1260                        scopeTyVars.endScope();
1261                        return ret;
1262                }
1263
1264                void Pass1::doBeginScope() {
1265                        adapters.beginScope();
1266                }
1267
1268                void Pass1::doEndScope() {
1269                        adapters.endScope();
1270                }
1271
1272////////////////////////////////////////// Pass2 ////////////////////////////////////////////////////
1273
1274                void Pass2::addAdapters( FunctionType *functionType ) {
1275                        std::list< DeclarationWithType *> &paramList = functionType->get_parameters();
1276                        std::list< FunctionType *> functions;
1277                        for ( std::list< DeclarationWithType *>::iterator arg = paramList.begin(); arg != paramList.end(); ++arg ) {
1278                                Type *orig = (*arg)->get_type();
1279                                findAndReplaceFunction( orig, functions, scopeTyVars, needsAdapter );
1280                                (*arg)->set_type( orig );
1281                        }
1282                        std::set< std::string > adaptersDone;
1283                        for ( std::list< FunctionType *>::iterator funType = functions.begin(); funType != functions.end(); ++funType ) {
1284                                std::string mangleName = mangleAdapterName( *funType, scopeTyVars );
1285                                if ( adaptersDone.find( mangleName ) == adaptersDone.end() ) {
1286                                        std::string adapterName = makeAdapterName( mangleName );
1287                                        paramList.push_front( new ObjectDecl( adapterName, Type::StorageClasses(), LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), makeAdapterType( *funType, scopeTyVars ) ), 0 ) );
1288                                        adaptersDone.insert( adaptersDone.begin(), mangleName );
1289                                }
1290                        }
1291//  deleteAll( functions );
1292                }
1293
1294                template< typename DeclClass >
1295                DeclClass * Pass2::handleDecl( DeclClass *decl ) {
1296                        DeclClass *ret = static_cast< DeclClass *>( Parent::mutate( decl ) );
1297
1298                        return ret;
1299                }
1300
1301                /// determines if `pref` is a prefix of `str`
1302                bool isPrefix( const std::string & str, const std::string & pref ) {
1303                        if ( pref.size() > str.size() ) return false;
1304                        auto its = std::mismatch( pref.begin(), pref.end(), str.begin() );
1305                        return its.first == pref.end();
1306                }
1307
1308                DeclarationWithType * Pass2::mutate( FunctionDecl *functionDecl ) {
1309                        functionDecl = safe_dynamic_cast< FunctionDecl * > ( handleDecl( functionDecl ) );
1310                        FunctionType * ftype = functionDecl->get_functionType();
1311                        if ( ! ftype->get_returnVals().empty() && functionDecl->get_statements() ) {
1312                                if ( ! isPrefix( functionDecl->get_name(), "_thunk" ) && ! isPrefix( functionDecl->get_name(), "_adapter" ) ) { // xxx - remove check for prefix once thunks properly use ctor/dtors
1313                                        assert( ftype->get_returnVals().size() == 1 );
1314                                        DeclarationWithType * retval = ftype->get_returnVals().front();
1315                                        if ( retval->get_name() == "" ) {
1316                                                retval->set_name( "_retval" );
1317                                        }
1318                                        functionDecl->get_statements()->get_kids().push_front( new DeclStmt( noLabels, retval ) );
1319                                        DeclarationWithType * newRet = retval->clone(); // for ownership purposes
1320                                        ftype->get_returnVals().front() = newRet;
1321                                }
1322                        }
1323                        // errors should have been caught by this point, remove initializers from parameters to allow correct codegen of default arguments
1324                        for ( Declaration * param : functionDecl->get_functionType()->get_parameters() ) {
1325                                if ( ObjectDecl * obj = dynamic_cast< ObjectDecl * >( param ) ) {
1326                                        delete obj->get_init();
1327                                        obj->set_init( nullptr );
1328                                }
1329                        }
1330                        return functionDecl;
1331                }
1332
1333                ObjectDecl * Pass2::mutate( ObjectDecl *objectDecl ) {
1334                        return handleDecl( objectDecl );
1335                }
1336
1337                template< typename AggDecl >
1338                AggDecl * Pass2::handleAggDecl( AggDecl * aggDecl ) {
1339                        // prevent tyVars from leaking into containing scope
1340                        scopeTyVars.beginScope();
1341                        Parent::mutate( aggDecl );
1342                        scopeTyVars.endScope();
1343                        return aggDecl;
1344                }
1345
1346                StructDecl * Pass2::mutate( StructDecl *aggDecl ) {
1347                        return handleAggDecl( aggDecl );
1348                }
1349
1350                UnionDecl * Pass2::mutate( UnionDecl *aggDecl ) {
1351                        return handleAggDecl( aggDecl );
1352                }
1353
1354                TypeDecl * Pass2::mutate( TypeDecl *typeDecl ) {
1355                        addToTyVarMap( typeDecl, scopeTyVars );
1356                        if ( typeDecl->get_base() ) {
1357                                return handleDecl( typeDecl );
1358                        } else {
1359                                return Parent::mutate( typeDecl );
1360                        }
1361                }
1362
1363                TypedefDecl * Pass2::mutate( TypedefDecl *typedefDecl ) {
1364                        return handleDecl( typedefDecl );
1365                }
1366
1367                Type * Pass2::mutate( PointerType *pointerType ) {
1368                        scopeTyVars.beginScope();
1369                        makeTyVarMap( pointerType, scopeTyVars );
1370
1371                        Type *ret = Parent::mutate( pointerType );
1372
1373                        scopeTyVars.endScope();
1374                        return ret;
1375                }
1376
1377                Type *Pass2::mutate( FunctionType *funcType ) {
1378                        scopeTyVars.beginScope();
1379                        makeTyVarMap( funcType, scopeTyVars );
1380
1381                        // move polymorphic return type to parameter list
1382                        if ( isDynRet( funcType ) ) {
1383                                ObjectDecl *ret = safe_dynamic_cast< ObjectDecl* >( funcType->get_returnVals().front() );
1384                                ret->set_type( new PointerType( Type::Qualifiers(), ret->get_type() ) );
1385                                funcType->get_parameters().push_front( ret );
1386                                funcType->get_returnVals().pop_front();
1387                                ret->set_init( nullptr ); // xxx - memory leak?
1388                        }
1389
1390                        // add size/align and assertions for type parameters to parameter list
1391                        std::list< DeclarationWithType *>::iterator last = funcType->get_parameters().begin();
1392                        std::list< DeclarationWithType *> inferredParams;
1393                        ObjectDecl newObj( "", Type::StorageClasses(), LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0 );
1394                        ObjectDecl newPtr( "", Type::StorageClasses(), LinkageSpec::C, 0,
1395                                           new PointerType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) ), 0 );
1396                        for ( Type::ForallList::const_iterator tyParm = funcType->get_forall().begin(); tyParm != funcType->get_forall().end(); ++tyParm ) {
1397                                ObjectDecl *sizeParm, *alignParm;
1398                                // add all size and alignment parameters to parameter list
1399                                if ( (*tyParm)->isComplete() ) {
1400                                        TypeInstType parmType( Type::Qualifiers(), (*tyParm)->get_name(), *tyParm );
1401                                        std::string parmName = mangleType( &parmType );
1402
1403                                        sizeParm = newObj.clone();
1404                                        sizeParm->set_name( sizeofName( parmName ) );
1405                                        last = funcType->get_parameters().insert( last, sizeParm );
1406                                        ++last;
1407
1408                                        alignParm = newObj.clone();
1409                                        alignParm->set_name( alignofName( parmName ) );
1410                                        last = funcType->get_parameters().insert( last, alignParm );
1411                                        ++last;
1412                                }
1413                                // move all assertions into parameter list
1414                                for ( std::list< DeclarationWithType *>::iterator assert = (*tyParm)->get_assertions().begin(); assert != (*tyParm)->get_assertions().end(); ++assert ) {
1415//      *assert = (*assert)->acceptMutator( *this );
1416                                        inferredParams.push_back( *assert );
1417                                }
1418                                (*tyParm)->get_assertions().clear();
1419                        }
1420
1421                        // add size/align for generic parameter types to parameter list
1422                        std::set< std::string > seenTypes; // sizeofName for generic types we've seen
1423                        for ( std::list< DeclarationWithType* >::const_iterator fnParm = last; fnParm != funcType->get_parameters().end(); ++fnParm ) {
1424                                Type *polyType = isPolyType( (*fnParm)->get_type(), scopeTyVars );
1425                                if ( polyType && ! dynamic_cast< TypeInstType* >( polyType ) ) {
1426                                        std::string typeName = mangleType( polyType );
1427                                        if ( seenTypes.count( typeName ) ) continue;
1428
1429                                        ObjectDecl *sizeParm, *alignParm, *offsetParm;
1430                                        sizeParm = newObj.clone();
1431                                        sizeParm->set_name( sizeofName( typeName ) );
1432                                        last = funcType->get_parameters().insert( last, sizeParm );
1433                                        ++last;
1434
1435                                        alignParm = newObj.clone();
1436                                        alignParm->set_name( alignofName( typeName ) );
1437                                        last = funcType->get_parameters().insert( last, alignParm );
1438                                        ++last;
1439
1440                                        if ( StructInstType *polyBaseStruct = dynamic_cast< StructInstType* >( polyType ) ) {
1441                                                // NOTE zero-length arrays are illegal in C, so empty structs have no offset array
1442                                                if ( ! polyBaseStruct->get_baseStruct()->get_members().empty() ) {
1443                                                        offsetParm = newPtr.clone();
1444                                                        offsetParm->set_name( offsetofName( typeName ) );
1445                                                        last = funcType->get_parameters().insert( last, offsetParm );
1446                                                        ++last;
1447                                                }
1448                                        }
1449
1450                                        seenTypes.insert( typeName );
1451                                }
1452                        }
1453
1454                        // splice assertion parameters into parameter list
1455                        funcType->get_parameters().splice( last, inferredParams );
1456                        addAdapters( funcType );
1457                        mutateAll( funcType->get_returnVals(), *this );
1458                        mutateAll( funcType->get_parameters(), *this );
1459
1460                        scopeTyVars.endScope();
1461                        return funcType;
1462                }
1463
1464////////////////////////////////////////// PolyGenericCalculator ////////////////////////////////////////////////////
1465
1466                PolyGenericCalculator::PolyGenericCalculator()
1467                        : Parent(), knownLayouts(), knownOffsets(), bufNamer( "_buf" ) {}
1468
1469                void PolyGenericCalculator::beginTypeScope( Type *ty ) {
1470                        scopeTyVars.beginScope();
1471                        makeTyVarMap( ty, scopeTyVars );
1472                }
1473
1474                void PolyGenericCalculator::endTypeScope() {
1475                        scopeTyVars.endScope();
1476                }
1477
1478                template< typename DeclClass >
1479                DeclClass * PolyGenericCalculator::handleDecl( DeclClass *decl, Type *type ) {
1480                        beginTypeScope( type );
1481                        // knownLayouts.beginScope();
1482                        // knownOffsets.beginScope();
1483
1484                        DeclClass *ret = static_cast< DeclClass *>( Parent::mutate( decl ) );
1485
1486                        // knownOffsets.endScope();
1487                        // knownLayouts.endScope();
1488                        endTypeScope();
1489                        return ret;
1490                }
1491
1492                ObjectDecl * PolyGenericCalculator::mutate( ObjectDecl *objectDecl ) {
1493                        return handleDecl( objectDecl, objectDecl->get_type() );
1494                }
1495
1496                DeclarationWithType * PolyGenericCalculator::mutate( FunctionDecl *functionDecl ) {
1497                        knownLayouts.beginScope();
1498                        knownOffsets.beginScope();
1499
1500                        DeclarationWithType * decl = handleDecl( functionDecl, functionDecl->get_functionType() );
1501                        knownOffsets.endScope();
1502                        knownLayouts.endScope();
1503                        return decl;
1504                }
1505
1506                TypedefDecl * PolyGenericCalculator::mutate( TypedefDecl *typedefDecl ) {
1507                        return handleDecl( typedefDecl, typedefDecl->get_base() );
1508                }
1509
1510                TypeDecl * PolyGenericCalculator::mutate( TypeDecl *typeDecl ) {
1511                        addToTyVarMap( typeDecl, scopeTyVars );
1512                        return Parent::mutate( typeDecl );
1513                }
1514
1515                Type * PolyGenericCalculator::mutate( PointerType *pointerType ) {
1516                        beginTypeScope( pointerType );
1517
1518                        Type *ret = Parent::mutate( pointerType );
1519
1520                        endTypeScope();
1521                        return ret;
1522                }
1523
1524                Type * PolyGenericCalculator::mutate( FunctionType *funcType ) {
1525                        beginTypeScope( funcType );
1526
1527                        // make sure that any type information passed into the function is accounted for
1528                        for ( std::list< DeclarationWithType* >::const_iterator fnParm = funcType->get_parameters().begin(); fnParm != funcType->get_parameters().end(); ++fnParm ) {
1529                                // condition here duplicates that in Pass2::mutate( FunctionType* )
1530                                Type *polyType = isPolyType( (*fnParm)->get_type(), scopeTyVars );
1531                                if ( polyType && ! dynamic_cast< TypeInstType* >( polyType ) ) {
1532                                        knownLayouts.insert( mangleType( polyType ) );
1533                                }
1534                        }
1535
1536                        Type *ret = Parent::mutate( funcType );
1537
1538                        endTypeScope();
1539                        return ret;
1540                }
1541
1542                Statement *PolyGenericCalculator::mutate( DeclStmt *declStmt ) {
1543                        if ( ObjectDecl *objectDecl = dynamic_cast< ObjectDecl *>( declStmt->get_decl() ) ) {
1544                                if ( findGeneric( objectDecl->get_type() ) ) {
1545                                        // change initialization of a polymorphic value object to allocate via a VLA
1546                                        // (alloca was previously used, but can't be safely used in loops)
1547                                        Type *declType = objectDecl->get_type();
1548                                        std::string bufName = bufNamer.newName();
1549                                        ObjectDecl *newBuf = new ObjectDecl( bufName, Type::StorageClasses(), LinkageSpec::C, 0,
1550                                                new ArrayType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::Kind::Char), new NameExpr( sizeofName( mangleType(declType) ) ),
1551                                                true, false, std::list<Attribute*>{ new Attribute( std::string{"aligned"}, std::list<Expression*>{ new ConstantExpr( Constant::from_int(8) ) } ) } ), 0 );
1552                                        stmtsToAdd.push_back( new DeclStmt( noLabels, newBuf ) );
1553
1554                                        delete objectDecl->get_init();
1555
1556                                        objectDecl->set_init( new SingleInit( new NameExpr( bufName ) ) );
1557                                }
1558                        }
1559                        return Parent::mutate( declStmt );
1560                }
1561
1562                /// Finds the member in the base list that matches the given declaration; returns its index, or -1 if not present
1563                long findMember( DeclarationWithType *memberDecl, std::list< Declaration* > &baseDecls ) {
1564                        long i = 0;
1565                        for(std::list< Declaration* >::const_iterator decl = baseDecls.begin(); decl != baseDecls.end(); ++decl, ++i ) {
1566                                if ( memberDecl->get_name() != (*decl)->get_name() ) continue;
1567
1568                                if ( DeclarationWithType *declWithType = dynamic_cast< DeclarationWithType* >( *decl ) ) {
1569                                        if ( memberDecl->get_mangleName().empty() || declWithType->get_mangleName().empty()
1570                                             || memberDecl->get_mangleName() == declWithType->get_mangleName() ) return i;
1571                                        else continue;
1572                                } else return i;
1573                        }
1574                        return -1;
1575                }
1576
1577                /// Returns an index expression into the offset array for a type
1578                Expression *makeOffsetIndex( Type *objectType, long i ) {
1579                        ConstantExpr *fieldIndex = new ConstantExpr( Constant::from_ulong( i ) );
1580                        UntypedExpr *fieldOffset = new UntypedExpr( new NameExpr( "?[?]" ) );
1581                        fieldOffset->get_args().push_back( new NameExpr( offsetofName( mangleType( objectType ) ) ) );
1582                        fieldOffset->get_args().push_back( fieldIndex );
1583                        return fieldOffset;
1584                }
1585
1586                Expression *PolyGenericCalculator::mutate( MemberExpr *memberExpr ) {
1587                        // mutate, exiting early if no longer MemberExpr
1588                        Expression *expr = Parent::mutate( memberExpr );
1589                        memberExpr = dynamic_cast< MemberExpr* >( expr );
1590                        if ( ! memberExpr ) return expr;
1591
1592                        // only mutate member expressions for polymorphic types
1593                        int tyDepth;
1594                        Type *objectType = hasPolyBase( memberExpr->get_aggregate()->get_result(), scopeTyVars, &tyDepth );
1595                        if ( ! objectType ) return memberExpr;
1596                        findGeneric( objectType ); // ensure layout for this type is available
1597
1598                        // replace member expression with dynamically-computed layout expression
1599                        Expression *newMemberExpr = 0;
1600                        if ( StructInstType *structType = dynamic_cast< StructInstType* >( objectType ) ) {
1601                                // look up offset index
1602                                long i = findMember( memberExpr->get_member(), structType->get_baseStruct()->get_members() );
1603                                if ( i == -1 ) return memberExpr;
1604
1605                                // replace member expression with pointer to base plus offset
1606                                UntypedExpr *fieldLoc = new UntypedExpr( new NameExpr( "?+?" ) );
1607                                Expression * aggr = memberExpr->get_aggregate()->clone();
1608                                delete aggr->get_env(); // xxx - there's a problem with keeping the env for some reason, so for now just get rid of it
1609                                aggr->set_env( nullptr );
1610                                fieldLoc->get_args().push_back( aggr );
1611                                fieldLoc->get_args().push_back( makeOffsetIndex( objectType, i ) );
1612                                fieldLoc->set_result( memberExpr->get_result()->clone() );
1613                                newMemberExpr = fieldLoc;
1614                        } else if ( dynamic_cast< UnionInstType* >( objectType ) ) {
1615                                // union members are all at offset zero, so just use the aggregate expr
1616                                Expression * aggr = memberExpr->get_aggregate()->clone();
1617                                delete aggr->get_env(); // xxx - there's a problem with keeping the env for some reason, so for now just get rid of it
1618                                aggr->set_env( nullptr );
1619                                newMemberExpr = aggr;
1620                                newMemberExpr->set_result( memberExpr->get_result()->clone() );
1621                        } else return memberExpr;
1622                        assert( newMemberExpr );
1623
1624                        Type *memberType = memberExpr->get_member()->get_type();
1625                        if ( ! isPolyType( memberType, scopeTyVars ) ) {
1626                                // Not all members of a polymorphic type are themselves of polymorphic type; in this case the member expression should be wrapped and dereferenced to form an lvalue
1627                                CastExpr *ptrCastExpr = new CastExpr( newMemberExpr, new PointerType( Type::Qualifiers(), memberType->clone() ) );
1628                                UntypedExpr *derefExpr = UntypedExpr::createDeref( ptrCastExpr );
1629                                newMemberExpr = derefExpr;
1630                        }
1631
1632                        delete memberExpr;
1633                        return newMemberExpr;
1634                }
1635
1636                ObjectDecl *PolyGenericCalculator::makeVar( const std::string &name, Type *type, Initializer *init ) {
1637                        ObjectDecl *newObj = new ObjectDecl( name, Type::StorageClasses(), LinkageSpec::C, 0, type, init );
1638                        stmtsToAdd.push_back( new DeclStmt( noLabels, newObj ) );
1639                        return newObj;
1640                }
1641
1642                void PolyGenericCalculator::addOtypeParamsToLayoutCall( UntypedExpr *layoutCall, const std::list< Type* > &otypeParams ) {
1643                        for ( std::list< Type* >::const_iterator param = otypeParams.begin(); param != otypeParams.end(); ++param ) {
1644                                if ( findGeneric( *param ) ) {
1645                                        // push size/align vars for a generic parameter back
1646                                        std::string paramName = mangleType( *param );
1647                                        layoutCall->get_args().push_back( new NameExpr( sizeofName( paramName ) ) );
1648                                        layoutCall->get_args().push_back( new NameExpr( alignofName( paramName ) ) );
1649                                } else {
1650                                        layoutCall->get_args().push_back( new SizeofExpr( (*param)->clone() ) );
1651                                        layoutCall->get_args().push_back( new AlignofExpr( (*param)->clone() ) );
1652                                }
1653                        }
1654                }
1655
1656                /// returns true if any of the otype parameters have a dynamic layout and puts all otype parameters in the output list
1657                bool findGenericParams( std::list< TypeDecl* > &baseParams, std::list< Expression* > &typeParams, std::list< Type* > &out ) {
1658                        bool hasDynamicLayout = false;
1659
1660                        std::list< TypeDecl* >::const_iterator baseParam = baseParams.begin();
1661                        std::list< Expression* >::const_iterator typeParam = typeParams.begin();
1662                        for ( ; baseParam != baseParams.end() && typeParam != typeParams.end(); ++baseParam, ++typeParam ) {
1663                                // skip non-otype parameters
1664                                if ( ! (*baseParam)->isComplete() ) continue;
1665                                TypeExpr *typeExpr = dynamic_cast< TypeExpr* >( *typeParam );
1666                                assert( typeExpr && "all otype parameters should be type expressions" );
1667
1668                                Type *type = typeExpr->get_type();
1669                                out.push_back( type );
1670                                if ( isPolyType( type ) ) hasDynamicLayout = true;
1671                        }
1672                        assert( baseParam == baseParams.end() && typeParam == typeParams.end() );
1673
1674                        return hasDynamicLayout;
1675                }
1676
1677                bool PolyGenericCalculator::findGeneric( Type *ty ) {
1678                        ty = replaceTypeInst( ty, env );
1679
1680                        if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( ty ) ) {
1681                                if ( scopeTyVars.find( typeInst->get_name() ) != scopeTyVars.end() ) {
1682                                        // NOTE assumes here that getting put in the scopeTyVars included having the layout variables set
1683                                        return true;
1684                                }
1685                                return false;
1686                        } else if ( StructInstType *structTy = dynamic_cast< StructInstType* >( ty ) ) {
1687                                // check if this type already has a layout generated for it
1688                                std::string typeName = mangleType( ty );
1689                                if ( knownLayouts.find( typeName ) != knownLayouts.end() ) return true;
1690
1691                                // check if any of the type parameters have dynamic layout; if none do, this type is (or will be) monomorphized
1692                                std::list< Type* > otypeParams;
1693                                if ( ! findGenericParams( *structTy->get_baseParameters(), structTy->get_parameters(), otypeParams ) ) return false;
1694
1695                                // insert local variables for layout and generate call to layout function
1696                                knownLayouts.insert( typeName );  // done early so as not to interfere with the later addition of parameters to the layout call
1697                                Type *layoutType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt );
1698
1699                                int n_members = structTy->get_baseStruct()->get_members().size();
1700                                if ( n_members == 0 ) {
1701                                        // all empty structs have the same layout - size 1, align 1
1702                                        makeVar( sizeofName( typeName ), layoutType, new SingleInit( new ConstantExpr( Constant::from_ulong( (unsigned long)1 ) ) ) );
1703                                        makeVar( alignofName( typeName ), layoutType->clone(), new SingleInit( new ConstantExpr( Constant::from_ulong( (unsigned long)1 ) ) ) );
1704                                        // NOTE zero-length arrays are forbidden in C, so empty structs have no offsetof array
1705                                } else {
1706                                        ObjectDecl *sizeVar = makeVar( sizeofName( typeName ), layoutType );
1707                                        ObjectDecl *alignVar = makeVar( alignofName( typeName ), layoutType->clone() );
1708                                        ObjectDecl *offsetVar = makeVar( offsetofName( typeName ), new ArrayType( Type::Qualifiers(), layoutType->clone(), new ConstantExpr( Constant::from_int( n_members ) ), false, false ) );
1709
1710                                        // generate call to layout function
1711                                        UntypedExpr *layoutCall = new UntypedExpr( new NameExpr( layoutofName( structTy->get_baseStruct() ) ) );
1712                                        layoutCall->get_args().push_back( new AddressExpr( new VariableExpr( sizeVar ) ) );
1713                                        layoutCall->get_args().push_back( new AddressExpr( new VariableExpr( alignVar ) ) );
1714                                        layoutCall->get_args().push_back( new VariableExpr( offsetVar ) );
1715                                        addOtypeParamsToLayoutCall( layoutCall, otypeParams );
1716
1717                                        stmtsToAdd.push_back( new ExprStmt( noLabels, layoutCall ) );
1718                                }
1719
1720                                return true;
1721                        } else if ( UnionInstType *unionTy = dynamic_cast< UnionInstType* >( ty ) ) {
1722                                // check if this type already has a layout generated for it
1723                                std::string typeName = mangleType( ty );
1724                                if ( knownLayouts.find( typeName ) != knownLayouts.end() ) return true;
1725
1726                                // check if any of the type parameters have dynamic layout; if none do, this type is (or will be) monomorphized
1727                                std::list< Type* > otypeParams;
1728                                if ( ! findGenericParams( *unionTy->get_baseParameters(), unionTy->get_parameters(), otypeParams ) ) return false;
1729
1730                                // insert local variables for layout and generate call to layout function
1731                                knownLayouts.insert( typeName );  // done early so as not to interfere with the later addition of parameters to the layout call
1732                                Type *layoutType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt );
1733
1734                                ObjectDecl *sizeVar = makeVar( sizeofName( typeName ), layoutType );
1735                                ObjectDecl *alignVar = makeVar( alignofName( typeName ), layoutType->clone() );
1736
1737                                // generate call to layout function
1738                                UntypedExpr *layoutCall = new UntypedExpr( new NameExpr( layoutofName( unionTy->get_baseUnion() ) ) );
1739                                layoutCall->get_args().push_back( new AddressExpr( new VariableExpr( sizeVar ) ) );
1740                                layoutCall->get_args().push_back( new AddressExpr( new VariableExpr( alignVar ) ) );
1741                                addOtypeParamsToLayoutCall( layoutCall, otypeParams );
1742
1743                                stmtsToAdd.push_back( new ExprStmt( noLabels, layoutCall ) );
1744
1745                                return true;
1746                        }
1747
1748                        return false;
1749                }
1750
1751                Expression *PolyGenericCalculator::mutate( SizeofExpr *sizeofExpr ) {
1752                        Type *ty = sizeofExpr->get_isType() ? sizeofExpr->get_type() : sizeofExpr->get_expr()->get_result();
1753                        if ( findGeneric( ty ) ) {
1754                                Expression *ret = new NameExpr( sizeofName( mangleType( ty ) ) );
1755                                delete sizeofExpr;
1756                                return ret;
1757                        }
1758                        return sizeofExpr;
1759                }
1760
1761                Expression *PolyGenericCalculator::mutate( AlignofExpr *alignofExpr ) {
1762                        Type *ty = alignofExpr->get_isType() ? alignofExpr->get_type() : alignofExpr->get_expr()->get_result();
1763                        if ( findGeneric( ty ) ) {
1764                                Expression *ret = new NameExpr( alignofName( mangleType( ty ) ) );
1765                                delete alignofExpr;
1766                                return ret;
1767                        }
1768                        return alignofExpr;
1769                }
1770
1771                Expression *PolyGenericCalculator::mutate( OffsetofExpr *offsetofExpr ) {
1772                        // mutate, exiting early if no longer OffsetofExpr
1773                        Expression *expr = Parent::mutate( offsetofExpr );
1774                        offsetofExpr = dynamic_cast< OffsetofExpr* >( expr );
1775                        if ( ! offsetofExpr ) return expr;
1776
1777                        // only mutate expressions for polymorphic structs/unions
1778                        Type *ty = offsetofExpr->get_type();
1779                        if ( ! findGeneric( ty ) ) return offsetofExpr;
1780
1781                        if ( StructInstType *structType = dynamic_cast< StructInstType* >( ty ) ) {
1782                                // replace offsetof expression by index into offset array
1783                                long i = findMember( offsetofExpr->get_member(), structType->get_baseStruct()->get_members() );
1784                                if ( i == -1 ) return offsetofExpr;
1785
1786                                Expression *offsetInd = makeOffsetIndex( ty, i );
1787                                delete offsetofExpr;
1788                                return offsetInd;
1789                        } else if ( dynamic_cast< UnionInstType* >( ty ) ) {
1790                                // all union members are at offset zero
1791                                delete offsetofExpr;
1792                                return new ConstantExpr( Constant::from_ulong( 0 ) );
1793                        } else return offsetofExpr;
1794                }
1795
1796                Expression *PolyGenericCalculator::mutate( OffsetPackExpr *offsetPackExpr ) {
1797                        StructInstType *ty = offsetPackExpr->get_type();
1798
1799                        Expression *ret = 0;
1800                        if ( findGeneric( ty ) ) {
1801                                // pull offset back from generated type information
1802                                ret = new NameExpr( offsetofName( mangleType( ty ) ) );
1803                        } else {
1804                                std::string offsetName = offsetofName( mangleType( ty ) );
1805                                if ( knownOffsets.find( offsetName ) != knownOffsets.end() ) {
1806                                        // use the already-generated offsets for this type
1807                                        ret = new NameExpr( offsetName );
1808                                } else {
1809                                        knownOffsets.insert( offsetName );
1810
1811                                        std::list< Declaration* > &baseMembers = ty->get_baseStruct()->get_members();
1812                                        Type *offsetType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt );
1813
1814                                        // build initializer list for offset array
1815                                        std::list< Initializer* > inits;
1816                                        for ( std::list< Declaration* >::const_iterator member = baseMembers.begin(); member != baseMembers.end(); ++member ) {
1817                                                if ( DeclarationWithType *memberDecl = dynamic_cast< DeclarationWithType* >( *member ) ) {
1818                                                        inits.push_back( new SingleInit( new OffsetofExpr( ty->clone(), memberDecl ) ) );
1819                                                } else {
1820                                                        assertf( false, "Requesting offset of Non-DWT member: %s", toString( *member ).c_str() );
1821                                                }
1822                                        }
1823
1824                                        // build the offset array and replace the pack with a reference to it
1825                                        ObjectDecl *offsetArray = makeVar( offsetName, new ArrayType( Type::Qualifiers(), offsetType, new ConstantExpr( Constant::from_ulong( baseMembers.size() ) ), false, false ),
1826                                                        new ListInit( inits ) );
1827                                        ret = new VariableExpr( offsetArray );
1828                                }
1829                        }
1830
1831                        delete offsetPackExpr;
1832                        return ret;
1833                }
1834
1835                void PolyGenericCalculator::doBeginScope() {
1836                        knownLayouts.beginScope();
1837                        knownOffsets.beginScope();
1838                }
1839
1840                void PolyGenericCalculator::doEndScope() {
1841                        knownLayouts.endScope();
1842                        knownOffsets.endScope();
1843                }
1844
1845////////////////////////////////////////// Pass3 ////////////////////////////////////////////////////
1846
1847                template< typename DeclClass >
1848                DeclClass * Pass3::handleDecl( DeclClass *decl, Type *type ) {
1849                        scopeTyVars.beginScope();
1850                        makeTyVarMap( type, scopeTyVars );
1851
1852                        DeclClass *ret = static_cast< DeclClass *>( Mutator::mutate( decl ) );
1853                        // ScrubTyVars::scrub( decl, scopeTyVars );
1854                        ScrubTyVars::scrubAll( decl );
1855
1856                        scopeTyVars.endScope();
1857                        return ret;
1858                }
1859
1860                ObjectDecl * Pass3::mutate( ObjectDecl *objectDecl ) {
1861                        return handleDecl( objectDecl, objectDecl->get_type() );
1862                }
1863
1864                DeclarationWithType * Pass3::mutate( FunctionDecl *functionDecl ) {
1865                        return handleDecl( functionDecl, functionDecl->get_functionType() );
1866                }
1867
1868                TypedefDecl * Pass3::mutate( TypedefDecl *typedefDecl ) {
1869                        return handleDecl( typedefDecl, typedefDecl->get_base() );
1870                }
1871
1872                /// Strips the members from a generic aggregate
1873                void stripGenericMembers(AggregateDecl* decl) {
1874                        if ( ! decl->get_parameters().empty() ) decl->get_members().clear();
1875                }
1876
1877                Declaration *Pass3::mutate( StructDecl *structDecl ) {
1878                        stripGenericMembers( structDecl );
1879                        return structDecl;
1880                }
1881               
1882                Declaration *Pass3::mutate( UnionDecl *unionDecl ) {
1883                        stripGenericMembers( unionDecl );
1884                        return unionDecl;
1885                }
1886
1887                TypeDecl * Pass3::mutate( TypeDecl *typeDecl ) {
1888//   Initializer *init = 0;
1889//   std::list< Expression *> designators;
1890//   addToTyVarMap( typeDecl, scopeTyVars );
1891//   if ( typeDecl->get_base() ) {
1892//     init = new SimpleInit( new SizeofExpr( handleDecl( typeDecl, typeDecl->get_base() ) ), designators );
1893//   }
1894//   return new ObjectDecl( typeDecl->get_name(), Declaration::Extern, LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::UnsignedInt ), init );
1895
1896                        addToTyVarMap( typeDecl, scopeTyVars );
1897                        return Mutator::mutate( typeDecl );
1898                }
1899
1900                Type * Pass3::mutate( PointerType *pointerType ) {
1901                        scopeTyVars.beginScope();
1902                        makeTyVarMap( pointerType, scopeTyVars );
1903
1904                        Type *ret = Mutator::mutate( pointerType );
1905
1906                        scopeTyVars.endScope();
1907                        return ret;
1908                }
1909
1910                Type * Pass3::mutate( FunctionType *functionType ) {
1911                        scopeTyVars.beginScope();
1912                        makeTyVarMap( functionType, scopeTyVars );
1913
1914                        Type *ret = Mutator::mutate( functionType );
1915
1916                        scopeTyVars.endScope();
1917                        return ret;
1918                }
1919        } // anonymous namespace
1920} // namespace GenPoly
1921
1922// Local Variables: //
1923// tab-width: 4 //
1924// mode: c++ //
1925// compile-command: "make install" //
1926// End: //
Note: See TracBrowser for help on using the repository browser.