X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fglsl%2Foptimize.cpp;h=220017971a2f75001cb6e30faeb4a4fecc2b9fa9;hb=3a675b53b811f50ab965405fbbf91282cab7f3cd;hp=9ab8ef70ef94dfc235e08ecee479792f9ae9cf2b;hpb=7335009e18ecbf53ad9f59d64eed2ed5abbe7b8b;p=libs%2Fgl.git diff --git a/source/glsl/optimize.cpp b/source/glsl/optimize.cpp index 9ab8ef70..22001797 100644 --- a/source/glsl/optimize.cpp +++ b/source/glsl/optimize.cpp @@ -268,9 +268,6 @@ 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) { } @@ -292,56 +289,9 @@ bool ExpressionInliner::apply(Stage &s) return r_any_inlined; } -void ExpressionInliner::visit_and_record(RefPtr &ptr, const Operator *outer_oper, bool on_rhs) +void ExpressionInliner::inline_expression(Expression &expr, RefPtr &ptr) { - 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) - { - /* 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; - } - - 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; -} - -void ExpressionInliner::inline_expression(Expression &expr, RefPtr &ptr, const Operator *outer_oper, const Operator *inner_oper, bool on_rhs) -{ - 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) - { - RefPtr parexpr = new ParenthesizedExpression; - parexpr->expression = expr.clone(); - ptr = parexpr; - } - else - ptr = expr.clone(); - + ptr = expr.clone(); r_any_inlined = true; } @@ -355,7 +305,7 @@ void ExpressionInliner::visit(Block &block) 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, j->second.outer_oper, j->second.inner_oper, j->second.inline_on_rhs); + inline_expression(*j->second.expression, *j->second.inline_point); expressions.erase(j++); } @@ -371,7 +321,30 @@ void ExpressionInliner::visit(Block &block) void ExpressionInliner::visit(RefPtr &expr) { - visit_and_record(expr, 0, false); + 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) @@ -396,34 +369,30 @@ void ExpressionInliner::visit(VariableReference &var) 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; + 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); + visit(binary.right); } - r_oper = binary.oper; r_trivial = false; } @@ -431,10 +400,10 @@ void ExpressionInliner::visit(Assignment &assign) { { SetFlag set_target(mutating); - visit_and_record(assign.left, assign.oper, false); + visit(assign.left); } r_oper = 0; - visit_and_record(assign.right, assign.oper, true); + visit(assign.right); map::iterator i = expressions.find(assign.target); if(i!=expressions.end()) @@ -444,18 +413,23 @@ void ExpressionInliner::visit(Assignment &assign) 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; + 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_oper = 0; r_trivial = false; } @@ -482,7 +456,6 @@ void ExpressionInliner::visit(VariableDeclaration &var) will have their values change throughout the iteration. */ info.expression = (iteration_init ? 0 : var.init_expression.get()); info.assign_scope = current_block; - info.inner_oper = r_oper; info.trivial = r_trivial; } } @@ -581,6 +554,12 @@ void UnusedTypeRemover::visit(BinaryExpression &binary) TraversingVisitor::visit(binary); } +void UnusedTypeRemover::visit(TernaryExpression &ternary) +{ + unused_nodes.erase(ternary.type); + TraversingVisitor::visit(ternary); +} + void UnusedTypeRemover::visit(FunctionCall &call) { unused_nodes.erase(call.type);