Track composite assignments and references in UnusedVariableRemover

[libs/gl.git] / source / glsl / optimize.cpp

diff --git a/source/glsl/optimize.cpp b/source/glsl/optimize.cpp
index 57182019012b731ba330e7fc38a1e86f1f2eeeaf..927047cc7c1e387890bf4a3d1a4a784e2039c7ac 100644 (file)
--- a/source/glsl/optimize.cpp
+++ b/source/glsl/optimize.cpp
@@ -963,7 +963,8 @@ UnusedVariableRemover::UnusedVariableRemover():
        interface_block(0),
        r_assignment(0),
        assignment_target(false),
-       r_side_effects(false)
+       r_side_effects(false),
+       composite_reference(false)
 { }
 
 bool UnusedVariableRemover::apply(Stage &s)
@@ -1008,18 +1009,80 @@ void UnusedVariableRemover::referenced(const Assignment::Target &target, Node &n
        if(!assignment_target)
        {
                for(vector<AssignmentInfo *>::const_iterator i=var_info.assignments.begin(); i!=var_info.assignments.end(); ++i)
-                       (*i)->used_by.push_back(&node);
+               {
+                       bool covered = true;
+                       for(unsigned j=0; (covered && j<(*i)->target.chain_len && j<target.chain_len); ++j)
+                       {
+                               Assignment::Target::ChainType type1 = static_cast<Assignment::Target::ChainType>((*i)->target.chain[j]&0xC0);
+                               Assignment::Target::ChainType type2 = static_cast<Assignment::Target::ChainType>(target.chain[j]&0xC0);
+                               if(type1==Assignment::Target::SWIZZLE || type2==Assignment::Target::SWIZZLE)
+                               {
+                                       unsigned index1 = (*i)->target.chain[j]&0x3F;
+                                       unsigned index2 = target.chain[j]&0x3F;
+                                       if(type1==Assignment::Target::SWIZZLE && type2==Assignment::Target::SWIZZLE)
+                                               covered = index1&index2;
+                                       else if(type1==Assignment::Target::ARRAY && index1<4)
+                                               covered = index2&(1<<index1);
+                                       else if(type2==Assignment::Target::ARRAY && index2<4)
+                                               covered = index1&(1<<index2);
+                                       /* If it's some other combination (shouldn't happen), leave
+                                       covered as true */
+                               }
+                               else
+                                       covered = ((*i)->target.chain[j]==target.chain[j]);
+                       }
+                       if(covered)
+                               (*i)->used_by.push_back(&node);
+               }
        }
 }
 
 void UnusedVariableRemover::visit(VariableReference &var)
 {
-       referenced(var.declaration, var);
+       if(composite_reference)
+               r_reference.declaration = var.declaration;
+       else
+               referenced(var.declaration, var);
 }
 
 void UnusedVariableRemover::visit(InterfaceBlockReference &iface)
 {
-       referenced(iface.declaration, iface);
+       if(composite_reference)
+               r_reference.declaration = iface.declaration;
+       else
+               referenced(iface.declaration, iface);
+}
+
+void UnusedVariableRemover::visit_composite(Expression &expr)
+{
+       if(!composite_reference)
+               r_reference = Assignment::Target();
+
+       SetFlag set_composite(composite_reference);
+       expr.visit(*this);
+}
+
+void UnusedVariableRemover::visit(MemberAccess &memacc)
+{
+       visit_composite(*memacc.left);
+
+       add_to_chain(r_reference, Assignment::Target::MEMBER, memacc.index);
+
+       if(!composite_reference && r_reference.declaration)
+               referenced(r_reference, memacc);
+}
+
+void UnusedVariableRemover::visit(Swizzle &swizzle)
+{
+       visit_composite(*swizzle.left);
+
+       unsigned mask = 0;
+       for(unsigned i=0; i<swizzle.count; ++i)
+               mask |= 1<<swizzle.components[i];
+       add_to_chain(r_reference, Assignment::Target::SWIZZLE, mask);
+
+       if(!composite_reference && r_reference.declaration)
+               referenced(r_reference, swizzle);
 }
 
 void UnusedVariableRemover::visit(UnaryExpression &unary)
@@ -1033,12 +1096,30 @@ void UnusedVariableRemover::visit(BinaryExpression &binary)
 {
        if(binary.oper->token[0]=='[')
        {
-               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);
+                       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)
@@ -1054,6 +1135,7 @@ 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. */