Remove dead code assignments and variable declarations.

This pass only works on assignments where the variable is never
referenced.  There is no code flow analysis, so it can't do a better
job of avoiding redundant assignments.

For now, the optimizer only does do_dead_code_unlinked(), so it won't
trim the builtin variable list or initializers outside of the scope of
functions.  This is because we don't have the visibility into other
functions that might get linked in in order to eliminate work on
global variables.

diff --git a/Makefile.am b/Makefile.am
index 1ef1a0266b2a9b762f99406515deab9155227df3..80b5c2ec680bf81dbff64fa7c8a2d3b671d9dc33 100644 (file)
--- a/Makefile.am
+++ b/Makefile.am
@@ -30,6 +30,7 @@ glsl_SOURCES = symbol_table.c hash_table.c glsl_types.cpp \
        ir_print_visitor.cpp ir_variable.cpp ir_function.cpp \
        ir_constant_expression.cpp \
        ir_constant_folding.cpp \
+       ir_dead_code.cpp \
        ir_expression_flattening.cpp \
        ir_function_inlining.cpp \
        ir_if_simplification.cpp

diff --git a/glsl_parser_extras.cpp b/glsl_parser_extras.cpp
index 455bf0c7a4a63e3648622b412324558bc9893577..f7ee891eeb6c87b490c8780a7301baea8380cf7b 100644 (file)
--- a/glsl_parser_extras.cpp
+++ b/glsl_parser_extras.cpp
@@ -35,6 +35,7 @@
 #include "glsl_parser_extras.h"
 #include "glsl_parser.h"
 #include "ir_constant_folding.h"
+#include "ir_dead_code.h"
 #include "ir_function_inlining.h"
 #include "ir_if_simplification.h"
 #include "ir_print_visitor.h"
@@ -761,6 +762,7 @@ main(int argc, char **argv)
 
         progress = do_function_inlining(&instructions) || progress;
         progress = do_if_simplification(&instructions) || progress;
+        progress = do_dead_code_unlinked(&instructions) || progress;
 
         /* Constant folding */
         ir_constant_folding_visitor constant_folding;

diff --git a/ir.h b/ir.h
index cb153be77de77291b2181d02f048246638f8cf4b..504cffb2d5495301f46bd5f401f95a52562bdccf 100644 (file)
--- a/ir.h
+++ b/ir.h
@@ -54,11 +54,13 @@ public:
    virtual class ir_variable *          as_variable()         { return NULL; }
    virtual class ir_dereference *       as_dereference()      { return NULL; }
    virtual class ir_rvalue *            as_rvalue()           { return NULL; }
+   virtual class ir_label *             as_label()            { return NULL; }
    virtual class ir_loop *              as_loop()             { return NULL; }
    virtual class ir_assignment *        as_assignment()       { return NULL; }
    virtual class ir_call *              as_call()             { return NULL; }
    virtual class ir_return *            as_return()           { return NULL; }
    virtual class ir_if *                as_if()               { return NULL; }
+   virtual class ir_swizzle *           as_swizzle()          { return NULL; }
    /*@}*/
 
 protected:
@@ -185,6 +187,11 @@ class ir_label : public ir_instruction {
 public:
    ir_label(const char *label, ir_function_signature *signature);
 
+   virtual ir_label *as_label()
+   {
+      return this;
+   }
+
    virtual void accept(ir_visitor *v)
    {
       v->visit(this);
@@ -681,6 +688,11 @@ public:
       /* empty */
    }
 
+   virtual ir_swizzle *as_swizzle()
+   {
+      return this;
+   }
+
    ir_swizzle *clone()
    {
       return new ir_swizzle(this->val, this->mask);

diff --git a/ir_dead_code.cpp b/ir_dead_code.cpp
new file mode 100644 (file)
index 0000000..aae45d9
--- /dev/null
+++ b/ir_dead_code.cpp
@@ -0,0 +1,336 @@
+/*
+ * 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.
+ */
+
+#define NULL 0
+#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 = false;
+      declaration = false;
+   }
+
+   ir_variable *var; /* The key: the variable's pointer. */
+   ir_assignment *assign; /* An assignment to the variable, if any */
+   bool referenced; /* If the variable has ever been referenced. */
+   bool declaration; /* If the variable had a decl in the instruction stream */
+};
+
+class ir_dead_code_visitor : public ir_visitor {
+public:
+
+   /**
+    * \name Visit methods
+    *
+    * As typical for the visitor pattern, there must be one \c visit method for
+    * each concrete subclass of \c ir_instruction.  Virtual base classes within
+    * the hierarchy should not have \c visit methods.
+    */
+   /*@{*/
+   virtual void visit(ir_variable *);
+   virtual void visit(ir_label *);
+   virtual void visit(ir_loop *);
+   virtual void visit(ir_loop_jump *);
+   virtual void visit(ir_function_signature *);
+   virtual void visit(ir_function *);
+   virtual void visit(ir_expression *);
+   virtual void visit(ir_swizzle *);
+   virtual void visit(ir_dereference *);
+   virtual void visit(ir_assignment *);
+   virtual void visit(ir_constant *);
+   virtual void visit(ir_call *);
+   virtual void visit(ir_return *);
+   virtual void visit(ir_if *);
+   /*@}*/
+
+   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;
+   }
+
+   variable_entry *entry = new variable_entry(var);
+   this->variable_list.push_tail(entry);
+   return entry;
+}
+
+void
+find_dead_code(exec_list *instructions, ir_dead_code_visitor *v)
+{
+   foreach_iter(exec_list_iterator, iter, *instructions) {
+      ir_instruction *ir = (ir_instruction *)iter.get();
+
+      ir->accept(v);
+   }
+}
+
+void
+ir_dead_code_visitor::visit(ir_variable *ir)
+{
+   variable_entry *entry = this->get_variable_entry(ir);
+   if (entry) {
+      entry->declaration = true;
+   }
+}
+
+
+void
+ir_dead_code_visitor::visit(ir_label *ir)
+{
+   ir->signature->accept(this);
+}
+
+void
+ir_dead_code_visitor::visit(ir_loop *ir)
+{
+   find_dead_code(&ir->body_instructions, this);
+   if (ir->from)
+      ir->from->accept(this);
+   if (ir->to)
+      ir->to->accept(this);
+   if (ir->increment)
+      ir->increment->accept(this);
+}
+
+void
+ir_dead_code_visitor::visit(ir_loop_jump *ir)
+{
+   (void) ir;
+}
+
+
+void
+ir_dead_code_visitor::visit(ir_function_signature *ir)
+{
+   find_dead_code(&ir->body, this);
+}
+
+void
+ir_dead_code_visitor::visit(ir_function *ir)
+{
+   (void) ir;
+}
+
+void
+ir_dead_code_visitor::visit(ir_expression *ir)
+{
+   unsigned int operand;
+
+   for (operand = 0; operand < ir->get_num_operands(); operand++) {
+      ir->operands[operand]->accept(this);
+   }
+}
+
+
+void
+ir_dead_code_visitor::visit(ir_swizzle *ir)
+{
+   ir->val->accept(this);
+}
+
+
+void
+ir_dead_code_visitor::visit(ir_dereference *ir)
+{
+   ir_variable *var;
+
+   if (ir->mode == ir_dereference::ir_reference_array) {
+      ir->selector.array_index->accept(this);
+   }
+
+   var = ir->var->as_variable();
+   if (var) {
+      variable_entry *entry = this->get_variable_entry(var);
+      entry->referenced = true;
+   } else {
+      ir->var->accept(this);
+   }
+}
+
+void
+ir_dead_code_visitor::visit(ir_assignment *ir)
+{
+   ir_instruction *lhs = ir->lhs;
+
+   /* Walk through the LHS and mark references for variables used in
+    * array indices but not for the assignment dereference.
+    */
+   while (lhs) {
+      if (lhs->as_variable())
+        break;
+
+      ir_dereference *deref = lhs->as_dereference();
+      if (deref) {
+        if (deref->mode == ir_dereference::ir_reference_array)
+           deref->selector.array_index->accept(this);
+        lhs = deref->var;
+      } else {
+        ir_swizzle *swiz = lhs->as_swizzle();
+
+        lhs = swiz->val;
+      }
+   }
+
+   ir->rhs->accept(this);
+   if (ir->condition)
+      ir->condition->accept(this);
+
+   variable_entry *entry;
+   entry = this->get_variable_entry(lhs->as_variable());
+   if (entry) {
+      if (entry->assign == NULL)
+        entry->assign = ir;
+   }
+}
+
+
+void
+ir_dead_code_visitor::visit(ir_constant *ir)
+{
+   (void) ir;
+}
+
+
+void
+ir_dead_code_visitor::visit(ir_call *ir)
+{
+   foreach_iter(exec_list_iterator, iter, *ir) {
+      ir_rvalue *param = (ir_rvalue *)iter.get();
+
+      /* FINISHME: handle out values. */
+      param->accept(this);
+   }
+
+   /* Ignore the callee.  Function bodies will get handled when they're
+    * encountered at the top level instruction stream and spawn their
+    * own dead code visitor.
+    */
+}
+
+
+void
+ir_dead_code_visitor::visit(ir_return *ir)
+{
+   ir->get_value()->accept(this);
+}
+
+
+void
+ir_dead_code_visitor::visit(ir_if *ir)
+{
+   ir->condition->accept(this);
+
+   find_dead_code(&ir->then_instructions, this);
+   find_dead_code(&ir->else_instructions, this);
+}
+
+/**
+ * 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;
+
+   find_dead_code(instructions, &v);
+
+   foreach_iter(exec_list_iterator, iter, v.variable_list) {
+      variable_entry *entry = (variable_entry *)iter.get();
+
+      if (entry->referenced || !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_label *label = ir->as_label();
+      if (label) {
+        if (do_dead_code(&label->signature->body))
+           progress = true;
+      }
+   }
+
+   return progress;
+}

diff --git a/ir_dead_code.h b/ir_dead_code.h
new file mode 100644 (file)
index 0000000..25bf6f6
--- /dev/null
+++ b/ir_dead_code.h
@@ -0,0 +1,32 @@
+/*
+ * 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.h
+ *
+ * Eliminates dead assignments and variable declarations from the code.
+ */
+
+bool do_dead_code(exec_list *instructions);
+bool do_dead_code_unlinked(exec_list *instructions);