src/mesa/drivers/dri/i965/brw_nir_analyze_boolean_resolves.c

   1 /*
   2  * Copyright © 2015 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 DEALINGS
  21  * IN THE SOFTWARE.
  22  *
  23  * Authors:
  24  *    Jason Ekstrand <jason@jlekstrand.net>
  25  */
  26
  27 #include "brw_nir.h"
  28
  29 /*
  30  * This file implements an analysis pass that determines when we have to do
  31  * a boolean resolve on Gen <= 5.  Instructions that need a boolean resolve
  32  * will have the booleans portion of the instr->pass_flags field set to
  33  * BRW_NIR_BOOLEAN_NEEDS_RESOLVE.
  34  */
  35
  36
  37 /** Returns the resolve status for the given source
  38  *
  39  * If the source has a parent instruction then the resolve status is the
  40  * status of the parent instruction.  If the source does not have a parent
  41  * instruction then we don't know so we return NON_BOOLEAN.
  42  */
  43 static uint8_t
  44 get_resolve_status_for_src(nir_src *src)
  45 {
  46    if (src->is_ssa) {
  47       nir_instr *src_instr = src->ssa->parent_instr;
  48       uint8_t resolve_status = src_instr->pass_flags & BRW_NIR_BOOLEAN_MASK;
  49
  50       /* If the source instruction needs resolve, then from the perspective
  51        * of the user, it's a true boolean.
  52        */
  53       if (resolve_status == BRW_NIR_BOOLEAN_NEEDS_RESOLVE)
  54          resolve_status = BRW_NIR_BOOLEAN_NO_RESOLVE;
  55       return resolve_status;
  56    } else {
  57       return BRW_NIR_NON_BOOLEAN;
  58    }
  59 }
  60
  61 /** Marks the given source as needing a resolve
  62  *
  63  * If the given source corresponds to an unresolved boolean it marks it as
  64  * needing a resolve.  Otherwise, we leave it alone.
  65  */
  66 static bool
  67 src_mark_needs_resolve(nir_src *src, void *void_state)
  68 {
  69    if (src->is_ssa) {
  70       nir_instr *src_instr = src->ssa->parent_instr;
  71       uint8_t resolve_status = src_instr->pass_flags & BRW_NIR_BOOLEAN_MASK;
  72
  73       /* If the source instruction is unresolved, then mark it as needing
  74        * to be resolved.
  75        */
  76       if (resolve_status == BRW_NIR_BOOLEAN_UNRESOLVED) {
  77          src_instr->pass_flags &= ~BRW_NIR_BOOLEAN_MASK;
  78          src_instr->pass_flags |= BRW_NIR_BOOLEAN_NEEDS_RESOLVE;
  79       }
  80
  81    }
  82
  83    return true;
  84 }
  85
  86 static bool
  87 analyze_boolean_resolves_block(nir_block *block, void *void_state)
  88 {
  89    nir_foreach_instr(block, instr) {
  90       switch (instr->type) {
  91       case nir_instr_type_alu: {
  92          /* For ALU instructions, the resolve status is handled in a
  93           * three-step process.
  94           *
  95           * 1) Look at the instruction type and sources and determine if it
  96           *    can be left unresolved.
  97           *
  98           * 2) Look at the destination and see if we have to resolve
  99           *    anyway.  (This is the case if this instruction is not the
 100           *    only instruction writing to a given register.)
 101           *
 102           * 3) If the instruction has a resolve status other than
 103           *    BOOL_UNRESOLVED or BOOL_NEEDS_RESOLVE then we walk through
 104           *    the sources and ensure that they are also resolved.  This
 105           *    ensures that we don't end up with any stray unresolved
 106           *    booleans going into ADDs or something like that.
 107           */
 108
 109          uint8_t resolve_status;
 110          nir_alu_instr *alu = nir_instr_as_alu(instr);
 111          switch (alu->op) {
 112          case nir_op_bany2:
 113          case nir_op_bany3:
 114          case nir_op_bany4:
 115          case nir_op_ball_fequal2:
 116          case nir_op_ball_iequal2:
 117          case nir_op_ball_fequal3:
 118          case nir_op_ball_iequal3:
 119          case nir_op_ball_fequal4:
 120          case nir_op_ball_iequal4:
 121          case nir_op_bany_fnequal2:
 122          case nir_op_bany_inequal2:
 123          case nir_op_bany_fnequal3:
 124          case nir_op_bany_inequal3:
 125          case nir_op_bany_fnequal4:
 126          case nir_op_bany_inequal4:
 127             /* These are only implemented by the vec4 backend and its
 128              * implementation emits resolved booleans.  At some point in the
 129              * future, this may change and we'll have to remove some of the
 130              * above cases.
 131              */
 132             resolve_status = BRW_NIR_BOOLEAN_NO_RESOLVE;
 133             break;
 134
 135          case nir_op_imov:
 136          case nir_op_inot:
 137             /* This is a single-source instruction.  Just copy the resolve
 138              * status from the source.
 139              */
 140             resolve_status = get_resolve_status_for_src(&alu->src[0].src);
 141             break;
 142
 143          case nir_op_iand:
 144          case nir_op_ior:
 145          case nir_op_ixor: {
 146             uint8_t src0_status = get_resolve_status_for_src(&alu->src[0].src);
 147             uint8_t src1_status = get_resolve_status_for_src(&alu->src[1].src);
 148
 149             if (src0_status == src1_status) {
 150                resolve_status = src0_status;
 151             } else if (src0_status == BRW_NIR_NON_BOOLEAN ||
 152                        src1_status == BRW_NIR_NON_BOOLEAN) {
 153                /* If one of the sources is a non-boolean then the whole
 154                 * thing is a non-boolean.
 155                 */
 156                resolve_status = BRW_NIR_NON_BOOLEAN;
 157             } else {
 158                /* At this point one of them is a true boolean and one is a
 159                 * boolean that needs a resolve.  We could either resolve the
 160                 * unresolved source or we could resolve here.  If we resolve
 161                 * the unresolved source then we get two resolves for the price
 162                 * of one.  Just set this one to BOOLEAN_NO_RESOLVE and we'll
 163                 * let the code below force a resolve on the unresolved source.
 164                 */
 165                resolve_status = BRW_NIR_BOOLEAN_NO_RESOLVE;
 166             }
 167             break;
 168          }
 169
 170          default:
 171             if (nir_op_infos[alu->op].output_type == nir_type_bool) {
 172                /* This instructions will turn into a CMP when we actually emit
 173                 * them so the result will have to be resolved before it can be
 174                 * used.
 175                 */
 176                resolve_status = BRW_NIR_BOOLEAN_UNRESOLVED;
 177
 178                /* Even though the destination is allowed to be left
 179                 * unresolved, the sources are treated as regular integers or
 180                 * floats so they need to be resolved.
 181                 */
 182                nir_foreach_src(instr, src_mark_needs_resolve, NULL);
 183             } else {
 184                resolve_status = BRW_NIR_NON_BOOLEAN;
 185             }
 186          }
 187
 188          /* If the destination is SSA, go ahead allow unresolved booleans.
 189           * If the destination register doesn't have a well-defined parent_instr
 190           * we need to resolve immediately.
 191           */
 192          if (!alu->dest.dest.is_ssa &&
 193              resolve_status == BRW_NIR_BOOLEAN_UNRESOLVED) {
 194             resolve_status = BRW_NIR_BOOLEAN_NEEDS_RESOLVE;
 195          }
 196
 197          instr->pass_flags = (instr->pass_flags & ~BRW_NIR_BOOLEAN_MASK) |
 198                              resolve_status;
 199
 200          /* Finally, resolve sources if it's needed */
 201          switch (resolve_status) {
 202          case BRW_NIR_BOOLEAN_NEEDS_RESOLVE:
 203          case BRW_NIR_BOOLEAN_UNRESOLVED:
 204             /* This instruction is either unresolved or we're doing the
 205              * resolve here; leave the sources alone.
 206              */
 207             break;
 208
 209          case BRW_NIR_BOOLEAN_NO_RESOLVE:
 210          case BRW_NIR_NON_BOOLEAN:
 211             nir_foreach_src(instr, src_mark_needs_resolve, NULL);
 212             break;
 213
 214          default:
 215             unreachable("Invalid boolean flag");
 216          }
 217
 218          break;
 219       }
 220
 221       case nir_instr_type_load_const: {
 222          nir_load_const_instr *load = nir_instr_as_load_const(instr);
 223
 224          /* For load_const instructions, it's a boolean exactly when it holds
 225           * one of the values NIR_TRUE or NIR_FALSE.
 226           *
 227           * Since load_const instructions don't have any sources, we don't
 228           * have to worry about resolving them.
 229           */
 230          instr->pass_flags &= ~BRW_NIR_BOOLEAN_MASK;
 231          if (load->value.u[0] == NIR_TRUE || load->value.u[0] == NIR_FALSE) {
 232             instr->pass_flags |= BRW_NIR_BOOLEAN_NO_RESOLVE;
 233          } else {
 234             instr->pass_flags |= BRW_NIR_NON_BOOLEAN;
 235          }
 236          continue;
 237       }
 238
 239       default:
 240          /* Everything else is an unknown non-boolean value and needs to
 241           * have all sources resolved.
 242           */
 243          instr->pass_flags = (instr->pass_flags & ~BRW_NIR_BOOLEAN_MASK) |
 244                              BRW_NIR_NON_BOOLEAN;
 245          nir_foreach_src(instr, src_mark_needs_resolve, NULL);
 246          continue;
 247       }
 248    }
 249
 250    nir_if *following_if = nir_block_get_following_if(block);
 251    if (following_if)
 252       src_mark_needs_resolve(&following_if->condition, NULL);
 253
 254    return true;
 255 }
 256
 257 static void
 258 analyze_boolean_resolves_impl(nir_function_impl *impl)
 259 {
 260    nir_foreach_block(impl, analyze_boolean_resolves_block, NULL);
 261 }
 262
 263 void
 264 brw_nir_analyze_boolean_resolves(nir_shader *shader)
 265 {
 266    nir_foreach_overload(shader, overload)
 267       if (overload->impl)
 268          analyze_boolean_resolves_impl(overload->impl);
 269 }