X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fglsl%2Foptimize.cpp;h=87a57eb7f82496c797c6afdcf7ddbb257049655c;hb=05d8360ceef28e0b36e96127e04a82dd77a5c433;hp=215466b2a8390425ea7d440dec710c14d5bb17c0;hpb=e2357c3e5438706ab6fcda86199cd897d46cfcd3;p=libs%2Fgl.git diff --git a/source/glsl/optimize.cpp b/source/glsl/optimize.cpp index 215466b2..87a57eb7 100644 --- a/source/glsl/optimize.cpp +++ b/source/glsl/optimize.cpp @@ -193,7 +193,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); @@ -216,31 +216,10 @@ void FunctionInliner::visit(Block &block) } } -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); + visit(*i); FunctionDeclaration *def = call.declaration; if(def) @@ -264,29 +243,12 @@ void FunctionInliner::visit(FunctionCall &call) } } -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); -} - void FunctionInliner::visit(Iteration &iter) { /* Visit the initialization statement before entering the loop body so the @@ -301,12 +263,6 @@ 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), @@ -393,35 +349,36 @@ void ExpressionInliner::visit(Block &block) { TraversingVisitor::visit(block); - for(map::iterator i=expressions.begin(); i!=expressions.end(); ) + for(map::iterator i=block.variables.begin(); i!=block.variables.end(); ++i) { - map::iterator j = block.variables.find(i->first->name); - if(j!=block.variables.end() && j->second==i->first) + map::iterator j = expressions.lower_bound(i->second); + for(; (j!=expressions.end() && j->first.declaration==i->second); ) { - 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); + if(j->second.expression && j->second.inline_point) + inline_expression(*j->second.expression, *j->second.inline_point, j->second.outer_oper, j->second.inner_oper, j->second.inline_on_rhs); - expressions.erase(i++); - } - 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; + 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) +{ + visit_and_record(expr, 0, false); } void ExpressionInliner::visit(VariableReference &var) { if(var.declaration) { - map::iterator i = expressions.find(var.declaration); + map::iterator i = expressions.find(var.declaration); if(i!=expressions.end()) { /* If a non-trivial expression is referenced multiple times, don't @@ -479,19 +436,16 @@ void ExpressionInliner::visit(Assignment &assign) r_oper = 0; visit_and_record(assign.right, assign.oper, true); - if(VariableDeclaration *target_var = dynamic_cast(assign.target.declaration)) + map::iterator i = expressions.find(assign.target); + if(i!=expressions.end()) { - map::iterator i = expressions.find(target_var); - 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.inner_oper = r_oper; - i->second.available = true; - } + /* 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; } r_oper = assign.oper; @@ -500,8 +454,7 @@ void ExpressionInliner::visit(Assignment &assign) void ExpressionInliner::visit(FunctionCall &call) { - for(NodeArray::iterator i=call.arguments.begin(); i!=call.arguments.end(); ++i) - visit_and_record(*i, 0, false); + TraversingVisitor::visit(call); r_oper = 0; r_trivial = false; } @@ -510,8 +463,7 @@ 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) @@ -535,12 +487,6 @@ void ExpressionInliner::visit(VariableDeclaration &var) } } -void ExpressionInliner::visit(Conditional &cond) -{ - visit_and_record(cond.condition, 0, false); - cond.body.visit(*this); -} - void ExpressionInliner::visit(Iteration &iter) { SetForScope set_block(current_block, &iter.body); @@ -552,16 +498,10 @@ 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); -} - -void ExpressionInliner::visit(Return &ret) -{ - if(ret.expression) - visit_and_record(ret.expression, 0, false); + visit(iter.loop_expression); } @@ -583,15 +523,14 @@ void ConstantConditionEliminator::visit(Block &block) void ConstantConditionEliminator::visit(Conditional &cond) { - ExpressionEvaluator eval; - cond.condition->visit(eval); - if(eval.is_result_valid()) - { - Block &block = (eval.get_result() ? cond.body : cond.else_body); - current_block->body.splice(insert_point, block.body); - nodes_to_remove.insert(&cond); - return; - } + if(Literal *literal = dynamic_cast(cond.condition.get())) + if(literal->value.check_type()) + { + Block &block = (literal->value.value() ? cond.body : cond.else_body); + current_block->body.splice(insert_point, block.body); + nodes_to_remove.insert(&cond); + return; + } TraversingVisitor::visit(cond); } @@ -618,15 +557,6 @@ void ConstantConditionEliminator::visit(Iteration &iter) } -UnusedVariableRemover::VariableInfo::VariableInfo(): - local(false), - output(false), - conditionally_assigned(false), - referenced(false), - interface_block(0) -{ } - - bool UnusedTypeRemover::apply(Stage &stage) { stage.content.visit(*this); @@ -694,6 +624,15 @@ void UnusedTypeRemover::visit(FunctionDeclaration &func) } +UnusedVariableRemover::VariableInfo::VariableInfo(): + local(false), + output(false), + conditionally_assigned(false), + referenced(false), + interface_block(0) +{ } + + UnusedVariableRemover::UnusedVariableRemover(): stage(0), interface_block(0), @@ -721,7 +660,7 @@ bool UnusedVariableRemover::apply(Stage &s) } if(output) { - if(!i->second.assignments.empty() && i->second.interface_block) + if((i->second.referenced || !i->second.assignments.empty()) && i->second.interface_block) used_interface_blocks.insert(i->second.interface_block); continue; }