X-Git-Url: http://git.tdb.fi/?p=libs%2Fgl.git;a=blobdiff_plain;f=source%2Fglsl%2Foptimize.cpp;h=6e4b56771fa3222ce778a53d37b828b5d34554cf;hp=414cf38754191a85d8b6643811c3dc5c4764f4b4;hb=HEAD;hpb=f526938b407e061c7424adedc34af4d1ff687f90 diff --git a/source/glsl/optimize.cpp b/source/glsl/optimize.cpp index 414cf387..a35e2cd2 100644 --- a/source/glsl/optimize.cpp +++ b/source/glsl/optimize.cpp @@ -1,6 +1,9 @@ +#include #include #include +#include #include "optimize.h" +#include "reflect.h" using namespace std; @@ -8,10 +11,49 @@ namespace Msp { namespace GL { namespace SL { -InlineableFunctionLocator::InlineableFunctionLocator(): - current_function(0), - return_count(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; + auto i = find_member(qualifiers, string("constant_id"), &Layout::Qualifier::name); + if(i!=qualifiers.end()) + { + specializable = true; + qualifiers.erase(i); + if(qualifiers.empty()) + var.layout = 0; + } + } + + if(specializable) + { + auto i = values->find(var.name); + if(i!=values->end()) + { + RefPtr literal = 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; + } + } +} + void InlineableFunctionLocator::visit(FunctionCall &call) { @@ -25,7 +67,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); } @@ -34,8 +76,11 @@ void InlineableFunctionLocator::visit(FunctionCall &call) void InlineableFunctionLocator::visit(FunctionDeclaration &func) { + bool has_out_params = any_of(func.parameters.begin(), func.parameters.end(), + [](const RefPtr &p){ return p->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,77 +109,96 @@ void InlineableFunctionLocator::visit(Return &ret) } -InlineContentInjector::InlineContentInjector(): - source_func(0), - remap_names(false), - deps_only(false) -{ } - -const string &InlineContentInjector::apply(Stage &stage, FunctionDeclaration &target_func, Block &tgt_blk, 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 = &tgt_blk; - 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. Only consider + names declared in blocks linearly related to the target block. */ + pass = REFERENCED; + tgt_blk.visit(*this); + for(const Block *b=&tgt_blk; b; b=b->parent) + for(const auto &kvp: b->variables) + referenced_names.insert(kvp.first); + for(const auto &kvp: stage.interface_blocks) + if(kvp.second->name.find(' ')!=string::npos) + for(const auto &kvp2: kvp.second->block_declaration->members.variables) + referenced_names.insert(kvp2.first); + + /* Inline and rename passes must be interleaved so used variable names are + known when inlining the return statement. */ + pass = INLINE; + staging_block.parent = &tgt_blk; + staging_block.variables.clear(); + + vector > params; + params.reserve(source_func->parameters.size()); + for(const RefPtr &p: source_func->parameters) + { + RefPtr var = p->clone(); + var->interface.clear(); + + SetForScope set_pass(pass, RENAME); + var->visit(*this); + + staging_block.body.push_back_nocopy(var); + params.push_back(var); + } + + for(const RefPtr &s: source_func->body.body) { r_inlined_statement = 0; - (*i)->visit(*this); + s->visit(*this); if(!r_inlined_statement) - r_inlined_statement = (*i)->clone(); + r_inlined_statement = s->clone(); - SetFlag set_remap(remap_names); + SetForScope set_pass(pass, RENAME); r_inlined_statement->visit(*this); - tgt_blk.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()) + auto 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); - } -} - -void InlineContentInjector::visit(InterfaceBlockReference &iface) -{ - if(!remap_names && iface.declaration) - { - SetFlag set_deps(deps_only); - dependencies.insert(iface.declaration); - iface.declaration->visit(*this); - } + else if(pass==REFERENCED) + referenced_names.insert(var.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); } @@ -142,32 +206,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) { - /* 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"); RefPtr var = new VariableDeclaration; var->source = ret.source; var->line = ret.line; @@ -179,11 +245,6 @@ void InlineContentInjector::visit(Return &ret) } -FunctionInliner::FunctionInliner(): - current_function(0), - r_any_inlined(false) -{ } - bool FunctionInliner::apply(Stage &s) { stage = &s; @@ -193,7 +254,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); @@ -209,38 +270,20 @@ 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(auto 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); -} - -void FunctionInliner::visit(BinaryExpression &binary) -{ - visit_and_inline(binary.left); - visit_and_inline(binary.right); -} - -void FunctionInliner::visit(MemberAccess &memacc) -{ - visit_and_inline(memacc.left); -} - -void FunctionInliner::visit(Swizzle &swizzle) -{ - visit_and_inline(swizzle.left); -} - void FunctionInliner::visit(FunctionCall &call) { - for(NodeArray::iterator i=call.arguments.begin(); i!=call.arguments.end(); ++i) - visit_and_inline(*i); + for(auto i=call.arguments.begin(); (!r_inlined_here && i!=call.arguments.end()); ++i) + visit(*i); + + if(r_inlined_here) + return; FunctionDeclaration *def = call.declaration; if(def) @@ -248,11 +291,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. if(result_name.empty()) - result_name = "msp_unused_from_inline"; + result_name = "_msp_unused_from_inline"; RefPtr ref = new VariableReference; ref->name = result_name; @@ -261,30 +304,15 @@ 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; } } -void FunctionInliner::visit(ExpressionStatement &expr) -{ - visit_and_inline(expr.expression); -} - -void FunctionInliner::visit(VariableDeclaration &var) -{ - if(var.init_expression) - visit_and_inline(var.init_expression); -} - void FunctionInliner::visit(FunctionDeclaration &func) { SetForScope set_func(current_function, &func); TraversingVisitor::visit(func); -} - -void FunctionInliner::visit(Conditional &cond) -{ - visit_and_inline(cond.condition); - cond.body.visit(*this); + r_inlined_here = false; } void FunctionInliner::visit(Iteration &iter) @@ -301,208 +329,150 @@ void FunctionInliner::visit(Iteration &iter) iter.body.visit(*this); } -void FunctionInliner::visit(Return &ret) -{ - if(ret.expression) - visit_and_inline(ret.expression); -} - - -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) -{ } - - -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) { s.content.visit(*this); - return r_any_inlined; -} -void ExpressionInliner::visit_and_record(RefPtr &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) + bool any_inlined = false; + for(ExpressionInfo &e: expressions) + if(e.expression && (e.trivial || e.uses.size()==1)) { - /* 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; + for(ExpressionUse &u: e.uses) + if(!u.blocked) + { + *u.reference = e.expression->clone(); + any_inlined = true; + } } - 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; + return any_inlined; } -void ExpressionInliner::inline_expression(Expression &expr, RefPtr &ptr, const Operator *outer_oper, const Operator *inner_oper, bool on_rhs) +void ExpressionInliner::visit(RefPtr &expr) { - 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) + r_ref_info = 0; + expr->visit(*this); + if(r_ref_info && r_ref_info->expression) { - RefPtr parexpr = new ParenthesizedExpression; - parexpr->expression = expr.clone(); - ptr = parexpr; - } - else - ptr = expr.clone(); - - r_any_inlined = true; -} - -void ExpressionInliner::visit(Block &block) -{ - TraversingVisitor::visit(block); + ExpressionUse use; + use.reference = &expr; + use.ref_scope = current_block; + use.blocked = access_write || r_ref_info->blocked; - for(map::iterator i=expressions.begin(); i!=expressions.end(); ) - { - map::iterator j = block.variables.find(i->first->name); - if(j!=block.variables.end() && j->second==i->first) + if(iteration_body && !r_ref_info->trivial) { - if(i->second.expression && i->second.inline_point) - inline_expression(*i->second.expression, *i->second.inline_point, i->second.outer_oper, i->second.inner_oper, i->second.inline_on_rhs); - - expressions.erase(i++); + /* Block inlining of non-trivial expressions assigned outside an + iteration statement. The iteration may run multiple times, which + would cause the expression to also be evaluated multiple times. */ + for(Block *i=iteration_body->parent; (!use.blocked && i); i=i->parent) + use.blocked = (i==r_ref_info->assign_scope); } - else - { - /* The expression was assigned in this block and may depend on local - variables of the block. If this is a conditionally executed block, - the assignment might not always happen. Mark the expression as not - available to any outer blocks. */ - if(i->second.assign_scope==&block) - i->second.available = false; - ++i; - } + /* Block inlining assignments from from inner scopes. The assignment may + depend on local variables of that scope or may not always be executed. */ + for(Block *i=r_ref_info->assign_scope->parent; (!use.blocked && i); i=i->parent) + use.blocked = (i==current_block); + + r_ref_info->uses.push_back(use); } + r_oper = expr->oper; + r_ref_info = 0; } void ExpressionInliner::visit(VariableReference &var) { - if(var.declaration) + if(var.declaration && access_read) { - 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; - } + auto i = assignments.find(var.declaration); + if(i!=assignments.end()) + r_ref_info = i->second; } } 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; + SetFlag set_write(access_write, (unary.oper->token[1]=='+' || unary.oper->token[1]=='-')); + visit(unary.expression); r_trivial = false; } void ExpressionInliner::visit(BinaryExpression &binary) { - visit_and_record(binary.left, binary.oper, false); + visit(binary.left); { - SetFlag clear_target(mutating, false); - visit_and_record(binary.right, binary.oper, true); + SetFlag clear_write(access_write, false); + visit(binary.right); } - r_oper = binary.oper; r_trivial = false; } void ExpressionInliner::visit(Assignment &assign) { { - SetFlag set_target(mutating); - visit_and_record(assign.left, assign.oper, false); + SetFlag set_read(access_read, assign.oper->token[0]!='='); + SetFlag set_write(access_write); + visit(assign.left); } r_oper = 0; - visit_and_record(assign.right, assign.oper, true); + r_trivial = true; + visit(assign.right); - if(assign.target_declaration) + auto i = assignments.find(assign.target.declaration); + if(i!=assignments.end()) { - map::iterator i = expressions.find(assign.target_declaration); - if(i!=expressions.end()) + if(iteration_body && i->second && i->second->expression) { - /* 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.inner_oper = r_oper; - i->second.available = true; + /* Block inlining into previous references within the iteration + statement. On iterations after the first they would refer to the + assignment within the iteration. */ + for(ExpressionUse &u: i->second->uses) + for(Block *k=u.ref_scope; (!u.blocked && k); k=k->parent) + u.blocked = (k==iteration_body); } + + for(; (i!=assignments.end() && i->first.declaration==assign.target.declaration); ++i) + if(targets_overlap(i->first, assign.target)) + i->second->blocked = true; + + expressions.emplace_back(); + ExpressionInfo &info = expressions.back(); + info.target = assign.target; + // Self-referencing assignments can't be inlined without additional work. + if(!assign.self_referencing) + info.expression = assign.right; + info.assign_scope = current_block; + info.trivial = r_trivial; + + assignments[assign.target] = &info; } - r_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) { - for(NodeArray::iterator i=call.arguments.begin(); i!=call.arguments.end(); ++i) - visit_and_record(*i, 0, false); - r_oper = 0; + TraversingVisitor::visit(call); r_trivial = false; } @@ -510,14 +480,13 @@ void ExpressionInliner::visit(VariableDeclaration &var) { r_oper = 0; r_trivial = true; - if(var.init_expression) - visit_and_record(var.init_expression, 0, false); + 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"); + constant = !any_of(var.layout->qualifiers.begin(), var.layout->qualifiers.end(), + [](const Layout::Qualifier &q){ return q.name=="constant_id"; }); } /* Only inline global variables if they're constant and have trivial @@ -525,20 +494,18 @@ void ExpressionInliner::visit(VariableDeclaration &var) analyze and non-trivial expressions could be expensive to inline. */ if((current_block->parent || (constant && r_trivial)) && var.interface.empty()) { - ExpressionInfo &info = expressions[&var]; + expressions.emplace_back(); + ExpressionInfo &info = expressions.back(); + info.target = &var; /* Assume variables declared in an iteration initialization statement will have their values change throughout the iteration. */ - info.expression = (iteration_init ? 0 : var.init_expression.get()); + if(!iteration_init) + info.expression = var.init_expression; info.assign_scope = current_block; - info.inner_oper = r_oper; info.trivial = r_trivial; - } -} -void ExpressionInliner::visit(Conditional &cond) -{ - visit_and_record(cond.condition, 0, false); - cond.body.visit(*this); + assignments[&var] = &info; + } } void ExpressionInliner::visit(Iteration &iter) @@ -552,107 +519,703 @@ void ExpressionInliner::visit(Iteration &iter) SetForScope set_body(iteration_body, &iter.body); if(iter.condition) - iter.condition->visit(*this); + visit(iter.condition); iter.body.visit(*this); if(iter.loop_expression) - iter.loop_expression->visit(*this); + visit(iter.loop_expression); +} + + +bool AggregateDismantler::apply(Stage &stage) +{ + stage.content.visit(*this); + + bool any_dismantled = false; + for(const auto &kvp: aggregates) + { + if(kvp.second.referenced || !kvp.second.members_referenced) + continue; + + for(const AggregateMember &m: kvp.second.members) + { + string name; + if(m.declaration) + name = format("%s_%s", kvp.second.declaration->name, m.declaration->name); + else + name = format("%s_%d", kvp.second.declaration->name, m.index); + + VariableDeclaration *var = new VariableDeclaration; + var->source = kvp.first->source; + var->line = kvp.first->line; + var->name = get_unused_variable_name(*kvp.second.decl_scope, name); + /* XXX This is kind of brittle and depends on the array declaration's + textual type not having brackets in it. */ + var->type = (m.declaration ? m.declaration : kvp.second.declaration)->type; + if(m.initializer) + var->init_expression = m.initializer->clone(); + + kvp.second.decl_scope->body.insert(kvp.second.insert_point, var); + + for(RefPtr *r: m.references) + { + VariableReference *ref = new VariableReference; + ref->name = var->name; + *r = ref; + } + + any_dismantled = true; + } + } + + return any_dismantled; +} + +void AggregateDismantler::visit(Block &block) +{ + SetForScope set_block(current_block, &block); + for(auto i=block.body.begin(); i!=block.body.end(); ++i) + { + insert_point = i; + (*i)->visit(*this); + } +} + +void AggregateDismantler::visit(RefPtr &expr) +{ + r_aggregate_ref = 0; + expr->visit(*this); + if(r_aggregate_ref && r_reference.chain_len==1) + { + if((r_reference.chain[0]&0x3F)!=0x3F) + { + r_aggregate_ref->members[r_reference.chain[0]&0x3F].references.push_back(&expr); + r_aggregate_ref->members_referenced = true; + } + else + /* If the accessed member is not known, mark the entire aggregate as + referenced. */ + r_aggregate_ref->referenced = true; + } + r_aggregate_ref = 0; +} + +void AggregateDismantler::visit(VariableReference &var) +{ + if(composite_reference) + r_reference.declaration = var.declaration; + else + { + /* If an aggregate variable is referenced as a whole, it should not be + dismantled. */ + auto i = aggregates.find(var.declaration); + if(i!=aggregates.end()) + i->second.referenced = true; + } +} + +void AggregateDismantler::visit_composite(RefPtr &expr) +{ + if(!composite_reference) + r_reference = Assignment::Target(); + + SetFlag set_composite(composite_reference); + visit(expr); +} + +void AggregateDismantler::visit(MemberAccess &memacc) +{ + visit_composite(memacc.left); + + add_to_chain(r_reference, Assignment::Target::MEMBER, memacc.index); + + if(r_reference.declaration && r_reference.chain_len==1) + { + auto i = aggregates.find(r_reference.declaration); + r_aggregate_ref = (i!=aggregates.end() ? &i->second : 0); + } + else + r_aggregate_ref = 0; +} + +void AggregateDismantler::visit(BinaryExpression &binary) +{ + if(binary.oper->token[0]=='[') + { + visit_composite(binary.left); + { + SetFlag clear_composite(composite_reference, false); + visit(binary.right); + } + + unsigned index = 0x3F; + if(Literal *literal_subscript = dynamic_cast(binary.right.get())) + if(literal_subscript->value.check_type()) + index = literal_subscript->value.value(); + add_to_chain(r_reference, Assignment::Target::ARRAY, index); + + if(r_reference.declaration && r_reference.chain_len==1) + { + auto i = aggregates.find(r_reference.declaration); + r_aggregate_ref = (i!=aggregates.end() ? &i->second : 0); + } + else + r_aggregate_ref = 0; + } + else + { + SetFlag clear_composite(composite_reference, false); + TraversingVisitor::visit(binary); + } +} + +void AggregateDismantler::visit(VariableDeclaration &var) +{ + TraversingVisitor::visit(var); + + if(var.interface.empty()) + { + if(const StructDeclaration *strct = dynamic_cast(var.type_declaration)) + { + const FunctionCall *init_call = dynamic_cast(var.init_expression.get()); + if((init_call && init_call->constructor) || !var.init_expression) + { + + Aggregate &aggre = aggregates[&var]; + aggre.declaration = &var; + aggre.decl_scope = current_block; + aggre.insert_point = insert_point; + + unsigned i = 0; + for(const RefPtr &s: strct->members.body) + { + if(const VariableDeclaration *mem_decl = dynamic_cast(s.get())) + { + AggregateMember member; + member.declaration = mem_decl; + member.index = i; + if(init_call) + member.initializer = init_call->arguments[i]; + aggre.members.push_back(member); + } + ++i; + } + } + } + else if(const Literal *literal_size = dynamic_cast(var.array_size.get())) + { + if(literal_size->value.check_type()) + { + Aggregate &aggre = aggregates[&var]; + aggre.declaration = &var; + aggre.decl_scope = current_block; + aggre.insert_point = insert_point; + + int size = literal_size->value.value(); + for(int i=0; i +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 +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(), Fmt().precision(8)); + if(literal->token.find('.')==string::npos && literal->token.find('e')==string::npos) + literal->token += ".0"; + } + else + { + r_constant = false; + return; + } + literal->value = r_constant_value; + expr = literal; + r_any_folded = true; +} + +void 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 ExpressionInliner::visit(Return &ret) +void ConstantFolder::visit(Assignment &assign) { - if(ret.expression) - visit_and_record(ret.expression, 0, false); + TraversingVisitor::visit(assign); + r_constant = false; } +void ConstantFolder::visit(TernaryExpression &ternary) +{ + TraversingVisitor::visit(ternary); + r_constant = false; +} -void ConstantConditionEliminator::apply(Stage &stage) +void ConstantFolder::visit(FunctionCall &call) +{ + if(call.constructor && call.type && call.arguments.size()==1) + { + const BasicTypeDeclaration *basic = dynamic_cast(call.type); + if(basic) + { + visit(call.arguments[0]); + bool can_fold = r_constant; + r_constant = false; + if(!can_fold) + return; + + if(basic->kind==BasicTypeDeclaration::BOOL) + convert_to_result(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); +} + + +bool ConstantConditionEliminator::apply(Stage &stage) { stage.content.visit(*this); NodeRemover().apply(stage, nodes_to_remove); + return !nodes_to_remove.empty(); +} + +ConstantConditionEliminator::ConstantStatus ConstantConditionEliminator::check_constant_condition(const Expression &expr) +{ + if(const Literal *literal = dynamic_cast(&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); - for(NodeList::iterator i=block.body.begin(); i!=block.body.end(); ++i) + for(auto i=block.body.begin(); i!=block.body.end(); ++i) { insert_point = i; (*i)->visit(*this); } } +void ConstantConditionEliminator::visit(RefPtr &expr) +{ + r_ternary_result = 0; + expr->visit(*this); + if(r_ternary_result) + expr = r_ternary_result; + r_ternary_result = 0; +} + +void ConstantConditionEliminator::visit(UnaryExpression &unary) +{ + if(unary.oper->token[1]=='+' || unary.oper->token[1]=='-') + if(const VariableReference *var = dynamic_cast(unary.expression.get())) + { + auto i = current_block->variables.find(var->name); + r_external_side_effects = (i==current_block->variables.end() || i->second!=var->declaration); + return; + } + + TraversingVisitor::visit(unary); +} + +void ConstantConditionEliminator::visit(Assignment &assign) +{ + auto i = find_if(current_block->variables, [&assign](const pair &kvp){ return kvp.second==assign.target.declaration; }); + if(i==current_block->variables.end()) + r_external_side_effects = true; + TraversingVisitor::visit(assign); +} + +void ConstantConditionEliminator::visit(TernaryExpression &ternary) +{ + ConstantStatus result = check_constant_condition(*ternary.condition); + if(result!=NOT_CONSTANT) + r_ternary_result = (result==CONSTANT_TRUE ? ternary.true_expr : ternary.false_expr); + else + r_ternary_result = 0; +} + +void ConstantConditionEliminator::visit(FunctionCall &call) +{ + r_external_side_effects = true; + TraversingVisitor::visit(call); +} + void ConstantConditionEliminator::visit(Conditional &cond) { - ExpressionEvaluator eval; - cond.condition->visit(eval); - if(eval.is_result_valid()) + ConstantStatus result = check_constant_condition(*cond.condition); + if(result!=NOT_CONSTANT) { - Block &block = (eval.get_result() ? cond.body : cond.else_body); + Block &block = (result==CONSTANT_TRUE ? cond.body : cond.else_body); + // TODO should check variable names for conflicts. Potentially reuse InlineContentInjector? current_block->body.splice(insert_point, block.body); nodes_to_remove.insert(&cond); return; } + r_external_side_effects = false; TraversingVisitor::visit(cond); + + if(cond.body.body.empty() && cond.else_body.body.empty() && !r_external_side_effects) + nodes_to_remove.insert(&cond); } void ConstantConditionEliminator::visit(Iteration &iter) { if(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(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; } } + r_external_side_effects = false; TraversingVisitor::visit(iter); + if(iter.body.body.empty() && !r_external_side_effects) + nodes_to_remove.insert(&iter); } -UnusedVariableRemover::VariableInfo::VariableInfo(): - local(false), - conditionally_assigned(false), - referenced(false) -{ } +bool UnreachableCodeRemover::apply(Stage &stage) +{ + stage.content.visit(*this); + NodeRemover().apply(stage, unreachable_nodes); + return !unreachable_nodes.empty(); +} +void UnreachableCodeRemover::visit(Block &block) +{ + auto i = block.body.begin(); + for(; (reachable && i!=block.body.end()); ++i) + (*i)->visit(*this); + for(; i!=block.body.end(); ++i) + unreachable_nodes.insert(i->get()); +} -bool UnusedTypeRemover::apply(Stage &stage) +void UnreachableCodeRemover::visit(FunctionDeclaration &func) { - stage.content.visit(*this); - NodeRemover().apply(stage, unused_nodes); - return !unused_nodes.empty(); + TraversingVisitor::visit(func); + reachable = true; } -void UnusedTypeRemover::visit(Literal &literal) +void UnreachableCodeRemover::visit(Conditional &cond) { - unused_nodes.erase(literal.type); + cond.body.visit(*this); + bool reachable_if_true = reachable; + reachable = true; + cond.else_body.visit(*this); + + reachable |= reachable_if_true; } -void UnusedTypeRemover::visit(UnaryExpression &unary) +void UnreachableCodeRemover::visit(Iteration &iter) { - unused_nodes.erase(unary.type); - TraversingVisitor::visit(unary); + 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(BinaryExpression &binary) + +bool UnusedTypeRemover::apply(Stage &stage) { - unused_nodes.erase(binary.type); - TraversingVisitor::visit(binary); + stage.content.visit(*this); + NodeRemover().apply(stage, unused_nodes); + return !unused_nodes.empty(); } -void UnusedTypeRemover::visit(FunctionCall &call) +void UnusedTypeRemover::visit(RefPtr &expr) { - unused_nodes.erase(call.type); - TraversingVisitor::visit(call); + unused_nodes.erase(expr->type); + TraversingVisitor::visit(expr); } void UnusedTypeRemover::visit(BasicTypeDeclaration &type) @@ -666,6 +1229,8 @@ void UnusedTypeRemover::visit(ImageTypeDeclaration &type) { if(type.base_type) unused_nodes.erase(type.base_type); + if(type.base_image) + unused_nodes.erase(type.base_image); unused_nodes.insert(&type); } @@ -678,11 +1243,7 @@ void UnusedTypeRemover::visit(StructDeclaration &strct) void UnusedTypeRemover::visit(VariableDeclaration &var) { unused_nodes.erase(var.type_declaration); -} - -void UnusedTypeRemover::visit(InterfaceBlock &iface) -{ - unused_nodes.erase(iface.type_declaration); + TraversingVisitor::visit(var); } void UnusedTypeRemover::visit(FunctionDeclaration &func) @@ -692,83 +1253,91 @@ void UnusedTypeRemover::visit(FunctionDeclaration &func) } -UnusedVariableRemover::UnusedVariableRemover(): - aggregate(0), - r_assignment(0), - assignment_target(false), - r_assign_to_subfield(false), - r_side_effects(false) -{ } - -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) - { - string interface = i->first->interface; - bool linked = i->first->linked_declaration; - map::iterator j = aggregates.find(i->first); - if(j!=aggregates.end()) - if(InterfaceBlock *iface = dynamic_cast(j->second)) - { - interface = iface->interface; - linked = iface->linked_block; - } + stage = &s; + s.content.visit(*this); - /* Don't remove output variables which are used by the next stage or the - graphics API. */ - if(interface=="out" && (stage.type==Stage::FRAGMENT || linked || !i->first->name.compare(0, 3, "gl_"))) - continue; + for(const AssignmentInfo &a: assignments) + if(a.used_by.empty()) + unused_nodes.insert(a.node); - // Mark other unreferenced global variables as unused. - if(!i->second.referenced) + for(const auto &kvp: variables) + { + if(!kvp.second.referenced) + unused_nodes.insert(kvp.first); + else if(kvp.second.output) { - unused_nodes.insert(i->first); - clear_assignments(i->second, true); + /* The last visible assignments of output variables are used by the + next stage or the API. */ + for(AssignmentInfo *a: kvp.second.assignments) + unused_nodes.erase(a->node); } } - variables.pop_back(); - NodeRemover().apply(stage, unused_nodes); + NodeRemover().apply(s, unused_nodes); return !unused_nodes.empty(); } -void UnusedVariableRemover::visit(VariableReference &var) +void UnusedVariableRemover::referenced(const Assignment::Target &target, Node &node) { - map::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]; - // Previous assignments are used by this reference. - clear_assignments(var_info, false); - var_info.referenced = true; + bool loop_external = false; + for(AssignmentInfo *a: var_info.assignments) + if(targets_overlap(a->target, target)) + { + a->used_by.push_back(&node); + if(a->in_looptoken[0]=='[') { - if(assignment_target) - r_assign_to_subfield = true; - 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); + SetForScope clear_reference(r_reference, Assignment::Target()); + binary.right->visit(*this); + } + + add_to_chain(r_reference, Assignment::Target::ARRAY, 0x3F); + + if(!composite_reference && r_reference.declaration) + referenced(r_reference, binary); } else + { + SetFlag clear_composite(composite_reference, false); TraversingVisitor::visit(binary); + } +} + +void UnusedVariableRemover::visit(TernaryExpression &ternary) +{ + SetFlag clear_composite(composite_reference, false); + TraversingVisitor::visit(ternary); } void UnusedVariableRemover::visit(Assignment &assign) { { - SetFlag set(assignment_target, !assign.self_referencing); + SetFlag set(assignment_target, (assign.oper->token[0]=='=')); assign.left->visit(*this); } assign.right->visit(*this); @@ -805,170 +1391,176 @@ 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]; - /* An assignment which completely replaces the value of the variable causes - any previous unreferenced assignments to be unused. */ - 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(const auto &kvp: variables) + if(kvp.second.output) + referenced(kvp.first, call); + } } -void UnusedVariableRemover::clear_assignments(VariableInfo &var_info, bool mark_unused) +void UnusedVariableRemover::record_assignment(const Assignment::Target &target, Node &node) { - if(mark_unused) + assignments.emplace_back(); + AssignmentInfo &assign_info = assignments.back(); + assign_info.node = &node; + assign_info.target = target; + assign_info.in_loop = in_loop; + + /* An assignment to the target hides any assignments to the same target or + its subfields. */ + VariableInfo &var_info = variables[target.declaration]; + for(unsigned i=0; i::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_subfield)); + 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); + SetFlag set_struct(in_struct); TraversingVisitor::visit(strct); } void UnusedVariableRemover::visit(VariableDeclaration &var) { - if(aggregate) - aggregates[&var] = aggregate; - else + TraversingVisitor::visit(var); + + if(in_struct) + return; + + VariableInfo &var_info = variables[&var]; + + /* Mark variables as output if they're used by the next stage or the + graphics API. */ + bool builtin = (!var.name.compare(0, 3, "gl_") || (var.block_declaration && !var.block_declaration->block_name.compare(0, 3, "gl_"))); + var_info.output = (var.interface=="out" && (stage->type==Stage::FRAGMENT || var.linked_declaration || builtin)); + + // Linked outputs are automatically referenced. + if(var_info.output && var.linked_declaration) + var_info.referenced = true; + + 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); } - TraversingVisitor::visit(var); } -void UnusedVariableRemover::visit(InterfaceBlock &iface) +void UnusedVariableRemover::merge_variables(const BlockVariableMap &other_vars) { - SetForScope set(aggregate, &iface); - unused_nodes.insert(&iface); - iface.struct_declaration->members.visit(*this); + for(const auto &kvp: other_vars) + { + auto j = variables.find(kvp.first); + if(j!=variables.end()) + { + /* 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()); ++k) + if(kvp.second.assignments[k]!=j->second.assignments[k]) + break; + + // Remaining assignments are unique to each block; merge them. + j->second.assignments.insert(j->second.assignments.end(), kvp.second.assignments.begin()+k, kvp.second.assignments.end()); + j->second.referenced |= kvp.second.referenced; + } + else + variables.insert(kvp); + } } 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(); + if(func.body.body.empty()) + return; - /* Mark global variables as conditionally assigned so assignments in other - functions won't be removed. */ - for(BlockVariableMap::iterator i=block_variables.begin(); i!=block_variables.end(); ++i) - if(!i->second.local) - i->second.conditionally_assigned = true; + BlockVariableMap saved_vars = variables; + // Assignments from other functions should not be visible. + for(auto &kvp: variables) + kvp.second.assignments.resize(kvp.second.initialized); + TraversingVisitor::visit(func); + swap(variables, saved_vars); + merge_variables(saved_vars); /* 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) - block_variables[i->get()].referenced = true; - - merge_down_variables(); -} - -void UnusedVariableRemover::merge_down_variables() -{ - BlockVariableMap &parent_variables = variables[variables.size()-2]; - BlockVariableMap &block_variables = variables.back(); - for(BlockVariableMap::iterator i=block_variables.begin(); i!=block_variables.end(); ++i) + for(const RefPtr &p: func.parameters) { - if(i->second.local) - { - if(!i->second.referenced) - unused_nodes.insert(i->first); - /* Any unreferenced assignments when a variable runs out of scope - become unused. */ - clear_assignments(i->second, true); - continue; - } - - BlockVariableMap::iterator j = parent_variables.find(i->first); - if(j==parent_variables.end()) - parent_variables.insert(*i); - else - { - // Merge a non-local variable's state into the parent scope. - if(i->second.referenced || !i->second.conditionally_assigned) - clear_assignments(j->second, !i->second.referenced); - j->second.conditionally_assigned = i->second.conditionally_assigned; - j->second.referenced |= i->second.referenced; - j->second.assignments.insert(j->second.assignments.end(), i->second.assignments.begin(), i->second.assignments.end()); - } + auto j = variables.find(p.get()); + if(j!=variables.end()) + j->second.referenced = true; } - variables.pop_back(); } void UnusedVariableRemover::visit(Conditional &cond) { cond.condition->visit(*this); - variables.push_back(BlockVariableMap()); + BlockVariableMap saved_vars = variables; cond.body.visit(*this); - - BlockVariableMap if_variables; - swap(variables.back(), if_variables); + swap(saved_vars, variables); cond.else_body.visit(*this); - // Combine variables from both branches. - BlockVariableMap &else_variables = variables.back(); - for(BlockVariableMap::iterator i=else_variables.begin(); i!=else_variables.end(); ++i) - { - BlockVariableMap::iterator j = if_variables.find(i->first); - if(j!=if_variables.end()) - { - // The variable was found in both branches. - 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 - // Mark variables found in only one branch as conditionally assigned. - i->second.conditionally_assigned = true; - } + /* 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); +} - /* Move variables which were only used in the if block into the combined - block. */ - for(BlockVariableMap::iterator i=if_variables.begin(); i!=if_variables.end(); ++i) +void UnusedVariableRemover::visit(Iteration &iter) +{ + BlockVariableMap saved_vars = variables; + vector saved_refs; + swap(loop_ext_refs, saved_refs); { - i->second.conditionally_assigned = true; - else_variables.insert(*i); + if(iter.init_statement) + iter.init_statement->visit(*this); + SetForScope set_loop(in_loop, in_loop+1); + if(iter.condition) + iter.condition->visit(*this); + iter.body.visit(*this); + if(iter.loop_expression) + iter.loop_expression->visit(*this); } + swap(loop_ext_refs, saved_refs); - merge_down_variables(); -} + /* Visit the external references of the loop again to record assignments + done in the loop as used. */ + for(Node *n: saved_refs) + n->visit(*this); -void UnusedVariableRemover::visit(Iteration &iter) -{ - variables.push_back(BlockVariableMap()); - TraversingVisitor::visit(iter); - 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); }