From 7f7eaf0285d011f7cc7e1a63133184a50b24ecaa Mon Sep 17 00:00:00 2001
From: Eric Anholt <eric@anholt.net>
Date: Thu, 5 Aug 2010 11:01:09 -0700
Subject: ir_structure_splitting: New pass to chop structures into their
 components.

This doesn't do anything if your structure goes through an uninlined
function call or if whole-structure assignment occurs.  As such, the
impact is limited, at least until we do some global copy propagation
to reduce whole-structure assignment.
---
 src/glsl/ir_structure_splitting.cpp | 378 ++++++++++++++++++++++++++++++++++++
 1 file changed, 378 insertions(+)
 create mode 100644 src/glsl/ir_structure_splitting.cpp

(limited to 'src/glsl/ir_structure_splitting.cpp')

diff --git a/src/glsl/ir_structure_splitting.cpp b/src/glsl/ir_structure_splitting.cpp
new file mode 100644
index 0000000000..f57ae44aae
--- /dev/null
+++ b/src/glsl/ir_structure_splitting.cpp
@@ -0,0 +1,378 @@
+/*
+ * 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_structure_splitting.cpp
+ *
+ * If a structure is only ever referenced by its components, then
+ * split those components out to individual variables so they can be
+ * handled normally by other optimization passes.
+ *
+ * This skips structures like uniforms, which need to be accessible as
+ * structures for their access by the GL.
+ */
+
+#include "ir.h"
+#include "ir_visitor.h"
+#include "glsl_types.h"
+
+class variable_entry : public exec_node
+{
+public:
+   variable_entry(ir_variable *var)
+   {
+      this->var = var;
+      this->whole_structure_access = 0;
+      this->declaration = false;
+      this->components = NULL;
+      this->mem_ctx = NULL;
+   }
+
+   ir_variable *var; /* The key: the variable's pointer. */
+
+   /** Number of times the variable is referenced, including assignments. */
+   unsigned whole_structure_access;
+
+   bool declaration; /* If the variable had a decl in the instruction stream */
+
+   ir_variable **components;
+
+   /** talloc_parent(this->var) -- the shader's talloc context. */
+   void *mem_ctx;
+};
+
+class ir_structure_reference_visitor : public ir_hierarchical_visitor {
+public:
+   ir_structure_reference_visitor(void)
+   {
+      this->mem_ctx = talloc_new(NULL);
+      this->variable_list.make_empty();
+   }
+
+   ~ir_structure_reference_visitor(void)
+   {
+      talloc_free(mem_ctx);
+   }
+
+   virtual ir_visitor_status visit(ir_variable *);
+   virtual ir_visitor_status visit(ir_dereference_variable *);
+   virtual ir_visitor_status visit(ir_dereference_record *);
+
+   virtual ir_visitor_status visit_enter(ir_function_signature *);
+
+   variable_entry *get_variable_entry(ir_variable *var);
+
+   /* List of variable_entry */
+   exec_list variable_list;
+
+   void *mem_ctx;
+};
+
+variable_entry *
+ir_structure_reference_visitor::get_variable_entry(ir_variable *var)
+{
+   assert(var);
+
+   if (!var->type->is_record())
+      return NULL;
+
+   foreach_iter(exec_list_iterator, iter, this->variable_list) {
+      variable_entry *entry = (variable_entry *)iter.get();
+      if (entry->var == var)
+	 return entry;
+   }
+
+   variable_entry *entry = new(mem_ctx) variable_entry(var);
+   this->variable_list.push_tail(entry);
+   return entry;
+}
+
+
+ir_visitor_status
+ir_structure_reference_visitor::visit(ir_variable *ir)
+{
+   variable_entry *entry = this->get_variable_entry(ir);
+
+   if (entry)
+      entry->declaration = true;
+
+   return visit_continue;
+}
+
+ir_visitor_status
+ir_structure_reference_visitor::visit(ir_dereference_variable *ir)
+{
+   ir_variable *const var = ir->variable_referenced();
+   variable_entry *entry = this->get_variable_entry(var);
+
+   if (entry)
+      entry->whole_structure_access++;
+
+   return visit_continue;
+}
+
+ir_visitor_status
+ir_structure_reference_visitor::visit(ir_dereference_record *ir)
+{
+   /* Don't descend into the ir_dereference_variable below. */
+   return visit_continue;
+}
+
+ir_visitor_status
+ir_structure_reference_visitor::visit_enter(ir_function_signature *ir)
+{
+   /* We don't want to descend into the function parameters and
+    * dead-code eliminate them, so just accept the body here.
+    */
+   visit_list_elements(this, &ir->body);
+   return visit_continue_with_parent;
+}
+
+class ir_structure_splitting_visitor : public ir_hierarchical_visitor {
+public:
+   ir_structure_splitting_visitor(exec_list *vars)
+   {
+      this->variable_list = vars;
+   }
+
+   virtual ~ir_structure_splitting_visitor()
+   {
+   }
+
+   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 *);
+
+   void split_deref(ir_dereference **deref);
+   void split_rvalue(ir_rvalue **rvalue);
+   struct variable_entry *get_splitting_entry(ir_variable *var);
+
+   exec_list *variable_list;
+   void *mem_ctx;
+};
+
+struct variable_entry *
+ir_structure_splitting_visitor::get_splitting_entry(ir_variable *var)
+{
+   assert(var);
+
+   if (!var->type->is_record())
+      return NULL;
+
+   foreach_iter(exec_list_iterator, iter, *this->variable_list) {
+      variable_entry *entry = (variable_entry *)iter.get();
+      if (entry->var == var) {
+	 return entry;
+      }
+   }
+
+   return NULL;
+}
+
+void
+ir_structure_splitting_visitor::split_deref(ir_dereference **deref)
+{
+   if ((*deref)->ir_type != ir_type_dereference_record)
+      return;
+
+   ir_dereference_record *deref_record = (ir_dereference_record *)deref;
+   ir_dereference_variable *deref_var = deref_record->as_dereference_variable();
+   if (!deref_var)
+      return;
+
+   variable_entry *entry = get_splitting_entry(deref_var->var);
+   if (entry)
+      return;
+
+   unsigned int i;
+   for (i = 0; i < entry->var->type->length; i++) {
+      if (strcmp(deref_record->field,
+		 entry->var->type->fields.structure[i].name) == 0)
+	 break;
+   }
+   assert(i != entry->var->type->length);
+
+   *deref = new(entry->mem_ctx) ir_dereference_variable(entry->components[i]);
+}
+
+void
+ir_structure_splitting_visitor::split_rvalue(ir_rvalue **rvalue)
+{
+   ir_dereference *deref = (*rvalue)->as_dereference();
+
+   if (!deref)
+      return;
+
+   split_deref(&deref);
+   *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);
+   return visit_continue;
+}
+
+ir_visitor_status
+ir_structure_splitting_visitor::visit_leave(ir_assignment *ir)
+{
+   split_rvalue(&ir->rhs);
+   split_rvalue(&ir->condition);
+   split_deref(&ir->lhs);
+
+   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)
+{
+   ir_structure_reference_visitor refs;
+   void *mem_ctx = talloc_new(NULL);
+
+   /* Trim out variables we can't split. */
+   foreach_iter(exec_list_iterator, iter, refs.variable_list) {
+      variable_entry *entry = (variable_entry *)iter.get();
+      if (!entry->declaration || entry->whole_structure_access) {
+	 entry->remove();
+      }
+   }
+
+   if (refs.variable_list.is_empty())
+      return false;
+
+   /* Replace the decls of the structures to be split with their split
+    * components.
+    */
+   foreach_iter(exec_list_iterator, iter, refs.variable_list) {
+      variable_entry *entry = (variable_entry *)iter.get();
+      const struct glsl_type *type = entry->var->type;
+
+      entry->mem_ctx = talloc_parent(entry->var);
+
+      entry->components = talloc_array(mem_ctx,
+				       ir_variable *,
+				       type->length);
+
+      for (unsigned int i = 0; i < entry->var->type->length; i++) {
+	 const char *name = talloc_asprintf(mem_ctx, "%s_%s",
+					    type->name,
+					    type->fields.structure[i].name);
+
+	 entry->components[i] =
+	    new(entry->mem_ctx) ir_variable(type->fields.structure[i].type,
+					    name,
+					    ir_var_temporary);
+	 entry->var->insert_before(entry->components[i]);
+      }
+
+      entry->var->remove();
+   }
+
+   ir_structure_splitting_visitor split(&refs.variable_list);
+   visit_list_elements(&split, instructions);
+
+   talloc_free(mem_ctx);
+
+   return true;
+}
-- 
cgit v1.2.3


From 0a0ab121f87a3b00e29c20a38fdd28e2fc31bae7 Mon Sep 17 00:00:00 2001
From: Eric Anholt <eric@anholt.net>
Date: Thu, 5 Aug 2010 13:25:39 -0700
Subject: ir_structure_splitting: Massive fixing to this.

I'd missed putting in the actual "find structures to split" part, so
most of the code didn't do anything.  I was running on too large of an
app and assuming the lack of progress was elsewhere.
---
 src/glsl/ir_structure_splitting.cpp | 43 +++++++++++++++++++++++++++++--------
 1 file changed, 34 insertions(+), 9 deletions(-)

(limited to 'src/glsl/ir_structure_splitting.cpp')

diff --git a/src/glsl/ir_structure_splitting.cpp b/src/glsl/ir_structure_splitting.cpp
index f57ae44aae..902eeadb2a 100644
--- a/src/glsl/ir_structure_splitting.cpp
+++ b/src/glsl/ir_structure_splitting.cpp
@@ -34,8 +34,11 @@
 
 #include "ir.h"
 #include "ir_visitor.h"
+#include "ir_print_visitor.h"
 #include "glsl_types.h"
 
+static bool debug = false;
+
 class variable_entry : public exec_node
 {
 public:
@@ -76,7 +79,7 @@ public:
 
    virtual ir_visitor_status visit(ir_variable *);
    virtual ir_visitor_status visit(ir_dereference_variable *);
-   virtual ir_visitor_status visit(ir_dereference_record *);
+   virtual ir_visitor_status visit_enter(ir_dereference_record *);
 
    virtual ir_visitor_status visit_enter(ir_function_signature *);
 
@@ -93,7 +96,7 @@ ir_structure_reference_visitor::get_variable_entry(ir_variable *var)
 {
    assert(var);
 
-   if (!var->type->is_record())
+   if (!var->type->is_record() || var->mode == ir_var_uniform)
       return NULL;
 
    foreach_iter(exec_list_iterator, iter, this->variable_list) {
@@ -132,10 +135,10 @@ ir_structure_reference_visitor::visit(ir_dereference_variable *ir)
 }
 
 ir_visitor_status
-ir_structure_reference_visitor::visit(ir_dereference_record *ir)
+ir_structure_reference_visitor::visit_enter(ir_dereference_record *ir)
 {
    /* Don't descend into the ir_dereference_variable below. */
-   return visit_continue;
+   return visit_continue_with_parent;
 }
 
 ir_visitor_status
@@ -162,6 +165,7 @@ 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 *);
@@ -200,13 +204,13 @@ ir_structure_splitting_visitor::split_deref(ir_dereference **deref)
    if ((*deref)->ir_type != ir_type_dereference_record)
       return;
 
-   ir_dereference_record *deref_record = (ir_dereference_record *)deref;
-   ir_dereference_variable *deref_var = deref_record->as_dereference_variable();
+   ir_dereference_record *deref_record = (ir_dereference_record *)*deref;
+   ir_dereference_variable *deref_var = deref_record->record->as_dereference_variable();
    if (!deref_var)
       return;
 
    variable_entry *entry = get_splitting_entry(deref_var->var);
-   if (entry)
+   if (!entry)
       return;
 
    unsigned int i;
@@ -223,6 +227,9 @@ ir_structure_splitting_visitor::split_deref(ir_dereference **deref)
 void
 ir_structure_splitting_visitor::split_rvalue(ir_rvalue **rvalue)
 {
+   if (!*rvalue)
+      return;
+
    ir_dereference *deref = (*rvalue)->as_dereference();
 
    if (!deref)
@@ -281,6 +288,14 @@ 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;
 }
 
@@ -328,11 +343,19 @@ bool
 do_structure_splitting(exec_list *instructions)
 {
    ir_structure_reference_visitor refs;
-   void *mem_ctx = talloc_new(NULL);
+
+   visit_list_elements(&refs, instructions);
 
    /* Trim out variables we can't split. */
    foreach_iter(exec_list_iterator, iter, refs.variable_list) {
       variable_entry *entry = (variable_entry *)iter.get();
+
+      if (debug) {
+	 printf("structure %s@%p: decl %d, whole_access %d\n",
+		entry->var->name, entry->var, entry->declaration,
+		entry->whole_structure_access);
+      }
+
       if (!entry->declaration || entry->whole_structure_access) {
 	 entry->remove();
       }
@@ -341,6 +364,8 @@ do_structure_splitting(exec_list *instructions)
    if (refs.variable_list.is_empty())
       return false;
 
+   void *mem_ctx = talloc_new(NULL);
+
    /* Replace the decls of the structures to be split with their split
     * components.
     */
@@ -356,7 +381,7 @@ do_structure_splitting(exec_list *instructions)
 
       for (unsigned int i = 0; i < entry->var->type->length; i++) {
 	 const char *name = talloc_asprintf(mem_ctx, "%s_%s",
-					    type->name,
+					    entry->var->name,
 					    type->fields.structure[i].name);
 
 	 entry->components[i] =
-- 
cgit v1.2.3


From f8d2cfe4a699faebd42bd1874ef0329d37791dd7 Mon Sep 17 00:00:00 2001
From: Eric Anholt <eric@anholt.net>
Date: Sun, 8 Aug 2010 23:29:54 -0700
Subject: glsl2: Handle plain variable copies in struct splitting.

glsl-fs-raytrace goes from 620 Mesa IR instructions out of the
compiler to 585.
---
 src/glsl/ir_structure_splitting.cpp | 54 ++++++++++++++++++++++++++++++++++---
 1 file changed, 51 insertions(+), 3 deletions(-)

(limited to 'src/glsl/ir_structure_splitting.cpp')

diff --git a/src/glsl/ir_structure_splitting.cpp b/src/glsl/ir_structure_splitting.cpp
index 902eeadb2a..f9931670bd 100644
--- a/src/glsl/ir_structure_splitting.cpp
+++ b/src/glsl/ir_structure_splitting.cpp
@@ -80,7 +80,7 @@ public:
    virtual ir_visitor_status visit(ir_variable *);
    virtual ir_visitor_status visit(ir_dereference_variable *);
    virtual ir_visitor_status visit_enter(ir_dereference_record *);
-
+   virtual ir_visitor_status visit_enter(ir_assignment *);
    virtual ir_visitor_status visit_enter(ir_function_signature *);
 
    variable_entry *get_variable_entry(ir_variable *var);
@@ -141,6 +141,19 @@ ir_structure_reference_visitor::visit_enter(ir_dereference_record *ir)
    return visit_continue_with_parent;
 }
 
+ir_visitor_status
+ir_structure_reference_visitor::visit_enter(ir_assignment *ir)
+{
+   if (ir->lhs->as_dereference_variable() &&
+       ir->rhs->as_dereference_variable() &&
+       !ir->condition) {
+      /* We'll split copies of a structure to copies of components, so don't
+       * descend to the ir_dereference_variables.
+       */
+      return visit_continue_with_parent;
+   }
+}
+
 ir_visitor_status
 ir_structure_reference_visitor::visit_enter(ir_function_signature *ir)
 {
@@ -302,9 +315,44 @@ ir_structure_splitting_visitor::visit_leave(ir_dereference_record *ir)
 ir_visitor_status
 ir_structure_splitting_visitor::visit_leave(ir_assignment *ir)
 {
-   split_rvalue(&ir->rhs);
+   ir_dereference_variable *lhs_deref = ir->lhs->as_dereference_variable();
+   ir_dereference_variable *rhs_deref = ir->rhs->as_dereference_variable();
+   variable_entry *lhs_entry = lhs_deref ? get_splitting_entry(lhs_deref->var) : NULL;
+   variable_entry *rhs_entry = rhs_deref ? get_splitting_entry(rhs_deref->var) : NULL;
+   const glsl_type *type = ir->rhs->type;
+
+   if ((lhs_entry || rhs_entry) && !ir->condition) {
+      for (unsigned int i = 0; i < type->length; i++) {
+	 ir_dereference *new_lhs, *new_rhs;
+	 void *mem_ctx = lhs_entry ? lhs_entry->mem_ctx : rhs_entry->mem_ctx;
+
+	 if (lhs_entry) {
+	    new_lhs = new(mem_ctx) ir_dereference_variable(lhs_entry->components[i]);
+	 } else {
+	    new_lhs = new(mem_ctx)
+	       ir_dereference_record(ir->lhs->clone(mem_ctx, NULL),
+				     type->fields.structure[i].name);
+	 }
+
+	 if (rhs_entry) {
+	    new_rhs = new(mem_ctx) ir_dereference_variable(rhs_entry->components[i]);
+	 } else {
+	    new_rhs = new(mem_ctx)
+	       ir_dereference_record(ir->rhs->clone(mem_ctx, NULL),
+				     type->fields.structure[i].name);
+	 }
+
+	 ir->insert_before(new(mem_ctx) ir_assignment(new_lhs,
+						      new_rhs,
+						      NULL));
+      }
+      ir->remove();
+   } else {
+      split_rvalue(&ir->rhs);
+      split_deref(&ir->lhs);
+   }
+
    split_rvalue(&ir->condition);
-   split_deref(&ir->lhs);
 
    return visit_continue;
 }
-- 
cgit v1.2.3


From 5023edaf5d037c9b71f1795ac4b890f175507576 Mon Sep 17 00:00:00 2001
From: Aras Pranckevicius <aras@unity3d.com>
Date: Mon, 9 Aug 2010 11:50:24 +0300
Subject: glsl: fix missing return in ir_structure_splitting

---
 src/glsl/ir_structure_splitting.cpp | 1 +
 1 file changed, 1 insertion(+)

(limited to 'src/glsl/ir_structure_splitting.cpp')

diff --git a/src/glsl/ir_structure_splitting.cpp b/src/glsl/ir_structure_splitting.cpp
index f9931670bd..9dc5941207 100644
--- a/src/glsl/ir_structure_splitting.cpp
+++ b/src/glsl/ir_structure_splitting.cpp
@@ -152,6 +152,7 @@ ir_structure_reference_visitor::visit_enter(ir_assignment *ir)
        */
       return visit_continue_with_parent;
    }
+   return visit_continue;
 }
 
 ir_visitor_status
-- 
cgit v1.2.3


From ffd3f15e965d451b1aef032015cc2edea66c30fa Mon Sep 17 00:00:00 2001
From: Brian Paul <brianp@vmware.com>
Date: Wed, 11 Aug 2010 14:00:15 -0600
Subject: glsl2: add cast to silence warning

---
 src/glsl/ir_structure_splitting.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/glsl/ir_structure_splitting.cpp')

diff --git a/src/glsl/ir_structure_splitting.cpp b/src/glsl/ir_structure_splitting.cpp
index 9dc5941207..2f83896263 100644
--- a/src/glsl/ir_structure_splitting.cpp
+++ b/src/glsl/ir_structure_splitting.cpp
@@ -401,7 +401,7 @@ do_structure_splitting(exec_list *instructions)
 
       if (debug) {
 	 printf("structure %s@%p: decl %d, whole_access %d\n",
-		entry->var->name, entry->var, entry->declaration,
+		entry->var->name, (void *) entry->var, entry->declaration,
 		entry->whole_structure_access);
       }
 
-- 
cgit v1.2.3


From b3b0cf6a4c6b23e0ebe7e5f5ab1b7cacf27268b1 Mon Sep 17 00:00:00 2001
From: Eric Anholt <eric@anholt.net>
Date: Fri, 13 Aug 2010 20:39:24 -0700
Subject: 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                   |   1 +
 src/glsl/ir_algebraic.cpp           | 120 ++++----------------------------
 src/glsl/ir_rvalue_visitor.cpp      | 134 ++++++++++++++++++++++++++++++++++++
 src/glsl/ir_rvalue_visitor.h        |  47 +++++++++++++
 src/glsl/ir_structure_splitting.cpp | 109 ++---------------------------
 5 files changed, 203 insertions(+), 208 deletions(-)
 create mode 100644 src/glsl/ir_rvalue_visitor.cpp
 create mode 100644 src/glsl/ir_rvalue_visitor.h

(limited to 'src/glsl/ir_structure_splitting.cpp')

diff --git a/src/glsl/Makefile b/src/glsl/Makefile
index 2f62517e95..48b7c8f66b 100644
--- a/src/glsl/Makefile
+++ b/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 \
diff --git a/src/glsl/ir_algebraic.cpp b/src/glsl/ir_algebraic.cpp
index 86fb7e49c0..a66c820a27 100644
--- a/src/glsl/ir_algebraic.cpp
+++ b/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;
-}
-
-ir_visitor_status
-ir_algebraic_visitor::visit_leave(ir_expression *ir)
-{
-   unsigned int operand;
-
-   for (operand = 0; operand < ir->get_num_operands(); operand++) {
-      ir->operands[operand] = handle_expression(ir->operands[operand]);
-   }
-
-   return visit_continue;
-}
-
-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;
+   return ir;
 }
 
-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)
+void
+ir_algebraic_visitor::handle_rvalue(ir_rvalue **rvalue)
 {
-   foreach_iter(exec_list_iterator, iter, *ir) {
-      ir_rvalue *param = (ir_rvalue *)iter.get();
-      ir_rvalue *new_param = handle_expression(param);
+   if (!*rvalue)
+      return;
 
-      if (new_param != param) {
-	 param->replace_with(new_param);
-      }
-   }
-   return visit_continue;
-}
+   ir_expression *expr = (*rvalue)->as_expression();
+   if (!expr)
+      return;
 
-ir_visitor_status
-ir_algebraic_visitor::visit_leave(ir_return *ir)
-{
-   ir->value = handle_expression(ir->value);;
-   return visit_continue;
+   *rvalue = handle_expression(expr);
 }
 
-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)
 {
diff --git a/src/glsl/ir_rvalue_visitor.cpp b/src/glsl/ir_rvalue_visitor.cpp
new file mode 100644
index 0000000000..613b07c302
--- /dev/null
+++ b/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;
+}
diff --git a/src/glsl/ir_rvalue_visitor.h b/src/glsl/ir_rvalue_visitor.h
new file mode 100644
index 0000000000..31a56beb9b
--- /dev/null
+++ b/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;
+};
diff --git a/src/glsl/ir_structure_splitting.cpp b/src/glsl/ir_structure_splitting.cpp
index 2f83896263..e257defb1a 100644
--- a/src/glsl/ir_structure_splitting.cpp
+++ b/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);
-
-   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;
-}
+   handle_rvalue(&ir->condition);
 
-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)
 {
-- 
cgit v1.2.3


From 1cbcf6693aa490c4dcb56712bfb9998deb270f08 Mon Sep 17 00:00:00 2001
From: José Fonseca <jfonseca@vmware.com>
Date: Sat, 14 Aug 2010 15:35:57 +0100
Subject: glsl: Standardize a few more uses of struct vs class keyword.

---
 src/glsl/glsl_symbol_table.h        |  2 +-
 src/glsl/glsl_types.h               | 13 +++++++------
 src/glsl/ir.h                       |  4 ++--
 src/glsl/ir_structure_splitting.cpp |  4 ++--
 src/glsl/ir_tree_grafting.cpp       |  2 +-
 5 files changed, 13 insertions(+), 12 deletions(-)

(limited to 'src/glsl/ir_structure_splitting.cpp')

diff --git a/src/glsl/glsl_symbol_table.h b/src/glsl/glsl_symbol_table.h
index 02e4542cf3..4cb7559e9a 100644
--- a/src/glsl/glsl_symbol_table.h
+++ b/src/glsl/glsl_symbol_table.h
@@ -40,7 +40,7 @@ extern "C" {
  * Wraps the existing \c _mesa_symbol_table data structure to enforce some
  * type safe and some symbol table invariants.
  */
-class glsl_symbol_table {
+struct glsl_symbol_table {
 private:
    enum glsl_symbol_name_space {
       glsl_variable_name_space = 0,
diff --git a/src/glsl/glsl_types.h b/src/glsl/glsl_types.h
index 97d0d98c62..80cec635d9 100644
--- a/src/glsl/glsl_types.h
+++ b/src/glsl/glsl_types.h
@@ -35,6 +35,7 @@ extern "C" {
 }
 
 struct _mesa_glsl_parse_state;
+struct glsl_symbol_table;
 
 extern "C" void
 _mesa_glsl_initialize_types(struct _mesa_glsl_parse_state *state);
@@ -209,7 +210,7 @@ struct glsl_type {
    /**
     * Generate the constructor for this type and add it to the symbol table
     */
-   class ir_function *generate_constructor(class glsl_symbol_table *) const;
+   class ir_function *generate_constructor(glsl_symbol_table *) const;
 
    /**
     * Query the total number of scalars that make up a scalar, vector or matrix
@@ -449,12 +450,12 @@ private:
     * the world in a public header file.
     */
    /*@{*/
-   static void generate_110_types(class glsl_symbol_table *);
-   static void generate_120_types(class glsl_symbol_table *);
-   static void generate_130_types(class glsl_symbol_table *);
-   static void generate_ARB_texture_rectangle_types(class glsl_symbol_table *,
+   static void generate_110_types(glsl_symbol_table *);
+   static void generate_120_types(glsl_symbol_table *);
+   static void generate_130_types(glsl_symbol_table *);
+   static void generate_ARB_texture_rectangle_types(glsl_symbol_table *,
 						    bool);
-   static void generate_EXT_texture_array_types(class glsl_symbol_table *,
+   static void generate_EXT_texture_array_types(glsl_symbol_table *,
 						bool);
    /*@}*/
 
diff --git a/src/glsl/ir.h b/src/glsl/ir.h
index eb9e6cdf0e..b04222893c 100644
--- a/src/glsl/ir.h
+++ b/src/glsl/ir.h
@@ -1383,11 +1383,11 @@ _mesa_glsl_release_functions(void);
 extern void
 reparent_ir(exec_list *list, void *mem_ctx);
 
-class glsl_symbol_table;
+struct glsl_symbol_table;
 
 extern void
 import_prototypes(const exec_list *source, exec_list *dest,
-		  class glsl_symbol_table *symbols, void *mem_ctx);
+		  struct glsl_symbol_table *symbols, void *mem_ctx);
 
 extern bool
 ir_has_call(ir_instruction *ir);
diff --git a/src/glsl/ir_structure_splitting.cpp b/src/glsl/ir_structure_splitting.cpp
index e257defb1a..c0244071ee 100644
--- a/src/glsl/ir_structure_splitting.cpp
+++ b/src/glsl/ir_structure_splitting.cpp
@@ -181,13 +181,13 @@ public:
 
    void split_deref(ir_dereference **deref);
    void handle_rvalue(ir_rvalue **rvalue);
-   struct variable_entry *get_splitting_entry(ir_variable *var);
+   variable_entry *get_splitting_entry(ir_variable *var);
 
    exec_list *variable_list;
    void *mem_ctx;
 };
 
-struct variable_entry *
+variable_entry *
 ir_structure_splitting_visitor::get_splitting_entry(ir_variable *var)
 {
    assert(var);
diff --git a/src/glsl/ir_tree_grafting.cpp b/src/glsl/ir_tree_grafting.cpp
index e80db31cb3..6acc5b86c5 100644
--- a/src/glsl/ir_tree_grafting.cpp
+++ b/src/glsl/ir_tree_grafting.cpp
@@ -324,7 +324,7 @@ tree_grafting_basic_block(ir_instruction *bb_first,
 	  lhs_var->mode == ir_var_inout)
 	 continue;
 
-      struct variable_entry *entry = info->refs->get_variable_entry(lhs_var);
+      variable_entry *entry = info->refs->get_variable_entry(lhs_var);
 
       if (!entry->declaration ||
 	  entry->assigned_count != 1 ||
-- 
cgit v1.2.3


From d0a9cbd20ee0a1b5c350fed1c470946e4500f793 Mon Sep 17 00:00:00 2001
From: Ian Romanick <ian.d.romanick@intel.com>
Date: Mon, 16 Aug 2010 13:59:01 -0700
Subject: glsl2: Silence unused variable warning

---
 src/glsl/ir_structure_splitting.cpp | 1 +
 1 file changed, 1 insertion(+)

(limited to 'src/glsl/ir_structure_splitting.cpp')

diff --git a/src/glsl/ir_structure_splitting.cpp b/src/glsl/ir_structure_splitting.cpp
index c0244071ee..91f6dac23e 100644
--- a/src/glsl/ir_structure_splitting.cpp
+++ b/src/glsl/ir_structure_splitting.cpp
@@ -138,6 +138,7 @@ ir_structure_reference_visitor::visit(ir_dereference_variable *ir)
 ir_visitor_status
 ir_structure_reference_visitor::visit_enter(ir_dereference_record *ir)
 {
+   (void) ir;
    /* Don't descend into the ir_dereference_variable below. */
    return visit_continue_with_parent;
 }
-- 
cgit v1.2.3


From 81137623e55bb003d2479385547028661c71b415 Mon Sep 17 00:00:00 2001
From: Brian Paul <brianp@vmware.com>
Date: Tue, 24 Aug 2010 10:21:25 -0600
Subject: glsl2: rename local variable_entry class

With MSVC it seems that this class and its constructor is colliding
with the one in ir_variable_refcount.cpp.  Rename the class here to
avoid the collision.

This is a bit of a hack.  Can the two variable_entry classes be merged
and shared?
---
 src/glsl/ir_structure_splitting.cpp | 39 +++++++++++++++++++++----------------
 1 file changed, 22 insertions(+), 17 deletions(-)

(limited to 'src/glsl/ir_structure_splitting.cpp')

diff --git a/src/glsl/ir_structure_splitting.cpp b/src/glsl/ir_structure_splitting.cpp
index 91f6dac23e..ff3ec936eb 100644
--- a/src/glsl/ir_structure_splitting.cpp
+++ b/src/glsl/ir_structure_splitting.cpp
@@ -40,10 +40,14 @@
 
 static bool debug = false;
 
-class variable_entry : public exec_node
+// XXX using variable_entry2 here to avoid collision (MSVC multiply-defined
+// function) with the variable_entry class seen in ir_variable_refcount.h
+// Perhaps we can use the one in ir_variable_refcount.h and make this class
+// here go away?
+class variable_entry2 : public exec_node
 {
 public:
-   variable_entry(ir_variable *var)
+   variable_entry2(ir_variable *var)
    {
       this->var = var;
       this->whole_structure_access = 0;
@@ -65,6 +69,7 @@ public:
    void *mem_ctx;
 };
 
+
 class ir_structure_reference_visitor : public ir_hierarchical_visitor {
 public:
    ir_structure_reference_visitor(void)
@@ -84,7 +89,7 @@ public:
    virtual ir_visitor_status visit_enter(ir_assignment *);
    virtual ir_visitor_status visit_enter(ir_function_signature *);
 
-   variable_entry *get_variable_entry(ir_variable *var);
+   variable_entry2 *get_variable_entry2(ir_variable *var);
 
    /* List of variable_entry */
    exec_list variable_list;
@@ -92,8 +97,8 @@ public:
    void *mem_ctx;
 };
 
-variable_entry *
-ir_structure_reference_visitor::get_variable_entry(ir_variable *var)
+variable_entry2 *
+ir_structure_reference_visitor::get_variable_entry2(ir_variable *var)
 {
    assert(var);
 
@@ -101,12 +106,12 @@ ir_structure_reference_visitor::get_variable_entry(ir_variable *var)
       return NULL;
 
    foreach_iter(exec_list_iterator, iter, this->variable_list) {
-      variable_entry *entry = (variable_entry *)iter.get();
+      variable_entry2 *entry = (variable_entry2 *)iter.get();
       if (entry->var == var)
 	 return entry;
    }
 
-   variable_entry *entry = new(mem_ctx) variable_entry(var);
+   variable_entry2 *entry = new(mem_ctx) variable_entry2(var);
    this->variable_list.push_tail(entry);
    return entry;
 }
@@ -115,7 +120,7 @@ ir_structure_reference_visitor::get_variable_entry(ir_variable *var)
 ir_visitor_status
 ir_structure_reference_visitor::visit(ir_variable *ir)
 {
-   variable_entry *entry = this->get_variable_entry(ir);
+   variable_entry2 *entry = this->get_variable_entry2(ir);
 
    if (entry)
       entry->declaration = true;
@@ -127,7 +132,7 @@ ir_visitor_status
 ir_structure_reference_visitor::visit(ir_dereference_variable *ir)
 {
    ir_variable *const var = ir->variable_referenced();
-   variable_entry *entry = this->get_variable_entry(var);
+   variable_entry2 *entry = this->get_variable_entry2(var);
 
    if (entry)
       entry->whole_structure_access++;
@@ -182,13 +187,13 @@ public:
 
    void split_deref(ir_dereference **deref);
    void handle_rvalue(ir_rvalue **rvalue);
-   variable_entry *get_splitting_entry(ir_variable *var);
+   variable_entry2 *get_splitting_entry(ir_variable *var);
 
    exec_list *variable_list;
    void *mem_ctx;
 };
 
-variable_entry *
+variable_entry2 *
 ir_structure_splitting_visitor::get_splitting_entry(ir_variable *var)
 {
    assert(var);
@@ -197,7 +202,7 @@ ir_structure_splitting_visitor::get_splitting_entry(ir_variable *var)
       return NULL;
 
    foreach_iter(exec_list_iterator, iter, *this->variable_list) {
-      variable_entry *entry = (variable_entry *)iter.get();
+      variable_entry2 *entry = (variable_entry2 *)iter.get();
       if (entry->var == var) {
 	 return entry;
       }
@@ -217,7 +222,7 @@ ir_structure_splitting_visitor::split_deref(ir_dereference **deref)
    if (!deref_var)
       return;
 
-   variable_entry *entry = get_splitting_entry(deref_var->var);
+   variable_entry2 *entry = get_splitting_entry(deref_var->var);
    if (!entry)
       return;
 
@@ -252,8 +257,8 @@ ir_structure_splitting_visitor::visit_leave(ir_assignment *ir)
 {
    ir_dereference_variable *lhs_deref = ir->lhs->as_dereference_variable();
    ir_dereference_variable *rhs_deref = ir->rhs->as_dereference_variable();
-   variable_entry *lhs_entry = lhs_deref ? get_splitting_entry(lhs_deref->var) : NULL;
-   variable_entry *rhs_entry = rhs_deref ? get_splitting_entry(rhs_deref->var) : NULL;
+   variable_entry2 *lhs_entry = lhs_deref ? get_splitting_entry(lhs_deref->var) : NULL;
+   variable_entry2 *rhs_entry = rhs_deref ? get_splitting_entry(rhs_deref->var) : NULL;
    const glsl_type *type = ir->rhs->type;
 
    if ((lhs_entry || rhs_entry) && !ir->condition) {
@@ -301,7 +306,7 @@ do_structure_splitting(exec_list *instructions)
 
    /* Trim out variables we can't split. */
    foreach_iter(exec_list_iterator, iter, refs.variable_list) {
-      variable_entry *entry = (variable_entry *)iter.get();
+      variable_entry2 *entry = (variable_entry2 *)iter.get();
 
       if (debug) {
 	 printf("structure %s@%p: decl %d, whole_access %d\n",
@@ -323,7 +328,7 @@ do_structure_splitting(exec_list *instructions)
     * components.
     */
    foreach_iter(exec_list_iterator, iter, refs.variable_list) {
-      variable_entry *entry = (variable_entry *)iter.get();
+      variable_entry2 *entry = (variable_entry2 *)iter.get();
       const struct glsl_type *type = entry->var->type;
 
       entry->mem_ctx = talloc_parent(entry->var);
-- 
cgit v1.2.3