Home | History | Annotate | Download | only in glsl 
      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 opt_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_variable_refcount.h"
     33 #include "glsl_types.h"
     34 
     35 static bool debug = false;
     36 
     37 /**
     38  * Do a dead code pass over instructions and everything that instructions
     39  * references.
     40  *
     41  * Note that this will remove assignments to globals, so it is not suitable
     42  * for usage on an unlinked instruction stream.
     43  */
     44 bool
     45 do_dead_code(exec_list *instructions)
     46 {
     47    ir_variable_refcount_visitor v;
     48    bool progress = false;
     49 
     50    v.run(instructions);
     51 
     52    foreach_iter(exec_list_iterator, iter, v.variable_list) {
     53       variable_entry *entry = (variable_entry *)iter.get();
     54 
     55       /* Since each assignment is a reference, the refereneced count must be
     56        * greater than or equal to the assignment count.  If they are equal,
     57        * then all of the references are assignments, and the variable is
     58        * dead.
     59        *
     60        * Note that if the variable is neither assigned nor referenced, both
     61        * counts will be zero and will be caught by the equality test.
     62        */
     63       assert(entry->referenced_count >= entry->assigned_count);
     64 
     65       if (debug) {
     66 	 printf("%s@%p: %d refs, %d assigns, %sdeclared in our scope\n",
     67 		entry->var->name, (void *) entry->var,
     68 		entry->referenced_count, entry->assigned_count,
     69 		entry->declaration ? "" : "not ");
     70       }
     71 
     72       if ((entry->referenced_count > entry->assigned_count)
     73 	  || !entry->declaration)
     74 	 continue;
     75 
     76       if (entry->assign) {
     77 	 /* Remove a single dead assignment to the variable we found.
     78 	  * Don't do so if it's a shader output, though.
     79 	  */
     80 	 if (entry->var->mode != ir_var_out &&
     81 	     entry->var->mode != ir_var_inout &&
     82 	     !ir_has_call(entry->assign)) {
     83 	    entry->assign->remove();
     84 	    progress = true;
     85 
     86 	    if (debug) {
     87 	       printf("Removed assignment to %s@%p\n",
     88 		      entry->var->name, (void *) entry->var);
     89 	    }
     90 	 }
     91       } else {
     92 	 /* If there are no assignments or references to the variable left,
     93 	  * then we can remove its declaration.
     94 	  */
     95 
     96 	 /* uniform initializers are precious, and could get used by another
     97 	  * stage.
     98 	  */
     99 	 if (entry->var->mode == ir_var_uniform &&
    100 	     entry->var->constant_value)
    101 	    continue;
    102 
    103 	 entry->var->remove();
    104 	 progress = true;
    105 
    106 	 if (debug) {
    107 	    printf("Removed declaration of %s@%p\n",
    108 		   entry->var->name, (void *) entry->var);
    109 	 }
    110       }
    111    }
    112 
    113    return progress;
    114 }
    115 
    116 /**
    117  * Does a dead code pass on the functions present in the instruction stream.
    118  *
    119  * This is suitable for use while the program is not linked, as it will
    120  * ignore variable declarations (and the assignments to them) for variables
    121  * with global scope.
    122  */
    123 bool
    124 do_dead_code_unlinked(exec_list *instructions)
    125 {
    126    bool progress = false;
    127 
    128    foreach_iter(exec_list_iterator, iter, *instructions) {
    129       ir_instruction *ir = (ir_instruction *)iter.get();
    130       ir_function *f = ir->as_function();
    131       if (f) {
    132 	 foreach_iter(exec_list_iterator, sigiter, *f) {
    133 	    ir_function_signature *sig =
    134 	       (ir_function_signature *) sigiter.get();
    135 	    if (do_dead_code(&sig->body))
    136 	       progress = true;
    137 	 }
    138       }
    139    }
    140 
    141    return progress;
    142 }
    143