X-Git-Url: http://git.tdb.fi/?p=libs%2Fgl.git;a=blobdiff_plain;f=source%2Fglsl%2Foptimize.cpp;h=ed20bb175dcc9277e1ff84e2e1a1734b2279668f;hp=8a9992a2dba88a054dfeed5f5f681ba012946147;hb=8bf70f4d445cf63386ad7aafc5b3ebdbd8369939;hpb=8173340a7737e32cb25b21b67049102bd1526beb diff --git a/source/glsl/optimize.cpp b/source/glsl/optimize.cpp index 8a9992a2..ed20bb17 100644 --- a/source/glsl/optimize.cpp +++ b/source/glsl/optimize.cpp @@ -1,6 +1,8 @@ #include #include +#include #include "optimize.h" +#include "reflect.h" using namespace std; @@ -8,6 +10,55 @@ namespace Msp { namespace GL { namespace SL { +ConstantSpecializer::ConstantSpecializer(): + values(0) +{ } + +void ConstantSpecializer::apply(Stage &stage, const map &v) +{ + values = &v; + stage.content.visit(*this); +} + +void ConstantSpecializer::visit(VariableDeclaration &var) +{ + bool specializable = false; + if(var.layout) + { + vector &qualifiers = var.layout->qualifiers; + for(vector::iterator i=qualifiers.begin(); (!specializable && i!=qualifiers.end()); ++i) + if(i->name=="constant_id") + { + specializable = true; + qualifiers.erase(i); + } + + if(qualifiers.empty()) + var.layout = 0; + } + + if(specializable) + { + map::const_iterator i = values->find(var.name); + if(i!=values->end()) + { + RefPtr literal = new Literal; + if(var.type=="bool") + { + literal->token = (i->second ? "true" : "false"); + literal->value = static_cast(i->second); + } + else if(var.type=="int") + { + literal->token = lexical_cast(i->second); + literal->value = i->second; + } + var.init_expression = literal; + } + } +} + + InlineableFunctionLocator::InlineableFunctionLocator(): current_function(0), return_count(0) @@ -23,7 +74,9 @@ void InlineableFunctionLocator::visit(FunctionCall &call) { unsigned &count = refcounts[def]; ++count; - if(count>1 || def==current_function) + /* 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); } @@ -32,8 +85,12 @@ void InlineableFunctionLocator::visit(FunctionCall &call) void InlineableFunctionLocator::visit(FunctionDeclaration &func) { + bool has_out_params = false; + for(NodeArray::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 || func.source==BUILTIN_SOURCE) && !has_out_params) inlineable.insert(func.definition); SetForScope set(current_function, &func); @@ -64,75 +121,97 @@ void InlineableFunctionLocator::visit(Return &ret) InlineContentInjector::InlineContentInjector(): source_func(0), - remap_names(false), - deps_only(false) + pass(REFERENCED) { } -const string &InlineContentInjector::apply(Stage &stage, FunctionDeclaration &target_func, Block &tgtb, const NodeList::iterator &ins_pt, FunctionDeclaration &src) +string InlineContentInjector::apply(Stage &stage, FunctionDeclaration &target_func, Block &tgt_blk, const NodeList::iterator &ins_pt, FunctionCall &call) { - target_block = &tgtb; - source_func = &src; - for(NodeList::iterator i=src.body.body.begin(); i!=src.body.body.end(); ++i) + source_func = call.declaration->definition; + + /* 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(); + + vector > params; + params.reserve(source_func->parameters.size()); + for(NodeArray::iterator i=source_func->parameters.begin(); i!=source_func->parameters.end(); ++i) + { + RefPtr var = (*i)->clone(); + var->interface.clear(); + + SetForScope set_pass(pass, RENAME); + var->visit(*this); + + staging_block.body.push_back_nocopy(var); + params.push_back(var); + } + + for(NodeList::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 set_pass(pass, RENAME); r_inlined_statement->visit(*this); - tgtb.body.insert(ins_pt, r_inlined_statement); + + staging_block.body.push_back_nocopy(r_inlined_statement); } - NodeReorderer().apply(stage, target_func, dependencies); + /* 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); - return r_result_name; -} + /* 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); -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; + // Put the argument expressions in place after all renaming has been done. + for(unsigned i=0; iparameters.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(remap_names) + if(pass==RENAME) { - map::const_iterator i = variable_map.find(var.name); - if(i!=variable_map.end()) + map::const_iterator i = staging_block.variables.find(var.name); + if(i!=staging_block.variables.end()) var.name = i->second->name; } - else if(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) - { - SetFlag set_deps(deps_only); - dependencies.insert(iface.declaration); - iface.declaration->visit(*this); - } + if(pass==REFERENCED) + referenced_names.insert(iface.name); } void InlineContentInjector::visit(FunctionCall &call) { - if(!remap_names && call.declaration) - dependencies.insert(call.declaration); + if(pass==REFERENCED) + referenced_names.insert(call.name); TraversingVisitor::visit(call); } @@ -140,30 +219,34 @@ 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) + if(pass==RENAME) { - RefPtr 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(); + /* 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(ret.expression) + if(pass==INLINE && ret.expression) { - 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"); RefPtr var = new VariableDeclaration; var->source = ret.source; var->line = ret.line; @@ -177,7 +260,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) @@ -189,7 +273,7 @@ bool FunctionInliner::apply(Stage &s) return r_any_inlined; } -void FunctionInliner::visit_and_inline(RefPtr &ptr) +void FunctionInliner::visit(RefPtr &ptr) { r_inline_result = 0; ptr->visit(*this); @@ -198,42 +282,27 @@ void FunctionInliner::visit_and_inline(RefPtr &ptr) ptr = r_inline_result; r_any_inlined = true; } + r_inline_result = 0; } void FunctionInliner::visit(Block &block) { SetForScope set_block(current_block, &block); SetForScope::iterator> save_insert_point(insert_point, block.body.begin()); - for(NodeList::iterator i=block.body.begin(); i!=block.body.end(); ++i) + for(NodeList::iterator i=block.body.begin(); (!r_inlined_here && i!=block.body.end()); ++i) { insert_point = i; (*i)->visit(*this); } } -void FunctionInliner::visit(UnaryExpression &unary) -{ - visit_and_inline(unary.expression); - r_inline_result = 0; -} - -void FunctionInliner::visit(BinaryExpression &binary) -{ - visit_and_inline(binary.left); - visit_and_inline(binary.right); - r_inline_result = 0; -} - -void FunctionInliner::visit(MemberAccess &memacc) -{ - visit_and_inline(memacc.left); - r_inline_result = 0; -} - void FunctionInliner::visit(FunctionCall &call) { - for(NodeArray::iterator i=call.arguments.begin(); i!=call.arguments.end(); ++i) - visit_and_inline(*i); + for(NodeArray::iterator 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) @@ -241,11 +310,11 @@ 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 + // This will later get removed by UnusedVariableRemover. if(result_name.empty()) - result_name = "msp_unused_from_inline"; + result_name = "_msp_unused_from_inline"; RefPtr ref = new VariableReference; ref->name = result_name; @@ -254,55 +323,562 @@ 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; } - else - r_inline_result = 0; } -void FunctionInliner::visit(ExpressionStatement &expr) +void FunctionInliner::visit(FunctionDeclaration &func) { - visit_and_inline(expr.expression); + SetForScope set_func(current_function, &func); + TraversingVisitor::visit(func); + r_inlined_here = false; } -void FunctionInliner::visit(VariableDeclaration &var) +void FunctionInliner::visit(Iteration &iter) { - if(var.init_expression) - visit_and_inline(var.init_expression); - r_inline_result = 0; + /* 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 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); } -void FunctionInliner::visit(FunctionDeclaration &func) + +ExpressionInliner::ExpressionInliner(): + r_ref_info(0), + r_any_inlined(false), + r_trivial(false), + mutating(false), + iteration_init(false), + iteration_body(0), + r_oper(0) +{ } + +bool ExpressionInliner::apply(Stage &s) { - SetForScope set_func(current_function, &func); - TraversingVisitor::visit(func); + s.content.visit(*this); + return r_any_inlined; } -void FunctionInliner::visit(Conditional &cond) +void ExpressionInliner::inline_expression(Expression &expr, RefPtr &ptr) { - visit_and_inline(cond.condition); - cond.body.visit(*this); + ptr = expr.clone(); + r_any_inlined = true; } -void FunctionInliner::visit(Iteration &iter) +void ExpressionInliner::visit(Block &block) +{ + TraversingVisitor::visit(block); + + for(map::iterator i=block.variables.begin(); i!=block.variables.end(); ++i) + { + map::iterator j = expressions.lower_bound(i->second); + 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); + + expressions.erase(j++); + } + } + + /* Expressions assigned in this block may depend on local variables of the + block. If this is a conditionally executed block, the assignments might not + always happen. Mark the expressions as not available to any outer blocks. */ + for(map::iterator i=expressions.begin(); i!=expressions.end(); ++i) + if(i->second.assign_scope==&block) + i->second.available = false; +} + +void ExpressionInliner::visit(RefPtr &expr) +{ + 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) +{ + if(var.declaration) + { + map::iterator i = expressions.find(var.declaration); + if(i!=expressions.end()) + { + /* If a non-trivial expression is referenced multiple times, don't + inline it. */ + if(i->second.inline_point && !i->second.trivial) + i->second.expression = 0; + /* Mutating expressions are analogous to self-referencing assignments + and prevent inlining. */ + if(mutating) + i->second.expression = 0; + 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_target(mutating, mutating || unary.oper->token[1]=='+' || unary.oper->token[1]=='-'); + visit(unary.expression); + r_trivial = false; +} + +void ExpressionInliner::visit(BinaryExpression &binary) +{ + visit(binary.left); + { + SetFlag clear_target(mutating, false); + visit(binary.right); + } + r_trivial = false; +} + +void ExpressionInliner::visit(Assignment &assign) +{ + { + SetFlag set_target(mutating); + visit(assign.left); + } + r_oper = 0; + visit(assign.right); + + map::iterator i = expressions.find(assign.target); + if(i!=expressions.end()) + { + /* Self-referencing assignments can't be inlined without additional + work. Just clear any previous expression. */ + i->second.expression = (assign.self_referencing ? 0 : assign.right.get()); + i->second.assign_scope = current_block; + i->second.inline_point = 0; + i->second.available = true; + } + + 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) + { + for(vector::const_iterator i=var.layout->qualifiers.begin(); (constant && i!=var.layout->qualifiers.end()); ++i) + constant = (i->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()) + { + ExpressionInfo &info = expressions[&var]; + /* Assume variables declared in an iteration initialization statement + will have their values change throughout the iteration. */ + info.expression = (iteration_init ? 0 : var.init_expression.get()); + info.assign_scope = current_block; + info.trivial = r_trivial; + } +} + +void ExpressionInliner::visit(Iteration &iter) { SetForScope set_block(current_block, &iter.body); if(iter.init_statement) + { + SetFlag set_init(iteration_init); iter.init_statement->visit(*this); - /* Skip the condition and loop expression parts because they're executed on - every iteration of the loop */ + } + + SetForScope set_body(iteration_body, &iter.body); + if(iter.condition) + visit(iter.condition); iter.body.visit(*this); + if(iter.loop_expression) + visit(iter.loop_expression); } -void FunctionInliner::visit(Return &ret) + +template +T ConstantFolder::evaluate_logical(char oper, T left, T right) { - if(ret.expression) - visit_and_inline(ret.expression); + switch(oper) + { + case '&': return left&right; + case '|': return left|right; + case '^': return left^right; + default: return T(); + } } +template +bool ConstantFolder::evaluate_relation(const char *oper, T left, T right) +{ + switch(oper[0]|oper[1]) + { + case '<': return left': return left>right; + case '>'|'=': return left>=right; + default: return false; + } +} + +template +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 +T ConstantFolder::evaluate_int_special_op(char oper, T left, T right) +{ + switch(oper) + { + case '%': return left%right; + case '<': return left<': return left>>right; + default: return T(); + } +} + +template +void ConstantFolder::convert_to_result(const Variant &value) +{ + if(value.check_type()) + set_result(static_cast(value.value())); + else if(value.check_type()) + set_result(static_cast(value.value())); + else if(value.check_type()) + set_result(static_cast(value.value())); + else if(value.check_type()) + set_result(static_cast(value.value())); +} + +void ConstantFolder::set_result(const Variant &value, bool literal) +{ + r_constant_value = value; + r_constant = true; + r_literal = literal; +} + +void ConstantFolder::visit(RefPtr &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; + + RefPtr literal = new Literal; + if(r_constant_value.check_type()) + literal->token = (r_constant_value.value() ? "true" : "false"); + else if(r_constant_value.check_type()) + literal->token = lexical_cast(r_constant_value.value()); + else if(r_constant_value.check_type()) + literal->token = lexical_cast(r_constant_value.value())+"u"; + else if(r_constant_value.check_type()) + { + literal->token = lexical_cast(r_constant_value.value()); + 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) +{ + 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; + + char oper = unary.oper->token[0]; + char oper2 = unary.oper->token[1]; + if(oper=='!') + { + if(r_constant_value.check_type()) + set_result(!r_constant_value.value()); + } + else if(oper=='~') + { + if(r_constant_value.check_type()) + set_result(~r_constant_value.value()); + else if(r_constant_value.check_type()) + set_result(~r_constant_value.value()); + } + else if(oper=='-' && !oper2) + { + if(r_constant_value.check_type()) + set_result(-r_constant_value.value()); + else if(r_constant_value.check_type()) + set_result(-r_constant_value.value()); + else if(r_constant_value.check_type()) + set_result(-r_constant_value.value()); + } +} + +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; + + // 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()) + set_result(evaluate_logical(oper, left_value.value(), r_constant_value.value())); + else if(!oper2 && left_value.check_type()) + set_result(evaluate_logical(oper, left_value.value(), r_constant_value.value())); + else if(!oper2 && left_value.check_type()) + set_result(evaluate_logical(oper, left_value.value(), r_constant_value.value())); + } + else if((oper=='<' || oper=='>') && oper2!=oper) + { + if(left_value.check_type()) + set_result(evaluate_relation(binary.oper->token, left_value.value(), r_constant_value.value())); + else if(left_value.check_type()) + set_result(evaluate_relation(binary.oper->token, left_value.value(), r_constant_value.value())); + else if(left_value.check_type()) + set_result(evaluate_relation(binary.oper->token, left_value.value(), r_constant_value.value())); + } + else if((oper=='=' || oper=='!') && oper2=='=') + { + if(left_value.check_type()) + set_result((left_value.value()==r_constant_value.value()) == (oper=='=')); + else if(left_value.check_type()) + set_result((left_value.value()==r_constant_value.value()) == (oper=='=')); + else if(left_value.check_type()) + set_result((left_value.value()==r_constant_value.value()) == (oper=='=')); + } + else if(oper=='+' || oper=='-' || oper=='*' || oper=='/') + { + if(left_value.check_type()) + set_result(evaluate_arithmetic(oper, left_value.value(), r_constant_value.value())); + else if(left_value.check_type()) + set_result(evaluate_arithmetic(oper, left_value.value(), r_constant_value.value())); + else if(left_value.check_type()) + set_result(evaluate_arithmetic(oper, left_value.value(), r_constant_value.value())); + } + else if(oper=='%' || ((oper=='<' || oper=='>') && oper2==oper)) + { + if(left_value.check_type()) + set_result(evaluate_int_special_op(oper, left_value.value(), r_constant_value.value())); + else if(left_value.check_type()) + set_result(evaluate_int_special_op(oper, left_value.value(), r_constant_value.value())); + } +} + +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) +{ + if(call.constructor && call.type && call.arguments.size()==1) + { + const BasicTypeDeclaration *basic = dynamic_cast(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(r_constant_value); + else if(basic->kind==BasicTypeDeclaration::INT && basic->size==32 && basic->sign) + convert_to_result(r_constant_value); + else if(basic->kind==BasicTypeDeclaration::INT && basic->size==32 && !basic->sign) + convert_to_result(r_constant_value); + else if(basic->kind==BasicTypeDeclaration::FLOAT && basic->size==32) + convert_to_result(r_constant_value); + + return; + } + } + + 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 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() && !r_constant_value.value()) + { + RefPtr 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) { @@ -310,6 +886,14 @@ void ConstantConditionEliminator::apply(Stage &stage) NodeRemover().apply(stage, nodes_to_remove); } +ConstantConditionEliminator::ConstantStatus ConstantConditionEliminator::check_constant_condition(const Expression &expr) +{ + if(const Literal *literal = dynamic_cast(&expr)) + if(literal->value.check_type()) + return (literal->value.value() ? CONSTANT_TRUE : CONSTANT_FALSE); + return NOT_CONSTANT; +} + void ConstantConditionEliminator::visit(Block &block) { SetForScope set_block(current_block, &block); @@ -318,145 +902,290 @@ void ConstantConditionEliminator::visit(Block &block) insert_point = i; (*i)->visit(*this); } - - for(map::const_iterator i=block.variables.begin(); i!=block.variables.end(); ++i) - variable_values.erase(i->second); } -void ConstantConditionEliminator::visit(UnaryExpression &unary) +void ConstantConditionEliminator::visit(RefPtr &expr) { - if(VariableReference *var = dynamic_cast(unary.expression.get())) - if(unary.oper->token[1]=='+' || unary.oper->token[1]=='-') - variable_values.erase(var->declaration); + r_ternary_result = 0; + expr->visit(*this); + if(r_ternary_result) + expr = r_ternary_result; + r_ternary_result = 0; } -void ConstantConditionEliminator::visit(Assignment &assign) +void ConstantConditionEliminator::visit(TernaryExpression &ternary) { - variable_values.erase(assign.target_declaration); + 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(Conditional &cond) { - bool constant = var.constant; - if(constant && var.layout) + ConstantStatus result = check_constant_condition(*cond.condition); + if(result!=NOT_CONSTANT) { - for(vector::const_iterator i=var.layout->qualifiers.begin(); (constant && i!=var.layout->qualifiers.end()); ++i) - constant = (i->name!="constant_id"); + 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; } - if((constant || current_block->parent) && var.init_expression) - variable_values[&var] = var.init_expression.get(); + + TraversingVisitor::visit(cond); } -void ConstantConditionEliminator::visit(Conditional &cond) +void ConstantConditionEliminator::visit(Iteration &iter) { - if(!record_only) + if(iter.condition) { - ExpressionEvaluator eval(variable_values); - cond.condition->visit(eval); - if(eval.is_result_valid()) + ConstantStatus result = check_constant_condition(*iter.condition); + if(result==CONSTANT_FALSE) { - Block &block = (eval.get_result() ? cond.body : cond.else_body); - current_block->body.splice(insert_point, block.body); - nodes_to_remove.insert(&cond); + nodes_to_remove.insert(&iter); return; } } - TraversingVisitor::visit(cond); + TraversingVisitor::visit(iter); } -void ConstantConditionEliminator::visit(Iteration &iter) + +UnreachableCodeRemover::UnreachableCodeRemover(): + reachable(true) +{ } + +bool UnreachableCodeRemover::apply(Stage &stage) { - if(!record_only) - { - if(iter.condition) - { - /* 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; - } - } + stage.content.visit(*this); + NodeRemover().apply(stage, unreachable_nodes); + return !unreachable_nodes.empty(); +} - /* 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); - } +void UnreachableCodeRemover::visit(Block &block) +{ + NodeList::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 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; +} + +void UnreachableCodeRemover::visit(Iteration &iter) +{ TraversingVisitor::visit(iter); - if(VariableDeclaration *init_decl = dynamic_cast(iter.init_statement.get())) - variable_values.erase(init_decl); + /* Always consider code after a loop reachable, since there's no checking + for whether the loop executes. */ + reachable = true; } -UnusedVariableRemover::VariableInfo::VariableInfo(): - local(false), - conditionally_assigned(false), - referenced(false) -{ } +bool UnusedTypeRemover::apply(Stage &stage) +{ + stage.content.visit(*this); + NodeRemover().apply(stage, unused_nodes); + return !unused_nodes.empty(); +} + +void UnusedTypeRemover::visit(RefPtr &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); + 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(InterfaceBlock &iface) +{ + unused_nodes.erase(iface.type_declaration); +} + +void UnusedTypeRemover::visit(FunctionDeclaration &func) +{ + unused_nodes.erase(func.return_type_declaration); + TraversingVisitor::visit(func); +} UnusedVariableRemover::UnusedVariableRemover(): - aggregate(0), + stage(0), + interface_block(0), r_assignment(0), assignment_target(false), - r_assign_to_subscript(false), - r_side_effects(false) + r_side_effects(false), + in_struct(false), + composite_reference(false), + in_loop(0) { } -bool UnusedVariableRemover::apply(Stage &stage) +bool UnusedVariableRemover::apply(Stage &s) { - 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) + stage = &s; + s.content.visit(*this); + + for(list::const_iterator i=assignments.begin(); i!=assignments.end(); ++i) + if(i->used_by.empty()) + unused_nodes.insert(i->node); + + for(BlockVariableMap::const_iterator i=variables.begin(); i!=variables.end(); ++i) { - 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(i->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(vector::const_iterator j=i->second.assignments.begin(); j!=i->second.assignments.end(); ++j) + unused_nodes.erase((*j)->node); } + + if(!i->second.output && !i->second.referenced) + { + // Don't remove variables from inside interface blocks. + if(!i->second.interface_block) + unused_nodes.insert(i->first); + } + else if(i->second.interface_block) + // Interface blocks are kept if even one member is used. + unused_nodes.erase(i->second.interface_block); } - 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::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]; - clear_assignments(var_info, false); - var_info.referenced = true; + bool loop_external = false; + for(vector::const_iterator i=var_info.assignments.begin(); i!=var_info.assignments.end(); ++i) + { + bool covered = true; + for(unsigned j=0; (covered && j<(*i)->target.chain_len && j((*i)->target.chain[j]&0xC0); + Assignment::Target::ChainType type2 = static_cast(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<target.chain[j]==target.chain[j]); + } + + if(covered) + { + (*i)->used_by.push_back(&node); + if((*i)->in_looptoken[0]=='[') { - if(assignment_target) - r_assign_to_subscript = true; - binary.left->visit(*this); - SetForScope 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) { { - r_assign_to_subscript = false; - SetForScope set(assignment_target, !assign.self_referencing); + SetFlag set(assignment_target, (assign.oper->token[0]=='=')); assign.left->visit(*this); } assign.right->visit(*this); @@ -494,27 +1238,46 @@ 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. */ r_side_effects = true; -} -void UnusedVariableRemover::record_assignment(VariableDeclaration &var, Node &node, bool chained) -{ - VariableInfo &var_info = variables.back()[&var]; - if(!chained) - clear_assignments(var_info, true); - var_info.assignments.push_back(&node); - var_info.conditionally_assigned = false; + if(stage->type==Stage::GEOMETRY && call.name=="EmitVertex") + { + for(map::const_iterator i=variables.begin(); i!=variables.end(); ++i) + if(i->second.output) + referenced(i->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.push_back(AssignmentInfo()); + 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::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 && jtarget_declaration) - record_assignment(*r_assignment->target_declaration, expr, (r_assignment->self_referencing || r_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 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; + TraversingVisitor::visit(var); + + if(in_struct) + return; + + VariableInfo &var_info = variables[&var]; + var_info.interface_block = interface_block; + + /* Mark variables as output if they're used by the next stage or the + graphics API. */ + if(interface_block) + var_info.output = (interface_block->interface=="out" && (interface_block->linked_block || !interface_block->block_name.compare(0, 3, "gl_"))); else + var_info.output = (var.interface=="out" && (stage->type==Stage::FRAGMENT || var.linked_declaration || !var.name.compare(0, 3, "gl_"))); + + if(var.init_expression) { - variables.back()[&var].local = true; - if(var.init_expression) - record_assignment(var, *var.init_expression, false); + var_info.initialized = true; + record_assignment(&var, *var.init_expression); } - unused_nodes.erase(var.type_declaration); - TraversingVisitor::visit(var); } void UnusedVariableRemover::visit(InterfaceBlock &iface) { - SetForScope set(aggregate, &iface); - unused_nodes.insert(&iface); - TraversingVisitor::visit(iface); -} - -void UnusedVariableRemover::visit(FunctionDeclaration &func) -{ - variables.push_back(BlockVariableMap()); - - for(NodeArray::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) - i->second.conditionally_assigned = true; - for(NodeArray::iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i) - block_variables[i->get()].referenced = true; - merge_down_variables(); + VariableInfo &var_info = variables[&iface]; + var_info.output = (iface.interface=="out" && (iface.linked_block || !iface.block_name.compare(0, 3, "gl_"))); } -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(BlockVariableMap::const_iterator i=other_vars.begin(); i!=other_vars.end(); ++i) { - if(i->second.local) + BlockVariableMap::iterator j = variables.find(i->first); + if(j!=variables.end()) { - if(!i->second.referenced) - unused_nodes.insert(i->first); - clear_assignments(i->second, i->first->interface!="out"); - continue; - } - - 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; + /* The merged blocks started as copies of each other so any common + assignments must be in the beginning. */ + unsigned k = 0; + for(; (ksecond.assignments.size() && ksecond.assignments.size()); ++k) + if(i->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(), i->second.assignments.begin()+k, i->second.assignments.end()); j->second.referenced |= i->second.referenced; - j->second.assignments.insert(j->second.assignments.end(), i->second.assignments.begin(), i->second.assignments.end()); } + else + variables.insert(*i); } - 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(BlockVariableMap::iterator i=variables.begin(); i!=variables.end(); ++i) + i->second.assignments.resize(i->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(NodeArray::iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i) { - 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; + BlockVariableMap::iterator j = variables.find(i->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 saved_refs; + swap(loop_ext_refs, saved_refs); + { + SetForScope set_loop(in_loop, in_loop+1); + TraversingVisitor::visit(iter); + } + 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) - clear_assignments(i->second, false); + /* Visit the external references of the loop again to record assignments + done in the loop as used. */ + for(vector::const_iterator i=saved_refs.begin(); i!=saved_refs.end(); ++i) + (*i)->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); }