glsl2: Add a generic visitor class to call back with pointers to each rvalue.

I keep copy and pasting this code all over, so consolidate it in one
place.

src/glsl/Makefile

@@ -57,6 +57,7 @@ CXX_SOURCES = \
 	ir_mod_to_fract.cpp \
 	ir_print_visitor.cpp \
 	ir_reader.cpp \
+	ir_rvalue_visitor.cpp \
 	ir_set_program_inouts.cpp \
 	ir_structure_splitting.cpp \
 	ir_sub_to_add_neg.cpp \

src/glsl/ir_algebraic.cpp

@@ -30,6 +30,7 @@
 
 #include "ir.h"
 #include "ir_visitor.h"
+#include "ir_rvalue_visitor.h"
 #include "ir_optimization.h"
 #include "glsl_types.h"
 
@@ -37,7 +38,7 @@
  * Visitor class for replacing expressions with ir_constant values.
  */
 
-class ir_algebraic_visitor : public ir_hierarchical_visitor {
+class ir_algebraic_visitor : public ir_rvalue_visitor {
 public:
    ir_algebraic_visitor()
    {
@@ -48,16 +49,8 @@ public:
    {
    }
 
-   virtual ir_visitor_status visit_leave(ir_assignment *);
-   virtual ir_visitor_status visit_leave(ir_call *);
-   virtual ir_visitor_status visit_leave(ir_dereference_array *);
-   virtual ir_visitor_status visit_leave(ir_expression *);
-   virtual ir_visitor_status visit_leave(ir_if *);
-   virtual ir_visitor_status visit_leave(ir_return *);
-   virtual ir_visitor_status visit_leave(ir_swizzle *);
-   virtual ir_visitor_status visit_leave(ir_texture *);
-
-   ir_rvalue *handle_expression(ir_rvalue *in_ir);
+   ir_rvalue *handle_expression(ir_expression *ir);
+   void handle_rvalue(ir_rvalue **rvalue);
    bool reassociate_constant(ir_expression *ir1,
 			     int const_index,
 			     ir_constant *constant,
@@ -224,22 +217,15 @@ ir_algebraic_visitor::reassociate_constant(ir_expression *ir1, int const_index,
 }
 
 ir_rvalue *
-ir_algebraic_visitor::handle_expression(ir_rvalue *in_ir)
+ir_algebraic_visitor::handle_expression(ir_expression *ir)
 {
-   ir_expression *ir = (ir_expression *)in_ir;
    ir_constant *op_const[2] = {NULL, NULL};
    ir_expression *op_expr[2] = {NULL, NULL};
    unsigned int i;
 
-   if (!in_ir)
-      return NULL;
-
-   if (in_ir->ir_type != ir_type_expression)
-      return in_ir;
-
    for (i = 0; i < ir->get_num_operands(); i++) {
       if (ir->operands[i]->type->is_matrix())
-	 return in_ir;
+	 return ir;
 
       op_const[i] = ir->operands[i]->constant_expression_value();
       op_expr[i] = ir->operands[i]->as_expression();
@@ -379,98 +365,22 @@ ir_algebraic_visitor::handle_expression(ir_rvalue *in_ir)
       break;
    }
 
-   return in_ir;
+   return ir;
 }
 
-ir_visitor_status
-ir_algebraic_visitor::visit_leave(ir_expression *ir)
+void
+ir_algebraic_visitor::handle_rvalue(ir_rvalue **rvalue)
 {
-   unsigned int operand;
+   if (!*rvalue)
+      return;
 
-   for (operand = 0; operand < ir->get_num_operands(); operand++) {
-      ir->operands[operand] = handle_expression(ir->operands[operand]);
-   }
+   ir_expression *expr = (*rvalue)->as_expression();
+   if (!expr)
+      return;
 
-   return visit_continue;
+   *rvalue = handle_expression(expr);
 }
 
-ir_visitor_status
-ir_algebraic_visitor::visit_leave(ir_texture *ir)
-{
-   ir->coordinate = handle_expression(ir->coordinate);
-   ir->projector = handle_expression(ir->projector);
-   ir->shadow_comparitor = handle_expression(ir->shadow_comparitor);
-
-   switch (ir->op) {
-   case ir_tex:
-      break;
-   case ir_txb:
-      ir->lod_info.bias = handle_expression(ir->lod_info.bias);
-      break;
-   case ir_txf:
-   case ir_txl:
-      ir->lod_info.lod = handle_expression(ir->lod_info.lod);
-      break;
-   case ir_txd:
-      ir->lod_info.grad.dPdx = handle_expression(ir->lod_info.grad.dPdx);
-      ir->lod_info.grad.dPdy = handle_expression(ir->lod_info.grad.dPdy);
-      break;
-   }
-
-   return visit_continue;
-}
-
-ir_visitor_status
-ir_algebraic_visitor::visit_leave(ir_swizzle *ir)
-{
-   ir->val = handle_expression(ir->val);
-   return visit_continue;
-}
-
-ir_visitor_status
-ir_algebraic_visitor::visit_leave(ir_dereference_array *ir)
-{
-   ir->array_index = handle_expression(ir->array_index);
-   return visit_continue;
-}
-
-ir_visitor_status
-ir_algebraic_visitor::visit_leave(ir_assignment *ir)
-{
-   ir->rhs = handle_expression(ir->rhs);
-   ir->condition = handle_expression(ir->condition);
-   return visit_continue;
-}
-
-ir_visitor_status
-ir_algebraic_visitor::visit_leave(ir_call *ir)
-{
-   foreach_iter(exec_list_iterator, iter, *ir) {
-      ir_rvalue *param = (ir_rvalue *)iter.get();
-      ir_rvalue *new_param = handle_expression(param);
-
-      if (new_param != param) {
-	 param->replace_with(new_param);
-      }
-   }
-   return visit_continue;
-}
-
-ir_visitor_status
-ir_algebraic_visitor::visit_leave(ir_return *ir)
-{
-   ir->value = handle_expression(ir->value);;
-   return visit_continue;
-}
-
-ir_visitor_status
-ir_algebraic_visitor::visit_leave(ir_if *ir)
-{
-   ir->condition = handle_expression(ir->condition);
-   return visit_continue;
-}
-
-
 bool
 do_algebraic(exec_list *instructions)
 {

src/glsl/ir_rvalue_visitor.cpp

@@ -0,0 +1,134 @@
+/*
+ * Copyright © 2010 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+/**
+ * \file ir_rvalue_visitor.cpp
+ *
+ * Generic class to implement the common pattern we have of wanting to
+ * visit each ir_rvalue * and possibly change that node to a different
+ * class.
+ */
+
+#include "ir.h"
+#include "ir_visitor.h"
+#include "ir_rvalue_visitor.h"
+#include "ir_print_visitor.h"
+#include "glsl_types.h"
+
+ir_visitor_status
+ir_rvalue_visitor::visit_leave(ir_expression *ir)
+{
+   unsigned int operand;
+
+   for (operand = 0; operand < ir->get_num_operands(); operand++) {
+      handle_rvalue(&ir->operands[operand]);
+   }
+
+   return visit_continue;
+}
+
+ir_visitor_status
+ir_rvalue_visitor::visit_leave(ir_texture *ir)
+{
+   handle_rvalue(&ir->coordinate);
+   handle_rvalue(&ir->projector);
+   handle_rvalue(&ir->shadow_comparitor);
+
+   switch (ir->op) {
+   case ir_tex:
+      break;
+   case ir_txb:
+      handle_rvalue(&ir->lod_info.bias);
+      break;
+   case ir_txf:
+   case ir_txl:
+      handle_rvalue(&ir->lod_info.lod);
+      break;
+   case ir_txd:
+      handle_rvalue(&ir->lod_info.grad.dPdx);
+      handle_rvalue(&ir->lod_info.grad.dPdy);
+      break;
+   }
+
+   return visit_continue;
+}
+
+ir_visitor_status
+ir_rvalue_visitor::visit_leave(ir_swizzle *ir)
+{
+   handle_rvalue(&ir->val);
+   return visit_continue;
+}
+
+ir_visitor_status
+ir_rvalue_visitor::visit_leave(ir_dereference_array *ir)
+{
+   handle_rvalue(&ir->array_index);
+   handle_rvalue(&ir->array);
+   return visit_continue;
+}
+
+ir_visitor_status
+ir_rvalue_visitor::visit_leave(ir_dereference_record *ir)
+{
+   handle_rvalue(&ir->record);
+   return visit_continue;
+}
+
+ir_visitor_status
+ir_rvalue_visitor::visit_leave(ir_assignment *ir)
+{
+   handle_rvalue(&ir->rhs);
+   handle_rvalue(&ir->condition);
+
+   return visit_continue;
+}
+
+ir_visitor_status
+ir_rvalue_visitor::visit_leave(ir_call *ir)
+{
+   foreach_iter(exec_list_iterator, iter, *ir) {
+      ir_rvalue *param = (ir_rvalue *)iter.get();
+      ir_rvalue *new_param = param;
+      handle_rvalue(&new_param);
+
+      if (new_param != param) {
+	 param->replace_with(new_param);
+      }
+   }
+   return visit_continue;
+}
+
+ir_visitor_status
+ir_rvalue_visitor::visit_leave(ir_return *ir)
+{
+   handle_rvalue(&ir->value);;
+   return visit_continue;
+}
+
+ir_visitor_status
+ir_rvalue_visitor::visit_leave(ir_if *ir)
+{
+   handle_rvalue(&ir->condition);
+   return visit_continue;
+}

src/glsl/ir_rvalue_visitor.h

@@ -0,0 +1,47 @@
+/*
+ * Copyright © 2010 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+/**
+ * \file ir_rvalue_visitor.h
+ *
+ * Generic class to implement the common pattern we have of wanting to
+ * visit each ir_rvalue * and possibly change that node to a different
+ * class.  Just implement handle_rvalue() and you will be called with
+ * a pointer to each rvalue in the tree.
+ */
+
+class ir_rvalue_visitor : public ir_hierarchical_visitor {
+public:
+
+   virtual ir_visitor_status visit_leave(ir_assignment *);
+   virtual ir_visitor_status visit_leave(ir_call *);
+   virtual ir_visitor_status visit_leave(ir_dereference_array *);
+   virtual ir_visitor_status visit_leave(ir_dereference_record *);
+   virtual ir_visitor_status visit_leave(ir_expression *);
+   virtual ir_visitor_status visit_leave(ir_if *);
+   virtual ir_visitor_status visit_leave(ir_return *);
+   virtual ir_visitor_status visit_leave(ir_swizzle *);
+   virtual ir_visitor_status visit_leave(ir_texture *);
+
+   virtual void handle_rvalue(ir_rvalue **rvalue) = 0;
+};

src/glsl/ir_structure_splitting.cpp

@@ -35,6 +35,7 @@
 #include "ir.h"
 #include "ir_visitor.h"
 #include "ir_print_visitor.h"
+#include "ir_rvalue_visitor.h"
 #include "glsl_types.h"
 
 static bool debug = false;
@@ -165,7 +166,7 @@ ir_structure_reference_visitor::visit_enter(ir_function_signature *ir)
    return visit_continue_with_parent;
 }
 
-class ir_structure_splitting_visitor : public ir_hierarchical_visitor {
+class ir_structure_splitting_visitor : public ir_rvalue_visitor {
 public:
    ir_structure_splitting_visitor(exec_list *vars)
    {
@@ -177,17 +178,9 @@ public:
    }
 
    virtual ir_visitor_status visit_leave(ir_assignment *);
-   virtual ir_visitor_status visit_leave(ir_call *);
-   virtual ir_visitor_status visit_leave(ir_dereference_array *);
-   virtual ir_visitor_status visit_leave(ir_dereference_record *);
-   virtual ir_visitor_status visit_leave(ir_expression *);
-   virtual ir_visitor_status visit_leave(ir_if *);
-   virtual ir_visitor_status visit_leave(ir_return *);
-   virtual ir_visitor_status visit_leave(ir_swizzle *);
-   virtual ir_visitor_status visit_leave(ir_texture *);
 
    void split_deref(ir_dereference **deref);
-   void split_rvalue(ir_rvalue **rvalue);
+   void handle_rvalue(ir_rvalue **rvalue);
    struct variable_entry *get_splitting_entry(ir_variable *var);
 
    exec_list *variable_list;
@@ -239,7 +232,7 @@ ir_structure_splitting_visitor::split_deref(ir_dereference **deref)
 }
 
 void
-ir_structure_splitting_visitor::split_rvalue(ir_rvalue **rvalue)
+ir_structure_splitting_visitor::handle_rvalue(ir_rvalue **rvalue)
 {
    if (!*rvalue)
       return;
@@ -253,66 +246,6 @@ ir_structure_splitting_visitor::split_rvalue(ir_rvalue **rvalue)
    *rvalue = deref;
 }
 
-ir_visitor_status
-ir_structure_splitting_visitor::visit_leave(ir_expression *ir)
-{
-   unsigned int operand;
-
-   for (operand = 0; operand < ir->get_num_operands(); operand++) {
-      split_rvalue(&ir->operands[operand]);
-   }
-
-   return visit_continue;
-}
-
-ir_visitor_status
-ir_structure_splitting_visitor::visit_leave(ir_texture *ir)
-{
-   split_rvalue(&ir->coordinate);
-   split_rvalue(&ir->projector);
-   split_rvalue(&ir->shadow_comparitor);
-
-   switch (ir->op) {
-   case ir_tex:
-      break;
-   case ir_txb:
-      split_rvalue(&ir->lod_info.bias);
-      break;
-   case ir_txf:
-   case ir_txl:
-      split_rvalue(&ir->lod_info.lod);
-      break;
-   case ir_txd:
-      split_rvalue(&ir->lod_info.grad.dPdx);
-      split_rvalue(&ir->lod_info.grad.dPdy);
-      break;
-   }
-
-   return visit_continue;
-}
-
-ir_visitor_status
-ir_structure_splitting_visitor::visit_leave(ir_swizzle *ir)
-{
-   split_rvalue(&ir->val);
-   return visit_continue;
-}
-
-ir_visitor_status
-ir_structure_splitting_visitor::visit_leave(ir_dereference_array *ir)
-{
-   split_rvalue(&ir->array_index);
-   split_rvalue(&ir->array);
-   return visit_continue;
-}
-
-ir_visitor_status
-ir_structure_splitting_visitor::visit_leave(ir_dereference_record *ir)
-{
-   split_rvalue(&ir->record);
-   return visit_continue;
-}
-
 ir_visitor_status
 ir_structure_splitting_visitor::visit_leave(ir_assignment *ir)
 {
@@ -349,45 +282,15 @@ ir_structure_splitting_visitor::visit_leave(ir_assignment *ir)
       }
       ir->remove();
    } else {
-      split_rvalue(&ir->rhs);
+      handle_rvalue(&ir->rhs);
       split_deref(&ir->lhs);
    }
 
-   split_rvalue(&ir->condition);
+   handle_rvalue(&ir->condition);
 
    return visit_continue;
 }
 
-ir_visitor_status
-ir_structure_splitting_visitor::visit_leave(ir_call *ir)
-{
-   foreach_iter(exec_list_iterator, iter, *ir) {
-      ir_rvalue *param = (ir_rvalue *)iter.get();
-      ir_rvalue *new_param = param;
-      split_rvalue(&new_param);
-
-      if (new_param != param) {
-	 param->replace_with(new_param);
-      }
-   }
-   return visit_continue;
-}
-
-ir_visitor_status
-ir_structure_splitting_visitor::visit_leave(ir_return *ir)
-{
-   split_rvalue(&ir->value);;
-   return visit_continue;
-}
-
-ir_visitor_status
-ir_structure_splitting_visitor::visit_leave(ir_if *ir)
-{
-   split_rvalue(&ir->condition);
-   return visit_continue;
-}
-
-
 bool
 do_structure_splitting(exec_list *instructions)
 {