Index: src/GenPoly/Box.cc
===================================================================
--- src/GenPoly/Box.cc	(revision 2edd80ae7bb41eee0783cfcc80573f533b6ee760)
+++ src/GenPoly/Box.cc	(revision f6cc2096d769efbc869dcf738710880abb631748)
@@ -27,6 +27,7 @@
 #include "Box.h"
 #include "DeclMutator.h"
+#include "Lvalue.h"
+#include "FindFunction.h"
 #include "PolyMutator.h"
-#include "FindFunction.h"
 #include "ScopedSet.h"
 #include "ScrubTyVars.h"
@@ -755,17 +756,15 @@
 
 		void Pass1::boxParam( Type *param, Expression *&arg, const TyVarMap &exprTyVars ) {
-			assert( arg->has_result() );
+			assertf( arg->has_result(), "arg does not have result: %s", toString( arg ).c_str() );
 			if ( isPolyType( param, exprTyVars ) ) {
-				if ( isPolyType( arg->get_result() ) ) {
+				Type * newType = arg->get_result()->clone();
+				if ( env ) env->apply( newType );
+				std::auto_ptr<Type> manager( newType );
+				if ( isPolyType( newType ) ) {
 					// if the argument's type is polymorphic, we don't need to box again!
 					return;
 				} else if ( arg->get_result()->get_lvalue() ) {
-					// VariableExpr and MemberExpr are lvalues; need to check this isn't coming from the second arg of a comma expression though (not an lvalue)
-					// xxx - need to test that this code is still reachable
-					if ( CommaExpr *commaArg = dynamic_cast< CommaExpr* >( arg ) ) {
-						commaArg->set_arg2( new AddressExpr( commaArg->get_arg2() ) );
-					} else {
-						arg = new AddressExpr( arg );
-					}
+					// argument expression may be CFA lvalue, but not C lvalue -- apply generalizedLvalue transformations.
+					arg =  generalizedLvalue( new AddressExpr( arg ) );
 					if ( ! ResolvExpr::typesCompatible( param, arg->get_result(), SymTab::Indexer() ) ) {
 						// silence warnings by casting boxed parameters when the actual type does not match up with the formal type.
@@ -1879,5 +1878,5 @@
 			return structDecl;
 		}
-		
+
 		Declaration *Pass3::mutate( UnionDecl *unionDecl ) {
 			stripGenericMembers( unionDecl );
Index: src/GenPoly/Lvalue.cc
===================================================================
--- src/GenPoly/Lvalue.cc	(revision 2edd80ae7bb41eee0783cfcc80573f533b6ee760)
+++ src/GenPoly/Lvalue.cc	(revision f6cc2096d769efbc869dcf738710880abb631748)
@@ -27,6 +27,9 @@
 #include "SynTree/Mutator.h"
 #include "SymTab/Indexer.h"
+
 #include "ResolvExpr/Resolver.h"
+#include "ResolvExpr/TypeEnvironment.h"
 #include "ResolvExpr/typeops.h"
+#include "ResolvExpr/Unify.h"
 
 #include "Common/UniqueName.h"
@@ -60,5 +63,9 @@
 			typedef Mutator Parent;
 
+			virtual Expression * mutate( MemberExpr * memExpr );
 			virtual Expression * mutate( AddressExpr * addressExpr );
+
+			template<typename Func>
+			Expression * applyTransformation( Expression * expr, Expression * arg, Func mkExpr );
 		};
 	} // namespace
@@ -71,4 +78,9 @@
 		acceptAll( translationUnit, p2 );
 		mutateAll( translationUnit, genLval );
+	}
+
+	Expression * generalizedLvalue( Expression * expr ) {
+		GeneralizedLvalue genLval;
+		return expr->acceptMutator( genLval );
 	}
 
@@ -163,19 +175,44 @@
 		}
 
-		Expression * GeneralizedLvalue::mutate( AddressExpr * addrExpr ) {
-			addrExpr = safe_dynamic_cast< AddressExpr * >( Parent::mutate( addrExpr ) );
-			if ( CommaExpr * commaExpr = dynamic_cast< CommaExpr * >( addrExpr->get_arg() ) ) {
+		template<typename Func>
+		Expression * GeneralizedLvalue::applyTransformation( Expression * expr, Expression * arg, Func mkExpr ) {
+			if ( CommaExpr * commaExpr = dynamic_cast< CommaExpr * >( arg ) ) {
 				Expression * arg1 = commaExpr->get_arg1()->clone();
 				Expression * arg2 = commaExpr->get_arg2()->clone();
-				delete addrExpr;
-				return new CommaExpr( arg1, new AddressExpr( arg2 ) );
-			} else if ( ConditionalExpr * condExpr = dynamic_cast< ConditionalExpr * >( addrExpr->get_arg() ) ) {
+				Expression * ret = new CommaExpr( arg1, mkExpr( arg2 ) );
+				ret->set_env( expr->get_env() );
+				expr->set_env( nullptr );
+				delete expr;
+				return ret->acceptMutator( *this );
+			} else if ( ConditionalExpr * condExpr = dynamic_cast< ConditionalExpr * >( arg ) ) {
 				Expression * arg1 = condExpr->get_arg1()->clone();
 				Expression * arg2 = condExpr->get_arg2()->clone();
 				Expression * arg3 = condExpr->get_arg3()->clone();
-				delete addrExpr;
-				return new ConditionalExpr( arg1, new AddressExpr( arg2 ), new AddressExpr( arg3 ) );
+				ConditionalExpr * ret = new ConditionalExpr( arg1, mkExpr( arg2 ), mkExpr( arg3 ) );
+				ret->set_env( expr->get_env() );
+				expr->set_env( nullptr );
+				delete expr;
+
+				// conditional expr type may not be either of the argument types, need to unify
+				using namespace ResolvExpr;
+				Type* commonType = nullptr;
+				TypeEnvironment newEnv;
+				AssertionSet needAssertions, haveAssertions;
+				OpenVarSet openVars;
+				unify( ret->get_arg2()->get_result(), ret->get_arg3()->get_result(), newEnv, needAssertions, haveAssertions, openVars, SymTab::Indexer(), commonType );
+				ret->set_result( commonType ? commonType : ret->get_arg2()->get_result()->clone() );
+				return ret->acceptMutator( *this );
 			}
-			return addrExpr;
+			return expr;
+		}
+
+		Expression * GeneralizedLvalue::mutate( MemberExpr * memExpr ) {
+			Parent::mutate( memExpr );
+			return applyTransformation( memExpr, memExpr->get_aggregate(), [=]( Expression * aggr ) { return new MemberExpr( memExpr->get_member(), aggr ); } );
+		}
+
+		Expression * GeneralizedLvalue::mutate( AddressExpr * addrExpr ) {
+			addrExpr = safe_dynamic_cast< AddressExpr * >( Parent::mutate( addrExpr ) );
+			return applyTransformation( addrExpr, addrExpr->get_arg(), []( Expression * arg ) { return new AddressExpr( arg ); } );
 		}
 	} // namespace
Index: src/GenPoly/Lvalue.h
===================================================================
--- src/GenPoly/Lvalue.h	(revision 2edd80ae7bb41eee0783cfcc80573f533b6ee760)
+++ src/GenPoly/Lvalue.h	(revision f6cc2096d769efbc869dcf738710880abb631748)
@@ -5,5 +5,5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// Lvalue.h -- 
+// Lvalue.h --
 //
 // Author           : Richard C. Bilson
@@ -23,4 +23,7 @@
 	/// replaces return type of `lvalue T` with `T*`, along with appropriate address-of and dereference operators
 	void convertLvalue( std::list< Declaration* >& translationUnit );
+
+	/// applies transformations that allow GCC to accept more complicated lvalue expressions, e.g. &(a, b)
+	Expression * generalizedLvalue( Expression * expr );
 } // namespace GenPoly