src/compiler/glsl/gl_nir_lower_samplers_as_deref.c

   1 /*
   2  * Copyright (C) 2005-2007  Brian Paul   All Rights Reserved.
   3  * Copyright (C) 2008  VMware, Inc.   All Rights Reserved.
   4  * Copyright © 2014 Intel Corporation
   5  * Copyright © 2017 Advanced Micro Devices, Inc.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the "Software"),
   9  * to deal in the Software without restriction, including without limitation
  10  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  11  * and/or sell copies of the Software, and to permit persons to whom the
  12  * Software is furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the next
  15  * paragraph) shall be included in all copies or substantial portions of the
  16  * Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  19  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  21  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  22  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  23  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  24  * DEALINGS IN THE SOFTWARE.
  25  */
  26
  27 /**
  28  * \file
  29  *
  30  * Lower sampler and image references of (non-bindless) uniforms by removing
  31  * struct dereferences, and synthesizing new uniform variables without structs
  32  * if required.
  33  *
  34  * This will allow backends to have a simple, uniform treatment of bindless and
  35  * non-bindless samplers and images.
  36  *
  37  * Example:
  38  *
  39  *   struct S {
  40  *      sampler2D tex[2];
  41  *      sampler2D other;
  42  *   };
  43  *   uniform S s[2];
  44  *
  45  *   tmp = texture(s[n].tex[m], coord);
  46  *
  47  * Becomes:
  48  *
  49  *   decl_var uniform INTERP_MODE_NONE sampler2D[2][2] lower@s.tex (...)
  50  *
  51  *   vec1 32 ssa_idx = $(2 * n + m)
  52  *   vec4 32 ssa_out = tex ssa_coord (coord), lower@s.tex[n][m] (texture), lower@s.tex[n][m] (sampler)
  53  *
  54  * and lower@s.tex has var->data.binding set to the base index as defined by
  55  * the opaque uniform mapping.
  56  */
  57
  58 #include "compiler/nir/nir.h"
  59 #include "compiler/nir/nir_builder.h"
  60 #include "compiler/nir/nir_deref.h"
  61 #include "gl_nir.h"
  62 #include "ir_uniform.h"
  63
  64 #include "main/compiler.h"
  65 #include "main/mtypes.h"
  66
  67 struct lower_samplers_as_deref_state {
  68    nir_shader *shader;
  69    const struct gl_shader_program *shader_program;
  70    struct hash_table *remap_table;
  71 };
  72
  73 /* Prepare for removing struct derefs.  This pre-pass generates the name
  74  * of the lowered deref, and calculates the lowered type and location.
  75  * After that, once looking up (or creating if needed) the lowered var,
  76  * constructing the new chain of deref instructions is a simple loop
  77  * that skips the struct deref's
  78  *
  79  * path:     appended to as we descend down the chain of deref instrs
  80  *           and remove struct derefs
  81  * location: increased as we descend down and remove struct derefs
  82  * type:     updated as we recurse back up the chain of deref instrs
  83  *           with the resulting type after removing struct derefs
  84  */
  85 static void
  86 remove_struct_derefs_prep(nir_deref_instr **p, char **name,
  87                           unsigned *location, const struct glsl_type **type)
  88 {
  89    nir_deref_instr *cur = p[0], *next = p[1];
  90
  91    if (!next) {
  92       *type = cur->type;
  93       return;
  94    }
  95
  96    switch (next->deref_type) {
  97    case nir_deref_type_array: {
  98       unsigned length = glsl_get_length(cur->type);
  99
 100       remove_struct_derefs_prep(&p[1], name, location, type);
 101
 102       *type = glsl_array_type(*type, length);
 103       break;
 104    }
 105
 106    case nir_deref_type_struct: {
 107       *location += glsl_get_record_location_offset(cur->type, next->strct.index);
 108       ralloc_asprintf_append(name, ".%s",
 109                              glsl_get_struct_elem_name(cur->type, next->strct.index));
 110
 111       remove_struct_derefs_prep(&p[1], name, location, type);
 112       break;
 113    }
 114
 115    default:
 116       unreachable("Invalid deref type");
 117       break;
 118    }
 119 }
 120
 121 static nir_deref_instr *
 122 lower_deref(nir_builder *b, struct lower_samplers_as_deref_state *state,
 123             nir_deref_instr *deref)
 124 {
 125    nir_variable *var = nir_deref_instr_get_variable(deref);
 126    gl_shader_stage stage = state->shader->info.stage;
 127
 128    if (var->data.bindless || var->data.mode != nir_var_uniform)
 129       return NULL;
 130
 131    nir_deref_path path;
 132    nir_deref_path_init(&path, deref, state->remap_table);
 133    assert(path.path[0]->deref_type == nir_deref_type_var);
 134
 135    char *name = ralloc_asprintf(state->remap_table, "lower@%s", var->name);
 136    unsigned location = var->data.location;
 137    const struct glsl_type *type = NULL;
 138    unsigned binding;
 139
 140    /*
 141     * We end up needing to do this in two passes, in order to generate
 142     * the name of the lowered var (and detecting whether there even are
 143     * any struct deref's), and then the second pass to construct the
 144     * actual deref instructions after looking up / generating a new
 145     * nir_variable (since we need to construct the deref_var first)
 146     */
 147
 148    remove_struct_derefs_prep(path.path, &name, &location, &type);
 149
 150    assert(location < state->shader_program->data->NumUniformStorage &&
 151           state->shader_program->data->UniformStorage[location].opaque[stage].active);
 152
 153    binding = state->shader_program->data->UniformStorage[location].opaque[stage].index;
 154
 155    if (var->type == type) {
 156       /* Fast path: We did not encounter any struct derefs. */
 157       var->data.binding = binding;
 158       return deref;
 159    }
 160
 161    uint32_t hash = _mesa_key_hash_string(name);
 162    struct hash_entry *h =
 163       _mesa_hash_table_search_pre_hashed(state->remap_table, hash, name);
 164
 165    if (h) {
 166       var = (nir_variable *)h->data;
 167    } else {
 168       var = nir_variable_create(state->shader, nir_var_uniform, type, name);
 169       var->data.binding = binding;
 170       _mesa_hash_table_insert_pre_hashed(state->remap_table, hash, name, var);
 171    }
 172
 173    /* construct a new deref based on lowered var (skipping the struct deref's
 174     * from the original deref:
 175     */
 176    nir_deref_instr *new_deref = nir_build_deref_var(b, var);
 177    for (nir_deref_instr **p = &path.path[1]; *p; p++) {
 178       if ((*p)->deref_type == nir_deref_type_struct)
 179          continue;
 180
 181       assert((*p)->deref_type == nir_deref_type_array);
 182
 183       new_deref = nir_build_deref_array(b, new_deref,
 184                                         nir_ssa_for_src(b, (*p)->arr.index, 1));
 185    }
 186
 187    return new_deref;
 188 }
 189
 190 static bool
 191 lower_sampler(nir_tex_instr *instr, struct lower_samplers_as_deref_state *state,
 192               nir_builder *b)
 193 {
 194    int texture_idx =
 195       nir_tex_instr_src_index(instr, nir_tex_src_texture_deref);
 196    int sampler_idx =
 197       nir_tex_instr_src_index(instr, nir_tex_src_sampler_deref);
 198
 199    if (texture_idx < 0)
 200       return false;
 201
 202    assert(texture_idx >= 0 && sampler_idx >= 0);
 203    assert(instr->src[texture_idx].src.is_ssa);
 204    assert(instr->src[sampler_idx].src.is_ssa);
 205    assert(instr->src[texture_idx].src.ssa == instr->src[sampler_idx].src.ssa);
 206
 207    b->cursor = nir_before_instr(&instr->instr);
 208
 209    nir_deref_instr *texture_deref =
 210       lower_deref(b, state, nir_src_as_deref(instr->src[texture_idx].src));
 211    /* don't lower bindless: */
 212    if (!texture_deref)
 213       return false;
 214    nir_instr_rewrite_src(&instr->instr, &instr->src[texture_idx].src,
 215                          nir_src_for_ssa(&texture_deref->dest.ssa));
 216
 217    nir_deref_instr *sampler_deref =
 218       lower_deref(b, state, nir_src_as_deref(instr->src[sampler_idx].src));
 219    nir_instr_rewrite_src(&instr->instr, &instr->src[sampler_idx].src,
 220                          nir_src_for_ssa(&sampler_deref->dest.ssa));
 221
 222    return true;
 223 }
 224
 225 static bool
 226 lower_intrinsic(nir_intrinsic_instr *instr,
 227                 struct lower_samplers_as_deref_state *state,
 228                 nir_builder *b)
 229 {
 230    if (instr->intrinsic == nir_intrinsic_image_deref_load ||
 231        instr->intrinsic == nir_intrinsic_image_deref_store ||
 232        instr->intrinsic == nir_intrinsic_image_deref_atomic_add ||
 233        instr->intrinsic == nir_intrinsic_image_deref_atomic_min ||
 234        instr->intrinsic == nir_intrinsic_image_deref_atomic_max ||
 235        instr->intrinsic == nir_intrinsic_image_deref_atomic_and ||
 236        instr->intrinsic == nir_intrinsic_image_deref_atomic_or ||
 237        instr->intrinsic == nir_intrinsic_image_deref_atomic_xor ||
 238        instr->intrinsic == nir_intrinsic_image_deref_atomic_exchange ||
 239        instr->intrinsic == nir_intrinsic_image_deref_atomic_comp_swap ||
 240        instr->intrinsic == nir_intrinsic_image_deref_atomic_fadd ||
 241        instr->intrinsic == nir_intrinsic_image_deref_size) {
 242
 243       b->cursor = nir_before_instr(&instr->instr);
 244       nir_deref_instr *deref =
 245          lower_deref(b, state, nir_src_as_deref(instr->src[0]));
 246       /* don't lower bindless: */
 247       if (!deref)
 248          return false;
 249       nir_instr_rewrite_src(&instr->instr, &instr->src[0],
 250                             nir_src_for_ssa(&deref->dest.ssa));
 251       return true;
 252    }
 253
 254    return false;
 255 }
 256
 257 static bool
 258 lower_impl(nir_function_impl *impl, struct lower_samplers_as_deref_state *state)
 259 {
 260    nir_builder b;
 261    nir_builder_init(&b, impl);
 262    bool progress = false;
 263
 264    nir_foreach_block(block, impl) {
 265       nir_foreach_instr(instr, block) {
 266          if (instr->type == nir_instr_type_tex)
 267             progress |= lower_sampler(nir_instr_as_tex(instr), state, &b);
 268          else if (instr->type == nir_instr_type_intrinsic)
 269             progress |= lower_intrinsic(nir_instr_as_intrinsic(instr), state, &b);
 270       }
 271    }
 272
 273    return progress;
 274 }
 275
 276 bool
 277 gl_nir_lower_samplers_as_deref(nir_shader *shader,
 278                                const struct gl_shader_program *shader_program)
 279 {
 280    bool progress = false;
 281    struct lower_samplers_as_deref_state state;
 282
 283    state.shader = shader;
 284    state.shader_program = shader_program;
 285    state.remap_table = _mesa_hash_table_create(NULL, _mesa_key_hash_string,
 286                                                _mesa_key_string_equal);
 287
 288    nir_foreach_function(function, shader) {
 289       if (function->impl)
 290          progress |= lower_impl(function->impl, &state);
 291    }
 292
 293    /* keys are freed automatically by ralloc */
 294    _mesa_hash_table_destroy(state.remap_table, NULL);
 295
 296    if (progress)
 297       nir_remove_dead_derefs(shader);
 298
 299    return progress;
 300 }