Fix various issues with constant condition elimination

[libs/gl.git] / source / programcompiler.cpp

diff --git a/source/programcompiler.cpp b/source/programcompiler.cpp
index 0aed5936af82948eb1c040621e61b7dea83b2b18..1f014f72c654d3e678f706cfff28f9d5173407f4 100644 (file)
--- a/source/programcompiler.cpp
+++ b/source/programcompiler.cpp
@@ -208,6 +208,7 @@ void ProgramCompiler::generate(Stage &stage)
        apply<InterfaceGenerator>(stage);
        apply<VariableResolver>(stage);
        apply<DeclarationReorderer>(stage);
+       apply<FunctionResolver>(stage);
        apply<LegacyConverter>(stage);
 }
 
@@ -459,6 +460,8 @@ void ProgramCompiler::Formatter::visit(VariableDeclaration &var)
        }
        if(var.constant)
                formatted += "const ";
+       if(!var.interpolation.empty())
+               formatted += format("%s ", var.interpolation);
        if(!var.sampling.empty())
                formatted += format("%s ", var.sampling);
        if(!var.interface.empty() && var.interface!=block_interface)
@@ -554,8 +557,12 @@ void ProgramCompiler::Formatter::visit(Iteration &iter)
 
 void ProgramCompiler::Formatter::visit(Return &ret)
 {
-       formatted += "return ";
-       ret.expression->visit(*this);
+       formatted += "return";
+       if(ret.expression)
+       {
+               formatted += ' ';
+               ret.expression->visit(*this);
+       }
        formatted += ';';
 }
 
@@ -1168,6 +1175,12 @@ void ProgramCompiler::FunctionInliner::visit(BinaryExpression &binary)
        inline_result = 0;
 }
 
+void ProgramCompiler::FunctionInliner::visit(MemberAccess &memacc)
+{
+       visit_and_inline(memacc.left);
+       inline_result = 0;
+}
+
 void ProgramCompiler::FunctionInliner::visit(FunctionCall &call)
 {
        for(vector<RefPtr<Expression> >::iterator i=call.arguments.begin(); i!=call.arguments.end(); ++i)
@@ -1286,7 +1299,8 @@ void ProgramCompiler::ExpressionEvaluator::visit(BinaryExpression &binary)
 
 
 ProgramCompiler::ConstantConditionEliminator::ConstantConditionEliminator():
-       scope_level(0)
+       scope_level(0),
+       record_only(false)
 { }
 
 void ProgramCompiler::ConstantConditionEliminator::visit(Block &block)
@@ -1298,6 +1312,13 @@ void ProgramCompiler::ConstantConditionEliminator::visit(Block &block)
                variable_values.erase(i->second);
 }
 
+void ProgramCompiler::ConstantConditionEliminator::visit(UnaryExpression &unary)
+{
+       if(VariableReference *var = dynamic_cast<VariableReference *>(unary.expression.get()))
+               if(unary.oper=="++" || unary.oper=="--")
+                       variable_values.erase(var->declaration);
+}
+
 void ProgramCompiler::ConstantConditionEliminator::visit(Assignment &assign)
 {
        variable_values.erase(assign.target_declaration);
@@ -1311,28 +1332,49 @@ void ProgramCompiler::ConstantConditionEliminator::visit(VariableDeclaration &va
 
 void ProgramCompiler::ConstantConditionEliminator::visit(Conditional &cond)
 {
-       ExpressionEvaluator eval(variable_values);
-       cond.condition->visit(eval);
-       if(eval.result_valid)
-               flatten_block(eval.result ? cond.body : cond.else_body);
-       else
-               TraversingVisitor::visit(cond);
+       if(!record_only)
+       {
+               ExpressionEvaluator eval(variable_values);
+               cond.condition->visit(eval);
+               if(eval.result_valid)
+               {
+                       flatten_block(eval.result ? cond.body : cond.else_body);
+                       return;
+               }
+       }
+
+       TraversingVisitor::visit(cond);
 }
 
 void ProgramCompiler::ConstantConditionEliminator::visit(Iteration &iter)
 {
-       if(iter.condition)
+       if(!record_only)
        {
-               ExpressionEvaluator eval;
-               iter.condition->visit(eval);
-               if(eval.result_valid && !eval.result)
+               if(iter.condition)
                {
-                       remove_node = true;
-                       return;
+                       /* 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.result_valid && !eval.result)
+                       {
+                               remove_node = true;
+                               return;
+                       }
                }
+
+               /* 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);
        }
 
        TraversingVisitor::visit(iter);
+
+       if(VariableDeclaration *init_decl = dynamic_cast<VariableDeclaration *>(iter.init_statement.get()))
+               variable_values.erase(init_decl);
 }
 
 
@@ -1762,6 +1804,22 @@ bool ProgramCompiler::LegacyConverter::supports_interface_layouts() const
                return check_version(Version(3, 30));
 }
 
+bool ProgramCompiler::LegacyConverter::supports_centroid_sampling() const
+{
+       if(target_api==OPENGL_ES2)
+               return check_version(Version(3, 0));
+       else
+               return check_version(Version(1, 20));
+}
+
+bool ProgramCompiler::LegacyConverter::supports_sample_sampling() const
+{
+       if(target_api==OPENGL_ES2)
+               return check_version(Version(3, 20));
+       else
+               return check_version(Version(4, 0));
+}
+
 void ProgramCompiler::LegacyConverter::visit(VariableDeclaration &var)
 {
        if(var.layout && !supports_interface_layouts())
@@ -1789,6 +1847,17 @@ void ProgramCompiler::LegacyConverter::visit(VariableDeclaration &var)
                }
        }
 
+       if(var.sampling=="centroid")
+       {
+               if(!supports_centroid_sampling())
+                       var.sampling = string();
+       }
+       else if(var.sampling=="sample")
+       {
+               if(!supports_sample_sampling())
+                       var.sampling = string();
+       }
+
        if((var.interface=="in" || var.interface=="out") && !supports_unified_interface_syntax())
        {
                if(stage->type==FRAGMENT && var.interface=="out")