src/freedreno/ir3/ir3_dce.c

   1 /*
   2  * Copyright (C) 2014 Rob Clark <robclark@freedesktop.org>
   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 FROM,
  20  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  21  * SOFTWARE.
  22  *
  23  * Authors:
  24  *    Rob Clark <robclark@freedesktop.org>
  25  */
  26
  27 #include "util/u_math.h"
  28
  29 #include "ir3.h"
  30 #include "ir3_shader.h"
  31
  32 /*
  33  * Dead code elimination:
  34  */
  35
  36 static void
  37 mark_array_use(struct ir3_instruction *instr, struct ir3_register *reg)
  38 {
  39         if (reg->flags & IR3_REG_ARRAY) {
  40                 struct ir3_array *arr =
  41                         ir3_lookup_array(instr->block->shader, reg->array.id);
  42                 arr->unused = false;
  43         }
  44 }
  45
  46 static void
  47 instr_dce(struct ir3_instruction *instr, bool falsedep)
  48 {
  49         /* don't mark falsedep's as used, but otherwise process them normally: */
  50         if (!falsedep)
  51                 instr->flags &= ~IR3_INSTR_UNUSED;
  52
  53         if (ir3_instr_check_mark(instr))
  54                 return;
  55
  56         if (writes_gpr(instr))
  57                 mark_array_use(instr, instr->regs[0]);   /* dst */
  58
  59         foreach_src (reg, instr)
  60                 mark_array_use(instr, reg);              /* src */
  61
  62         foreach_ssa_src_n (src, i, instr) {
  63                 instr_dce(src, __is_false_dep(instr, i));
  64         }
  65 }
  66
  67 static bool
  68 remove_unused_by_block(struct ir3_block *block)
  69 {
  70         bool progress = false;
  71         foreach_instr_safe (instr, &block->instr_list) {
  72                 if (instr->opc == OPC_END || instr->opc == OPC_CHSH || instr->opc == OPC_CHMASK)
  73                         continue;
  74                 if (instr->flags & IR3_INSTR_UNUSED) {
  75                         if (instr->opc == OPC_META_SPLIT) {
  76                                 struct ir3_instruction *src = ssa(instr->regs[1]);
  77                                 /* tex (cat5) instructions have a writemask, so we can
  78                                  * mask off unused components.  Other instructions do not.
  79                                  */
  80                                 if (src && is_tex_or_prefetch(src) && (src->regs[0]->wrmask > 1)) {
  81                                         src->regs[0]->wrmask &= ~(1 << instr->split.off);
  82
  83                                         /* prune no-longer needed right-neighbors.  We could
  84                                          * probably do the same for left-neighbors (ie. tex
  85                                          * fetch that only need .yw components), but that
  86                                          * makes RA a bit more confusing than it already is
  87                                          */
  88                                         struct ir3_instruction *n = instr;
  89                                         while (n && n->cp.right)
  90                                                 n = n->cp.right;
  91                                         while (n->flags & IR3_INSTR_UNUSED) {
  92                                                 n = n->cp.left;
  93                                                 if (!n)
  94                                                         break;
  95                                                 n->cp.right = NULL;
  96                                         }
  97                                 }
  98                         }
  99
 100                         /* prune false-deps, etc: */
 101                         foreach_ssa_use (use, instr)
 102                                 foreach_ssa_srcp_n (srcp, n, use)
 103                                         if (*srcp == instr)
 104                                                 *srcp = NULL;
 105
 106                         list_delinit(&instr->node);
 107                         progress = true;
 108                 }
 109         }
 110         return progress;
 111 }
 112
 113 static bool
 114 find_and_remove_unused(struct ir3 *ir, struct ir3_shader_variant *so)
 115 {
 116         unsigned i;
 117         bool progress = false;
 118
 119         ir3_clear_mark(ir);
 120
 121         /* initially mark everything as unused, we'll clear the flag as we
 122          * visit the instructions:
 123          */
 124         foreach_block (block, &ir->block_list) {
 125                 foreach_instr (instr, &block->instr_list) {
 126                         /* special case, if pre-fs texture fetch used, we cannot
 127                          * eliminate the barycentric i/j input
 128                          */
 129                         if (so->num_sampler_prefetch &&
 130                                         (instr->opc == OPC_META_INPUT) &&
 131                                         (instr->input.sysval == SYSTEM_VALUE_BARYCENTRIC_PERSP_PIXEL))
 132                                 continue;
 133                         instr->flags |= IR3_INSTR_UNUSED;
 134                 }
 135         }
 136
 137         foreach_array (arr, &ir->array_list)
 138                 arr->unused = true;
 139
 140         foreach_output (out, ir)
 141                 instr_dce(out, false);
 142
 143         foreach_block (block, &ir->block_list) {
 144                 for (i = 0; i < block->keeps_count; i++)
 145                         instr_dce(block->keeps[i], false);
 146
 147                 /* We also need to account for if-condition: */
 148                 if (block->condition)
 149                         instr_dce(block->condition, false);
 150         }
 151
 152         /* remove un-used instructions: */
 153         foreach_block (block, &ir->block_list) {
 154                 progress |= remove_unused_by_block(block);
 155         }
 156
 157         /* remove un-used arrays: */
 158         foreach_array_safe (arr, &ir->array_list) {
 159                 if (arr->unused)
 160                         list_delinit(&arr->node);
 161         }
 162
 163         /* fixup wrmask of split instructions to account for adjusted tex
 164          * wrmask's:
 165          */
 166         foreach_block (block, &ir->block_list) {
 167                 foreach_instr (instr, &block->instr_list) {
 168                         if (instr->opc != OPC_META_SPLIT)
 169                                 continue;
 170
 171                         struct ir3_instruction *src = ssa(instr->regs[1]);
 172                         if (!is_tex_or_prefetch(src))
 173                                 continue;
 174
 175                         instr->regs[1]->wrmask = src->regs[0]->wrmask;
 176                 }
 177         }
 178
 179         /* note that we can end up with unused indirects, but we should
 180          * not end up with unused predicates.
 181          */
 182         for (i = 0; i < ir->a0_users_count; i++) {
 183                 struct ir3_instruction *instr = ir->a0_users[i];
 184                 if (instr && (instr->flags & IR3_INSTR_UNUSED))
 185                         ir->a0_users[i] = NULL;
 186         }
 187
 188         for (i = 0; i < ir->a1_users_count; i++) {
 189                 struct ir3_instruction *instr = ir->a1_users[i];
 190                 if (instr && (instr->flags & IR3_INSTR_UNUSED))
 191                         ir->a1_users[i] = NULL;
 192         }
 193
 194         /* cleanup unused inputs: */
 195         foreach_input_n (in, n, ir)
 196                 if (in->flags & IR3_INSTR_UNUSED)
 197                         ir->inputs[n] = NULL;
 198
 199         return progress;
 200 }
 201
 202 bool
 203 ir3_dce(struct ir3 *ir, struct ir3_shader_variant *so)
 204 {
 205         void *mem_ctx = ralloc_context(NULL);
 206         bool progress, made_progress = false;
 207
 208         ir3_find_ssa_uses(ir, mem_ctx, true);
 209
 210         do {
 211                 progress = find_and_remove_unused(ir, so);
 212                 made_progress |= progress;
 213         } while (progress);
 214
 215         ralloc_free(mem_ctx);
 216
 217         return made_progress;
 218 }