X-Git-Url: http://git.tdb.fi/?p=libs%2Fgl.git;a=blobdiff_plain;f=source%2Fglsl%2Foptimize.cpp;h=7d605f1f12bc755812a3252172828a84d3720777;hp=9ab8ef70ef94dfc235e08ecee479792f9ae9cf2b;hb=4790c6a06072814b21f5b3f24b53c6936915308d;hpb=7335009e18ecbf53ad9f59d64eed2ed5abbe7b8b

diff --git a/source/glsl/optimize.cpp b/source/glsl/optimize.cpp
index 9ab8ef70..7d605f1f 100644
--- a/source/glsl/optimize.cpp
+++ b/source/glsl/optimize.cpp
@@ -34,8 +34,12 @@ void InlineableFunctionLocator::visit(FunctionCall &call)
 
 void InlineableFunctionLocator::visit(FunctionDeclaration &func)
 {
+	bool has_out_params = false;
+	for(NodeArray<VariableDeclaration>::const_iterator i=func.parameters.begin(); (!has_out_params && i!=func.parameters.end()); ++i)
+		has_out_params = ((*i)->interface=="out");
+
 	unsigned &count = refcounts[func.definition];
-	if(count<=1 && func.parameters.empty())
+	if(count<=1 && !has_out_params)
 		inlineable.insert(func.definition);
 
 	SetForScope<FunctionDeclaration *> set(current_function, &func);
@@ -66,75 +70,117 @@ void InlineableFunctionLocator::visit(Return &ret)
 
 InlineContentInjector::InlineContentInjector():
 	source_func(0),
-	remap_names(false),
-	deps_only(false)
+	pass(DEPENDS)
 { }
 
-const string &InlineContentInjector::apply(Stage &stage, FunctionDeclaration &target_func, Block &tgt_blk, const NodeList<Statement>::iterator &ins_pt, FunctionDeclaration &src)
+const string &InlineContentInjector::apply(Stage &stage, FunctionDeclaration &target_func, Block &tgt_blk, const NodeList<Statement>::iterator &ins_pt, FunctionCall &call)
 {
-	target_block = &tgt_blk;
-	source_func = &src;
-	for(NodeList<Statement>::iterator i=src.body.body.begin(); i!=src.body.body.end(); ++i)
+	source_func = call.declaration->definition;
+
+	// Collect all declarations the inlined function depends on.
+	pass = DEPENDS;
+	source_func->visit(*this);
+
+	/* Populate referenced_names from the target function so we can rename
+	variables from the inlined function that would conflict. */
+	pass = REFERENCED;
+	target_func.visit(*this);
+
+	/* 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();
+	remap_prefix = source_func->name;
+
+	std::vector<RefPtr<VariableDeclaration> > params;
+	params.reserve(source_func->parameters.size());
+	for(NodeArray<VariableDeclaration>::iterator i=source_func->parameters.begin(); i!=source_func->parameters.end(); ++i)
+	{
+		RefPtr<VariableDeclaration> var = (*i)->clone();
+		var->interface.clear();
+
+		SetForScope<Pass> set_pass(pass, RENAME);
+		var->visit(*this);
+
+		staging_block.body.push_back(0);
+		staging_block.body.back() = var;
+		params.push_back(var);
+	}
+
+	for(NodeList<Statement>::iterator i=source_func->body.body.begin(); i!=source_func->body.body.end(); ++i)
 	{
 		r_inlined_statement = 0;
 		(*i)->visit(*this);
 		if(!r_inlined_statement)
 			r_inlined_statement = (*i)->clone();
 
-		SetFlag set_remap(remap_names);
+		SetForScope<Pass> set_pass(pass, RENAME);
 		r_inlined_statement->visit(*this);
-		tgt_blk.body.insert(ins_pt, r_inlined_statement);
+
+		staging_block.body.push_back(0);
+		staging_block.body.back() = 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;
+	remap_prefix = target_func.name;
+	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, dependencies);
 
 	return r_result_name;
 }
 
-string InlineContentInjector::create_unused_name(const string &base, bool always_prefix)
-{
-	string result = base;
-	if(always_prefix || target_block->variables.count(result))
-		result = format("_%s_%s", source_func->name, base);
-	unsigned initial_size = result.size();
-	for(unsigned i=1; target_block->variables.count(result); ++i)
-	{
-		result.erase(initial_size);
-		result += format("_%d", i);
-	}
-	return result;
-}
-
 void InlineContentInjector::visit(VariableReference &var)
 {
-	if(remap_names)
+	if(pass==RENAME)
 	{
-		map<string, VariableDeclaration *>::const_iterator i = variable_map.find(var.name);
-		if(i!=variable_map.end())
+		map<string, VariableDeclaration *>::const_iterator i = staging_block.variables.find(var.name);
+		if(i!=staging_block.variables.end())
 			var.name = i->second->name;
 	}
-	else if(var.declaration)
+	else if(pass==DEPENDS && var.declaration)
 	{
-		SetFlag set_deps(deps_only);
 		dependencies.insert(var.declaration);
 		var.declaration->visit(*this);
 	}
+	else if(pass==REFERENCED)
+		referenced_names.insert(var.name);
 }
 
 void InlineContentInjector::visit(InterfaceBlockReference &iface)
 {
-	if(!remap_names && iface.declaration)
+	if(pass==DEPENDS && iface.declaration)
 	{
-		SetFlag set_deps(deps_only);
 		dependencies.insert(iface.declaration);
 		iface.declaration->visit(*this);
 	}
+	else if(pass==REFERENCED)
+		referenced_names.insert(iface.name);
 }
 
 void InlineContentInjector::visit(FunctionCall &call)
 {
-	if(!remap_names && call.declaration)
+	if(pass==DEPENDS && call.declaration)
 		dependencies.insert(call.declaration);
+	else if(pass==REFERENCED)
+		referenced_names.insert(call.name);
 	TraversingVisitor::visit(call);
 }
 
@@ -142,32 +188,36 @@ void InlineContentInjector::visit(VariableDeclaration &var)
 {
 	TraversingVisitor::visit(var);
 
-	if(var.type_declaration)
+	if(pass==RENAME)
 	{
-		SetFlag set_deps(deps_only);
-		dependencies.insert(var.type_declaration);
-		var.type_declaration->visit(*this);
+		staging_block.variables[var.name] = &var;
+		if(referenced_names.count(var.name))
+		{
+			string mapped_name = get_unused_variable_name(staging_block, var.name, remap_prefix);
+			if(mapped_name!=var.name)
+			{
+				staging_block.variables[mapped_name] = &var;
+				var.name = mapped_name;
+			}
+		}
 	}
-
-	if(!remap_names && !deps_only)
+	else if(pass==DEPENDS && var.type_declaration)
 	{
-		RefPtr<VariableDeclaration> inlined_var = var.clone();
-		inlined_var->name = create_unused_name(var.name, false);
-		r_inlined_statement = inlined_var;
-
-		variable_map[var.name] = inlined_var.get();
+		dependencies.insert(var.type_declaration);
+		var.type_declaration->visit(*this);
 	}
+	else if(pass==REFERENCED)
+		referenced_names.insert(var.type);
 }
 
 void InlineContentInjector::visit(Return &ret)
 {
 	TraversingVisitor::visit(ret);
 
-	if(ret.expression)
+	if(pass==INLINE && ret.expression)
 	{
-		/* Create a new variable to hold the return value of the inlined
-		function. */
-		r_result_name = create_unused_name("return", true);
+		// Create a new variable to hold the return value of the inlined function.
+		r_result_name = get_unused_variable_name(staging_block, "_return", source_func->name);
 		RefPtr<VariableDeclaration> var = new VariableDeclaration;
 		var->source = ret.source;
 		var->line = ret.line;
@@ -181,7 +231,8 @@ void InlineContentInjector::visit(Return &ret)
 
 FunctionInliner::FunctionInliner():
 	current_function(0),
-	r_any_inlined(false)
+	r_any_inlined(false),
+	r_inlined_here(false)
 { }
 
 bool FunctionInliner::apply(Stage &s)
@@ -209,7 +260,7 @@ 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(NodeList<Statement>::iterator i=block.body.begin(); i!=block.body.end(); ++i)
+	for(NodeList<Statement>::iterator i=block.body.begin(); (!r_inlined_here && i!=block.body.end()); ++i)
 	{
 		insert_point = i;
 		(*i)->visit(*this);
@@ -218,6 +269,9 @@ void FunctionInliner::visit(Block &block)
 
 void FunctionInliner::visit(FunctionCall &call)
 {
+	if(r_inlined_here)
+		return;
+
 	for(NodeArray<Expression>::iterator i=call.arguments.begin(); i!=call.arguments.end(); ++i)
 		visit(*i);
 
@@ -227,7 +281,7 @@ void FunctionInliner::visit(FunctionCall &call)
 
 	if(def && inlineable.count(def))
 	{
-		string result_name = InlineContentInjector().apply(*stage, *current_function, *current_block, insert_point, *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())
@@ -240,6 +294,7 @@ void FunctionInliner::visit(FunctionCall &call)
 		/* Inlined variables need to be resolved before this function can be
 		inlined further. */
 		inlineable.erase(current_function);
+		r_inlined_here = true;
 	}
 }
 
@@ -247,6 +302,7 @@ void FunctionInliner::visit(FunctionDeclaration &func)
 {
 	SetForScope<FunctionDeclaration *> set_func(current_function, &func);
 	TraversingVisitor::visit(func);
+	r_inlined_here = false;
 }
 
 void FunctionInliner::visit(Iteration &iter)
@@ -268,9 +324,6 @@ ExpressionInliner::ExpressionInfo::ExpressionInfo():
 	expression(0),
 	assign_scope(0),
 	inline_point(0),
-	inner_oper(0),
-	outer_oper(0),
-	inline_on_rhs(false),
 	trivial(false),
 	available(true)
 { }
@@ -292,56 +345,9 @@ bool ExpressionInliner::apply(Stage &s)
 	return r_any_inlined;
 }
 
-void ExpressionInliner::visit_and_record(RefPtr<Expression> &ptr, const Operator *outer_oper, bool on_rhs)
-{
-	r_ref_info = 0;
-	ptr->visit(*this);
-	if(r_ref_info && r_ref_info->expression && r_ref_info->available)
-	{
-		if(iteration_body && !r_ref_info->trivial)
-		{
-			/* Don't inline non-trivial expressions which were assigned outside
-			an iteration statement.  The iteration may run multiple times, which
-			would cause the expression to also be evaluated multiple times. */
-			Block *i = r_ref_info->assign_scope;
-			for(; (i && i!=iteration_body); i=i->parent) ;
-			if(!i)
-				return;
-		}
-
-		r_ref_info->outer_oper = outer_oper;
-		if(r_ref_info->trivial)
-			inline_expression(*r_ref_info->expression, ptr, outer_oper, r_ref_info->inner_oper, on_rhs);
-		else
-		{
-			/* Record the inline point for a non-trivial expression but don't
-			inline it yet.  It might turn out it shouldn't be inlined after all. */
-			r_ref_info->inline_point = &ptr;
-			r_ref_info->inline_on_rhs = on_rhs;
-		}
-	}
-	r_ref_info = 0;
-}
-
-void ExpressionInliner::inline_expression(Expression &expr, RefPtr<Expression> &ptr, const Operator *outer_oper, const Operator *inner_oper, bool on_rhs)
+void ExpressionInliner::inline_expression(Expression &expr, RefPtr<Expression> &ptr)
 {
-	unsigned outer_precedence = (outer_oper ? outer_oper->precedence : 20);
-	unsigned inner_precedence = (inner_oper ? inner_oper->precedence : 0);
-
-	bool needs_parentheses = (inner_precedence>=outer_precedence);
-	if(inner_oper && inner_oper==outer_oper)
-		// Omit parentheses if the operator's natural grouping works out.
-		needs_parentheses = (inner_oper->assoc!=Operator::ASSOCIATIVE && on_rhs!=(inner_oper->assoc==Operator::RIGHT_TO_LEFT));
-
-	if(needs_parentheses)
-	{
-		RefPtr<ParenthesizedExpression> parexpr = new ParenthesizedExpression;
-		parexpr->expression = expr.clone();
-		ptr = parexpr;
-	}
-	else
-		ptr = expr.clone();
-
+	ptr = expr.clone();
 	r_any_inlined = true;
 }
 
@@ -355,7 +361,7 @@ void ExpressionInliner::visit(Block &block)
 		for(; (j!=expressions.end() && j->first.declaration==i->second); )
 		{
 			if(j->second.expression && j->second.inline_point)
-				inline_expression(*j->second.expression, *j->second.inline_point, j->second.outer_oper, j->second.inner_oper, j->second.inline_on_rhs);
+				inline_expression(*j->second.expression, *j->second.inline_point);
 
 			expressions.erase(j++);
 		}
@@ -371,7 +377,30 @@ void ExpressionInliner::visit(Block &block)
 
 void ExpressionInliner::visit(RefPtr<Expression> &expr)
 {
-	visit_and_record(expr, 0, false);
+	r_ref_info = 0;
+	expr->visit(*this);
+	if(r_ref_info && r_ref_info->expression && r_ref_info->available)
+	{
+		if(iteration_body && !r_ref_info->trivial)
+		{
+			/* Don't inline non-trivial expressions which were assigned outside
+			an iteration statement.  The iteration may run multiple times, which
+			would cause the expression to also be evaluated multiple times. */
+			Block *i = r_ref_info->assign_scope;
+			for(; (i && i!=iteration_body); i=i->parent) ;
+			if(!i)
+				return;
+		}
+
+		if(r_ref_info->trivial)
+			inline_expression(*r_ref_info->expression, expr);
+		else
+			/* Record the inline point for a non-trivial expression but don't
+			inline it yet.  It might turn out it shouldn't be inlined after all. */
+			r_ref_info->inline_point = &expr;
+	}
+	r_oper = expr->oper;
+	r_ref_info = 0;
 }
 
 void ExpressionInliner::visit(VariableReference &var)
@@ -396,34 +425,30 @@ void ExpressionInliner::visit(VariableReference &var)
 
 void ExpressionInliner::visit(MemberAccess &memacc)
 {
-	visit_and_record(memacc.left, memacc.oper, false);
-	r_oper = memacc.oper;
+	visit(memacc.left);
 	r_trivial = false;
 }
 
 void ExpressionInliner::visit(Swizzle &swizzle)
 {
-	visit_and_record(swizzle.left, swizzle.oper, false);
-	r_oper = swizzle.oper;
+	visit(swizzle.left);
 	r_trivial = false;
 }
 
 void ExpressionInliner::visit(UnaryExpression &unary)
 {
 	SetFlag set_target(mutating, mutating || unary.oper->token[1]=='+' || unary.oper->token[1]=='-');
-	visit_and_record(unary.expression, unary.oper, false);
-	r_oper = unary.oper;
+	visit(unary.expression);
 	r_trivial = false;
 }
 
 void ExpressionInliner::visit(BinaryExpression &binary)
 {
-	visit_and_record(binary.left, binary.oper, false);
+	visit(binary.left);
 	{
 		SetFlag clear_target(mutating, false);
-		visit_and_record(binary.right, binary.oper, true);
+		visit(binary.right);
 	}
-	r_oper = binary.oper;
 	r_trivial = false;
 }
 
@@ -431,10 +456,10 @@ void ExpressionInliner::visit(Assignment &assign)
 {
 	{
 		SetFlag set_target(mutating);
-		visit_and_record(assign.left, assign.oper, false);
+		visit(assign.left);
 	}
 	r_oper = 0;
-	visit_and_record(assign.right, assign.oper, true);
+	visit(assign.right);
 
 	map<Assignment::Target, ExpressionInfo>::iterator i = expressions.find(assign.target);
 	if(i!=expressions.end())
@@ -444,18 +469,23 @@ void ExpressionInliner::visit(Assignment &assign)
 		i->second.expression = (assign.self_referencing ? 0 : assign.right.get());
 		i->second.assign_scope = current_block;
 		i->second.inline_point = 0;
-		i->second.inner_oper = r_oper;
 		i->second.available = true;
 	}
 
-	r_oper = assign.oper;
+	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_oper = 0;
 	r_trivial = false;
 }
 
@@ -482,7 +512,6 @@ void ExpressionInliner::visit(VariableDeclaration &var)
 		will have their values change throughout the iteration. */
 		info.expression = (iteration_init ? 0 : var.init_expression.get());
 		info.assign_scope = current_block;
-		info.inner_oper = r_oper;
 		info.trivial = r_trivial;
 	}
 }
@@ -505,12 +534,301 @@ void ExpressionInliner::visit(Iteration &iter)
 }
 
 
+BasicTypeDeclaration::Kind ConstantFolder::get_value_kind(const Variant &value)
+{
+	if(value.check_type<bool>())
+		return BasicTypeDeclaration::BOOL;
+	else if(value.check_type<int>())
+		return BasicTypeDeclaration::INT;
+	else if(value.check_type<float>())
+		return BasicTypeDeclaration::FLOAT;
+	else
+		return BasicTypeDeclaration::VOID;
+}
+
+template<typename T>
+T ConstantFolder::evaluate_logical(char oper, T left, T right)
+{
+	switch(oper)
+	{
+	case '&': return left&right;
+	case '|': return left|right;
+	case '^': return left^right;
+	default: return T();
+	}
+}
+
+template<typename T>
+bool ConstantFolder::evaluate_relation(const char *oper, T left, T right)
+{
+	switch(oper[0]|oper[1])
+	{
+	case '<': return left<right;
+	case '<'|'=': return left<=right;
+	case '>': return left>right;
+	case '>'|'=': return left>=right;
+	default: return false;
+	}
+}
+
+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();
+	}
+}
+
+void ConstantFolder::set_result(const Variant &value, bool literal)
+{
+	r_constant_value = value;
+	r_constant = true;
+	r_literal = literal;
+}
+
+void ConstantFolder::visit(RefPtr<Expression> &expr)
+{
+	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;
+
+	BasicTypeDeclaration::Kind kind = get_value_kind(r_constant_value);
+	if(kind==BasicTypeDeclaration::VOID)
+	{
+		r_constant = false;
+		return;
+	}
+
+	RefPtr<Literal> literal = new Literal;
+	if(kind==BasicTypeDeclaration::BOOL)
+		literal->token = (r_constant_value.value<bool>() ? "true" : "false");
+	else if(kind==BasicTypeDeclaration::INT)
+		literal->token = lexical_cast<string>(r_constant_value.value<int>());
+	else if(kind==BasicTypeDeclaration::FLOAT)
+		literal->token = lexical_cast<string>(r_constant_value.value<float>());
+	literal->value = r_constant_value;
+	expr = literal;
+}
+
+void ConstantFolder::visit(Literal &literal)
+{
+	set_result(literal.value, true);
+}
+
+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)
+	{
+		set_result(iter_init_value);
+		r_uses_iter_var = true;
+	}
+}
+
+void ConstantFolder::visit(MemberAccess &memacc)
+{
+	TraversingVisitor::visit(memacc);
+	r_constant = false;
+}
+
+void ConstantFolder::visit(Swizzle &swizzle)
+{
+	TraversingVisitor::visit(swizzle);
+	r_constant = false;
+}
+
+void ConstantFolder::visit(UnaryExpression &unary)
+{
+	TraversingVisitor::visit(unary);
+	bool can_fold = r_constant;
+	r_constant = false;
+	if(!can_fold)
+		return;
+
+	BasicTypeDeclaration::Kind kind = get_value_kind(r_constant_value);
+
+	char oper = unary.oper->token[0];
+	char oper2 = unary.oper->token[1];
+	if(oper=='!')
+	{
+		if(kind==BasicTypeDeclaration::BOOL)
+			set_result(!r_constant_value.value<bool>());
+	}
+	else if(oper=='~')
+	{
+		if(kind==BasicTypeDeclaration::INT)
+			set_result(~r_constant_value.value<int>());
+	}
+	else if(oper=='-' && !oper2)
+	{
+		if(kind==BasicTypeDeclaration::INT)
+			set_result(-r_constant_value.value<int>());
+		else if(kind==BasicTypeDeclaration::FLOAT)
+			set_result(-r_constant_value.value<float>());
+	}
+}
+
+void ConstantFolder::visit(BinaryExpression &binary)
+{
+	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;
+
+	BasicTypeDeclaration::Kind left_kind = get_value_kind(left_value);
+	BasicTypeDeclaration::Kind right_kind = get_value_kind(r_constant_value);
+	// Currently only expressions with both sides of equal types are handled.
+	if(left_kind!=right_kind)
+		return;
+
+	char oper = binary.oper->token[0];
+	char oper2 = binary.oper->token[1];
+	if(oper=='&' || oper=='|' || oper=='^')
+	{
+		if(oper2==oper && left_kind==BasicTypeDeclaration::BOOL)
+			set_result(evaluate_logical(oper, left_value.value<bool>(), r_constant_value.value<bool>()));
+		else if(!oper2 && left_kind==BasicTypeDeclaration::INT)
+			set_result(evaluate_logical(oper, left_value.value<int>(), r_constant_value.value<int>()));
+	}
+	else if((oper=='<' || oper=='>') && oper2!=oper)
+	{
+		if(left_kind==BasicTypeDeclaration::INT)
+			set_result(evaluate_relation(binary.oper->token, left_value.value<int>(), r_constant_value.value<int>()));
+		else if(left_kind==BasicTypeDeclaration::FLOAT)
+			set_result(evaluate_relation(binary.oper->token, left_value.value<float>(), r_constant_value.value<float>()));
+	}
+	else if((oper=='=' || oper=='!') && oper2=='=')
+	{
+		if(left_kind==BasicTypeDeclaration::INT)
+			set_result((left_value.value<int>()==r_constant_value.value<int>()) == (oper=='='));
+		if(left_kind==BasicTypeDeclaration::FLOAT)
+			set_result((left_value.value<float>()==r_constant_value.value<float>()) == (oper=='='));
+	}
+	else if(oper=='+' || oper=='-' || oper=='*' || oper=='/')
+	{
+		if(left_kind==BasicTypeDeclaration::INT)
+			set_result(evaluate_arithmetic(oper, left_value.value<int>(), r_constant_value.value<int>()));
+		else if(left_kind==BasicTypeDeclaration::FLOAT)
+			set_result(evaluate_arithmetic(oper, left_value.value<float>(), r_constant_value.value<float>()));
+	}
+	else if(oper=='%' || ((oper=='<' || oper=='>') && oper2==oper))
+	{
+		if(left_kind!=BasicTypeDeclaration::INT)
+			return;
+
+		if(oper=='%')
+			set_result(left_value.value<int>()%r_constant_value.value<int>());
+		else if(oper=='<')
+			set_result(left_value.value<int>()<<r_constant_value.value<int>());
+		else if(oper=='>')
+			set_result(left_value.value<int>()>>r_constant_value.value<int>());
+	}
+}
+
+void ConstantFolder::visit(Assignment &assign)
+{
+	TraversingVisitor::visit(assign);
+	r_constant = false;
+}
+
+void ConstantFolder::visit(TernaryExpression &ternary)
+{
+	TraversingVisitor::visit(ternary);
+	r_constant = false;
+}
+
+void ConstantFolder::visit(FunctionCall &call)
+{
+	TraversingVisitor::visit(call);
+	r_constant = false;
+}
+
+void ConstantFolder::visit(VariableDeclaration &var)
+{
+	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 ConstantFolder::visit(Iteration &iter)
+{
+	SetForScope<Block *> set_block(current_block, &iter.body);
+
+	/* 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);
+}
+
+
 void ConstantConditionEliminator::apply(Stage &stage)
 {
 	stage.content.visit(*this);
 	NodeRemover().apply(stage, nodes_to_remove);
 }
 
+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);
@@ -521,16 +839,35 @@ void ConstantConditionEliminator::visit(Block &block)
 	}
 }
 
+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(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(Conditional &cond)
 {
-	if(Literal *literal = dynamic_cast<Literal *>(cond.condition.get()))
-		if(literal->value.check_type<bool>())
-		{
-			Block &block = (literal->value.value<bool>() ? cond.body : cond.else_body);
-			current_block->body.splice(insert_point, block.body);
-			nodes_to_remove.insert(&cond);
-			return;
-		}
+	ConstantStatus result = check_constant_condition(*cond.condition);
+	if(result!=NOT_CONSTANT)
+	{
+		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;
+	}
 
 	TraversingVisitor::visit(cond);
 }
@@ -539,14 +876,8 @@ void ConstantConditionEliminator::visit(Iteration &iter)
 {
 	if(iter.condition)
 	{
-		/* If the loop condition is always false on the first iteration, the
-		entire loop can be removed */
-		ExpressionEvaluator::ValueMap values;
-		if(VariableDeclaration *var = dynamic_cast<VariableDeclaration *>(iter.init_statement.get()))
-			values[var] = var->init_expression.get();
-		ExpressionEvaluator eval(values);
-		iter.condition->visit(eval);
-		if(eval.is_result_valid() && !eval.get_result())
+		ConstantStatus result = check_constant_condition(*iter.condition);
+		if(result==CONSTANT_FALSE)
 		{
 			nodes_to_remove.insert(&iter);
 			return;
@@ -581,6 +912,12 @@ void UnusedTypeRemover::visit(BinaryExpression &binary)
 	TraversingVisitor::visit(binary);
 }
 
+void UnusedTypeRemover::visit(TernaryExpression &ternary)
+{
+	unused_nodes.erase(ternary.type);
+	TraversingVisitor::visit(ternary);
+}
+
 void UnusedTypeRemover::visit(FunctionCall &call)
 {
 	unused_nodes.erase(call.type);