X-Git-Url: http://git.tdb.fi/?p=libs%2Fgl.git;a=blobdiff_plain;f=source%2Fglsl%2Foptimize.cpp;h=ed20bb175dcc9277e1ff84e2e1a1734b2279668f;hp=32f7ce67959b388fa1bc2c2fb58ecc344a11bb87;hb=8bf70f4d445cf63386ad7aafc5b3ebdbd8369939;hpb=2280a09a286bbff2eb41783f8023863f320a3736

diff --git a/source/glsl/optimize.cpp b/source/glsl/optimize.cpp
index 32f7ce67..ed20bb17 100644
--- a/source/glsl/optimize.cpp
+++ b/source/glsl/optimize.cpp
@@ -1,5 +1,6 @@
 #include <msp/core/raii.h>
 #include <msp/strings/format.h>
+#include <msp/strings/utils.h>
 #include "optimize.h"
 #include "reflect.h"
 
@@ -75,7 +76,7 @@ void InlineableFunctionLocator::visit(FunctionCall &call)
 		++count;
 		/* Don't inline functions which are called more than once or are called
 		recursively. */
-		if(count>1 || def==current_function)
+		if((count>1 && def->source!=BUILTIN_SOURCE) || def==current_function)
 			inlineable.erase(def);
 	}
 
@@ -89,7 +90,7 @@ void InlineableFunctionLocator::visit(FunctionDeclaration &func)
 		has_out_params = ((*i)->interface=="out");
 
 	unsigned &count = refcounts[func.definition];
-	if(count<=1 && !has_out_params)
+	if((count<=1 || func.source==BUILTIN_SOURCE) && !has_out_params)
 		inlineable.insert(func.definition);
 
 	SetForScope<FunctionDeclaration *> set(current_function, &func);
@@ -138,7 +139,7 @@ string InlineContentInjector::apply(Stage &stage, FunctionDeclaration &target_fu
 	staging_block.parent = &tgt_blk;
 	staging_block.variables.clear();
 
-	std::vector<RefPtr<VariableDeclaration> > params;
+	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)
 	{
@@ -553,18 +554,6 @@ 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)
 {
@@ -603,6 +592,31 @@ T ConstantFolder::evaluate_arithmetic(char oper, T left, T right)
 	}
 }
 
+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();
+	}
+}
+
+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 ConstantFolder::set_result(const Variant &value, bool literal)
 {
 	r_constant_value = value;
@@ -623,22 +637,27 @@ void ConstantFolder::visit(RefPtr<Expression> &expr)
 	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)
+	if(r_constant_value.check_type<bool>())
 		literal->token = (r_constant_value.value<bool>() ? "true" : "false");
-	else if(kind==BasicTypeDeclaration::INT)
+	else if(r_constant_value.check_type<int>())
 		literal->token = lexical_cast<string>(r_constant_value.value<int>());
-	else if(kind==BasicTypeDeclaration::FLOAT)
+	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>());
+		if(isnumrc(literal->token))
+			literal->token += ".0";
+	}
+	else
+	{
+		r_constant = false;
+		return;
+	}
 	literal->value = r_constant_value;
 	expr = literal;
+	r_any_folded = true;
 }
 
 void ConstantFolder::visit(Literal &literal)
@@ -678,25 +697,27 @@ void ConstantFolder::visit(UnaryExpression &unary)
 	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)
+		if(r_constant_value.check_type<bool>())
 			set_result(!r_constant_value.value<bool>());
 	}
 	else if(oper=='~')
 	{
-		if(kind==BasicTypeDeclaration::INT)
+		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(kind==BasicTypeDeclaration::INT)
+		if(r_constant_value.check_type<int>())
 			set_result(-r_constant_value.value<int>());
-		else if(kind==BasicTypeDeclaration::FLOAT)
+		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>());
 	}
 }
@@ -716,53 +737,54 @@ void ConstantFolder::visit(BinaryExpression &binary)
 	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)
+	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_kind==BasicTypeDeclaration::BOOL)
+		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_kind==BasicTypeDeclaration::INT)
+		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_kind==BasicTypeDeclaration::INT)
+		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_kind==BasicTypeDeclaration::FLOAT)
+		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_kind==BasicTypeDeclaration::INT)
+		if(left_value.check_type<int>())
 			set_result((left_value.value<int>()==r_constant_value.value<int>()) == (oper=='='));
-		if(left_kind==BasicTypeDeclaration::FLOAT)
+		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_kind==BasicTypeDeclaration::INT)
+		if(left_value.check_type<int>())
 			set_result(evaluate_arithmetic(oper, left_value.value<int>(), r_constant_value.value<int>()));
-		else if(left_kind==BasicTypeDeclaration::FLOAT)
+		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_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>());
+		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>()));
 	}
 }
 
@@ -780,6 +802,30 @@ void ConstantFolder::visit(TernaryExpression &ternary)
 
 void ConstantFolder::visit(FunctionCall &call)
 {
+	if(call.constructor && call.type && call.arguments.size()==1)
+	{
+		const BasicTypeDeclaration *basic = dynamic_cast<const BasicTypeDeclaration *>(call.type);
+		if(basic)
+		{
+			call.arguments[0]->visit(*this);
+			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;
+		}
+	}
+
 	TraversingVisitor::visit(call);
 	r_constant = false;
 }
@@ -907,40 +953,63 @@ void ConstantConditionEliminator::visit(Iteration &iter)
 }
 
 
-bool UnusedTypeRemover::apply(Stage &stage)
+UnreachableCodeRemover::UnreachableCodeRemover():
+	reachable(true)
+{ }
+
+bool UnreachableCodeRemover::apply(Stage &stage)
 {
 	stage.content.visit(*this);
-	NodeRemover().apply(stage, unused_nodes);
-	return !unused_nodes.empty();
+	NodeRemover().apply(stage, unreachable_nodes);
+	return !unreachable_nodes.empty();
 }
 
-void UnusedTypeRemover::visit(Literal &literal)
+void UnreachableCodeRemover::visit(Block &block)
 {
-	unused_nodes.erase(literal.type);
+	NodeList<Statement>::iterator 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());
 }
 
-void UnusedTypeRemover::visit(UnaryExpression &unary)
+void UnreachableCodeRemover::visit(FunctionDeclaration &func)
 {
-	unused_nodes.erase(unary.type);
-	TraversingVisitor::visit(unary);
+	TraversingVisitor::visit(func);
+	reachable = true;
 }
 
-void UnusedTypeRemover::visit(BinaryExpression &binary)
+void UnreachableCodeRemover::visit(Conditional &cond)
 {
-	unused_nodes.erase(binary.type);
-	TraversingVisitor::visit(binary);
+	cond.body.visit(*this);
+	bool reachable_if_true = reachable;
+	reachable = true;
+	cond.else_body.visit(*this);
+
+	reachable |= reachable_if_true;
 }
 
-void UnusedTypeRemover::visit(TernaryExpression &ternary)
+void UnreachableCodeRemover::visit(Iteration &iter)
 {
-	unused_nodes.erase(ternary.type);
-	TraversingVisitor::visit(ternary);
+	TraversingVisitor::visit(iter);
+
+	/* Always consider code after a loop reachable, since there's no checking
+	for whether the loop executes. */
+	reachable = true;
 }
 
-void UnusedTypeRemover::visit(FunctionCall &call)
+
+bool UnusedTypeRemover::apply(Stage &stage)
 {
-	unused_nodes.erase(call.type);
-	TraversingVisitor::visit(call);
+	stage.content.visit(*this);
+	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)
@@ -966,6 +1035,7 @@ void UnusedTypeRemover::visit(StructDeclaration &strct)
 void UnusedTypeRemover::visit(VariableDeclaration &var)
 {
 	unused_nodes.erase(var.type_declaration);
+	TraversingVisitor::visit(var);
 }
 
 void UnusedTypeRemover::visit(InterfaceBlock &iface)
@@ -985,7 +1055,10 @@ UnusedVariableRemover::UnusedVariableRemover():
 	interface_block(0),
 	r_assignment(0),
 	assignment_target(false),
-	r_side_effects(false)
+	r_side_effects(false),
+	in_struct(false),
+	composite_reference(false),
+	in_loop(0)
 { }
 
 bool UnusedVariableRemover::apply(Stage &s)
@@ -1029,19 +1102,90 @@ void UnusedVariableRemover::referenced(const Assignment::Target &target, Node &n
 	var_info.referenced = true;
 	if(!assignment_target)
 	{
+		bool loop_external = false;
 		for(vector<AssignmentInfo *>::const_iterator i=var_info.assignments.begin(); i!=var_info.assignments.end(); ++i)
-			(*i)->used_by.push_back(&node);
+		{
+			bool covered = true;
+			for(unsigned j=0; (covered && j<(*i)->target.chain_len && j<target.chain_len); ++j)
+			{
+				Assignment::Target::ChainType type1 = static_cast<Assignment::Target::ChainType>((*i)->target.chain[j]&0xC0);
+				Assignment::Target::ChainType type2 = static_cast<Assignment::Target::ChainType>(target.chain[j]&0xC0);
+				if(type1==Assignment::Target::SWIZZLE || type2==Assignment::Target::SWIZZLE)
+				{
+					unsigned index1 = (*i)->target.chain[j]&0x3F;
+					unsigned index2 = target.chain[j]&0x3F;
+					if(type1==Assignment::Target::SWIZZLE && type2==Assignment::Target::SWIZZLE)
+						covered = index1&index2;
+					else if(type1==Assignment::Target::ARRAY && index1<4)
+						covered = index2&(1<<index1);
+					else if(type2==Assignment::Target::ARRAY && index2<4)
+						covered = index1&(1<<index2);
+					/* If it's some other combination (shouldn't happen), leave
+					covered as true */
+				}
+				else
+					covered = ((*i)->target.chain[j]==target.chain[j]);
+			}
+
+			if(covered)
+			{
+				(*i)->used_by.push_back(&node);
+				if((*i)->in_loop<in_loop)
+					loop_external = true;
+			}
+		}
+
+		if(loop_external)
+			loop_ext_refs.push_back(&node);
 	}
 }
 
 void UnusedVariableRemover::visit(VariableReference &var)
 {
-	referenced(var.declaration, var);
+	if(composite_reference)
+		r_reference.declaration = var.declaration;
+	else
+		referenced(var.declaration, var);
 }
 
 void UnusedVariableRemover::visit(InterfaceBlockReference &iface)
 {
-	referenced(iface.declaration, iface);
+	if(composite_reference)
+		r_reference.declaration = iface.declaration;
+	else
+		referenced(iface.declaration, iface);
+}
+
+void UnusedVariableRemover::visit_composite(Expression &expr)
+{
+	if(!composite_reference)
+		r_reference = Assignment::Target();
+
+	SetFlag set_composite(composite_reference);
+	expr.visit(*this);
+}
+
+void UnusedVariableRemover::visit(MemberAccess &memacc)
+{
+	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)
@@ -1055,12 +1199,30 @@ void UnusedVariableRemover::visit(BinaryExpression &binary)
 {
 	if(binary.oper->token[0]=='[')
 	{
-		binary.left->visit(*this);
-		SetFlag set(assignment_target, false);
-		binary.right->visit(*this);
+		visit_composite(*binary.left);
+
+		{
+			SetFlag clear_assignment(assignment_target, false);
+			SetFlag clear_composite(composite_reference, false);
+			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)
@@ -1076,6 +1238,7 @@ void UnusedVariableRemover::visit(Assignment &assign)
 
 void UnusedVariableRemover::visit(FunctionCall &call)
 {
+	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. */
@@ -1095,6 +1258,7 @@ void UnusedVariableRemover::record_assignment(const Assignment::Target &target,
 	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. */
@@ -1127,8 +1291,19 @@ void UnusedVariableRemover::visit(ExpressionStatement &expr)
 		unused_nodes.insert(&expr);
 }
 
+void UnusedVariableRemover::visit(StructDeclaration &strct)
+{
+	SetFlag set_struct(in_struct);
+	TraversingVisitor::visit(strct);
+}
+
 void UnusedVariableRemover::visit(VariableDeclaration &var)
 {
+	TraversingVisitor::visit(var);
+
+	if(in_struct)
+		return;
+
 	VariableInfo &var_info = variables[&var];
 	var_info.interface_block = interface_block;
 
@@ -1144,7 +1319,6 @@ void UnusedVariableRemover::visit(VariableDeclaration &var)
 		var_info.initialized = true;
 		record_assignment(&var, *var.init_expression);
 	}
-	TraversingVisitor::visit(var);
 }
 
 void UnusedVariableRemover::visit(InterfaceBlock &iface)
@@ -1216,7 +1390,18 @@ void UnusedVariableRemover::visit(Conditional &cond)
 void UnusedVariableRemover::visit(Iteration &iter)
 {
 	BlockVariableMap saved_vars = variables;
-	TraversingVisitor::visit(iter);
+	vector<Node *> saved_refs;
+	swap(loop_ext_refs, saved_refs);
+	{
+		SetForScope<unsigned> set_loop(in_loop, in_loop+1);
+		TraversingVisitor::visit(iter);
+	}
+	swap(loop_ext_refs, saved_refs);
+
+	/* Visit the external references of the loop again to record assignments
+	done in the loop as used. */
+	for(vector<Node *>::const_iterator i=saved_refs.begin(); i!=saved_refs.end(); ++i)
+		(*i)->visit(*this);
 
 	/* Merge assignments from the iteration, without clearing previous state.
 	Further analysis is needed to determine which parts of the iteration body