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_ball_fequal2:
 113          case nir_op_ball_iequal2:
 114          case nir_op_ball_fequal3:
 115          case nir_op_ball_iequal3:
 116          case nir_op_ball_fequal4:
 117          case nir_op_ball_iequal4:
 118          case nir_op_bany_fnequal2:
 119          case nir_op_bany_inequal2:
 120          case nir_op_bany_fnequal3:
 121          case nir_op_bany_inequal3:
 122          case nir_op_bany_fnequal4:
 123          case nir_op_bany_inequal4:
 124             /* These are only implemented by the vec4 backend and its
 125              * implementation emits resolved booleans.  At some point in the
 126              * future, this may change and we'll have to remove some of the
 127              * above cases.
 128              */
 129             resolve_status = BRW_NIR_BOOLEAN_NO_RESOLVE;
 130             break;
 131
 132          case nir_op_imov:
 133          case nir_op_inot:
 134             /* This is a single-source instruction.  Just copy the resolve
 135              * status from the source.
 136              */
 137             resolve_status = get_resolve_status_for_src(&alu->src[0].src);
 138             break;
 139
 140          case nir_op_iand:
 141          case nir_op_ior:
 142          case nir_op_ixor: {
 143             uint8_t src0_status = get_resolve_status_for_src(&alu->src[0].src);
 144             uint8_t src1_status = get_resolve_status_for_src(&alu->src[1].src);
 145
 146             if (src0_status == src1_status) {
 147                resolve_status = src0_status;
 148             } else if (src0_status == BRW_NIR_NON_BOOLEAN ||
 149                        src1_status == BRW_NIR_NON_BOOLEAN) {
 150                /* If one of the sources is a non-boolean then the whole
 151                 * thing is a non-boolean.
 152                 */
 153                resolve_status = BRW_NIR_NON_BOOLEAN;
 154             } else {
 155                /* At this point one of them is a true boolean and one is a
 156                 * boolean that needs a resolve.  We could either resolve the
 157                 * unresolved source or we could resolve here.  If we resolve
 158                 * the unresolved source then we get two resolves for the price
 159                 * of one.  Just set this one to BOOLEAN_NO_RESOLVE and we'll
 160                 * let the code below force a resolve on the unresolved source.
 161                 */
 162                resolve_status = BRW_NIR_BOOLEAN_NO_RESOLVE;
 163             }
 164             break;
 165          }
 166
 167          default:
 168             if (nir_op_infos[alu->op].output_type == nir_type_bool) {
 169                /* This instructions will turn into a CMP when we actually emit
 170                 * them so the result will have to be resolved before it can be
 171                 * used.
 172                 */
 173                resolve_status = BRW_NIR_BOOLEAN_UNRESOLVED;
 174
 175                /* Even though the destination is allowed to be left
 176                 * unresolved, the sources are treated as regular integers or
 177                 * floats so they need to be resolved.
 178                 */
 179                nir_foreach_src(instr, src_mark_needs_resolve, NULL);
 180             } else {
 181                resolve_status = BRW_NIR_NON_BOOLEAN;
 182             }
 183          }
 184
 185          /* If the destination is SSA, go ahead allow unresolved booleans.
 186           * If the destination register doesn't have a well-defined parent_instr
 187           * we need to resolve immediately.
 188           */
 189          if (!alu->dest.dest.is_ssa &&
 190              resolve_status == BRW_NIR_BOOLEAN_UNRESOLVED) {
 191             resolve_status = BRW_NIR_BOOLEAN_NEEDS_RESOLVE;
 192          }
 193
 194          instr->pass_flags = (instr->pass_flags & ~BRW_NIR_BOOLEAN_MASK) |
 195                              resolve_status;
 196
 197          /* Finally, resolve sources if it's needed */
 198          switch (resolve_status) {
 199          case BRW_NIR_BOOLEAN_NEEDS_RESOLVE:
 200          case BRW_NIR_BOOLEAN_UNRESOLVED:
 201             /* This instruction is either unresolved or we're doing the
 202              * resolve here; leave the sources alone.
 203              */
 204             break;
 205
 206          case BRW_NIR_BOOLEAN_NO_RESOLVE:
 207          case BRW_NIR_NON_BOOLEAN:
 208             nir_foreach_src(instr, src_mark_needs_resolve, NULL);
 209             break;
 210
 211          default:
 212             unreachable("Invalid boolean flag");
 213          }
 214
 215          break;
 216       }
 217
 218       case nir_instr_type_load_const: {
 219          nir_load_const_instr *load = nir_instr_as_load_const(instr);
 220
 221          /* For load_const instructions, it's a boolean exactly when it holds
 222           * one of the values NIR_TRUE or NIR_FALSE.
 223           *
 224           * Since load_const instructions don't have any sources, we don't
 225           * have to worry about resolving them.
 226           */
 227          instr->pass_flags &= ~BRW_NIR_BOOLEAN_MASK;
 228          if (load->value.u[0] == NIR_TRUE || load->value.u[0] == NIR_FALSE) {
 229             instr->pass_flags |= BRW_NIR_BOOLEAN_NO_RESOLVE;
 230          } else {
 231             instr->pass_flags |= BRW_NIR_NON_BOOLEAN;
 232          }
 233          continue;
 234       }
 235
 236       default:
 237          /* Everything else is an unknown non-boolean value and needs to
 238           * have all sources resolved.
 239           */
 240          instr->pass_flags = (instr->pass_flags & ~BRW_NIR_BOOLEAN_MASK) |
 241                              BRW_NIR_NON_BOOLEAN;
 242          nir_foreach_src(instr, src_mark_needs_resolve, NULL);
 243          continue;
 244       }
 245    }
 246
 247    nir_if *following_if = nir_block_get_following_if(block);
 248    if (following_if)
 249       src_mark_needs_resolve(&following_if->condition, NULL);
 250
 251    return true;
 252 }
 253
 254 static void
 255 analyze_boolean_resolves_impl(nir_function_impl *impl)
 256 {
 257    nir_foreach_block(impl, analyze_boolean_resolves_block, NULL);
 258 }
 259
 260 void
 261 brw_nir_analyze_boolean_resolves(nir_shader *shader)
 262 {
 263    nir_foreach_function(shader, function) {
 264       if (function->impl)
 265          analyze_boolean_resolves_impl(function->impl);
 266    }
 267 }