src/glsl/ir_dead_code.cpp

   1 /*
   2  * Copyright © 2010 Intel Corporation
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  21  * DEALINGS IN THE SOFTWARE.
  22  */
  23
  24 /**
  25  * \file ir_dead_code.cpp
  26  *
  27  * Eliminates dead assignments and variable declarations from the code.
  28  */
  29
  30 #include "ir.h"
  31 #include "ir_visitor.h"
  32 #include "ir_expression_flattening.h"
  33 #include "glsl_types.h"
  34
  35 class variable_entry : public exec_node
  36 {
  37 public:
  38    variable_entry(ir_variable *var)
  39    {
  40       this->var = var;
  41       assign = NULL;
  42       referenced_count = 0;
  43       assigned_count = 0;
  44       declaration = false;
  45    }
  46
  47    ir_variable *var; /* The key: the variable's pointer. */
  48    ir_assignment *assign; /* An assignment to the variable, if any */
  49
  50    /** Number of times the variable is referenced, including assignments. */
  51    unsigned referenced_count;
  52
  53    /** Number of times the variable is assignmened. */
  54    unsigned assigned_count;
  55
  56    bool declaration; /* If the variable had a decl in the instruction stream */
  57 };
  58
  59 class ir_dead_code_visitor : public ir_hierarchical_visitor {
  60 public:
  61    virtual ir_visitor_status visit(ir_variable *);
  62    virtual ir_visitor_status visit(ir_dereference_variable *);
  63
  64    virtual ir_visitor_status visit_enter(ir_function *);
  65    virtual ir_visitor_status visit_leave(ir_assignment *);
  66
  67    variable_entry *get_variable_entry(ir_variable *var);
  68
  69    bool (*predicate)(ir_instruction *ir);
  70
  71    /* List of variable_entry */
  72    exec_list variable_list;
  73
  74    void *mem_ctx;
  75 };
  76
  77
  78 variable_entry *
  79 ir_dead_code_visitor::get_variable_entry(ir_variable *var)
  80 {
  81    assert(var);
  82    foreach_iter(exec_list_iterator, iter, this->variable_list) {
  83       variable_entry *entry = (variable_entry *)iter.get();
  84       if (entry->var == var)
  85          return entry;
  86    }
  87
  88    variable_entry *entry = new(mem_ctx) variable_entry(var);
  89    this->variable_list.push_tail(entry);
  90    return entry;
  91 }
  92
  93
  94 ir_visitor_status
  95 ir_dead_code_visitor::visit(ir_variable *ir)
  96 {
  97    variable_entry *entry = this->get_variable_entry(ir);
  98    if (entry)
  99       entry->declaration = true;
 100
 101    return visit_continue;
 102 }
 103
 104
 105 ir_visitor_status
 106 ir_dead_code_visitor::visit(ir_dereference_variable *ir)
 107 {
 108    ir_variable *const var = ir->variable_referenced();
 109    variable_entry *entry = this->get_variable_entry(var);
 110
 111    if (entry)
 112       entry->referenced_count++;
 113
 114    return visit_continue;
 115 }
 116
 117
 118 ir_visitor_status
 119 ir_dead_code_visitor::visit_enter(ir_function *ir)
 120 {
 121    (void) ir;
 122    return visit_continue_with_parent;
 123 }
 124
 125
 126 ir_visitor_status
 127 ir_dead_code_visitor::visit_leave(ir_assignment *ir)
 128 {
 129    variable_entry *entry;
 130    entry = this->get_variable_entry(ir->lhs->variable_referenced());
 131    if (entry) {
 132       entry->assigned_count++;
 133       if (entry->assign == NULL)
 134          entry->assign = ir;
 135    }
 136
 137    return visit_continue;
 138 }
 139
 140
 141 /**
 142  * Do a dead code pass over instructions and everything that instructions
 143  * references.
 144  *
 145  * Note that this will remove assignments to globals, so it is not suitable
 146  * for usage on an unlinked instruction stream.
 147  */
 148 bool
 149 do_dead_code(struct _mesa_glsl_parse_state *state,
 150              exec_list *instructions)
 151 {
 152    ir_dead_code_visitor v;
 153    bool progress = false;
 154
 155    v.mem_ctx = state;
 156    v.run(instructions);
 157
 158    foreach_iter(exec_list_iterator, iter, v.variable_list) {
 159       variable_entry *entry = (variable_entry *)iter.get();
 160
 161       /* Since each assignment is a reference, the refereneced count must be
 162        * greater than or equal to the assignment count.  If they are equal,
 163        * then all of the references are assignments, and the variable is
 164        * dead.
 165        *
 166        * Note that if the variable is neither assigned nor referenced, both
 167        * counts will be zero and will be caught by the equality test.
 168        */
 169       assert(entry->referenced_count >= entry->assigned_count);
 170
 171       if ((entry->referenced_count > entry->assigned_count)
 172           || !entry->declaration)
 173          continue;
 174
 175       if (entry->assign) {
 176          /* Remove a single dead assignment to the variable we found.
 177           * Don't do so if it's a shader output, though.
 178           */
 179          if (!entry->var->shader_out) {
 180             entry->assign->remove();
 181             progress = true;
 182          }
 183       } else {
 184          /* If there are no assignments or references to the variable left,
 185           * then we can remove its declaration.
 186           */
 187          entry->var->remove();
 188          progress = true;
 189       }
 190    }
 191    return progress;
 192 }
 193
 194 /**
 195  * Does a dead code pass on the functions present in the instruction stream.
 196  *
 197  * This is suitable for use while the program is not linked, as it will
 198  * ignore variable declarations (and the assignments to them) for variables
 199  * with global scope.
 200  */
 201 bool
 202 do_dead_code_unlinked(struct _mesa_glsl_parse_state *state,
 203                       exec_list *instructions)
 204 {
 205    bool progress = false;
 206
 207    foreach_iter(exec_list_iterator, iter, *instructions) {
 208       ir_instruction *ir = (ir_instruction *)iter.get();
 209       ir_function *f = ir->as_function();
 210       if (f) {
 211          foreach_iter(exec_list_iterator, sigiter, *f) {
 212             ir_function_signature *sig =
 213                (ir_function_signature *) sigiter.get();
 214             if (do_dead_code(state, &sig->body))
 215                progress = true;
 216          }
 217       }
 218    }
 219
 220    return progress;
 221 }