X-Git-Url: http://git.tdb.fi/?p=libs%2Fgl.git;a=blobdiff_plain;f=source%2Fglsl%2Foptimize.cpp;h=6e4b56771fa3222ce778a53d37b828b5d34554cf;hp=1ebb87c5c2ea23360c33917104745273de6d8da0;hb=HEAD;hpb=bd8816692056230c36504dcccd76c6946dff47b1

diff --git a/source/glsl/optimize.cpp b/source/glsl/optimize.cpp
index 1ebb87c5..a35e2cd2 100644
--- a/source/glsl/optimize.cpp
+++ b/source/glsl/optimize.cpp
@@ -1,5 +1,9 @@
+#include <msp/core/algorithm.h>
 #include <msp/core/raii.h>
+#include <msp/strings/format.h>
+#include <msp/strings/utils.h>
 #include "optimize.h"
+#include "reflect.h"
 
 using namespace std;
 
@@ -7,443 +11,1556 @@ namespace Msp {
 namespace GL {
 namespace SL {
 
-InlineableFunctionLocator::InlineableFunctionLocator():
-	in_function(0)
-{ }
+void ConstantSpecializer::apply(Stage &stage, const map<string, int> &v)
+{
+	values = &v;
+	stage.content.visit(*this);
+}
+
+void ConstantSpecializer::visit(VariableDeclaration &var)
+{
+	bool specializable = false;
+	if(var.layout)
+	{
+		vector<Layout::Qualifier> &qualifiers = var.layout->qualifiers;
+		auto i = find_member(qualifiers, string("constant_id"), &Layout::Qualifier::name);
+		if(i!=qualifiers.end())
+		{
+			specializable = true;
+			qualifiers.erase(i);
+			if(qualifiers.empty())
+				var.layout = 0;
+		}
+	}
+
+	if(specializable)
+	{
+		auto i = values->find(var.name);
+		if(i!=values->end())
+		{
+			RefPtr<Literal> literal = new Literal;
+			if(var.type=="bool")
+			{
+				literal->token = (i->second ? "true" : "false");
+				literal->value = static_cast<bool>(i->second);
+			}
+			else if(var.type=="int")
+			{
+				literal->token = lexical_cast<string>(i->second);
+				literal->value = i->second;
+			}
+			var.init_expression = literal;
+		}
+	}
+}
+
+
+void InlineableFunctionLocator::visit(FunctionCall &call)
+{
+	FunctionDeclaration *def = call.declaration;
+	if(def)
+		def = def->definition;
+
+	if(def)
+	{
+		unsigned &count = refcounts[def];
+		++count;
+		/* Don't inline functions which are called more than once or are called
+		recursively. */
+		if((count>1 && def->source!=BUILTIN_SOURCE) || def==current_function)
+			inlineable.erase(def);
+	}
+
+	TraversingVisitor::visit(call);
+}
+
+void InlineableFunctionLocator::visit(FunctionDeclaration &func)
+{
+	bool has_out_params = any_of(func.parameters.begin(), func.parameters.end(),
+		[](const RefPtr<VariableDeclaration> &p){ return p->interface=="out"; });
+
+	unsigned &count = refcounts[func.definition];
+	if((count<=1 || func.source==BUILTIN_SOURCE) && !has_out_params)
+		inlineable.insert(func.definition);
+
+	SetForScope<FunctionDeclaration *> set(current_function, &func);
+	return_count = 0;
+	TraversingVisitor::visit(func);
+}
+
+void InlineableFunctionLocator::visit(Conditional &cond)
+{
+	TraversingVisitor::visit(cond);
+	inlineable.erase(current_function);
+}
+
+void InlineableFunctionLocator::visit(Iteration &iter)
+{
+	TraversingVisitor::visit(iter);
+	inlineable.erase(current_function);
+}
+
+void InlineableFunctionLocator::visit(Return &ret)
+{
+	TraversingVisitor::visit(ret);
+	if(return_count)
+		inlineable.erase(current_function);
+	++return_count;
+}
+
+
+string InlineContentInjector::apply(Stage &stage, FunctionDeclaration &target_func, Block &tgt_blk, const NodeList<Statement>::iterator &ins_pt, FunctionCall &call)
+{
+	source_func = call.declaration->definition;
+
+	/* Populate referenced_names from the target function so we can rename
+	variables from the inlined function that would conflict.  Only consider
+	names declared in blocks linearly related to the target block. */
+	pass = REFERENCED;
+	tgt_blk.visit(*this);
+	for(const Block *b=&tgt_blk; b; b=b->parent)
+		for(const auto &kvp: b->variables)
+			referenced_names.insert(kvp.first);
+	for(const auto &kvp: stage.interface_blocks)
+		if(kvp.second->name.find(' ')!=string::npos)
+			for(const auto &kvp2: kvp.second->block_declaration->members.variables)
+				referenced_names.insert(kvp2.first);
+
+	/* Inline and rename passes must be interleaved so used variable names are
+	known when inlining the return statement. */
+	pass = INLINE;
+	staging_block.parent = &tgt_blk;
+	staging_block.variables.clear();
+
+	vector<RefPtr<VariableDeclaration> > params;
+	params.reserve(source_func->parameters.size());
+	for(const RefPtr<VariableDeclaration> &p: source_func->parameters)
+	{
+		RefPtr<VariableDeclaration> var = p->clone();
+		var->interface.clear();
+
+		SetForScope<Pass> set_pass(pass, RENAME);
+		var->visit(*this);
+
+		staging_block.body.push_back_nocopy(var);
+		params.push_back(var);
+	}
+
+	for(const RefPtr<Statement> &s: source_func->body.body)
+	{
+		r_inlined_statement = 0;
+		s->visit(*this);
+		if(!r_inlined_statement)
+			r_inlined_statement = s->clone();
+
+		SetForScope<Pass> set_pass(pass, RENAME);
+		r_inlined_statement->visit(*this);
+
+		staging_block.body.push_back_nocopy(r_inlined_statement);
+	}
+
+	/* Now collect names from the staging block.  Local variables that would
+	have conflicted with the target function were renamed earlier. */
+	pass = REFERENCED;
+	referenced_names.clear();
+	staging_block.variables.clear();
+	staging_block.visit(*this);
+
+	/* Rename variables in the target function so they don't interfere with
+	global identifiers used by the source function. */
+	pass = RENAME;
+	staging_block.parent = source_func->body.parent;
+	target_func.visit(*this);
+
+	// Put the argument expressions in place after all renaming has been done.
+	for(unsigned i=0; i<source_func->parameters.size(); ++i)
+		params[i]->init_expression = call.arguments[i]->clone();
+
+	tgt_blk.body.splice(ins_pt, staging_block.body);
+
+	NodeReorderer().apply(stage, target_func, DependencyCollector().apply(*source_func));
+
+	return r_result_name;
+}
+
+void InlineContentInjector::visit(VariableReference &var)
+{
+	if(pass==RENAME)
+	{
+		auto i = staging_block.variables.find(var.name);
+		if(i!=staging_block.variables.end())
+			var.name = i->second->name;
+	}
+	else if(pass==REFERENCED)
+		referenced_names.insert(var.name);
+}
+
+void InlineContentInjector::visit(FunctionCall &call)
+{
+	if(pass==REFERENCED)
+		referenced_names.insert(call.name);
+	TraversingVisitor::visit(call);
+}
+
+void InlineContentInjector::visit(VariableDeclaration &var)
+{
+	TraversingVisitor::visit(var);
+
+	if(pass==RENAME)
+	{
+		/* Check against conflicts with the other context as well as variables
+		already renamed here. */
+		bool conflict = (staging_block.variables.count(var.name) || referenced_names.count(var.name));
+		staging_block.variables[var.name] = &var;
+		if(conflict)
+		{
+			string mapped_name = get_unused_variable_name(staging_block, var.name);
+			if(mapped_name!=var.name)
+			{
+				staging_block.variables[mapped_name] = &var;
+				var.name = mapped_name;
+			}
+		}
+	}
+	else if(pass==REFERENCED)
+		referenced_names.insert(var.type);
+}
+
+void InlineContentInjector::visit(Return &ret)
+{
+	TraversingVisitor::visit(ret);
+
+	if(pass==INLINE && ret.expression)
+	{
+		// Create a new variable to hold the return value of the inlined function.
+		r_result_name = get_unused_variable_name(staging_block, "_return");
+		RefPtr<VariableDeclaration> var = new VariableDeclaration;
+		var->source = ret.source;
+		var->line = ret.line;
+		var->type = source_func->return_type;
+		var->name = r_result_name;
+		var->init_expression = ret.expression->clone();
+		r_inlined_statement = var;
+	}
+}
+
+
+bool FunctionInliner::apply(Stage &s)
+{
+	stage = &s;
+	inlineable = InlineableFunctionLocator().apply(s);
+	r_any_inlined = false;
+	s.content.visit(*this);
+	return r_any_inlined;
+}
+
+void FunctionInliner::visit(RefPtr<Expression> &ptr)
+{
+	r_inline_result = 0;
+	ptr->visit(*this);
+	if(r_inline_result)
+	{
+		ptr = r_inline_result;
+		r_any_inlined = true;
+	}
+	r_inline_result = 0;
+}
+
+void FunctionInliner::visit(Block &block)
+{
+	SetForScope<Block *> set_block(current_block, &block);
+	SetForScope<NodeList<Statement>::iterator> save_insert_point(insert_point, block.body.begin());
+	for(auto i=block.body.begin(); (!r_inlined_here && i!=block.body.end()); ++i)
+	{
+		insert_point = i;
+		(*i)->visit(*this);
+	}
+}
+
+void FunctionInliner::visit(FunctionCall &call)
+{
+	for(auto i=call.arguments.begin(); (!r_inlined_here && i!=call.arguments.end()); ++i)
+		visit(*i);
+
+	if(r_inlined_here)
+		return;
+
+	FunctionDeclaration *def = call.declaration;
+	if(def)
+		def = def->definition;
+
+	if(def && inlineable.count(def))
+	{
+		string result_name = InlineContentInjector().apply(*stage, *current_function, *current_block, insert_point, call);
+
+		// This will later get removed by UnusedVariableRemover.
+		if(result_name.empty())
+			result_name = "_msp_unused_from_inline";
+
+		RefPtr<VariableReference> ref = new VariableReference;
+		ref->name = result_name;
+		r_inline_result = ref;
+
+		/* Inlined variables need to be resolved before this function can be
+		inlined further. */
+		inlineable.erase(current_function);
+		r_inlined_here = true;
+	}
+}
+
+void FunctionInliner::visit(FunctionDeclaration &func)
+{
+	SetForScope<FunctionDeclaration *> set_func(current_function, &func);
+	TraversingVisitor::visit(func);
+	r_inlined_here = false;
+}
+
+void FunctionInliner::visit(Iteration &iter)
+{
+	/* Visit the initialization statement before entering the loop body so the
+	inlined statements get inserted outside. */
+	if(iter.init_statement)
+		iter.init_statement->visit(*this);
+
+	SetForScope<Block *> set_block(current_block, &iter.body);
+	/* Skip the condition and loop expression parts because they're not properly
+	inside the body block.  Inlining anything into them will require a more
+	comprehensive transformation. */
+	iter.body.visit(*this);
+}
+
+
+bool ExpressionInliner::apply(Stage &s)
+{
+	s.content.visit(*this);
+
+	bool any_inlined = false;
+	for(ExpressionInfo &e: expressions)
+		if(e.expression && (e.trivial || e.uses.size()==1))
+		{
+			for(ExpressionUse &u: e.uses)
+				if(!u.blocked)
+				{
+					*u.reference = e.expression->clone();
+					any_inlined = true;
+				}
+		}
+
+	return any_inlined;
+}
+
+void ExpressionInliner::visit(RefPtr<Expression> &expr)
+{
+	r_ref_info = 0;
+	expr->visit(*this);
+	if(r_ref_info && r_ref_info->expression)
+	{
+		ExpressionUse use;
+		use.reference = &expr;
+		use.ref_scope = current_block;
+		use.blocked = access_write || r_ref_info->blocked;
+
+		if(iteration_body && !r_ref_info->trivial)
+		{
+			/* Block inlining of non-trivial expressions assigned outside an
+			iteration statement.  The iteration may run multiple times, which
+			would cause the expression to also be evaluated multiple times. */
+			for(Block *i=iteration_body->parent; (!use.blocked && i); i=i->parent)
+				use.blocked = (i==r_ref_info->assign_scope);
+		}
+
+		/* Block inlining assignments from from inner scopes.  The assignment may
+		depend on local variables of that scope or may not always be executed. */
+		for(Block *i=r_ref_info->assign_scope->parent; (!use.blocked && i); i=i->parent)
+			use.blocked = (i==current_block);
+
+		r_ref_info->uses.push_back(use);
+	}
+	r_oper = expr->oper;
+	r_ref_info = 0;
+}
+
+void ExpressionInliner::visit(VariableReference &var)
+{
+	if(var.declaration && access_read)
+	{
+		auto i = assignments.find(var.declaration);
+		if(i!=assignments.end())
+			r_ref_info = i->second;
+	}
+}
+
+void ExpressionInliner::visit(MemberAccess &memacc)
+{
+	visit(memacc.left);
+	r_trivial = false;
+}
+
+void ExpressionInliner::visit(Swizzle &swizzle)
+{
+	visit(swizzle.left);
+	r_trivial = false;
+}
+
+void ExpressionInliner::visit(UnaryExpression &unary)
+{
+	SetFlag set_write(access_write, (unary.oper->token[1]=='+' || unary.oper->token[1]=='-'));
+	visit(unary.expression);
+	r_trivial = false;
+}
+
+void ExpressionInliner::visit(BinaryExpression &binary)
+{
+	visit(binary.left);
+	{
+		SetFlag clear_write(access_write, false);
+		visit(binary.right);
+	}
+	r_trivial = false;
+}
+
+void ExpressionInliner::visit(Assignment &assign)
+{
+	{
+		SetFlag set_read(access_read, assign.oper->token[0]!='=');
+		SetFlag set_write(access_write);
+		visit(assign.left);
+	}
+	r_oper = 0;
+	r_trivial = true;
+	visit(assign.right);
+
+	auto i = assignments.find(assign.target.declaration);
+	if(i!=assignments.end())
+	{
+		if(iteration_body && i->second && i->second->expression)
+		{
+			/* Block inlining into previous references within the iteration
+			statement.  On iterations after the first they would refer to the
+			assignment within the iteration. */
+			for(ExpressionUse &u: i->second->uses)
+				for(Block *k=u.ref_scope; (!u.blocked && k); k=k->parent)
+					u.blocked = (k==iteration_body);
+		}
+
+		for(; (i!=assignments.end() && i->first.declaration==assign.target.declaration); ++i)
+			if(targets_overlap(i->first, assign.target))
+				i->second->blocked = true;
+
+		expressions.emplace_back();
+		ExpressionInfo &info = expressions.back();
+		info.target = assign.target;
+		// Self-referencing assignments can't be inlined without additional work.
+		if(!assign.self_referencing)
+			info.expression = assign.right;
+		info.assign_scope = current_block;
+		info.trivial = r_trivial;
+
+		assignments[assign.target] = &info;
+	}
+
+	r_trivial = false;
+}
+
+void ExpressionInliner::visit(TernaryExpression &ternary)
+{
+	visit(ternary.condition);
+	visit(ternary.true_expr);
+	visit(ternary.false_expr);
+	r_trivial = false;
+}
+
+void ExpressionInliner::visit(FunctionCall &call)
+{
+	TraversingVisitor::visit(call);
+	r_trivial = false;
+}
+
+void ExpressionInliner::visit(VariableDeclaration &var)
+{
+	r_oper = 0;
+	r_trivial = true;
+	TraversingVisitor::visit(var);
+
+	bool constant = var.constant;
+	if(constant && var.layout)
+	{
+		constant = !any_of(var.layout->qualifiers.begin(), var.layout->qualifiers.end(),
+			[](const Layout::Qualifier &q){ return q.name=="constant_id"; });
+	}
+
+	/* Only inline global variables if they're constant and have trivial
+	initializers.  Non-constant variables could change in ways which are hard to
+	analyze and non-trivial expressions could be expensive to inline.  */
+	if((current_block->parent || (constant && r_trivial)) && var.interface.empty())
+	{
+		expressions.emplace_back();
+		ExpressionInfo &info = expressions.back();
+		info.target = &var;
+		/* Assume variables declared in an iteration initialization statement
+		will have their values change throughout the iteration. */
+		if(!iteration_init)
+			info.expression = var.init_expression;
+		info.assign_scope = current_block;
+		info.trivial = r_trivial;
+
+		assignments[&var] = &info;
+	}
+}
+
+void ExpressionInliner::visit(Iteration &iter)
+{
+	SetForScope<Block *> set_block(current_block, &iter.body);
+	if(iter.init_statement)
+	{
+		SetFlag set_init(iteration_init);
+		iter.init_statement->visit(*this);
+	}
+
+	SetForScope<Block *> set_body(iteration_body, &iter.body);
+	if(iter.condition)
+		visit(iter.condition);
+	iter.body.visit(*this);
+	if(iter.loop_expression)
+		visit(iter.loop_expression);
+}
+
+
+bool AggregateDismantler::apply(Stage &stage)
+{
+	stage.content.visit(*this);
+
+	bool any_dismantled = false;
+	for(const auto &kvp: aggregates)
+	{
+		if(kvp.second.referenced || !kvp.second.members_referenced)
+			continue;
+
+		for(const AggregateMember &m: kvp.second.members)
+		{
+			string name;
+			if(m.declaration)
+				name = format("%s_%s", kvp.second.declaration->name, m.declaration->name);
+			else
+				name = format("%s_%d", kvp.second.declaration->name, m.index);
+
+			VariableDeclaration *var = new VariableDeclaration;
+			var->source = kvp.first->source;
+			var->line = kvp.first->line;
+			var->name = get_unused_variable_name(*kvp.second.decl_scope, name);
+			/* XXX This is kind of brittle and depends on the array declaration's
+			textual type not having brackets in it. */
+			var->type = (m.declaration ? m.declaration : kvp.second.declaration)->type;
+			if(m.initializer)
+				var->init_expression = m.initializer->clone();
+
+			kvp.second.decl_scope->body.insert(kvp.second.insert_point, var);
+
+			for(RefPtr<Expression> *r: m.references)
+			{
+				VariableReference *ref = new VariableReference;
+				ref->name = var->name;
+				*r = ref;
+			}
+
+			any_dismantled = true;
+		}
+	}
+
+	return any_dismantled;
+}
+
+void AggregateDismantler::visit(Block &block)
+{
+	SetForScope<Block *> set_block(current_block, &block);
+	for(auto i=block.body.begin(); i!=block.body.end(); ++i)
+	{
+		insert_point = i;
+		(*i)->visit(*this);
+	}
+}
+
+void AggregateDismantler::visit(RefPtr<Expression> &expr)
+{
+	r_aggregate_ref = 0;
+	expr->visit(*this);
+	if(r_aggregate_ref && r_reference.chain_len==1)
+	{
+		if((r_reference.chain[0]&0x3F)!=0x3F)
+		{
+			r_aggregate_ref->members[r_reference.chain[0]&0x3F].references.push_back(&expr);
+			r_aggregate_ref->members_referenced = true;
+		}
+		else
+			/* If the accessed member is not known, mark the entire aggregate as
+			referenced. */
+			r_aggregate_ref->referenced = true;
+	}
+	r_aggregate_ref = 0;
+}
+
+void AggregateDismantler::visit(VariableReference &var)
+{
+	if(composite_reference)
+		r_reference.declaration = var.declaration;
+	else
+	{
+		/* If an aggregate variable is referenced as a whole, it should not be
+		dismantled. */
+		auto i = aggregates.find(var.declaration);
+		if(i!=aggregates.end())
+			i->second.referenced = true;
+	}
+}
+
+void AggregateDismantler::visit_composite(RefPtr<Expression> &expr)
+{
+	if(!composite_reference)
+		r_reference = Assignment::Target();
+
+	SetFlag set_composite(composite_reference);
+	visit(expr);
+}
+
+void AggregateDismantler::visit(MemberAccess &memacc)
+{
+	visit_composite(memacc.left);
+
+	add_to_chain(r_reference, Assignment::Target::MEMBER, memacc.index);
+
+	if(r_reference.declaration && r_reference.chain_len==1)
+	{
+		auto i = aggregates.find(r_reference.declaration);
+		r_aggregate_ref = (i!=aggregates.end() ? &i->second : 0);
+	}
+	else
+		r_aggregate_ref = 0;
+}
+
+void AggregateDismantler::visit(BinaryExpression &binary)
+{
+	if(binary.oper->token[0]=='[')
+	{
+		visit_composite(binary.left);
+		{
+			SetFlag clear_composite(composite_reference, false);
+			visit(binary.right);
+		}
+
+		unsigned index = 0x3F;
+		if(Literal *literal_subscript = dynamic_cast<Literal *>(binary.right.get()))
+			if(literal_subscript->value.check_type<int>())
+				index = literal_subscript->value.value<int>();
+		add_to_chain(r_reference, Assignment::Target::ARRAY, index);
+
+		if(r_reference.declaration && r_reference.chain_len==1)
+		{
+			auto i = aggregates.find(r_reference.declaration);
+			r_aggregate_ref = (i!=aggregates.end() ? &i->second : 0);
+		}
+		else
+			r_aggregate_ref = 0;
+	}
+	else
+	{
+		SetFlag clear_composite(composite_reference, false);
+		TraversingVisitor::visit(binary);
+	}
+}
+
+void AggregateDismantler::visit(VariableDeclaration &var)
+{
+	TraversingVisitor::visit(var);
+
+	if(var.interface.empty())
+	{
+		if(const StructDeclaration *strct = dynamic_cast<const StructDeclaration *>(var.type_declaration))
+		{
+			const FunctionCall *init_call = dynamic_cast<const FunctionCall *>(var.init_expression.get());
+			if((init_call && init_call->constructor) || !var.init_expression)
+			{
+
+				Aggregate &aggre = aggregates[&var];
+				aggre.declaration = &var;
+				aggre.decl_scope = current_block;
+				aggre.insert_point = insert_point;
+
+				unsigned i = 0;
+				for(const RefPtr<Statement> &s: strct->members.body)
+				{
+					if(const VariableDeclaration *mem_decl = dynamic_cast<const VariableDeclaration *>(s.get()))
+					{
+						AggregateMember member;
+						member.declaration = mem_decl;
+						member.index = i;
+						if(init_call)
+							member.initializer = init_call->arguments[i];
+						aggre.members.push_back(member);
+					}
+					++i;
+				}
+			}
+		}
+		else if(const Literal *literal_size = dynamic_cast<const Literal *>(var.array_size.get()))
+		{
+			if(literal_size->value.check_type<int>())
+			{
+				Aggregate &aggre = aggregates[&var];
+				aggre.declaration = &var;
+				aggre.decl_scope = current_block;
+				aggre.insert_point = insert_point;
+
+				int size = literal_size->value.value<int>();
+				for(int i=0; i<size; ++i)
+				{
+					AggregateMember member;
+					member.index = i;
+					// Array initializers are not supported yet
+					aggre.members.push_back(member);
+				}
+			}
+		}
+	}
+}
 
-void InlineableFunctionLocator::visit(FunctionCall &call)
+void AggregateDismantler::visit(FunctionDeclaration &func)
 {
-	FunctionDeclaration *def = call.declaration;
-	if(def && def->definition!=def)
-		def = def->definition;
+	func.body.visit(*this);
+}
 
-	if(def)
+
+template<typename T>
+T ConstantFolder::evaluate_logical(char oper, T left, T right)
+{
+	switch(oper)
 	{
-		unsigned &count = refcounts[def];
-		++count;
-		if(count>1 || def==in_function)
-			inlineable.erase(def);
+	case '&': return left&right;
+	case '|': return left|right;
+	case '^': return left^right;
+	default: return T();
 	}
-
-	TraversingVisitor::visit(call);
 }
 
-void InlineableFunctionLocator::visit(FunctionDeclaration &func)
+template<typename T>
+bool ConstantFolder::evaluate_relation(const char *oper, T left, T right)
 {
-	unsigned &count = refcounts[func.definition];
-	if(!count && func.parameters.empty())
-		inlineable.insert(func.definition);
+	switch(oper[0]|oper[1])
+	{
+	case '<': return left<right;
+	case '<'|'=': return left<=right;
+	case '>': return left>right;
+	case '>'|'=': return left>=right;
+	default: return false;
+	}
+}
 
-	SetForScope<FunctionDeclaration *> set(in_function, &func);
-	TraversingVisitor::visit(func);
+template<typename T>
+T ConstantFolder::evaluate_arithmetic(char oper, T left, T right)
+{
+	switch(oper)
+	{
+	case '+': return left+right;
+	case '-': return left-right;
+	case '*': return left*right;
+	case '/': return left/right;
+	default: return T();
+	}
 }
 
+template<typename T>
+T ConstantFolder::evaluate_int_special_op(char oper, T left, T right)
+{
+	switch(oper)
+	{
+	case '%': return left%right;
+	case '<': return left<<right;
+	case '>': return left>>right;
+	default: return T();
+	}
+}
 
-FunctionInliner::FunctionInliner():
-	extract_result(0)
-{ }
+template<typename T>
+void ConstantFolder::convert_to_result(const Variant &value)
+{
+	if(value.check_type<bool>())
+		set_result(static_cast<T>(value.value<bool>()));
+	else if(value.check_type<int>())
+		set_result(static_cast<T>(value.value<int>()));
+	else if(value.check_type<unsigned>())
+		set_result(static_cast<T>(value.value<unsigned>()));
+	else if(value.check_type<float>())
+		set_result(static_cast<T>(value.value<float>()));
+}
 
-void FunctionInliner::apply(Stage &stage)
+void ConstantFolder::set_result(const Variant &value, bool literal)
 {
-	inlineable = InlineableFunctionLocator().apply(stage);
-	stage.content.visit(*this);
+	r_constant_value = value;
+	r_constant = true;
+	r_literal = literal;
 }
 
-void FunctionInliner::visit_and_inline(RefPtr<Expression> &ptr)
+void ConstantFolder::visit(RefPtr<Expression> &expr)
 {
-	inline_result = 0;
-	ptr->visit(*this);
-	if(inline_result)
-		ptr = inline_result;
+	r_constant_value = Variant();
+	r_constant = false;
+	r_literal = false;
+	r_uses_iter_var = false;
+	expr->visit(*this);
+	/* Don't replace literals since they'd only be replaced with an identical
+	literal.  Also skip anything that uses an iteration variable, but pass on
+	the result so the Iteration visiting function can handle it. */
+	if(!r_constant || r_literal || r_uses_iter_var)
+		return;
+
+	RefPtr<Literal> literal = new Literal;
+	if(r_constant_value.check_type<bool>())
+		literal->token = (r_constant_value.value<bool>() ? "true" : "false");
+	else if(r_constant_value.check_type<int>())
+		literal->token = lexical_cast<string>(r_constant_value.value<int>());
+	else if(r_constant_value.check_type<unsigned>())
+		literal->token = lexical_cast<string>(r_constant_value.value<unsigned>())+"u";
+	else if(r_constant_value.check_type<float>())
+	{
+		literal->token = lexical_cast<string>(r_constant_value.value<float>(), Fmt().precision(8));
+		if(literal->token.find('.')==string::npos && literal->token.find('e')==string::npos)
+			literal->token += ".0";
+	}
+	else
+	{
+		r_constant = false;
+		return;
+	}
+	literal->value = r_constant_value;
+	expr = literal;
+	r_any_folded = true;
 }
 
-void FunctionInliner::visit(Block &block)
+void ConstantFolder::visit(Literal &literal)
 {
-	if(extract_result)
-		--extract_result;
+	set_result(literal.value, true);
+}
 
-	for(NodeList<Statement>::iterator i=block.body.begin(); i!=block.body.end(); ++i)
+void ConstantFolder::visit(VariableReference &var)
+{
+	/* If an iteration variable is initialized with a constant value, return
+	that value here for the purpose of evaluating the loop condition for the
+	first iteration. */
+	if(var.declaration==iteration_var)
 	{
-		(*i)->visit(*this);
-		if(extract_result)
-			--extract_result;
+		set_result(iter_init_value);
+		r_uses_iter_var = true;
 	}
 }
 
-void FunctionInliner::visit(UnaryExpression &unary)
+void ConstantFolder::visit(MemberAccess &memacc)
 {
-	visit_and_inline(unary.expression);
-	inline_result = 0;
+	TraversingVisitor::visit(memacc);
+	r_constant = false;
 }
 
-void FunctionInliner::visit(BinaryExpression &binary)
+void ConstantFolder::visit(Swizzle &swizzle)
 {
-	visit_and_inline(binary.left);
-	visit_and_inline(binary.right);
-	inline_result = 0;
+	TraversingVisitor::visit(swizzle);
+	r_constant = false;
 }
 
-void FunctionInliner::visit(MemberAccess &memacc)
+void ConstantFolder::visit(UnaryExpression &unary)
 {
-	visit_and_inline(memacc.left);
-	inline_result = 0;
+	TraversingVisitor::visit(unary);
+	bool can_fold = r_constant;
+	r_constant = false;
+	if(!can_fold)
+		return;
+
+	char oper = unary.oper->token[0];
+	char oper2 = unary.oper->token[1];
+	if(oper=='!')
+	{
+		if(r_constant_value.check_type<bool>())
+			set_result(!r_constant_value.value<bool>());
+	}
+	else if(oper=='~')
+	{
+		if(r_constant_value.check_type<int>())
+			set_result(~r_constant_value.value<int>());
+		else if(r_constant_value.check_type<unsigned>())
+			set_result(~r_constant_value.value<unsigned>());
+	}
+	else if(oper=='-' && !oper2)
+	{
+		if(r_constant_value.check_type<int>())
+			set_result(-r_constant_value.value<int>());
+		else if(r_constant_value.check_type<unsigned>())
+			set_result(-r_constant_value.value<unsigned>());
+		else if(r_constant_value.check_type<float>())
+			set_result(-r_constant_value.value<float>());
+	}
 }
 
-void FunctionInliner::visit(FunctionCall &call)
+void ConstantFolder::visit(BinaryExpression &binary)
 {
-	for(NodeArray<Expression>::iterator i=call.arguments.begin(); i!=call.arguments.end(); ++i)
-		visit_and_inline(*i);
+	visit(binary.left);
+	bool left_constant = r_constant;
+	bool left_iter_var = r_uses_iter_var;
+	Variant left_value = r_constant_value;
+	visit(binary.right);
+	if(left_iter_var)
+		r_uses_iter_var = true;
+
+	bool can_fold = (left_constant && r_constant);
+	r_constant = false;
+	if(!can_fold)
+		return;
+
+	// Currently only expressions with both sides of equal types are handled.
+	if(!left_value.check_same_type(r_constant_value))
+		return;
+
+	char oper = binary.oper->token[0];
+	char oper2 = binary.oper->token[1];
+	if(oper=='&' || oper=='|' || oper=='^')
+	{
+		if(oper2==oper && left_value.check_type<bool>())
+			set_result(evaluate_logical(oper, left_value.value<bool>(), r_constant_value.value<bool>()));
+		else if(!oper2 && left_value.check_type<int>())
+			set_result(evaluate_logical(oper, left_value.value<int>(), r_constant_value.value<int>()));
+		else if(!oper2 && left_value.check_type<unsigned>())
+			set_result(evaluate_logical(oper, left_value.value<unsigned>(), r_constant_value.value<unsigned>()));
+	}
+	else if((oper=='<' || oper=='>') && oper2!=oper)
+	{
+		if(left_value.check_type<int>())
+			set_result(evaluate_relation(binary.oper->token, left_value.value<int>(), r_constant_value.value<int>()));
+		else if(left_value.check_type<unsigned>())
+			set_result(evaluate_relation(binary.oper->token, left_value.value<unsigned>(), r_constant_value.value<unsigned>()));
+		else if(left_value.check_type<float>())
+			set_result(evaluate_relation(binary.oper->token, left_value.value<float>(), r_constant_value.value<float>()));
+	}
+	else if((oper=='=' || oper=='!') && oper2=='=')
+	{
+		if(left_value.check_type<int>())
+			set_result((left_value.value<int>()==r_constant_value.value<int>()) == (oper=='='));
+		else if(left_value.check_type<unsigned>())
+			set_result((left_value.value<unsigned>()==r_constant_value.value<unsigned>()) == (oper=='='));
+		else if(left_value.check_type<float>())
+			set_result((left_value.value<float>()==r_constant_value.value<float>()) == (oper=='='));
+	}
+	else if(oper=='+' || oper=='-' || oper=='*' || oper=='/')
+	{
+		if(left_value.check_type<int>())
+			set_result(evaluate_arithmetic(oper, left_value.value<int>(), r_constant_value.value<int>()));
+		else if(left_value.check_type<unsigned>())
+			set_result(evaluate_arithmetic(oper, left_value.value<unsigned>(), r_constant_value.value<unsigned>()));
+		else if(left_value.check_type<float>())
+			set_result(evaluate_arithmetic(oper, left_value.value<float>(), r_constant_value.value<float>()));
+	}
+	else if(oper=='%' || ((oper=='<' || oper=='>') && oper2==oper))
+	{
+		if(left_value.check_type<int>())
+			set_result(evaluate_int_special_op(oper, left_value.value<int>(), r_constant_value.value<int>()));
+		else if(left_value.check_type<unsigned>())
+			set_result(evaluate_int_special_op(oper, left_value.value<unsigned>(), r_constant_value.value<unsigned>()));
+	}
+}
 
-	FunctionDeclaration *def = call.declaration;
-	if(def && def->definition!=def)
-		def = def->definition;
+void ConstantFolder::visit(Assignment &assign)
+{
+	TraversingVisitor::visit(assign);
+	r_constant = false;
+}
 
-	if(def && inlineable.count(def))
+void ConstantFolder::visit(TernaryExpression &ternary)
+{
+	TraversingVisitor::visit(ternary);
+	r_constant = false;
+}
+
+void ConstantFolder::visit(FunctionCall &call)
+{
+	if(call.constructor && call.type && call.arguments.size()==1)
 	{
-		extract_result = 2;
-		def->visit(*this);
+		const BasicTypeDeclaration *basic = dynamic_cast<const BasicTypeDeclaration *>(call.type);
+		if(basic)
+		{
+			visit(call.arguments[0]);
+			bool can_fold = r_constant;
+			r_constant = false;
+			if(!can_fold)
+				return;
+
+			if(basic->kind==BasicTypeDeclaration::BOOL)
+				convert_to_result<bool>(r_constant_value);
+			else if(basic->kind==BasicTypeDeclaration::INT && basic->size==32 && basic->sign)
+				convert_to_result<int>(r_constant_value);
+			else if(basic->kind==BasicTypeDeclaration::INT && basic->size==32 && !basic->sign)
+				convert_to_result<unsigned>(r_constant_value);
+			else if(basic->kind==BasicTypeDeclaration::FLOAT && basic->size==32)
+				convert_to_result<float>(r_constant_value);
+
+			return;
+		}
 	}
-	else
-		inline_result = 0;
+
+	TraversingVisitor::visit(call);
+	r_constant = false;
 }
 
-void FunctionInliner::visit(VariableDeclaration &var)
+void ConstantFolder::visit(VariableDeclaration &var)
 {
-	if(var.init_expression)
-		visit_and_inline(var.init_expression);
-	inline_result = 0;
+	if(iteration_init && var.init_expression)
+	{
+		visit(var.init_expression);
+		if(r_constant)
+		{
+			/* Record the value of a constant initialization expression of an
+			iteration, so it can be used to evaluate the loop condition. */
+			iteration_var = &var;
+			iter_init_value = r_constant_value;
+		}
+	}
+	else
+		TraversingVisitor::visit(var);
 }
 
-void FunctionInliner::visit(Return &ret)
+void ConstantFolder::visit(Iteration &iter)
 {
-	TraversingVisitor::visit(ret);
+	SetForScope<Block *> set_block(current_block, &iter.body);
 
-	if(extract_result)
-		inline_result = ret.expression->clone();
-}
+	/* The iteration variable is not normally inlined into expressions, so we
+	process it specially here.  If the initial value causes the loop condition
+	to evaluate to false, then the expression can be folded. */
+	iteration_var = 0;
+	if(iter.init_statement)
+	{
+		SetFlag set_init(iteration_init);
+		iter.init_statement->visit(*this);
+	}
+
+	if(iter.condition)
+	{
+		visit(iter.condition);
+		if(r_constant && r_constant_value.check_type<bool>() && !r_constant_value.value<bool>())
+		{
+			RefPtr<Literal> literal = new Literal;
+			literal->token = "false";
+			literal->value = r_constant_value;
+			iter.condition = literal;
+		}
+	}
+	iteration_var = 0;
 
+	iter.body.visit(*this);
+	if(iter.loop_expression)
+		visit(iter.loop_expression);
+}
 
-ConstantConditionEliminator::ConstantConditionEliminator():
-	record_only(false)
-{ }
 
-void ConstantConditionEliminator::apply(Stage &stage)
+bool ConstantConditionEliminator::apply(Stage &stage)
 {
 	stage.content.visit(*this);
 	NodeRemover().apply(stage, nodes_to_remove);
+	return !nodes_to_remove.empty();
+}
+
+ConstantConditionEliminator::ConstantStatus ConstantConditionEliminator::check_constant_condition(const Expression &expr)
+{
+	if(const Literal *literal = dynamic_cast<const Literal *>(&expr))
+		if(literal->value.check_type<bool>())
+			return (literal->value.value<bool>() ? CONSTANT_TRUE : CONSTANT_FALSE);
+	return NOT_CONSTANT;
 }
 
 void ConstantConditionEliminator::visit(Block &block)
 {
 	SetForScope<Block *> set_block(current_block, &block);
-	for(NodeList<Statement>::iterator i=block.body.begin(); i!=block.body.end(); ++i)
+	for(auto i=block.body.begin(); i!=block.body.end(); ++i)
 	{
 		insert_point = i;
 		(*i)->visit(*this);
 	}
+}
 
-	for(map<string, VariableDeclaration *>::const_iterator i=block.variables.begin(); i!=block.variables.end(); ++i)
-		variable_values.erase(i->second);
+void ConstantConditionEliminator::visit(RefPtr<Expression> &expr)
+{
+	r_ternary_result = 0;
+	expr->visit(*this);
+	if(r_ternary_result)
+		expr = r_ternary_result;
+	r_ternary_result = 0;
 }
 
 void ConstantConditionEliminator::visit(UnaryExpression &unary)
 {
-	if(VariableReference *var = dynamic_cast<VariableReference *>(unary.expression.get()))
-		if(unary.oper=="++" || unary.oper=="--")
-			variable_values.erase(var->declaration);
+	if(unary.oper->token[1]=='+' || unary.oper->token[1]=='-')
+		if(const VariableReference *var = dynamic_cast<const VariableReference *>(unary.expression.get()))
+		{
+			auto i = current_block->variables.find(var->name);
+			r_external_side_effects = (i==current_block->variables.end() || i->second!=var->declaration);
+			return;
+		}
+
+	TraversingVisitor::visit(unary);
 }
 
 void ConstantConditionEliminator::visit(Assignment &assign)
 {
-	variable_values.erase(assign.target_declaration);
+	auto i = find_if(current_block->variables, [&assign](const pair<string, VariableDeclaration *> &kvp){ return kvp.second==assign.target.declaration; });
+	if(i==current_block->variables.end())
+		r_external_side_effects = true;
+	TraversingVisitor::visit(assign);
+}
+
+void ConstantConditionEliminator::visit(TernaryExpression &ternary)
+{
+	ConstantStatus result = check_constant_condition(*ternary.condition);
+	if(result!=NOT_CONSTANT)
+		r_ternary_result = (result==CONSTANT_TRUE ? ternary.true_expr : ternary.false_expr);
+	else
+		r_ternary_result = 0;
 }
 
-void ConstantConditionEliminator::visit(VariableDeclaration &var)
+void ConstantConditionEliminator::visit(FunctionCall &call)
 {
-	if((var.constant || current_block->parent) && var.init_expression)
-		variable_values[&var] = var.init_expression.get();
+	r_external_side_effects = true;
+	TraversingVisitor::visit(call);
 }
 
 void ConstantConditionEliminator::visit(Conditional &cond)
 {
-	if(!record_only)
+	ConstantStatus result = check_constant_condition(*cond.condition);
+	if(result!=NOT_CONSTANT)
 	{
-		ExpressionEvaluator eval(variable_values);
-		cond.condition->visit(eval);
-		if(eval.is_result_valid())
-		{
-			Block &block = (eval.get_result() ? cond.body : cond.else_body);
-			current_block->body.splice(insert_point, block.body);
-			nodes_to_remove.insert(&cond);
-			return;
-		}
+		Block &block = (result==CONSTANT_TRUE ? cond.body : cond.else_body);
+		// TODO should check variable names for conflicts.  Potentially reuse InlineContentInjector?
+		current_block->body.splice(insert_point, block.body);
+		nodes_to_remove.insert(&cond);
+		return;
 	}
 
+	r_external_side_effects = false;
 	TraversingVisitor::visit(cond);
+
+	if(cond.body.body.empty() && cond.else_body.body.empty() && !r_external_side_effects)
+		nodes_to_remove.insert(&cond);
 }
 
 void ConstantConditionEliminator::visit(Iteration &iter)
 {
-	if(!record_only)
+	if(iter.condition)
 	{
-		if(iter.condition)
+		ConstantStatus result = check_constant_condition(*iter.condition);
+		if(result==CONSTANT_FALSE)
 		{
-			/* If the loop condition is always false on the first iteration, the
-			entire loop can be removed */
-			if(iter.init_statement)
-				iter.init_statement->visit(*this);
-			ExpressionEvaluator eval(variable_values);
-			iter.condition->visit(eval);
-			if(eval.is_result_valid() && !eval.get_result())
-			{
-				nodes_to_remove.insert(&iter);
-				return;
-			}
+			nodes_to_remove.insert(&iter);
+			return;
 		}
-
-		/* Record all assignments that occur inside the loop body so those
-		variables won't be considered as constant */
-		SetFlag set_record(record_only);
-		TraversingVisitor::visit(iter);
 	}
 
+	r_external_side_effects = false;
 	TraversingVisitor::visit(iter);
+	if(iter.body.body.empty() && !r_external_side_effects)
+		nodes_to_remove.insert(&iter);
+}
+
+
+bool UnreachableCodeRemover::apply(Stage &stage)
+{
+	stage.content.visit(*this);
+	NodeRemover().apply(stage, unreachable_nodes);
+	return !unreachable_nodes.empty();
+}
+
+void UnreachableCodeRemover::visit(Block &block)
+{
+	auto i = block.body.begin();
+	for(; (reachable && i!=block.body.end()); ++i)
+		(*i)->visit(*this);
+	for(; i!=block.body.end(); ++i)
+		unreachable_nodes.insert(i->get());
+}
 
-	if(VariableDeclaration *init_decl = dynamic_cast<VariableDeclaration *>(iter.init_statement.get()))
-		variable_values.erase(init_decl);
+void UnreachableCodeRemover::visit(FunctionDeclaration &func)
+{
+	TraversingVisitor::visit(func);
+	reachable = true;
 }
 
+void UnreachableCodeRemover::visit(Conditional &cond)
+{
+	cond.body.visit(*this);
+	bool reachable_if_true = reachable;
+	reachable = true;
+	cond.else_body.visit(*this);
+
+	reachable |= reachable_if_true;
+}
 
-UnusedVariableRemover::VariableInfo::VariableInfo():
-	local(false),
-	conditionally_assigned(false),
-	referenced(false)
-{ }
+void UnreachableCodeRemover::visit(Iteration &iter)
+{
+	TraversingVisitor::visit(iter);
 
+	/* Always consider code after a loop reachable, since there's no checking
+	for whether the loop executes. */
+	reachable = true;
+}
 
-UnusedVariableRemover::UnusedVariableRemover():
-	aggregate(0),
-	assignment(0),
-	assignment_target(false),
-	assign_to_subscript(false)
-{ }
 
-bool UnusedVariableRemover::apply(Stage &stage)
+bool UnusedTypeRemover::apply(Stage &stage)
 {
-	variables.push_back(BlockVariableMap());
 	stage.content.visit(*this);
-	BlockVariableMap &global_variables = variables.back();
-	for(BlockVariableMap::iterator i=global_variables.begin(); i!=global_variables.end(); ++i)
+	NodeRemover().apply(stage, unused_nodes);
+	return !unused_nodes.empty();
+}
+
+void UnusedTypeRemover::visit(RefPtr<Expression> &expr)
+{
+	unused_nodes.erase(expr->type);
+	TraversingVisitor::visit(expr);
+}
+
+void UnusedTypeRemover::visit(BasicTypeDeclaration &type)
+{
+	if(type.base_type)
+		unused_nodes.erase(type.base_type);
+	unused_nodes.insert(&type);
+}
+
+void UnusedTypeRemover::visit(ImageTypeDeclaration &type)
+{
+	if(type.base_type)
+		unused_nodes.erase(type.base_type);
+	if(type.base_image)
+		unused_nodes.erase(type.base_image);
+	unused_nodes.insert(&type);
+}
+
+void UnusedTypeRemover::visit(StructDeclaration &strct)
+{
+	unused_nodes.insert(&strct);
+	TraversingVisitor::visit(strct);
+}
+
+void UnusedTypeRemover::visit(VariableDeclaration &var)
+{
+	unused_nodes.erase(var.type_declaration);
+	TraversingVisitor::visit(var);
+}
+
+void UnusedTypeRemover::visit(FunctionDeclaration &func)
+{
+	unused_nodes.erase(func.return_type_declaration);
+	TraversingVisitor::visit(func);
+}
+
+
+bool UnusedVariableRemover::apply(Stage &s)
+{
+	stage = &s;
+	s.content.visit(*this);
+
+	for(const AssignmentInfo &a: assignments)
+		if(a.used_by.empty())
+			unused_nodes.insert(a.node);
+
+	for(const auto &kvp: variables)
 	{
-		if(i->first->interface=="out" && (stage.type==Stage::FRAGMENT || i->first->linked_declaration || !i->first->name.compare(0, 3, "gl_")))
-			continue;
-		if(!i->second.referenced)
+		if(!kvp.second.referenced)
+			unused_nodes.insert(kvp.first);
+		else if(kvp.second.output)
 		{
-			unused_nodes.insert(i->first);
-			clear_assignments(i->second, true);
+			/* The last visible assignments of output variables are used by the
+			next stage or the API. */
+			for(AssignmentInfo *a: kvp.second.assignments)
+				unused_nodes.erase(a->node);
 		}
 	}
-	variables.pop_back();
 
-	NodeRemover().apply(stage, unused_nodes);
+	NodeRemover().apply(s, unused_nodes);
 
 	return !unused_nodes.empty();
 }
 
-void UnusedVariableRemover::visit(VariableReference &var)
+void UnusedVariableRemover::referenced(const Assignment::Target &target, Node &node)
 {
-	map<VariableDeclaration *, Node *>::iterator i = aggregates.find(var.declaration);
-	if(i!=aggregates.end())
-		unused_nodes.erase(i->second);
-
-	if(var.declaration && !assignment_target)
+	VariableInfo &var_info = variables[target.declaration];
+	var_info.referenced = true;
+	if(!assignment_target)
 	{
-		VariableInfo &var_info = variables.back()[var.declaration];
-		var_info.assignments.clear();
-		var_info.referenced = true;
+		bool loop_external = false;
+		for(AssignmentInfo *a: var_info.assignments)
+			if(targets_overlap(a->target, target))
+			{
+				a->used_by.push_back(&node);
+				if(a->in_loop<in_loop)
+					loop_external = true;
+			}
+
+		if(loop_external)
+			loop_ext_refs.push_back(&node);
 	}
 }
 
-void UnusedVariableRemover::visit(InterfaceBlockReference &iface)
+void UnusedVariableRemover::visit(VariableReference &var)
+{
+	if(composite_reference)
+		r_reference.declaration = var.declaration;
+	else if(var.declaration)
+		referenced(var.declaration, var);
+}
+
+void UnusedVariableRemover::visit_composite(Expression &expr)
 {
-	unused_nodes.erase(iface.declaration);
+	if(!composite_reference)
+		r_reference = Assignment::Target();
+
+	SetFlag set_composite(composite_reference);
+	expr.visit(*this);
 }
 
 void UnusedVariableRemover::visit(MemberAccess &memacc)
 {
-	TraversingVisitor::visit(memacc);
-	unused_nodes.erase(memacc.declaration);
+	visit_composite(*memacc.left);
+
+	add_to_chain(r_reference, Assignment::Target::MEMBER, memacc.index);
+
+	if(!composite_reference && r_reference.declaration)
+		referenced(r_reference, memacc);
+}
+
+void UnusedVariableRemover::visit(Swizzle &swizzle)
+{
+	visit_composite(*swizzle.left);
+
+	unsigned mask = 0;
+	for(unsigned i=0; i<swizzle.count; ++i)
+		mask |= 1<<swizzle.components[i];
+	add_to_chain(r_reference, Assignment::Target::SWIZZLE, mask);
+
+	if(!composite_reference && r_reference.declaration)
+		referenced(r_reference, swizzle);
+}
+
+void UnusedVariableRemover::visit(UnaryExpression &unary)
+{
+	TraversingVisitor::visit(unary);
+	if(unary.oper->token[1]=='+' || unary.oper->token[1]=='-')
+		r_side_effects = true;
 }
 
 void UnusedVariableRemover::visit(BinaryExpression &binary)
 {
-	if(binary.oper=="[")
+	if(binary.oper->token[0]=='[')
 	{
-		if(assignment_target)
-			assign_to_subscript = true;
-		binary.left->visit(*this);
-		SetForScope<bool> set(assignment_target, false);
-		binary.right->visit(*this);
+		visit_composite(*binary.left);
+
+		{
+			SetFlag clear_assignment(assignment_target, false);
+			SetFlag clear_composite(composite_reference, false);
+			SetForScope<Assignment::Target> clear_reference(r_reference, Assignment::Target());
+			binary.right->visit(*this);
+		}
+
+		add_to_chain(r_reference, Assignment::Target::ARRAY, 0x3F);
+
+		if(!composite_reference && r_reference.declaration)
+			referenced(r_reference, binary);
 	}
 	else
+	{
+		SetFlag clear_composite(composite_reference, false);
 		TraversingVisitor::visit(binary);
+	}
+}
+
+void UnusedVariableRemover::visit(TernaryExpression &ternary)
+{
+	SetFlag clear_composite(composite_reference, false);
+	TraversingVisitor::visit(ternary);
 }
 
 void UnusedVariableRemover::visit(Assignment &assign)
 {
 	{
-		assign_to_subscript = false;
-		SetForScope<bool> set(assignment_target, !assign.self_referencing);
+		SetFlag set(assignment_target, (assign.oper->token[0]=='='));
 		assign.left->visit(*this);
 	}
 	assign.right->visit(*this);
-	assignment = &assign;
+	r_assignment = &assign;
+	r_side_effects = true;
 }
 
-void UnusedVariableRemover::record_assignment(VariableDeclaration &var, Node &node, bool chained)
+void UnusedVariableRemover::visit(FunctionCall &call)
 {
-	VariableInfo &var_info = variables.back()[&var];
-	if(!chained)
-		clear_assignments(var_info, true);
-	var_info.assignments.push_back(&node);
-	var_info.conditionally_assigned = false;
+	SetFlag clear_composite(composite_reference, false);
+	TraversingVisitor::visit(call);
+	/* Treat function calls as having side effects so expression statements
+	consisting of nothing but a function call won't be optimized away. */
+	r_side_effects = true;
+
+	if(stage->type==Stage::GEOMETRY && call.name=="EmitVertex")
+	{
+		for(const auto &kvp: variables)
+			if(kvp.second.output)
+				referenced(kvp.first, call);
+	}
 }
 
-void UnusedVariableRemover::clear_assignments(VariableInfo &var_info, bool mark_unused)
+void UnusedVariableRemover::record_assignment(const Assignment::Target &target, Node &node)
 {
-	if(mark_unused)
+	assignments.emplace_back();
+	AssignmentInfo &assign_info = assignments.back();
+	assign_info.node = &node;
+	assign_info.target = target;
+	assign_info.in_loop = in_loop;
+
+	/* An assignment to the target hides any assignments to the same target or
+	its subfields. */
+	VariableInfo &var_info = variables[target.declaration];
+	for(unsigned i=0; i<var_info.assignments.size(); )
 	{
-		for(vector<Node *>::iterator i=var_info.assignments.begin(); i!=var_info.assignments.end(); ++i)
-			unused_nodes.insert(*i);
+		const Assignment::Target &t = var_info.assignments[i]->target;
+
+		bool subfield = (t.chain_len>=target.chain_len);
+		for(unsigned j=0; (subfield && j<target.chain_len); ++j)
+			subfield = (t.chain[j]==target.chain[j]);
+
+		if(subfield)
+			var_info.assignments.erase(var_info.assignments.begin()+i);
+		else
+			++i;
 	}
-	var_info.assignments.clear();
+
+	var_info.assignments.push_back(&assign_info);
 }
 
 void UnusedVariableRemover::visit(ExpressionStatement &expr)
 {
-	assignment = 0;
+	r_assignment = 0;
+	r_side_effects = false;
 	TraversingVisitor::visit(expr);
-	if(assignment && assignment->target_declaration)
-		record_assignment(*assignment->target_declaration, expr, (assignment->self_referencing || assign_to_subscript));
+	if(r_assignment && r_assignment->target.declaration)
+		record_assignment(r_assignment->target, expr);
+	if(!r_side_effects)
+		unused_nodes.insert(&expr);
 }
 
 void UnusedVariableRemover::visit(StructDeclaration &strct)
 {
-	SetForScope<Node *> set(aggregate, &strct);
-	unused_nodes.insert(&strct);
+	SetFlag set_struct(in_struct);
 	TraversingVisitor::visit(strct);
 }
 
 void UnusedVariableRemover::visit(VariableDeclaration &var)
 {
-	if(aggregate)
-		aggregates[&var] = aggregate;
-	else
-	{
-		variables.back()[&var].local = true;
-		if(var.init_expression)
-			record_assignment(var, *var.init_expression, false);
-	}
-	unused_nodes.erase(var.type_declaration);
 	TraversingVisitor::visit(var);
-}
 
-void UnusedVariableRemover::visit(InterfaceBlock &iface)
-{
-	SetForScope<Node *> set(aggregate, &iface);
-	unused_nodes.insert(&iface);
-	TraversingVisitor::visit(iface);
-}
+	if(in_struct)
+		return;
 
-void UnusedVariableRemover::visit(FunctionDeclaration &func)
-{
-	variables.push_back(BlockVariableMap());
+	VariableInfo &var_info = variables[&var];
 
-	for(NodeArray<VariableDeclaration>::iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i)
-		(*i)->visit(*this);
-	func.body.visit(*this);
+	/* Mark variables as output if they're used by the next stage or the
+	graphics API. */
+	bool builtin = (!var.name.compare(0, 3, "gl_") || (var.block_declaration && !var.block_declaration->block_name.compare(0, 3, "gl_")));
+	var_info.output = (var.interface=="out" && (stage->type==Stage::FRAGMENT || var.linked_declaration || builtin));
+
+	// Linked outputs are automatically referenced.
+	if(var_info.output && var.linked_declaration)
+		var_info.referenced = true;
 
-	BlockVariableMap &block_variables = variables.back();
-	for(BlockVariableMap::iterator i=block_variables.begin(); i!=block_variables.end(); ++i)
-		i->second.conditionally_assigned = true;
-	for(NodeArray<VariableDeclaration>::iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i)
-		block_variables[i->get()].referenced = true;
-	merge_down_variables();
+	if(var.init_expression)
+	{
+		var_info.initialized = true;
+		record_assignment(&var, *var.init_expression);
+	}
 }
 
-void UnusedVariableRemover::merge_down_variables()
+void UnusedVariableRemover::merge_variables(const BlockVariableMap &other_vars)
 {
-	BlockVariableMap &parent_variables = variables[variables.size()-2];
-	BlockVariableMap &block_variables = variables.back();
-	for(BlockVariableMap::iterator i=block_variables.begin(); i!=block_variables.end(); ++i)
+	for(const auto &kvp: other_vars)
 	{
-		if(i->second.local)
+		auto j = variables.find(kvp.first);
+		if(j!=variables.end())
 		{
-			if(!i->second.referenced)
-				unused_nodes.insert(i->first);
-			clear_assignments(i->second, i->first->interface!="out");
-			continue;
+			/* The merged blocks started as copies of each other so any common
+			assignments must be in the beginning. */
+			unsigned k = 0;
+			for(; (k<kvp.second.assignments.size() && k<j->second.assignments.size()); ++k)
+				if(kvp.second.assignments[k]!=j->second.assignments[k])
+					break;
+
+			// Remaining assignments are unique to each block; merge them.
+			j->second.assignments.insert(j->second.assignments.end(), kvp.second.assignments.begin()+k, kvp.second.assignments.end());
+			j->second.referenced |= kvp.second.referenced;
 		}
-
-		BlockVariableMap::iterator j = parent_variables.find(i->first);
-		if(j==parent_variables.end())
-			parent_variables.insert(*i);
 		else
-		{
-			if(i->second.referenced || !i->second.conditionally_assigned)
-				clear_assignments(j->second, !i->second.referenced);
-			j->second.conditionally_assigned = i->second.conditionally_assigned;
-			j->second.referenced |= i->second.referenced;
-			j->second.assignments.insert(j->second.assignments.end(), i->second.assignments.begin(), i->second.assignments.end());
-		}
+			variables.insert(kvp);
 	}
-	variables.pop_back();
 }
 
-void UnusedVariableRemover::visit(Conditional &cond)
+void UnusedVariableRemover::visit(FunctionDeclaration &func)
 {
-	cond.condition->visit(*this);
-	variables.push_back(BlockVariableMap());
-	cond.body.visit(*this);
+	if(func.body.body.empty())
+		return;
 
-	BlockVariableMap if_variables;
-	swap(variables.back(), if_variables);
-	cond.else_body.visit(*this);
+	BlockVariableMap saved_vars = variables;
+	// Assignments from other functions should not be visible.
+	for(auto &kvp: variables)
+		kvp.second.assignments.resize(kvp.second.initialized);
+	TraversingVisitor::visit(func);
+	swap(variables, saved_vars);
+	merge_variables(saved_vars);
 
-	BlockVariableMap &else_variables = variables.back();
-	for(BlockVariableMap::iterator i=else_variables.begin(); i!=else_variables.end(); ++i)
+	/* Always treat function parameters as referenced.  Removing unused
+	parameters is not currently supported. */
+	for(const RefPtr<VariableDeclaration> &p: func.parameters)
 	{
-		BlockVariableMap::iterator j = if_variables.find(i->first);
-		if(j!=if_variables.end())
-		{
-			i->second.assignments.insert(i->second.assignments.end(), j->second.assignments.begin(), j->second.assignments.end());
-			i->second.conditionally_assigned |= j->second.conditionally_assigned;
-			if_variables.erase(j);
-		}
-		else
-			i->second.conditionally_assigned = true;
+		auto j = variables.find(p.get());
+		if(j!=variables.end())
+			j->second.referenced = true;
 	}
+}
 
-	for(BlockVariableMap::iterator i=if_variables.begin(); i!=if_variables.end(); ++i)
-	{
-		i->second.conditionally_assigned = true;
-		else_variables.insert(*i);
-	}
+void UnusedVariableRemover::visit(Conditional &cond)
+{
+	cond.condition->visit(*this);
+	BlockVariableMap saved_vars = variables;
+	cond.body.visit(*this);
+	swap(saved_vars, variables);
+	cond.else_body.visit(*this);
 
-	merge_down_variables();
+	/* Visible assignments after the conditional is the union of those visible
+	at the end of the if and else blocks.  If there was no else block, then it's
+	the union of the if block and the state before it. */
+	merge_variables(saved_vars);
 }
 
 void UnusedVariableRemover::visit(Iteration &iter)
 {
-	variables.push_back(BlockVariableMap());
-	TraversingVisitor::visit(iter);
+	BlockVariableMap saved_vars = variables;
+	vector<Node *> saved_refs;
+	swap(loop_ext_refs, saved_refs);
+	{
+		if(iter.init_statement)
+			iter.init_statement->visit(*this);
+		SetForScope<unsigned> set_loop(in_loop, in_loop+1);
+		if(iter.condition)
+			iter.condition->visit(*this);
+		iter.body.visit(*this);
+		if(iter.loop_expression)
+			iter.loop_expression->visit(*this);
+	}
+	swap(loop_ext_refs, saved_refs);
 
-	BlockVariableMap &block_variables = variables.back();
-	for(BlockVariableMap::iterator i=block_variables.begin(); i!=block_variables.end(); ++i)
-		if(!i->second.local && i->second.referenced)
-			i->second.assignments.clear();
+	/* Visit the external references of the loop again to record assignments
+	done in the loop as used. */
+	for(Node *n: saved_refs)
+		n->visit(*this);
 
-	merge_down_variables();
+	/* Merge assignments from the iteration, without clearing previous state.
+	Further analysis is needed to determine which parts of the iteration body
+	are always executed, if any. */
+	merge_variables(saved_vars);
 }