src/compiler/nir/nir_opt_shrink_vectors.c

   1 /*
   2  * Copyright © 2020 Google LLC
   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 DEALINGS
  21  * IN THE SOFTWARE.
  22  */
  23
  24 /**
  25  * @file
  26  *
  27  * Trims off the unused trailing components of SSA defs.
  28  *
  29  * Due to various optimization passes (or frontend implementations,
  30  * particularly prog_to_nir), we may have instructions generating vectors
  31  * whose components don't get read by any instruction.  While it can be tricky
  32  * to eliminate either unused low components of a writemask (you might need to
  33  * increment some offset from a load_uniform, for example) or channels in the
  34  * middle of a partially set writemask (you might need to reswizzle ALU ops
  35  * using the value), it is trivial to just drop the trailing components.
  36  *
  37  * This pass is probably only of use to vector backends -- scalar backends
  38  * typically get unused def channel trimming by scalarizing and dead code
  39  * elimination.
  40  */
  41
  42 #include "nir.h"
  43 #include "nir_builder.h"
  44
  45 static bool
  46 shrink_dest_to_read_mask(nir_ssa_def *def)
  47 {
  48    /* early out if there's nothing to do. */
  49    if (def->num_components == 1)
  50       return false;
  51
  52    unsigned mask = nir_ssa_def_components_read(def);
  53    int last_bit = util_last_bit(mask);
  54
  55    /* If nothing was read, leave it up to DCE. */
  56    if (!mask)
  57       return false;
  58
  59    if (def->num_components > last_bit) {
  60       def->num_components = last_bit;
  61       return true;
  62    }
  63
  64    return false;
  65 }
  66
  67 static bool
  68 opt_shrink_vectors_alu(nir_builder *b, nir_alu_instr *instr)
  69 {
  70    nir_ssa_def *def = &instr->dest.dest.ssa;
  71
  72    if (nir_op_infos[instr->op].output_size == 0) {
  73       if (shrink_dest_to_read_mask(def)) {
  74          instr->dest.write_mask &=
  75             BITFIELD_MASK(def->num_components);
  76
  77          return true;
  78       }
  79    } else {
  80
  81       switch (instr->op) {
  82       case nir_op_vec4:
  83       case nir_op_vec3:
  84       case nir_op_vec2: {
  85          unsigned mask = nir_ssa_def_components_read(def);
  86
  87          /* If nothing was read, leave it up to DCE. */
  88          if (mask == 0)
  89             return false;
  90
  91          int last_bit = util_last_bit(mask);
  92          if (last_bit < def->num_components) {
  93             nir_ssa_def *srcs[NIR_MAX_VEC_COMPONENTS] = { 0 };
  94             for (int i = 0; i < last_bit; i++)
  95                srcs[i] = nir_ssa_for_alu_src(b, instr, i);
  96
  97             nir_ssa_def *new_vec = nir_vec(b, srcs, last_bit);
  98             nir_ssa_def_rewrite_uses(def, nir_src_for_ssa(new_vec));
  99             return true;
 100          }
 101          break;
 102       }
 103
 104       default:
 105          break;
 106       }
 107    }
 108
 109    return false;
 110 }
 111
 112 static bool
 113 opt_shrink_vectors_intrinsic(nir_intrinsic_instr *instr)
 114 {
 115    switch (instr->intrinsic) {
 116    case nir_intrinsic_load_uniform:
 117    case nir_intrinsic_load_ubo:
 118    case nir_intrinsic_load_input:
 119    case nir_intrinsic_load_input_vertex:
 120    case nir_intrinsic_load_per_vertex_input:
 121    case nir_intrinsic_load_interpolated_input:
 122    case nir_intrinsic_load_ssbo:
 123    case nir_intrinsic_load_push_constant:
 124    case nir_intrinsic_load_constant:
 125    case nir_intrinsic_load_global:
 126    case nir_intrinsic_load_kernel_input:
 127    case nir_intrinsic_load_scratch:
 128       break;
 129    default:
 130       return false;
 131    }
 132
 133    assert(nir_intrinsic_infos[instr->intrinsic].has_dest);
 134    /* Must be a vectorized intrinsic that we can resize. */
 135    assert(instr->num_components != 0);
 136
 137    if (shrink_dest_to_read_mask(&instr->dest.ssa)) {
 138       instr->num_components = instr->dest.ssa.num_components;
 139       return true;
 140    }
 141
 142    return false;
 143 }
 144
 145 static bool
 146 opt_shrink_vectors_load_const(nir_load_const_instr *instr)
 147 {
 148    return shrink_dest_to_read_mask(&instr->def);
 149 }
 150
 151 static bool
 152 opt_shrink_vectors_ssa_undef(nir_ssa_undef_instr *instr)
 153 {
 154    return shrink_dest_to_read_mask(&instr->def);
 155 }
 156
 157 static bool
 158 opt_shrink_vectors_instr(nir_builder *b, nir_instr *instr)
 159 {
 160    b->cursor = nir_before_instr(instr);
 161
 162    switch (instr->type) {
 163    case nir_instr_type_alu:
 164       return opt_shrink_vectors_alu(b, nir_instr_as_alu(instr));
 165
 166    case nir_instr_type_intrinsic:
 167       return opt_shrink_vectors_intrinsic(nir_instr_as_intrinsic(instr));
 168
 169    case nir_instr_type_load_const:
 170       return opt_shrink_vectors_load_const(nir_instr_as_load_const(instr));
 171
 172    case nir_instr_type_ssa_undef:
 173       return opt_shrink_vectors_ssa_undef(nir_instr_as_ssa_undef(instr));
 174
 175    default:
 176       return false;
 177    }
 178
 179    return true;
 180 }
 181
 182 bool
 183 nir_opt_shrink_vectors(nir_shader *shader)
 184 {
 185    bool progress = false;
 186
 187    nir_foreach_function(function, shader) {
 188       if (!function->impl)
 189          continue;
 190
 191       nir_builder b;
 192       nir_builder_init(&b, function->impl);
 193
 194       nir_foreach_block(block, function->impl) {
 195          nir_foreach_instr(instr, block) {
 196             progress |= opt_shrink_vectors_instr(&b, instr);
 197          }
 198       }
 199
 200       if (progress) {
 201          nir_metadata_preserve(function->impl,
 202                                nir_metadata_block_index |
 203                                nir_metadata_dominance);
 204       } else {
 205          nir_metadata_preserve(function->impl, nir_metadata_all);
 206       }
 207    }
 208
 209    return progress;
 210 }