X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fglsl%2Foptimize.cpp;h=668f7c5ef2553d399feef9c6c60949990fa54150;hb=d5c38c181cac4da490c96123e5a88a8c06785e55;hp=c8c9041fd43c7c9814cbd53e4d3ab8a719252cb2;hpb=b89239e1d616f0c1d8e432b7df1eca149585cf5e;p=libs%2Fgl.git diff --git a/source/glsl/optimize.cpp b/source/glsl/optimize.cpp index c8c9041f..668f7c5e 100644 --- a/source/glsl/optimize.cpp +++ b/source/glsl/optimize.cpp @@ -66,14 +66,15 @@ void InlineableFunctionLocator::visit(Return &ret) InlineContentInjector::InlineContentInjector(): source_func(0), - remap_names(false), - deps_only(false) + remap_names(0) { } const string &InlineContentInjector::apply(Stage &stage, FunctionDeclaration &target_func, Block &tgt_blk, const NodeList::iterator &ins_pt, FunctionDeclaration &src) { - target_block = &tgt_blk; + staging_block.parent = &tgt_blk; source_func = &src; + remap_prefix = source_func->name; + for(NodeList::iterator i=src.body.body.begin(); i!=src.body.body.end(); ++i) { r_inlined_statement = 0; @@ -81,11 +82,18 @@ const string &InlineContentInjector::apply(Stage &stage, FunctionDeclaration &ta if(!r_inlined_statement) r_inlined_statement = (*i)->clone(); - SetFlag set_remap(remap_names); + SetForScope set_remap(remap_names, 2); r_inlined_statement->visit(*this); - tgt_blk.body.insert(ins_pt, r_inlined_statement); + staging_block.body.push_back(r_inlined_statement); } + SetForScope set_remap(remap_names, 1); + SetForScope set_prefix(remap_prefix, target_func.name); + staging_block.variables.clear(); + target_func.visit(*this); + + tgt_blk.body.splice(ins_pt, staging_block.body); + NodeReorderer().apply(stage, target_func, dependencies); return r_result_name; @@ -95,14 +103,17 @@ void InlineContentInjector::visit(VariableReference &var) { if(remap_names) { - 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); + if(!staging_block.variables.count(var.name)) + { + dependencies.insert(var.declaration); + referenced_names.insert(var.name); + } var.declaration->visit(*this); } } @@ -111,8 +122,8 @@ void InlineContentInjector::visit(InterfaceBlockReference &iface) { if(!remap_names && iface.declaration) { - SetFlag set_deps(deps_only); dependencies.insert(iface.declaration); + referenced_names.insert(iface.name); iface.declaration->visit(*this); } } @@ -120,7 +131,10 @@ void InlineContentInjector::visit(InterfaceBlockReference &iface) void InlineContentInjector::visit(FunctionCall &call) { if(!remap_names && call.declaration) + { dependencies.insert(call.declaration); + referenced_names.insert(call.name); + } TraversingVisitor::visit(call); } @@ -128,20 +142,22 @@ void InlineContentInjector::visit(VariableDeclaration &var) { TraversingVisitor::visit(var); - if(var.type_declaration) + if(remap_names) { - SetFlag set_deps(deps_only); - dependencies.insert(var.type_declaration); - var.type_declaration->visit(*this); + if(remap_names==2 || referenced_names.count(var.name)) + { + string mapped_name = get_unused_variable_name(staging_block, var.name, remap_prefix); + staging_block.variables[var.name] = &var; + if(mapped_name!=var.name) + staging_block.variables[mapped_name] = &var; + var.name = mapped_name; + } } - - if(!remap_names && !deps_only) + else if(var.type_declaration) { - RefPtr inlined_var = var.clone(); - inlined_var->name = get_unused_variable_name(*target_block, var.name, source_func->name); - r_inlined_statement = inlined_var; - - variable_map[var.name] = inlined_var.get(); + dependencies.insert(var.type_declaration); + referenced_names.insert(var.type_declaration->name); + var.type_declaration->visit(*this); } } @@ -149,11 +165,11 @@ void InlineContentInjector::visit(Return &ret) { TraversingVisitor::visit(ret); - if(ret.expression) + if(!remap_names && ret.expression) { /* Create a new variable to hold the return value of the inlined function. */ - r_result_name = get_unused_variable_name(*target_block, "_return", source_func->name); + r_result_name = get_unused_variable_name(staging_block, "_return", source_func->name); RefPtr var = new VariableDeclaration; var->source = ret.source; var->line = ret.line; @@ -167,7 +183,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) @@ -195,7 +212,7 @@ 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); @@ -204,6 +221,9 @@ void FunctionInliner::visit(Block &block) void FunctionInliner::visit(FunctionCall &call) { + if(r_inlined_here) + return; + for(NodeArray::iterator i=call.arguments.begin(); i!=call.arguments.end(); ++i) visit(*i); @@ -226,6 +246,7 @@ 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; } } @@ -233,6 +254,7 @@ void FunctionInliner::visit(FunctionDeclaration &func) { SetForScope set_func(current_function, &func); TraversingVisitor::visit(func); + r_inlined_here = false; } void FunctionInliner::visit(Iteration &iter) @@ -464,12 +486,301 @@ void ExpressionInliner::visit(Iteration &iter) } +BasicTypeDeclaration::Kind ConstantFolder::get_value_kind(const Variant &value) +{ + if(value.check_type()) + return BasicTypeDeclaration::BOOL; + else if(value.check_type()) + return BasicTypeDeclaration::INT; + else if(value.check_type()) + return BasicTypeDeclaration::FLOAT; + else + return BasicTypeDeclaration::VOID; +} + +template +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(); + } +} + +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; + + BasicTypeDeclaration::Kind kind = get_value_kind(r_constant_value); + if(kind==BasicTypeDeclaration::VOID) + { + r_constant = false; + return; + } + + RefPtr literal = new Literal; + if(kind==BasicTypeDeclaration::BOOL) + literal->token = (r_constant_value.value() ? "true" : "false"); + else if(kind==BasicTypeDeclaration::INT) + literal->token = lexical_cast(r_constant_value.value()); + else if(kind==BasicTypeDeclaration::FLOAT) + literal->token = lexical_cast(r_constant_value.value()); + literal->value = r_constant_value; + expr = literal; +} + +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; + + BasicTypeDeclaration::Kind kind = get_value_kind(r_constant_value); + + char oper = unary.oper->token[0]; + char oper2 = unary.oper->token[1]; + if(oper=='!') + { + if(kind==BasicTypeDeclaration::BOOL) + set_result(!r_constant_value.value()); + } + else if(oper=='~') + { + if(kind==BasicTypeDeclaration::INT) + set_result(~r_constant_value.value()); + } + else if(oper=='-' && !oper2) + { + if(kind==BasicTypeDeclaration::INT) + set_result(-r_constant_value.value()); + else if(kind==BasicTypeDeclaration::FLOAT) + 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; + + BasicTypeDeclaration::Kind left_kind = get_value_kind(left_value); + BasicTypeDeclaration::Kind right_kind = get_value_kind(r_constant_value); + // Currently only expressions with both sides of equal types are handled. + if(left_kind!=right_kind) + return; + + char oper = binary.oper->token[0]; + char oper2 = binary.oper->token[1]; + if(oper=='&' || oper=='|' || oper=='^') + { + if(oper2==oper && left_kind==BasicTypeDeclaration::BOOL) + set_result(evaluate_logical(oper, left_value.value(), r_constant_value.value())); + else if(!oper2 && left_kind==BasicTypeDeclaration::INT) + set_result(evaluate_logical(oper, left_value.value(), r_constant_value.value())); + } + else if((oper=='<' || oper=='>') && oper2!=oper) + { + if(left_kind==BasicTypeDeclaration::INT) + set_result(evaluate_relation(binary.oper->token, left_value.value(), r_constant_value.value())); + else if(left_kind==BasicTypeDeclaration::FLOAT) + set_result(evaluate_relation(binary.oper->token, left_value.value(), r_constant_value.value())); + } + else if((oper=='=' || oper=='!') && oper2=='=') + { + if(left_kind==BasicTypeDeclaration::INT) + set_result((left_value.value()==r_constant_value.value()) == (oper=='=')); + if(left_kind==BasicTypeDeclaration::FLOAT) + set_result((left_value.value()==r_constant_value.value()) == (oper=='=')); + } + else if(oper=='+' || oper=='-' || oper=='*' || oper=='/') + { + if(left_kind==BasicTypeDeclaration::INT) + set_result(evaluate_arithmetic(oper, left_value.value(), r_constant_value.value())); + else if(left_kind==BasicTypeDeclaration::FLOAT) + set_result(evaluate_arithmetic(oper, left_value.value(), r_constant_value.value())); + } + else if(oper=='%' || ((oper=='<' || oper=='>') && oper2==oper)) + { + if(left_kind!=BasicTypeDeclaration::INT) + return; + + if(oper=='%') + set_result(left_value.value()%r_constant_value.value()); + else if(oper=='<') + set_result(left_value.value()<()); + else if(oper=='>') + set_result(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) +{ + 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); +} + + void ConstantConditionEliminator::apply(Stage &stage) { stage.content.visit(*this); 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); @@ -480,16 +791,35 @@ void ConstantConditionEliminator::visit(Block &block) } } +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(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(Conditional &cond) { - 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; - } + ConstantStatus result = check_constant_condition(*cond.condition); + if(result!=NOT_CONSTANT) + { + 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; + } TraversingVisitor::visit(cond); } @@ -498,14 +828,8 @@ 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;