From 29285882676388aacff123e8bdf025904abf8ea9 Mon Sep 17 00:00:00 2001
From: Eric Anholt <eric@anholt.net>
Date: Thu, 24 Jun 2010 15:32:15 -0700
Subject: glsl2: Move the compiler to the subdirectory it will live in in Mesa.

---
 src/glsl/ir_dead_code.cpp | 219 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 219 insertions(+)
 create mode 100644 src/glsl/ir_dead_code.cpp

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

diff --git a/src/glsl/ir_dead_code.cpp b/src/glsl/ir_dead_code.cpp
new file mode 100644
index 0000000000..8821304682
--- /dev/null
+++ b/src/glsl/ir_dead_code.cpp
@@ -0,0 +1,219 @@
+/*
+ * 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_dead_code.cpp
+ *
+ * Eliminates dead assignments and variable declarations from the code.
+ */
+
+#include "ir.h"
+#include "ir_visitor.h"
+#include "ir_expression_flattening.h"
+#include "glsl_types.h"
+
+class variable_entry : public exec_node
+{
+public:
+   variable_entry(ir_variable *var)
+   {
+      this->var = var;
+      assign = NULL;
+      referenced_count = 0;
+      assigned_count = 0;
+      declaration = false;
+   }
+
+   ir_variable *var; /* The key: the variable's pointer. */
+   ir_assignment *assign; /* An assignment to the variable, if any */
+
+   /** Number of times the variable is referenced, including assignments. */
+   unsigned referenced_count;
+
+   /** Number of times the variable is assignmened. */
+   unsigned assigned_count;
+
+   bool declaration; /* If the variable had a decl in the instruction stream */
+};
+
+class ir_dead_code_visitor : public ir_hierarchical_visitor {
+public:
+   virtual ir_visitor_status visit(ir_variable *);
+   virtual ir_visitor_status visit(ir_dereference_variable *);
+
+   virtual ir_visitor_status visit_enter(ir_function *);
+   virtual ir_visitor_status visit_leave(ir_assignment *);
+
+   variable_entry *get_variable_entry(ir_variable *var);
+
+   bool (*predicate)(ir_instruction *ir);
+   ir_instruction *base_ir;
+
+   /* List of variable_entry */
+   exec_list variable_list;
+};
+
+
+variable_entry *
+ir_dead_code_visitor::get_variable_entry(ir_variable *var)
+{
+   assert(var);
+   foreach_iter(exec_list_iterator, iter, this->variable_list) {
+      variable_entry *entry = (variable_entry *)iter.get();
+      if (entry->var == var)
+	 return entry;
+   }
+
+   void *ctx = talloc_parent(var);
+
+   variable_entry *entry = new(ctx) variable_entry(var);
+   this->variable_list.push_tail(entry);
+   return entry;
+}
+
+
+ir_visitor_status
+ir_dead_code_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_dead_code_visitor::visit(ir_dereference_variable *ir)
+{
+   ir_variable *const var = ir->variable_referenced();
+   variable_entry *entry = this->get_variable_entry(var);
+
+   if (entry)
+      entry->referenced_count++;
+
+   return visit_continue;
+}
+
+
+ir_visitor_status
+ir_dead_code_visitor::visit_enter(ir_function *ir)
+{
+   (void) ir;
+   return visit_continue_with_parent;
+}
+
+
+ir_visitor_status
+ir_dead_code_visitor::visit_leave(ir_assignment *ir)
+{
+   variable_entry *entry;
+   entry = this->get_variable_entry(ir->lhs->variable_referenced());
+   if (entry) {
+      entry->assigned_count++;
+      if (entry->assign == NULL)
+	 entry->assign = ir;
+   }
+
+   return visit_continue;
+}
+
+
+/**
+ * Do a dead code pass over instructions and everything that instructions
+ * references.
+ *
+ * Note that this will remove assignments to globals, so it is not suitable
+ * for usage on an unlinked instruction stream.
+ */
+bool
+do_dead_code(exec_list *instructions)
+{
+   ir_dead_code_visitor v;
+   bool progress = false;
+
+   v.run(instructions);
+
+   foreach_iter(exec_list_iterator, iter, v.variable_list) {
+      variable_entry *entry = (variable_entry *)iter.get();
+
+      /* Since each assignment is a reference, the refereneced count must be
+       * greater than or equal to the assignment count.  If they are equal,
+       * then all of the references are assignments, and the variable is
+       * dead.
+       *
+       * Note that if the variable is neither assigned nor referenced, both
+       * counts will be zero and will be caught by the equality test.
+       */
+      assert(entry->referenced_count >= entry->assigned_count);
+
+      if ((entry->referenced_count > entry->assigned_count)
+	  || !entry->declaration)
+	 continue;
+
+      if (entry->assign) {
+	 /* Remove a single dead assignment to the variable we found.
+	  * Don't do so if it's a shader output, though.
+	  */
+	 if (!entry->var->shader_out) {
+	    entry->assign->remove();
+	    progress = true;
+	 }
+      } else {
+	 /* If there are no assignments or references to the variable left,
+	  * then we can remove its declaration.
+	  */
+	 entry->var->remove();
+	 progress = true;
+      }
+   }
+   return progress;
+}
+
+/**
+ * Does a dead code pass on the functions present in the instruction stream.
+ *
+ * This is suitable for use while the program is not linked, as it will
+ * ignore variable declarations (and the assignments to them) for variables
+ * with global scope.
+ */
+bool
+do_dead_code_unlinked(exec_list *instructions)
+{
+   bool progress = false;
+
+   foreach_iter(exec_list_iterator, iter, *instructions) {
+      ir_instruction *ir = (ir_instruction *)iter.get();
+      ir_function *f = ir->as_function();
+      if (f) {
+	 foreach_iter(exec_list_iterator, sigiter, *f) {
+	    ir_function_signature *sig =
+	       (ir_function_signature *) sigiter.get();
+	    if (do_dead_code(&sig->body))
+	       progress = true;
+	 }
+      }
+   }
+
+   return progress;
+}
-- 
cgit v1.2.3


From bda27424cf04c0d2ec2b49c56f562d5b2d2f0bff Mon Sep 17 00:00:00 2001
From: Eric Anholt <eric@anholt.net>
Date: Fri, 25 Jun 2010 13:38:38 -0700
Subject: glsl2: Use the parser state as the talloc context for dead code
 elimination.

This cuts runtime by around 20% from talloc_parent() lookups.
---
 src/glsl/ir_dead_code.cpp      | 15 +++++++++------
 src/glsl/ir_optimization.h     |  6 ++++--
 src/glsl/main.cpp              |  2 +-
 src/mesa/shader/ir_to_mesa.cpp |  2 +-
 4 files changed, 15 insertions(+), 10 deletions(-)

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

diff --git a/src/glsl/ir_dead_code.cpp b/src/glsl/ir_dead_code.cpp
index 8821304682..51fa96df0c 100644
--- a/src/glsl/ir_dead_code.cpp
+++ b/src/glsl/ir_dead_code.cpp
@@ -71,6 +71,8 @@ public:
 
    /* List of variable_entry */
    exec_list variable_list;
+
+   void *mem_ctx;
 };
 
 
@@ -84,9 +86,7 @@ ir_dead_code_visitor::get_variable_entry(ir_variable *var)
 	 return entry;
    }
 
-   void *ctx = talloc_parent(var);
-
-   variable_entry *entry = new(ctx) variable_entry(var);
+   variable_entry *entry = new(mem_ctx) variable_entry(var);
    this->variable_list.push_tail(entry);
    return entry;
 }
@@ -147,11 +147,13 @@ ir_dead_code_visitor::visit_leave(ir_assignment *ir)
  * for usage on an unlinked instruction stream.
  */
 bool
-do_dead_code(exec_list *instructions)
+do_dead_code(struct _mesa_glsl_parse_state *state,
+	     exec_list *instructions)
 {
    ir_dead_code_visitor v;
    bool progress = false;
 
+   v.mem_ctx = state;
    v.run(instructions);
 
    foreach_iter(exec_list_iterator, iter, v.variable_list) {
@@ -198,7 +200,8 @@ do_dead_code(exec_list *instructions)
  * with global scope.
  */
 bool
-do_dead_code_unlinked(exec_list *instructions)
+do_dead_code_unlinked(struct _mesa_glsl_parse_state *state,
+		      exec_list *instructions)
 {
    bool progress = false;
 
@@ -209,7 +212,7 @@ do_dead_code_unlinked(exec_list *instructions)
 	 foreach_iter(exec_list_iterator, sigiter, *f) {
 	    ir_function_signature *sig =
 	       (ir_function_signature *) sigiter.get();
-	    if (do_dead_code(&sig->body))
+	    if (do_dead_code(state, &sig->body))
 	       progress = true;
 	 }
       }
diff --git a/src/glsl/ir_optimization.h b/src/glsl/ir_optimization.h
index 432a33458c..147f92176b 100644
--- a/src/glsl/ir_optimization.h
+++ b/src/glsl/ir_optimization.h
@@ -32,9 +32,11 @@ bool do_constant_folding(exec_list *instructions);
 bool do_constant_variable(exec_list *instructions);
 bool do_constant_variable_unlinked(exec_list *instructions);
 bool do_copy_propagation(exec_list *instructions);
-bool do_dead_code(exec_list *instructions);
+bool do_dead_code(struct _mesa_glsl_parse_state *state,
+		  exec_list *instructions);
 bool do_dead_code_local(exec_list *instructions);
-bool do_dead_code_unlinked(exec_list *instructions);
+bool do_dead_code_unlinked(struct _mesa_glsl_parse_state *state,
+			   exec_list *instructions);
 bool do_function_inlining(exec_list *instructions);
 bool do_if_simplification(exec_list *instructions);
 bool do_swizzle_swizzle(exec_list *instructions);
diff --git a/src/glsl/main.cpp b/src/glsl/main.cpp
index dcd9bd69c0..b32e2ad3db 100644
--- a/src/glsl/main.cpp
+++ b/src/glsl/main.cpp
@@ -157,7 +157,7 @@ compile_shader(struct glsl_shader *shader)
 	 progress = do_if_simplification(&shader->ir) || progress;
 	 progress = do_copy_propagation(&shader->ir) || progress;
 	 progress = do_dead_code_local(&shader->ir) || progress;
-	 progress = do_dead_code_unlinked(&shader->ir) || progress;
+	 progress = do_dead_code_unlinked(state, &shader->ir) || progress;
 	 progress = do_constant_variable_unlinked(&shader->ir) || progress;
 	 progress = do_constant_folding(&shader->ir) || progress;
 	 progress = do_vec_index_to_swizzle(&shader->ir) || progress;
diff --git a/src/mesa/shader/ir_to_mesa.cpp b/src/mesa/shader/ir_to_mesa.cpp
index f58af0f65f..0425e7d91e 100644
--- a/src/mesa/shader/ir_to_mesa.cpp
+++ b/src/mesa/shader/ir_to_mesa.cpp
@@ -1332,7 +1332,7 @@ _mesa_get_glsl_shader(GLcontext *ctx, void *mem_ctx, struct gl_shader *sh)
 	 progress = do_if_simplification(&shader->ir) || progress;
 	 progress = do_copy_propagation(&shader->ir) || progress;
 	 progress = do_dead_code_local(&shader->ir) || progress;
-	 progress = do_dead_code_unlinked(&shader->ir) || progress;
+	 progress = do_dead_code_unlinked(state, &shader->ir) || progress;
 	 progress = do_constant_variable_unlinked(&shader->ir) || progress;
 	 progress = do_constant_folding(&shader->ir) || progress;
 	 progress = do_vec_index_to_swizzle(&shader->ir) || progress;
-- 
cgit v1.2.3


From 9acf618f24428eba72650c0e328e7ed52986728e Mon Sep 17 00:00:00 2001
From: Eric Anholt <eric@anholt.net>
Date: Thu, 1 Jul 2010 10:52:30 -0700
Subject: glsl2: Remove dead member from dead code visitor.

---
 src/glsl/ir_dead_code.cpp | 1 -
 1 file changed, 1 deletion(-)

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

diff --git a/src/glsl/ir_dead_code.cpp b/src/glsl/ir_dead_code.cpp
index 51fa96df0c..ea78107f49 100644
--- a/src/glsl/ir_dead_code.cpp
+++ b/src/glsl/ir_dead_code.cpp
@@ -67,7 +67,6 @@ public:
    variable_entry *get_variable_entry(ir_variable *var);
 
    bool (*predicate)(ir_instruction *ir);
-   ir_instruction *base_ir;
 
    /* List of variable_entry */
    exec_list variable_list;
-- 
cgit v1.2.3


From 66d4c65ee2c311ea0c71c39a28456d0c11798d6b Mon Sep 17 00:00:00 2001
From: Eric Anholt <eric@anholt.net>
Date: Tue, 27 Jul 2010 11:28:26 -0700
Subject: glsl2: Make the dead code handler make its own talloc context.

This way, we don't need to pass in a parse state, and the context
doesn't grow with the number of passes through optimization.
---
 src/glsl/ir_dead_code.cpp       | 12 ++++++------
 src/glsl/ir_optimization.h      |  6 ++----
 src/glsl/main.cpp               |  2 +-
 src/mesa/program/ir_to_mesa.cpp |  2 +-
 4 files changed, 10 insertions(+), 12 deletions(-)

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

diff --git a/src/glsl/ir_dead_code.cpp b/src/glsl/ir_dead_code.cpp
index ea78107f49..4804407bdc 100644
--- a/src/glsl/ir_dead_code.cpp
+++ b/src/glsl/ir_dead_code.cpp
@@ -146,13 +146,12 @@ ir_dead_code_visitor::visit_leave(ir_assignment *ir)
  * for usage on an unlinked instruction stream.
  */
 bool
-do_dead_code(struct _mesa_glsl_parse_state *state,
-	     exec_list *instructions)
+do_dead_code(exec_list *instructions)
 {
    ir_dead_code_visitor v;
    bool progress = false;
 
-   v.mem_ctx = state;
+   v.mem_ctx = talloc_new(NULL);
    v.run(instructions);
 
    foreach_iter(exec_list_iterator, iter, v.variable_list) {
@@ -188,6 +187,8 @@ do_dead_code(struct _mesa_glsl_parse_state *state,
 	 progress = true;
       }
    }
+   talloc_free(v.mem_ctx);
+
    return progress;
 }
 
@@ -199,8 +200,7 @@ do_dead_code(struct _mesa_glsl_parse_state *state,
  * with global scope.
  */
 bool
-do_dead_code_unlinked(struct _mesa_glsl_parse_state *state,
-		      exec_list *instructions)
+do_dead_code_unlinked(exec_list *instructions)
 {
    bool progress = false;
 
@@ -211,7 +211,7 @@ do_dead_code_unlinked(struct _mesa_glsl_parse_state *state,
 	 foreach_iter(exec_list_iterator, sigiter, *f) {
 	    ir_function_signature *sig =
 	       (ir_function_signature *) sigiter.get();
-	    if (do_dead_code(state, &sig->body))
+	    if (do_dead_code(&sig->body))
 	       progress = true;
 	 }
       }
diff --git a/src/glsl/ir_optimization.h b/src/glsl/ir_optimization.h
index 4f39565e5f..5dbb025d35 100644
--- a/src/glsl/ir_optimization.h
+++ b/src/glsl/ir_optimization.h
@@ -33,11 +33,9 @@ bool do_constant_folding(exec_list *instructions);
 bool do_constant_variable(exec_list *instructions);
 bool do_constant_variable_unlinked(exec_list *instructions);
 bool do_copy_propagation(exec_list *instructions);
-bool do_dead_code(struct _mesa_glsl_parse_state *state,
-		  exec_list *instructions);
+bool do_dead_code(exec_list *instructions);
 bool do_dead_code_local(exec_list *instructions);
-bool do_dead_code_unlinked(struct _mesa_glsl_parse_state *state,
-			   exec_list *instructions);
+bool do_dead_code_unlinked(exec_list *instructions);
 bool do_div_to_mul_rcp(exec_list *instructions);
 bool do_function_inlining(exec_list *instructions);
 bool do_if_return(exec_list *instructions);
diff --git a/src/glsl/main.cpp b/src/glsl/main.cpp
index b62902278c..08b133f124 100644
--- a/src/glsl/main.cpp
+++ b/src/glsl/main.cpp
@@ -162,7 +162,7 @@ compile_shader(struct gl_shader *shader)
 	 progress = do_if_simplification(shader->ir) || progress;
 	 progress = do_copy_propagation(shader->ir) || progress;
 	 progress = do_dead_code_local(shader->ir) || progress;
-	 progress = do_dead_code_unlinked(state, shader->ir) || progress;
+	 progress = do_dead_code_unlinked(shader->ir) || progress;
 	 progress = do_constant_variable_unlinked(shader->ir) || progress;
 	 progress = do_constant_folding(shader->ir) || progress;
 	 progress = do_algebraic(shader->ir) || progress;
diff --git a/src/mesa/program/ir_to_mesa.cpp b/src/mesa/program/ir_to_mesa.cpp
index 5cc999c2e3..409b6d7288 100644
--- a/src/mesa/program/ir_to_mesa.cpp
+++ b/src/mesa/program/ir_to_mesa.cpp
@@ -2237,7 +2237,7 @@ _mesa_glsl_compile_shader(GLcontext *ctx, struct gl_shader *shader)
 	 progress = do_if_simplification(shader->ir) || progress;
 	 progress = do_copy_propagation(shader->ir) || progress;
 	 progress = do_dead_code_local(shader->ir) || progress;
-	 progress = do_dead_code_unlinked(state, shader->ir) || progress;
+	 progress = do_dead_code_unlinked(shader->ir) || progress;
 	 progress = do_constant_variable_unlinked(shader->ir) || progress;
 	 progress = do_constant_folding(shader->ir) || progress;
 	 progress = do_algebraic(shader->ir) || progress;
-- 
cgit v1.2.3


From 5532c4ca696fea32fb9b2f8de15beabe4a20ae15 Mon Sep 17 00:00:00 2001
From: Eric Anholt <eric@anholt.net>
Date: Tue, 27 Jul 2010 11:29:17 -0700
Subject: glsl2: Fix the linked version of ir_dead_code.

If we don't walk into functions, we won't see any usage of variables
in the functions.
---
 src/glsl/ir_dead_code.cpp | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

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

diff --git a/src/glsl/ir_dead_code.cpp b/src/glsl/ir_dead_code.cpp
index 4804407bdc..eab459b920 100644
--- a/src/glsl/ir_dead_code.cpp
+++ b/src/glsl/ir_dead_code.cpp
@@ -61,7 +61,7 @@ public:
    virtual ir_visitor_status visit(ir_variable *);
    virtual ir_visitor_status visit(ir_dereference_variable *);
 
-   virtual ir_visitor_status visit_enter(ir_function *);
+   virtual ir_visitor_status visit_enter(ir_function_signature *);
    virtual ir_visitor_status visit_leave(ir_assignment *);
 
    variable_entry *get_variable_entry(ir_variable *var);
@@ -116,9 +116,12 @@ ir_dead_code_visitor::visit(ir_dereference_variable *ir)
 
 
 ir_visitor_status
-ir_dead_code_visitor::visit_enter(ir_function *ir)
+ir_dead_code_visitor::visit_enter(ir_function_signature *ir)
 {
-   (void) 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;
 }
 
-- 
cgit v1.2.3


From d72edc4dddb6dd7908ef0d3f2cec353b028bf6c5 Mon Sep 17 00:00:00 2001
From: Eric Anholt <eric@anholt.net>
Date: Fri, 30 Jul 2010 16:05:27 -0700
Subject: glsl2: Factor out the variable refcounting part of ir_dead_code.cpp.

---
 src/glsl/Makefile                 |   1 +
 src/glsl/ir_dead_code.cpp         | 114 +-------------------------------------
 src/glsl/ir_variable_refcount.cpp | 100 +++++++++++++++++++++++++++++++++
 src/glsl/ir_variable_refcount.h   |  87 +++++++++++++++++++++++++++++
 4 files changed, 190 insertions(+), 112 deletions(-)
 create mode 100644 src/glsl/ir_variable_refcount.cpp
 create mode 100644 src/glsl/ir_variable_refcount.h

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

diff --git a/src/glsl/Makefile b/src/glsl/Makefile
index cbdd0f9a7a..aa1922f3be 100644
--- a/src/glsl/Makefile
+++ b/src/glsl/Makefile
@@ -58,6 +58,7 @@ CXX_SOURCES = \
 	ir_swizzle_swizzle.cpp \
 	ir_validate.cpp \
 	ir_variable.cpp \
+	ir_variable_refcount.cpp \
 	ir_vec_index_to_cond_assign.cpp \
 	ir_vec_index_to_swizzle.cpp \
 	linker.cpp \
diff --git a/src/glsl/ir_dead_code.cpp b/src/glsl/ir_dead_code.cpp
index eab459b920..2b971b7aaa 100644
--- a/src/glsl/ir_dead_code.cpp
+++ b/src/glsl/ir_dead_code.cpp
@@ -29,118 +29,9 @@
 
 #include "ir.h"
 #include "ir_visitor.h"
-#include "ir_expression_flattening.h"
+#include "ir_variable_refcount.h"
 #include "glsl_types.h"
 
-class variable_entry : public exec_node
-{
-public:
-   variable_entry(ir_variable *var)
-   {
-      this->var = var;
-      assign = NULL;
-      referenced_count = 0;
-      assigned_count = 0;
-      declaration = false;
-   }
-
-   ir_variable *var; /* The key: the variable's pointer. */
-   ir_assignment *assign; /* An assignment to the variable, if any */
-
-   /** Number of times the variable is referenced, including assignments. */
-   unsigned referenced_count;
-
-   /** Number of times the variable is assignmened. */
-   unsigned assigned_count;
-
-   bool declaration; /* If the variable had a decl in the instruction stream */
-};
-
-class ir_dead_code_visitor : public ir_hierarchical_visitor {
-public:
-   virtual ir_visitor_status visit(ir_variable *);
-   virtual ir_visitor_status visit(ir_dereference_variable *);
-
-   virtual ir_visitor_status visit_enter(ir_function_signature *);
-   virtual ir_visitor_status visit_leave(ir_assignment *);
-
-   variable_entry *get_variable_entry(ir_variable *var);
-
-   bool (*predicate)(ir_instruction *ir);
-
-   /* List of variable_entry */
-   exec_list variable_list;
-
-   void *mem_ctx;
-};
-
-
-variable_entry *
-ir_dead_code_visitor::get_variable_entry(ir_variable *var)
-{
-   assert(var);
-   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_dead_code_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_dead_code_visitor::visit(ir_dereference_variable *ir)
-{
-   ir_variable *const var = ir->variable_referenced();
-   variable_entry *entry = this->get_variable_entry(var);
-
-   if (entry)
-      entry->referenced_count++;
-
-   return visit_continue;
-}
-
-
-ir_visitor_status
-ir_dead_code_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;
-}
-
-
-ir_visitor_status
-ir_dead_code_visitor::visit_leave(ir_assignment *ir)
-{
-   variable_entry *entry;
-   entry = this->get_variable_entry(ir->lhs->variable_referenced());
-   if (entry) {
-      entry->assigned_count++;
-      if (entry->assign == NULL)
-	 entry->assign = ir;
-   }
-
-   return visit_continue;
-}
-
-
 /**
  * Do a dead code pass over instructions and everything that instructions
  * references.
@@ -151,10 +42,9 @@ ir_dead_code_visitor::visit_leave(ir_assignment *ir)
 bool
 do_dead_code(exec_list *instructions)
 {
-   ir_dead_code_visitor v;
+   ir_variable_refcount_visitor v;
    bool progress = false;
 
-   v.mem_ctx = talloc_new(NULL);
    v.run(instructions);
 
    foreach_iter(exec_list_iterator, iter, v.variable_list) {
diff --git a/src/glsl/ir_variable_refcount.cpp b/src/glsl/ir_variable_refcount.cpp
new file mode 100644
index 0000000000..20c2f6602b
--- /dev/null
+++ b/src/glsl/ir_variable_refcount.cpp
@@ -0,0 +1,100 @@
+/*
+ * 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_variable_refcount.cpp
+ *
+ * Provides a visitor which produces a list of variables referenced,
+ * how many times they were referenced and assigned, and whether they
+ * were defined in the scope.
+ */
+
+#include "ir.h"
+#include "ir_visitor.h"
+#include "ir_variable_refcount.h"
+#include "glsl_types.h"
+
+variable_entry *
+ir_variable_refcount_visitor::get_variable_entry(ir_variable *var)
+{
+   assert(var);
+   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_variable_refcount_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_variable_refcount_visitor::visit(ir_dereference_variable *ir)
+{
+   ir_variable *const var = ir->variable_referenced();
+   variable_entry *entry = this->get_variable_entry(var);
+
+   if (entry)
+      entry->referenced_count++;
+
+   return visit_continue;
+}
+
+
+ir_visitor_status
+ir_variable_refcount_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;
+}
+
+
+ir_visitor_status
+ir_variable_refcount_visitor::visit_leave(ir_assignment *ir)
+{
+   variable_entry *entry;
+   entry = this->get_variable_entry(ir->lhs->variable_referenced());
+   if (entry) {
+      entry->assigned_count++;
+      if (entry->assign == NULL)
+	 entry->assign = ir;
+   }
+
+   return visit_continue;
+}
diff --git a/src/glsl/ir_variable_refcount.h b/src/glsl/ir_variable_refcount.h
new file mode 100644
index 0000000000..d69cab563e
--- /dev/null
+++ b/src/glsl/ir_variable_refcount.h
@@ -0,0 +1,87 @@
+/*
+ * 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_variable_refcount.h
+ *
+ * Provides a visitor which produces a list of variables referenced,
+ * how many times they were referenced and assigned, and whether they
+ * were defined in the scope.
+ */
+
+#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;
+      assign = NULL;
+      referenced_count = 0;
+      assigned_count = 0;
+      declaration = false;
+   }
+
+   ir_variable *var; /* The key: the variable's pointer. */
+   ir_assignment *assign; /* An assignment to the variable, if any */
+
+   /** Number of times the variable is referenced, including assignments. */
+   unsigned referenced_count;
+
+   /** Number of times the variable is assigned. */
+   unsigned assigned_count;
+
+   bool declaration; /* If the variable had a decl in the instruction stream */
+};
+
+class ir_variable_refcount_visitor : public ir_hierarchical_visitor {
+public:
+   ir_variable_refcount_visitor(void)
+   {
+      this->mem_ctx = talloc_new(NULL);
+      this->variable_list.make_empty();
+   }
+
+   ~ir_variable_refcount_visitor(void)
+   {
+      this->mem_ctx = talloc_new(NULL);
+   }
+
+   virtual ir_visitor_status visit(ir_variable *);
+   virtual ir_visitor_status visit(ir_dereference_variable *);
+
+   virtual ir_visitor_status visit_enter(ir_function_signature *);
+   virtual ir_visitor_status visit_leave(ir_assignment *);
+
+   variable_entry *get_variable_entry(ir_variable *var);
+
+   bool (*predicate)(ir_instruction *ir);
+
+   /* List of variable_entry */
+   exec_list variable_list;
+
+   void *mem_ctx;
+};
-- 
cgit v1.2.3


From 046bef235744e891e4a48076e1a3ff9a61a63092 Mon Sep 17 00:00:00 2001
From: Eric Anholt <eric@anholt.net>
Date: Wed, 4 Aug 2010 20:33:57 -0700
Subject: glsl2: Remove the shader_in/shader_out tracking separate from
 var->mode.

I introduced this for ir_dead_code to distinguish function parameter
outvals from varying outputs.  Only, since ast_to_hir's
current_function is unset when setting up function parameters (they're
needed for making the function signature in the first place), all
function parameter outvals were marked as shader outputs anyway.  This
meant that an inlined function's cloned outval was marked as a shader
output and couldn't be dead-code eliminated.  Instead, since
ir_dead_code doesn't even look at function parameters, just use
var->mode.

The longest Mesa IR coming out of ir_to_mesa for Yo Frankie drops from
725 instructions to 636.
---
 src/glsl/ast_to_hir.cpp   | 37 ++++++++++---------------------------
 src/glsl/ir.cpp           |  4 ----
 src/glsl/ir.h             | 14 ++++----------
 src/glsl/ir_clone.cpp     |  2 --
 src/glsl/ir_dead_code.cpp |  3 ++-
 src/glsl/ir_variable.cpp  | 12 +-----------
 src/glsl/linker.cpp       |  2 --
 7 files changed, 17 insertions(+), 57 deletions(-)

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

diff --git a/src/glsl/ast_to_hir.cpp b/src/glsl/ast_to_hir.cpp
index 14c528075b..292c7be621 100644
--- a/src/glsl/ast_to_hir.cpp
+++ b/src/glsl/ast_to_hir.cpp
@@ -1510,31 +1510,6 @@ apply_type_qualifier_to_variable(const struct ast_type_qualifier *qual,
    else if (qual->uniform)
       var->mode = ir_var_uniform;
 
-   if (qual->uniform)
-      var->shader_in = true;
-
-   /* Any 'in' or 'inout' variables at global scope must be marked as being
-    * shader inputs.  Likewise, any 'out' or 'inout' variables at global scope
-    * must be marked as being shader outputs.
-    */
-   if (state->current_function == NULL) {
-      switch (var->mode) {
-      case ir_var_in:
-      case ir_var_uniform:
-	 var->shader_in = true;
-	 break;
-      case ir_var_out:
-	 var->shader_out = true;
-	 break;
-      case ir_var_inout:
-	 var->shader_in = true;
-	 var->shader_out = true;
-	 break;
-      default:
-	 break;
-      }
-   }
-
    if (qual->flat)
       var->interpolation = ir_var_flat;
    else if (qual->noperspective)
@@ -1702,11 +1677,19 @@ ast_declarator_list::hir(exec_list *instructions,
 				       & loc);
 
       if (this->type->qualifier.invariant) {
-	 if ((state->target == vertex_shader) && !var->shader_out) {
+	 if ((state->target == vertex_shader) && !(var->mode == ir_var_out ||
+						   var->mode == ir_var_inout)) {
+	    /* FINISHME: Note that this doesn't work for invariant on
+	     * a function signature outval
+	     */
 	    _mesa_glsl_error(& loc, state,
 			     "`%s' cannot be marked invariant, vertex shader "
 			     "outputs only\n", var->name);
-	 } else if ((state->target == fragment_shader) && !var->shader_in) {
+	 } else if ((state->target == fragment_shader) &&
+		    !(var->mode == ir_var_in || var->mode == ir_var_inout)) {
+	    /* FINISHME: Note that this doesn't work for invariant on
+	     * a function signature inval
+	     */
 	    _mesa_glsl_error(& loc, state,
 			     "`%s' cannot be marked invariant, fragment shader "
 			     "inputs only\n", var->name);
diff --git a/src/glsl/ir.cpp b/src/glsl/ir.cpp
index c3bade8d54..dd059e470d 100644
--- a/src/glsl/ir.cpp
+++ b/src/glsl/ir.cpp
@@ -902,7 +902,6 @@ ir_swizzle::variable_referenced()
 ir_variable::ir_variable(const struct glsl_type *type, const char *name,
 			 ir_variable_mode mode)
    : max_array_access(0), read_only(false), centroid(false), invariant(false),
-     shader_in(false), shader_out(false),
      mode(mode), interpolation(ir_var_smooth), array_lvalue(false)
 {
    this->ir_type = ir_type_variable;
@@ -922,9 +921,6 @@ ir_variable::ir_variable(const struct glsl_type *type, const char *name,
 const char *
 ir_variable::interpolation_string() const
 {
-   if (!this->shader_in && !this->shader_out)
-      return "";
-
    switch (this->interpolation) {
    case ir_var_smooth:        return "smooth";
    case ir_var_flat:          return "flat";
diff --git a/src/glsl/ir.h b/src/glsl/ir.h
index 98789503e0..e61485813d 100644
--- a/src/glsl/ir.h
+++ b/src/glsl/ir.h
@@ -194,10 +194,10 @@ public:
    /**
     * Get the string value for the interpolation qualifier
     *
-    * \return
-    * If none of \c shader_in or \c shader_out is set, an empty string will
-    * be returned.  Otherwise the string that would be used in a shader to
-    * specify \c mode will be returned.
+    * \return The string that would be used in a shader to specify \c
+    * mode will be returned.
+    *
+    * This function should only be used on a shader input or output variable.
     */
    const char *interpolation_string() const;
 
@@ -221,12 +221,6 @@ public:
    unsigned read_only:1;
    unsigned centroid:1;
    unsigned invariant:1;
-   /** If the variable is initialized outside of the scope of the shader */
-   unsigned shader_in:1;
-   /**
-    * If the variable value is later used outside of the scope of the shader.
-    */
-   unsigned shader_out:1;
 
    unsigned mode:3;
    unsigned interpolation:2;
diff --git a/src/glsl/ir_clone.cpp b/src/glsl/ir_clone.cpp
index 0e202164b3..a72609601a 100644
--- a/src/glsl/ir_clone.cpp
+++ b/src/glsl/ir_clone.cpp
@@ -45,8 +45,6 @@ ir_variable::clone(void *mem_ctx, struct hash_table *ht) const
    var->read_only = this->read_only;
    var->centroid = this->centroid;
    var->invariant = this->invariant;
-   var->shader_in = this->shader_in;
-   var->shader_out = this->shader_out;
    var->interpolation = this->interpolation;
    var->array_lvalue = this->array_lvalue;
    var->location = this->location;
diff --git a/src/glsl/ir_dead_code.cpp b/src/glsl/ir_dead_code.cpp
index 2b971b7aaa..bf032f1dc2 100644
--- a/src/glsl/ir_dead_code.cpp
+++ b/src/glsl/ir_dead_code.cpp
@@ -68,7 +68,8 @@ do_dead_code(exec_list *instructions)
 	 /* Remove a single dead assignment to the variable we found.
 	  * Don't do so if it's a shader output, though.
 	  */
-	 if (!entry->var->shader_out) {
+	 if (entry->var->mode != ir_var_out &&
+	     entry->var->mode != ir_var_inout) {
 	    entry->assign->remove();
 	    progress = true;
 	 }
diff --git a/src/glsl/ir_variable.cpp b/src/glsl/ir_variable.cpp
index 478cefc5a6..d9a16d4287 100644
--- a/src/glsl/ir_variable.cpp
+++ b/src/glsl/ir_variable.cpp
@@ -43,22 +43,12 @@ add_variable(const char *name, enum ir_variable_mode mode, int slot,
 
    switch (var->mode) {
    case ir_var_auto:
-      var->read_only = true;
-      break;
    case ir_var_in:
-      var->shader_in = true;
+   case ir_var_uniform:
       var->read_only = true;
       break;
    case ir_var_inout:
-      var->shader_in = true;
-      var->shader_out = true;
-      break;
    case ir_var_out:
-      var->shader_out = true;
-      break;
-   case ir_var_uniform:
-      var->shader_in = true;
-      var->read_only = true;
       break;
    default:
       assert(0);
diff --git a/src/glsl/linker.cpp b/src/glsl/linker.cpp
index b2953c67d1..94db57d6a5 100644
--- a/src/glsl/linker.cpp
+++ b/src/glsl/linker.cpp
@@ -1124,7 +1124,6 @@ assign_varying_locations(struct gl_shader_program *prog,
        * by the following stage.
        */
       if (var->location == -1) {
-	 var->shader_out = false;
 	 var->mode = ir_var_auto;
       }
    }
@@ -1158,7 +1157,6 @@ assign_varying_locations(struct gl_shader_program *prog,
 	 /* An 'in' variable is only really a shader input if its
 	  * value is written by the previous stage.
 	  */
-	 var->shader_in = false;
 	 var->mode = ir_var_auto;
       }
    }
-- 
cgit v1.2.3


From 3bd7e70bf7c4a9a52b425284c9f23689f00de93c Mon Sep 17 00:00:00 2001
From: Eric Anholt <eric@anholt.net>
Date: Thu, 5 Aug 2010 12:07:23 -0700
Subject: glsl2: Add some easy-to-enable debug printfs to ir_dead_code.cpp.

---
 src/glsl/ir_dead_code.cpp | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

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

diff --git a/src/glsl/ir_dead_code.cpp b/src/glsl/ir_dead_code.cpp
index bf032f1dc2..a8d264f39a 100644
--- a/src/glsl/ir_dead_code.cpp
+++ b/src/glsl/ir_dead_code.cpp
@@ -32,6 +32,8 @@
 #include "ir_variable_refcount.h"
 #include "glsl_types.h"
 
+static bool debug = false;
+
 /**
  * Do a dead code pass over instructions and everything that instructions
  * references.
@@ -60,6 +62,13 @@ do_dead_code(exec_list *instructions)
        */
       assert(entry->referenced_count >= entry->assigned_count);
 
+      if (debug) {
+	 printf("%s@%p: %d refs, %d assigns, %sdeclared in our scope\n",
+		entry->var->name, entry->var,
+		entry->referenced_count, entry->assigned_count,
+		entry->declaration ? "" : "not ");
+      }
+
       if ((entry->referenced_count > entry->assigned_count)
 	  || !entry->declaration)
 	 continue;
@@ -72,6 +81,11 @@ do_dead_code(exec_list *instructions)
 	     entry->var->mode != ir_var_inout) {
 	    entry->assign->remove();
 	    progress = true;
+
+	    if (debug) {
+	       printf("Removed assignment to %s@%p\n",
+		      entry->var->name, entry->var);
+	    }
 	 }
       } else {
 	 /* If there are no assignments or references to the variable left,
@@ -79,6 +93,11 @@ do_dead_code(exec_list *instructions)
 	  */
 	 entry->var->remove();
 	 progress = true;
+
+	 if (debug) {
+	    printf("Removed declaration of %s@%p\n",
+		   entry->var->name, entry->var);
+	 }
       }
    }
    talloc_free(v.mem_ctx);
-- 
cgit v1.2.3


From 9f82806c7b5109553cf806a5652e6b6198665094 Mon Sep 17 00:00:00 2001
From: Eric Anholt <eric@anholt.net>
Date: Thu, 5 Aug 2010 12:10:31 -0700
Subject: glsl2: Don't dead-code eliminate a call where the return value is
 unused.

This showed up since the disabling of inlining at compile time, which
I apparently didn't regenerate piglit summary for.

Fixes:
glsl-deadcode-call.
---
 src/glsl/ir.h                   |  3 +++
 src/glsl/ir_basic_block.cpp     | 13 +++++++++----
 src/glsl/ir_dead_code.cpp       |  3 ++-
 src/glsl/ir_dead_code_local.cpp |  7 ++++++-
 4 files changed, 20 insertions(+), 6 deletions(-)

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

diff --git a/src/glsl/ir.h b/src/glsl/ir.h
index f58602515e..ef8339ce19 100644
--- a/src/glsl/ir.h
+++ b/src/glsl/ir.h
@@ -1389,4 +1389,7 @@ extern void
 import_prototypes(const exec_list *source, exec_list *dest,
 		  class glsl_symbol_table *symbols, void *mem_ctx);
 
+extern bool
+ir_has_call(ir_instruction *ir);
+
 #endif /* IR_H */
diff --git a/src/glsl/ir_basic_block.cpp b/src/glsl/ir_basic_block.cpp
index f9953ea42d..a833825962 100644
--- a/src/glsl/ir_basic_block.cpp
+++ b/src/glsl/ir_basic_block.cpp
@@ -49,6 +49,14 @@ public:
    bool has_call;
 };
 
+bool
+ir_has_call(ir_instruction *ir)
+{
+   ir_has_call_visitor v;
+   ir->accept(&v);
+   return v.has_call;
+}
+
 /**
  * Calls a user function for every basic block in the instruction stream.
  *
@@ -115,8 +123,6 @@ void call_for_basic_blocks(exec_list *instructions,
 	    call_for_basic_blocks(&ir_sig->body, callback, data);
 	 }
       } else if (ir->as_assignment()) {
-	 ir_has_call_visitor v;
-
 	 /* If there's a call in the expression tree being assigned,
 	  * then that ends the BB too.
 	  *
@@ -130,8 +136,7 @@ void call_for_basic_blocks(exec_list *instructions,
 	  * expression flattener may be useful before using the basic
 	  * block finder to get more maximal basic blocks out.
 	  */
-	 ir->accept(&v);
-	 if (v.has_call) {
+	 if (ir_has_call(ir)) {
 	    callback(leader, ir, data);
 	    leader = NULL;
 	 }
diff --git a/src/glsl/ir_dead_code.cpp b/src/glsl/ir_dead_code.cpp
index a8d264f39a..87988871c7 100644
--- a/src/glsl/ir_dead_code.cpp
+++ b/src/glsl/ir_dead_code.cpp
@@ -78,7 +78,8 @@ do_dead_code(exec_list *instructions)
 	  * Don't do so if it's a shader output, though.
 	  */
 	 if (entry->var->mode != ir_var_out &&
-	     entry->var->mode != ir_var_inout) {
+	     entry->var->mode != ir_var_inout &&
+	     !ir_has_call(entry->assign)) {
 	    entry->assign->remove();
 	    progress = true;
 
diff --git a/src/glsl/ir_dead_code_local.cpp b/src/glsl/ir_dead_code_local.cpp
index b22cc558df..4bbedf0ff9 100644
--- a/src/glsl/ir_dead_code_local.cpp
+++ b/src/glsl/ir_dead_code_local.cpp
@@ -156,7 +156,12 @@ process_assignment(void *ctx, ir_assignment *ir, exec_list *assignments)
       }
    }
 
-   /* Add this instruction to the assignment list. */
+   /* Add this instruction to the assignment list available to be removed.
+    * But not if the assignment has other side effects.
+    */
+   if (ir_has_call(ir))
+      return progress;
+
    assignment_entry *entry = new(ctx) assignment_entry(var, ir);
    assignments->push_tail(entry);
 
-- 
cgit v1.2.3


From 9f9386d22aca8d14d1b1e6d4de9b24dcb183ca10 Mon Sep 17 00:00:00 2001
From: Brian Paul <brianp@vmware.com>
Date: Wed, 11 Aug 2010 14:04:51 -0600
Subject: glsl2: added casts to silence warnings

---
 src/glsl/glsl_types.cpp   |  4 ++--
 src/glsl/ir_dead_code.cpp |  6 +++---
 src/glsl/ir_validate.cpp  | 14 +++++++-------
 3 files changed, 12 insertions(+), 12 deletions(-)

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

diff --git a/src/glsl/glsl_types.cpp b/src/glsl/glsl_types.cpp
index 9b1bef6cb8..2aba1e0ac1 100644
--- a/src/glsl/glsl_types.cpp
+++ b/src/glsl/glsl_types.cpp
@@ -400,7 +400,7 @@ glsl_type::get_array_instance(const glsl_type *base, unsigned array_size)
     * named 'foo'.
     */
    char key[128];
-   snprintf(key, sizeof(key), "%p[%u]", base, array_size);
+   snprintf(key, sizeof(key), "%p[%u]", (void *) base, array_size);
 
    const glsl_type *t = (glsl_type *) hash_table_find(array_types, key);
    if (t == NULL) {
@@ -458,7 +458,7 @@ glsl_type::record_key_hash(const void *a)
 	 break;
 
       size += snprintf(& hash_key[size], sizeof(hash_key) - size,
-		       "%p", key->fields.structure[i].type);
+		       "%p", (void *) key->fields.structure[i].type);
    }
 
    return hash_table_string_hash(& hash_key);
diff --git a/src/glsl/ir_dead_code.cpp b/src/glsl/ir_dead_code.cpp
index 87988871c7..fce921262f 100644
--- a/src/glsl/ir_dead_code.cpp
+++ b/src/glsl/ir_dead_code.cpp
@@ -64,7 +64,7 @@ do_dead_code(exec_list *instructions)
 
       if (debug) {
 	 printf("%s@%p: %d refs, %d assigns, %sdeclared in our scope\n",
-		entry->var->name, entry->var,
+		entry->var->name, (void *) entry->var,
 		entry->referenced_count, entry->assigned_count,
 		entry->declaration ? "" : "not ");
       }
@@ -85,7 +85,7 @@ do_dead_code(exec_list *instructions)
 
 	    if (debug) {
 	       printf("Removed assignment to %s@%p\n",
-		      entry->var->name, entry->var);
+		      entry->var->name, (void *) entry->var);
 	    }
 	 }
       } else {
@@ -97,7 +97,7 @@ do_dead_code(exec_list *instructions)
 
 	 if (debug) {
 	    printf("Removed declaration of %s@%p\n",
-		   entry->var->name, entry->var);
+		   entry->var->name, (void *) entry->var);
 	 }
       }
    }
diff --git a/src/glsl/ir_validate.cpp b/src/glsl/ir_validate.cpp
index 545fe2799f..6e08fa4025 100644
--- a/src/glsl/ir_validate.cpp
+++ b/src/glsl/ir_validate.cpp
@@ -82,14 +82,14 @@ ir_validate::visit(ir_dereference_variable *ir)
 {
    if ((ir->var == NULL) || (ir->var->as_variable() == NULL)) {
       printf("ir_dereference_variable @ %p does not specify a variable %p\n",
-	     ir, ir->var);
+	     (void *) ir, (void *) ir->var);
       abort();
    }
 
    if (hash_table_find(ht, ir->var) == NULL) {
       printf("ir_dereference_variable @ %p specifies undeclared variable "
 	     "`%s' @ %p\n",
-	     ir, ir->var->name, ir->var);
+	     (void *) ir, ir->var->name, (void *) ir->var);
       abort();
    }
 
@@ -122,8 +122,8 @@ ir_validate::visit_enter(ir_function *ir)
       printf("Function definition nested inside another function "
 	     "definition:\n");
       printf("%s %p inside %s %p\n",
-	     ir->name, ir,
-	     this->current_function->name, this->current_function);
+	     ir->name, (void *) ir,
+	     this->current_function->name, (void *) this->current_function);
       abort();
    }
 
@@ -154,9 +154,9 @@ ir_validate::visit_enter(ir_function_signature *ir)
       printf("Function signature nested inside wrong function "
 	     "definition:\n");
       printf("%p inside %s %p instead of %s %p\n",
-	     ir,
-	     this->current_function->name, this->current_function,
-	     ir->function_name(), ir->function());
+	     (void *) ir,
+	     this->current_function->name, (void *) this->current_function,
+	     ir->function_name(), (void *) ir->function());
       abort();
    }
 
-- 
cgit v1.2.3


From 0b09e6410f1173c2f69b601e43c5b14d8ad97345 Mon Sep 17 00:00:00 2001
From: Eric Anholt <eric@anholt.net>
Date: Wed, 18 Aug 2010 11:42:42 -0700
Subject: glsl2: Fix copy'n'paste hilarity leading to leaking in the refcount
 visitor.

---
 src/glsl/ir_dead_code.cpp       | 1 -
 src/glsl/ir_variable_refcount.h | 2 +-
 2 files changed, 1 insertion(+), 2 deletions(-)

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

diff --git a/src/glsl/ir_dead_code.cpp b/src/glsl/ir_dead_code.cpp
index fce921262f..7ff580d538 100644
--- a/src/glsl/ir_dead_code.cpp
+++ b/src/glsl/ir_dead_code.cpp
@@ -101,7 +101,6 @@ do_dead_code(exec_list *instructions)
 	 }
       }
    }
-   talloc_free(v.mem_ctx);
 
    return progress;
 }
diff --git a/src/glsl/ir_variable_refcount.h b/src/glsl/ir_variable_refcount.h
index 30dd2bd587..059ea097a6 100644
--- a/src/glsl/ir_variable_refcount.h
+++ b/src/glsl/ir_variable_refcount.h
@@ -67,7 +67,7 @@ public:
 
    ~ir_variable_refcount_visitor(void)
    {
-      this->mem_ctx = talloc_new(NULL);
+      talloc_free(this->mem_ctx);
    }
 
    virtual ir_visitor_status visit(ir_variable *);
-- 
cgit v1.2.3


From 7de4d8fe11c53e59265b8a4252ab9940ffcc9929 Mon Sep 17 00:00:00 2001
From: Eric Anholt <eric@anholt.net>
Date: Tue, 24 Aug 2010 15:30:42 -0700
Subject: glsl: Don't dead-code eliminate a uniform initializer.

Partial fix for glsl-uniform-initializer-5.
---
 src/glsl/ir_dead_code.cpp | 8 ++++++++
 1 file changed, 8 insertions(+)

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

diff --git a/src/glsl/ir_dead_code.cpp b/src/glsl/ir_dead_code.cpp
index 7ff580d538..5cf5e99add 100644
--- a/src/glsl/ir_dead_code.cpp
+++ b/src/glsl/ir_dead_code.cpp
@@ -92,6 +92,14 @@ do_dead_code(exec_list *instructions)
 	 /* If there are no assignments or references to the variable left,
 	  * then we can remove its declaration.
 	  */
+
+	 /* uniform initializers are precious, and could get used by another
+	  * stage.
+	  */
+	 if (entry->var->mode == ir_var_uniform &&
+	     entry->var->constant_value)
+	    continue;
+
 	 entry->var->remove();
 	 progress = true;
 
-- 
cgit v1.2.3