Context Navigation

source: src/GenPoly/Box.cc @ 43db35e

ADTast-experimental

Last change on this file since 43db35e was 18070ee, checked in by Thierry Delisle <tdelisle@…>, 2 years ago
Change box pass to scope better when polymorphic functions get assertions functions passed as parameter. fixes 214?
Property mode set to `100644`
File size: 90.4 KB

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: