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

   1 /*
   2  * Copyright © 2014 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
  24 #include "brw_nir.h"
  25 #include "brw_shader.h"
  26 #include "glsl/glsl_parser_extras.h"
  27 #include "glsl/nir/glsl_to_nir.h"
  28 #include "program/prog_to_nir.h"
  29
  30 static bool
  31 remap_vs_attrs(nir_block *block, void *closure)
  32 {
  33    GLbitfield64 inputs_read = *((GLbitfield64 *) closure);
  34
  35    nir_foreach_instr(block, instr) {
  36       if (instr->type != nir_instr_type_intrinsic)
  37          continue;
  38
  39       nir_intrinsic_instr *intrin = nir_instr_as_intrinsic(instr);
  40
  41       /* We set EmitNoIndirect for VS inputs, so there are no indirects. */
  42       assert(intrin->intrinsic != nir_intrinsic_load_input_indirect);
  43
  44       if (intrin->intrinsic == nir_intrinsic_load_input) {
  45          /* Attributes come in a contiguous block, ordered by their
  46           * gl_vert_attrib value.  That means we can compute the slot
  47           * number for an attribute by masking out the enabled attributes
  48           * before it and counting the bits.
  49           */
  50          int attr = intrin->const_index[0];
  51          int slot = _mesa_bitcount_64(inputs_read & BITFIELD64_MASK(attr));
  52          intrin->const_index[0] = 4 * slot;
  53       }
  54    }
  55    return true;
  56 }
  57
  58 static void
  59 brw_nir_lower_inputs(const struct brw_device_info *devinfo,
  60                      nir_shader *nir, bool is_scalar)
  61 {
  62    switch (nir->stage) {
  63    case MESA_SHADER_VERTEX:
  64       /* For now, leave the vec4 backend doing the old method. */
  65       if (!is_scalar) {
  66          nir_assign_var_locations(&nir->inputs, &nir->num_inputs,
  67                                   type_size_vec4);
  68          break;
  69       }
  70
  71       /* Start with the location of the variable's base. */
  72       foreach_list_typed(nir_variable, var, node, &nir->inputs) {
  73          var->data.driver_location = var->data.location;
  74       }
  75
  76       /* Now use nir_lower_io to walk dereference chains.  Attribute arrays
  77        * are loaded as one vec4 per element (or matrix column), so we use
  78        * type_size_vec4 here.
  79        */
  80       nir_lower_io(nir, nir_var_shader_in, type_size_vec4);
  81
  82       /* Finally, translate VERT_ATTRIB_* values into the actual registers.
  83        *
  84        * Note that we can use nir->info.inputs_read instead of key->inputs_read
  85        * since the two are identical aside from Gen4-5 edge flag differences.
  86        */
  87       GLbitfield64 inputs_read = nir->info.inputs_read;
  88       nir_foreach_overload(nir, overload) {
  89          if (overload->impl) {
  90             nir_foreach_block(overload->impl, remap_vs_attrs, &inputs_read);
  91          }
  92       }
  93       break;
  94    case MESA_SHADER_GEOMETRY: {
  95       if (!is_scalar) {
  96          foreach_list_typed(nir_variable, var, node, &nir->inputs) {
  97             var->data.driver_location = var->data.location;
  98          }
  99       } else {
 100          /* The GLSL linker will have already matched up GS inputs and
 101           * the outputs of prior stages.  The driver does extend VS outputs
 102           * in some cases, but only for legacy OpenGL or Gen4-5 hardware,
 103           * neither of which offer geometry shader support.  So we can
 104           * safely ignore that.
 105           *
 106           * For SSO pipelines, we use a fixed VUE map layout based on variable
 107           * locations, so we can rely on rendezvous-by-location to make this
 108           * work.
 109           *
 110           * However, we need to ignore VARYING_SLOT_PRIMITIVE_ID, as it's not
 111           * written by previous stages and shows up via payload magic.
 112           */
 113          struct brw_vue_map input_vue_map;
 114          GLbitfield64 inputs_read =
 115             nir->info.inputs_read & ~VARYING_BIT_PRIMITIVE_ID;
 116          brw_compute_vue_map(devinfo, &input_vue_map, inputs_read,
 117                              nir->info.separate_shader);
 118
 119          /* Start with the slot for the variable's base. */
 120          foreach_list_typed(nir_variable, var, node, &nir->inputs) {
 121             assert(input_vue_map.varying_to_slot[var->data.location] != -1);
 122             var->data.driver_location =
 123                input_vue_map.varying_to_slot[var->data.location];
 124          }
 125
 126          /* Inputs are stored in vec4 slots, so use type_size_vec4(). */
 127          nir_lower_io(nir, nir_var_shader_in, type_size_vec4);
 128       }
 129       break;
 130    }
 131    case MESA_SHADER_FRAGMENT:
 132       assert(is_scalar);
 133       nir_assign_var_locations(&nir->inputs, &nir->num_inputs,
 134                                type_size_scalar);
 135       break;
 136    case MESA_SHADER_COMPUTE:
 137       /* Compute shaders have no inputs. */
 138       assert(exec_list_is_empty(&nir->inputs));
 139       break;
 140    default:
 141       unreachable("unsupported shader stage");
 142    }
 143 }
 144
 145 static void
 146 brw_nir_lower_outputs(nir_shader *nir, bool is_scalar)
 147 {
 148    switch (nir->stage) {
 149    case MESA_SHADER_VERTEX:
 150    case MESA_SHADER_GEOMETRY:
 151       if (is_scalar) {
 152          nir_assign_var_locations(&nir->outputs, &nir->num_outputs,
 153                                   type_size_scalar);
 154       } else {
 155          nir_foreach_variable(var, &nir->outputs)
 156             var->data.driver_location = var->data.location;
 157       }
 158       break;
 159    case MESA_SHADER_FRAGMENT:
 160       nir_assign_var_locations(&nir->outputs, &nir->num_outputs,
 161                                type_size_scalar);
 162       break;
 163    case MESA_SHADER_COMPUTE:
 164       /* Compute shaders have no outputs. */
 165       assert(exec_list_is_empty(&nir->outputs));
 166       break;
 167    default:
 168       unreachable("unsupported shader stage");
 169    }
 170 }
 171
 172 static void
 173 nir_optimize(nir_shader *nir, bool is_scalar)
 174 {
 175    bool progress;
 176    do {
 177       progress = false;
 178       nir_lower_vars_to_ssa(nir);
 179       nir_validate_shader(nir);
 180
 181       if (is_scalar) {
 182          nir_lower_alu_to_scalar(nir);
 183          nir_validate_shader(nir);
 184       }
 185
 186       progress |= nir_copy_prop(nir);
 187       nir_validate_shader(nir);
 188
 189       if (is_scalar) {
 190          nir_lower_phis_to_scalar(nir);
 191          nir_validate_shader(nir);
 192       }
 193
 194       progress |= nir_copy_prop(nir);
 195       nir_validate_shader(nir);
 196       progress |= nir_opt_dce(nir);
 197       nir_validate_shader(nir);
 198       progress |= nir_opt_cse(nir);
 199       nir_validate_shader(nir);
 200       progress |= nir_opt_peephole_select(nir);
 201       nir_validate_shader(nir);
 202       progress |= nir_opt_algebraic(nir);
 203       nir_validate_shader(nir);
 204       progress |= nir_opt_constant_folding(nir);
 205       nir_validate_shader(nir);
 206       progress |= nir_opt_dead_cf(nir);
 207       nir_validate_shader(nir);
 208       progress |= nir_opt_remove_phis(nir);
 209       nir_validate_shader(nir);
 210       progress |= nir_opt_undef(nir);
 211       nir_validate_shader(nir);
 212    } while (progress);
 213 }
 214
 215 nir_shader *
 216 brw_create_nir(struct brw_context *brw,
 217                const struct gl_shader_program *shader_prog,
 218                const struct gl_program *prog,
 219                gl_shader_stage stage,
 220                bool is_scalar)
 221 {
 222    struct gl_context *ctx = &brw->ctx;
 223    const struct brw_device_info *devinfo = brw->intelScreen->devinfo;
 224    const nir_shader_compiler_options *options =
 225       ctx->Const.ShaderCompilerOptions[stage].NirOptions;
 226    static const nir_lower_tex_options tex_options = {
 227       .lower_txp = ~0,
 228    };
 229    bool debug_enabled = INTEL_DEBUG & intel_debug_flag_for_shader_stage(stage);
 230    nir_shader *nir;
 231
 232    /* First, lower the GLSL IR or Mesa IR to NIR */
 233    if (shader_prog) {
 234       nir = glsl_to_nir(shader_prog, stage, options);
 235    } else {
 236       nir = prog_to_nir(prog, options);
 237       nir_convert_to_ssa(nir); /* turn registers into SSA */
 238    }
 239    nir_validate_shader(nir);
 240
 241    if (stage == MESA_SHADER_GEOMETRY) {
 242       nir_lower_gs_intrinsics(nir);
 243       nir_validate_shader(nir);
 244    }
 245
 246    nir_lower_global_vars_to_local(nir);
 247    nir_validate_shader(nir);
 248
 249    nir_lower_tex(nir, &tex_options);
 250    nir_validate_shader(nir);
 251
 252    nir_normalize_cubemap_coords(nir);
 253    nir_validate_shader(nir);
 254
 255    nir_split_var_copies(nir);
 256    nir_validate_shader(nir);
 257
 258    nir_optimize(nir, is_scalar);
 259
 260    /* Lower a bunch of stuff */
 261    nir_lower_var_copies(nir);
 262    nir_validate_shader(nir);
 263
 264    /* Get rid of split copies */
 265    nir_optimize(nir, is_scalar);
 266
 267    brw_nir_lower_inputs(devinfo, nir, is_scalar);
 268    brw_nir_lower_outputs(nir, is_scalar);
 269    nir_assign_var_locations(&nir->uniforms,
 270                             &nir->num_uniforms,
 271                             is_scalar ? type_size_scalar : type_size_vec4);
 272    nir_lower_io(nir, -1, is_scalar ? type_size_scalar : type_size_vec4);
 273    nir_validate_shader(nir);
 274
 275    nir_remove_dead_variables(nir);
 276    nir_validate_shader(nir);
 277
 278    if (shader_prog) {
 279       nir_lower_samplers(nir, shader_prog);
 280       nir_validate_shader(nir);
 281    }
 282
 283    nir_lower_system_values(nir);
 284    nir_validate_shader(nir);
 285
 286    if (shader_prog) {
 287       nir_lower_atomics(nir, shader_prog);
 288       nir_validate_shader(nir);
 289    }
 290
 291    nir_optimize(nir, is_scalar);
 292
 293    if (brw->gen >= 6) {
 294       /* Try and fuse multiply-adds */
 295       nir_opt_peephole_ffma(nir);
 296       nir_validate_shader(nir);
 297    }
 298
 299    nir_opt_algebraic_late(nir);
 300    nir_validate_shader(nir);
 301
 302    nir_lower_locals_to_regs(nir);
 303    nir_validate_shader(nir);
 304
 305    nir_lower_to_source_mods(nir);
 306    nir_validate_shader(nir);
 307    nir_copy_prop(nir);
 308    nir_validate_shader(nir);
 309    nir_opt_dce(nir);
 310    nir_validate_shader(nir);
 311
 312    if (unlikely(debug_enabled)) {
 313       /* Re-index SSA defs so we print more sensible numbers. */
 314       nir_foreach_overload(nir, overload) {
 315          if (overload->impl)
 316             nir_index_ssa_defs(overload->impl);
 317       }
 318
 319       fprintf(stderr, "NIR (SSA form) for %s shader:\n",
 320               _mesa_shader_stage_to_string(stage));
 321       nir_print_shader(nir, stderr);
 322    }
 323
 324    nir_convert_from_ssa(nir, true);
 325    nir_validate_shader(nir);
 326
 327    if (!is_scalar) {
 328       nir_move_vec_src_uses_to_dest(nir);
 329       nir_validate_shader(nir);
 330
 331       nir_lower_vec_to_movs(nir);
 332       nir_validate_shader(nir);
 333    }
 334
 335    /* This is the last pass we run before we start emitting stuff.  It
 336     * determines when we need to insert boolean resolves on Gen <= 5.  We
 337     * run it last because it stashes data in instr->pass_flags and we don't
 338     * want that to be squashed by other NIR passes.
 339     */
 340    if (brw->gen <= 5)
 341       brw_nir_analyze_boolean_resolves(nir);
 342
 343    nir_sweep(nir);
 344
 345    if (unlikely(debug_enabled)) {
 346       fprintf(stderr, "NIR (final form) for %s shader:\n",
 347               _mesa_shader_stage_to_string(stage));
 348       nir_print_shader(nir, stderr);
 349    }
 350
 351    return nir;
 352 }
 353
 354 enum brw_reg_type
 355 brw_type_for_nir_type(nir_alu_type type)
 356 {
 357    switch (type) {
 358    case nir_type_unsigned:
 359       return BRW_REGISTER_TYPE_UD;
 360    case nir_type_bool:
 361    case nir_type_int:
 362       return BRW_REGISTER_TYPE_D;
 363    case nir_type_float:
 364       return BRW_REGISTER_TYPE_F;
 365    default:
 366       unreachable("unknown type");
 367    }
 368
 369    return BRW_REGISTER_TYPE_F;
 370 }
 371
 372 /* Returns the glsl_base_type corresponding to a nir_alu_type.
 373  * This is used by both brw_vec4_nir and brw_fs_nir.
 374  */
 375 enum glsl_base_type
 376 brw_glsl_base_type_for_nir_type(nir_alu_type type)
 377 {
 378    switch (type) {
 379    case nir_type_float:
 380       return GLSL_TYPE_FLOAT;
 381
 382    case nir_type_int:
 383       return GLSL_TYPE_INT;
 384
 385    case nir_type_unsigned:
 386       return GLSL_TYPE_UINT;
 387
 388    default:
 389       unreachable("bad type");
 390    }
 391 }