X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fglsl%2Foptimize.cpp;h=b7236feb6fafb4f7e0495b3b6e8260329f91b29b;hb=f76e62a74917dbd850912587a5e79240dec9681f;hp=208e17a39b49e6fe1fd92f10b31e65808e77068b;hpb=ab5f2e6f1ddd35f8f117460530d76c0ba0c9bc87;p=libs%2Fgl.git

diff --git a/source/glsl/optimize.cpp b/source/glsl/optimize.cpp
index 208e17a3..b7236feb 100644
--- a/source/glsl/optimize.cpp
+++ b/source/glsl/optimize.cpp
@@ -1,4 +1,5 @@
 #include <msp/core/raii.h>
+#include <msp/strings/format.h>
 #include "optimize.h"
 
 using namespace std;
@@ -8,20 +9,21 @@ namespace GL {
 namespace SL {
 
 InlineableFunctionLocator::InlineableFunctionLocator():
-	in_function(0)
+	current_function(0),
+	return_count(0)
 { }
 
 void InlineableFunctionLocator::visit(FunctionCall &call)
 {
 	FunctionDeclaration *def = call.declaration;
-	if(def && def->definition!=def)
+	if(def)
 		def = def->definition;
 
 	if(def)
 	{
 		unsigned &count = refcounts[def];
 		++count;
-		if(count>1 || def==in_function)
+		if(count>1 || def==current_function)
 			inlineable.erase(def);
 	}
 
@@ -31,22 +33,160 @@ void InlineableFunctionLocator::visit(FunctionCall &call)
 void InlineableFunctionLocator::visit(FunctionDeclaration &func)
 {
 	unsigned &count = refcounts[func.definition];
-	if(!count && func.parameters.empty())
+	if(count<=1 && func.parameters.empty())
 		inlineable.insert(func.definition);
 
-	SetForScope<FunctionDeclaration *> set(in_function, &func);
+	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;
+}
+
+
+InlineContentInjector::InlineContentInjector():
+	source_func(0),
+	remap_names(false),
+	deps_only(false)
+{ }
+
+const string &InlineContentInjector::apply(Stage &stage, FunctionDeclaration &target_func, Block &tgtb, const NodeList<Statement>::iterator &ins_pt, FunctionDeclaration &src)
+{
+	target_block = &tgtb;
+	source_func = &src;
+	for(NodeList<Statement>::iterator i=src.body.body.begin(); i!=src.body.body.end(); ++i)
+	{
+		inlined_statement = 0;
+		(*i)->visit(*this);
+		if(!inlined_statement)
+			inlined_statement = (*i)->clone();
+
+		SetFlag set_remap(remap_names);
+		inlined_statement->visit(*this);
+		tgtb.body.insert(ins_pt, inlined_statement);
+	}
+
+	NodeReorderer().apply(stage, target_func, dependencies);
+
+	return 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)
+	{
+		map<string, VariableDeclaration *>::const_iterator i = variable_map.find(var.name);
+		if(i!=variable_map.end())
+			var.name = i->second->name;
+	}
+	else if(var.declaration)
+	{
+		SetFlag set_deps(deps_only);
+		dependencies.insert(var.declaration);
+		var.declaration->visit(*this);
+	}
+}
+
+void InlineContentInjector::visit(InterfaceBlockReference &iface)
+{
+	if(!remap_names && iface.declaration)
+	{
+		SetFlag set_deps(deps_only);
+		dependencies.insert(iface.declaration);
+		iface.declaration->visit(*this);
+	}
+}
+
+void InlineContentInjector::visit(FunctionCall &call)
+{
+	if(!remap_names && call.declaration)
+		dependencies.insert(call.declaration);
+	TraversingVisitor::visit(call);
+}
+
+void InlineContentInjector::visit(VariableDeclaration &var)
+{
+	TraversingVisitor::visit(var);
+
+	if(var.type_declaration)
+	{
+		SetFlag set_deps(deps_only);
+		dependencies.insert(var.type_declaration);
+		var.type_declaration->visit(*this);
+	}
+
+	if(!remap_names && !deps_only)
+	{
+		RefPtr<VariableDeclaration> inlined_var = var.clone();
+		inlined_var->name = create_unused_name(var.name, false);
+		inlined_statement = inlined_var;
+
+		variable_map[var.name] = inlined_var.get();
+	}
+}
+
+void InlineContentInjector::visit(Return &ret)
+{
+	TraversingVisitor::visit(ret);
+
+	if(ret.expression)
+	{
+		result_name = create_unused_name("return", true);
+		RefPtr<VariableDeclaration> var = new VariableDeclaration;
+		var->source = ret.source;
+		var->line = ret.line;
+		var->type = source_func->return_type;
+		var->name = result_name;
+		var->init_expression = ret.expression->clone();
+		inlined_statement = var;
+	}
+}
+
 
 FunctionInliner::FunctionInliner():
-	extract_result(0)
+	current_function(0),
+	any_inlined(false)
 { }
 
-void FunctionInliner::apply(Stage &stage)
+bool FunctionInliner::apply(Stage &s)
 {
-	inlineable = InlineableFunctionLocator().apply(stage);
-	visit(stage.content);
+	stage = &s;
+	inlineable = InlineableFunctionLocator().apply(s);
+	any_inlined = false;
+	s.content.visit(*this);
+	return any_inlined;
 }
 
 void FunctionInliner::visit_and_inline(RefPtr<Expression> &ptr)
@@ -54,19 +194,20 @@ void FunctionInliner::visit_and_inline(RefPtr<Expression> &ptr)
 	inline_result = 0;
 	ptr->visit(*this);
 	if(inline_result)
+	{
 		ptr = inline_result;
+		any_inlined = true;
+	}
 }
 
 void FunctionInliner::visit(Block &block)
 {
-	if(extract_result)
-		--extract_result;
-
+	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)
 	{
+		insert_point = i;
 		(*i)->visit(*this);
-		if(extract_result)
-			--extract_result;
 	}
 }
 
@@ -95,18 +236,34 @@ void FunctionInliner::visit(FunctionCall &call)
 		visit_and_inline(*i);
 
 	FunctionDeclaration *def = call.declaration;
-	if(def && def->definition!=def)
+	if(def)
 		def = def->definition;
 
 	if(def && inlineable.count(def))
 	{
-		extract_result = 2;
-		def->visit(*this);
+		string result_name = InlineContentInjector().apply(*stage, *current_function, *current_block, insert_point, *def);
+
+		// 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;
+		inline_result = ref;
+
+		/* Inlined variables need to be resolved before this function can be
+		inlined further. */
+		inlineable.erase(current_function);
 	}
 	else
 		inline_result = 0;
 }
 
+void FunctionInliner::visit(ExpressionStatement &expr)
+{
+	visit_and_inline(expr.expression);
+}
+
 void FunctionInliner::visit(VariableDeclaration &var)
 {
 	if(var.init_expression)
@@ -114,30 +271,47 @@ void FunctionInliner::visit(VariableDeclaration &var)
 	inline_result = 0;
 }
 
-void FunctionInliner::visit(Return &ret)
+void FunctionInliner::visit(FunctionDeclaration &func)
 {
-	TraversingVisitor::visit(ret);
+	SetForScope<FunctionDeclaration *> set_func(current_function, &func);
+	TraversingVisitor::visit(func);
+}
 
-	if(extract_result)
-		inline_result = ret.expression->clone();
+void FunctionInliner::visit(Conditional &cond)
+{
+	visit_and_inline(cond.condition);
+	cond.body.visit(*this);
+}
+
+void FunctionInliner::visit(Iteration &iter)
+{
+	SetForScope<Block *> set_block(current_block, &iter.body);
+	if(iter.init_statement)
+		iter.init_statement->visit(*this);
+	/* Skip the condition and loop expression parts because they're executed on
+	every iteration of the loop */
+	iter.body.visit(*this);
+}
+
+void FunctionInliner::visit(Return &ret)
+{
+	if(ret.expression)
+		visit_and_inline(ret.expression);
 }
 
 
 ConstantConditionEliminator::ConstantConditionEliminator():
-	scope_level(0),
-	current_block(0),
 	record_only(false)
 { }
 
 void ConstantConditionEliminator::apply(Stage &stage)
 {
-	visit(stage.content);
+	stage.content.visit(*this);
 	NodeRemover().apply(stage, nodes_to_remove);
 }
 
 void ConstantConditionEliminator::visit(Block &block)
 {
-	SetForScope<unsigned> set(scope_level, scope_level+1);
 	SetForScope<Block *> set_block(current_block, &block);
 	for(NodeList<Statement>::iterator i=block.body.begin(); i!=block.body.end(); ++i)
 	{
@@ -152,7 +326,7 @@ void ConstantConditionEliminator::visit(Block &block)
 void ConstantConditionEliminator::visit(UnaryExpression &unary)
 {
 	if(VariableReference *var = dynamic_cast<VariableReference *>(unary.expression.get()))
-		if(unary.oper=="++" || unary.oper=="--")
+		if(unary.oper->token[1]=='+' || unary.oper->token[1]=='-')
 			variable_values.erase(var->declaration);
 }
 
@@ -163,7 +337,13 @@ void ConstantConditionEliminator::visit(Assignment &assign)
 
 void ConstantConditionEliminator::visit(VariableDeclaration &var)
 {
-	if(var.constant || scope_level>1)
+	bool constant = var.constant;
+	if(constant && var.layout)
+	{
+		for(vector<Layout::Qualifier>::const_iterator i=var.layout->qualifiers.begin(); (constant && i!=var.layout->qualifiers.end()); ++i)
+			constant = (i->name!="constant_id");
+	}
+	if((constant || current_block->parent) && var.init_expression)
 		variable_values[&var] = var.init_expression.get();
 }
 
@@ -229,13 +409,13 @@ UnusedVariableRemover::UnusedVariableRemover():
 	assignment(0),
 	assignment_target(false),
 	assign_to_subscript(false),
-	global_scope(true)
+	side_effects(false)
 { }
 
 bool UnusedVariableRemover::apply(Stage &stage)
 {
 	variables.push_back(BlockVariableMap());
-	visit(stage.content);
+	stage.content.visit(*this);
 	BlockVariableMap &global_variables = variables.back();
 	for(BlockVariableMap::iterator i=global_variables.begin(); i!=global_variables.end(); ++i)
 	{
@@ -263,20 +443,32 @@ void UnusedVariableRemover::visit(VariableReference &var)
 	if(var.declaration && !assignment_target)
 	{
 		VariableInfo &var_info = variables.back()[var.declaration];
-		var_info.assignments.clear();
+		clear_assignments(var_info, false);
 		var_info.referenced = true;
 	}
 }
 
+void UnusedVariableRemover::visit(InterfaceBlockReference &iface)
+{
+	unused_nodes.erase(iface.declaration);
+}
+
 void UnusedVariableRemover::visit(MemberAccess &memacc)
 {
 	TraversingVisitor::visit(memacc);
 	unused_nodes.erase(memacc.declaration);
 }
 
+void UnusedVariableRemover::visit(UnaryExpression &unary)
+{
+	TraversingVisitor::visit(unary);
+	if(unary.oper->token[1]=='+' || unary.oper->token[1]=='-')
+		side_effects = true;
+}
+
 void UnusedVariableRemover::visit(BinaryExpression &binary)
 {
-	if(binary.oper=="[")
+	if(binary.oper->token[0]=='[')
 	{
 		if(assignment_target)
 			assign_to_subscript = true;
@@ -297,6 +489,13 @@ void UnusedVariableRemover::visit(Assignment &assign)
 	}
 	assign.right->visit(*this);
 	assignment = &assign;
+	side_effects = true;
+}
+
+void UnusedVariableRemover::visit(FunctionCall &call)
+{
+	TraversingVisitor::visit(call);
+	side_effects = true;
 }
 
 void UnusedVariableRemover::record_assignment(VariableDeclaration &var, Node &node, bool chained)
@@ -321,9 +520,12 @@ void UnusedVariableRemover::clear_assignments(VariableInfo &var_info, bool mark_
 void UnusedVariableRemover::visit(ExpressionStatement &expr)
 {
 	assignment = 0;
+	side_effects = false;
 	TraversingVisitor::visit(expr);
 	if(assignment && assignment->target_declaration)
 		record_assignment(*assignment->target_declaration, expr, (assignment->self_referencing || assign_to_subscript));
+	if(!side_effects)
+		unused_nodes.insert(&expr);
 }
 
 void UnusedVariableRemover::visit(StructDeclaration &strct)
@@ -358,12 +560,9 @@ void UnusedVariableRemover::visit(FunctionDeclaration &func)
 {
 	variables.push_back(BlockVariableMap());
 
-	{
-		SetForScope<bool> set(global_scope, false);
-		for(NodeArray<VariableDeclaration>::iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i)
-			(*i)->visit(*this);
-		func.body.visit(*this);
-	}
+	for(NodeArray<VariableDeclaration>::iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i)
+		(*i)->visit(*this);
+	func.body.visit(*this);
 
 	BlockVariableMap &block_variables = variables.back();
 	for(BlockVariableMap::iterator i=block_variables.begin(); i!=block_variables.end(); ++i)
@@ -443,7 +642,7 @@ void UnusedVariableRemover::visit(Iteration &iter)
 	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();
+			clear_assignments(i->second, false);
 
 	merge_down_variables();
 }
@@ -451,7 +650,7 @@ void UnusedVariableRemover::visit(Iteration &iter)
 
 bool UnusedFunctionRemover::apply(Stage &stage)
 {
-	visit(stage.content);
+	stage.content.visit(*this);
 	NodeRemover().apply(stage, unused_nodes);
 	return !unused_nodes.empty();
 }