Module: Mesa Branch: main Commit: bedf504d385bdae9a54500ac6dceae009914302a URL: http://cgit.freedesktop.org/mesa/mesa/commit/?id=bedf504d385bdae9a54500ac6dceae009914302a
Author: Timothy Arceri <tarc...@itsqueeze.com> Date: Fri Oct 6 12:49:54 2023 +1100 glsl: add nir based lower_named_interface_blocks() This will be used in the following patch to replace the GLSL IR version of this pass. Acked-by: Marek Olšák <marek.ol...@amd.com> Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/26001> --- src/compiler/glsl/gl_nir.h | 2 + .../glsl/gl_nir_lower_named_interface_blocks.c | 335 +++++++++++++++++++++ src/compiler/glsl/meson.build | 1 + 3 files changed, 338 insertions(+) diff --git a/src/compiler/glsl/gl_nir.h b/src/compiler/glsl/gl_nir.h index 245c2a0a09c..81159845aff 100644 --- a/src/compiler/glsl/gl_nir.h +++ b/src/compiler/glsl/gl_nir.h @@ -50,6 +50,8 @@ bool gl_nir_lower_blend_equation_advanced(nir_shader *sh, bool coherent); bool gl_nir_lower_buffers(nir_shader *shader, const struct gl_shader_program *shader_program); +void gl_nir_lower_named_interface_blocks(struct gl_shader_program *prog); + void gl_nir_lower_packed_varyings(const struct gl_constants *consts, struct gl_shader_program *prog, void *mem_ctx, unsigned locations_used, diff --git a/src/compiler/glsl/gl_nir_lower_named_interface_blocks.c b/src/compiler/glsl/gl_nir_lower_named_interface_blocks.c new file mode 100644 index 00000000000..18bac021a16 --- /dev/null +++ b/src/compiler/glsl/gl_nir_lower_named_interface_blocks.c @@ -0,0 +1,335 @@ +/* + * Copyright © 2013 Intel Corporation + * Copyright © 2023 Valve Corporation + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +/** + * + * This lowering pass converts all interface blocks with instance names + * into interface blocks without an instance name. + * + * For example, the following shader: + * + * out block { + * float block_var; + * } inst_name; + * + * main() + * { + * inst_name.block_var = 0.0; + * } + * + * Is rewritten to: + * + * out block { + * float block_var; + * }; + * + * main() + * { + * block_var = 0.0; + * } + * + * This takes place after the shader code has already been verified with + * the interface name in place. + * + * The linking phase will use the interface block name rather than the + * interface's instance name when linking interfaces. + * + * This modification to the ir allows our currently existing dead code + * elimination to work with interface blocks without changes. + */ + +#include "nir.h" +#include "nir_builder.h" +#include "nir_deref.h" +#include "nir_types.h" +#include "gl_nir.h" + +#include "main/shader_types.h" + +struct lower_named_block_state { + void *mem_ctx; + struct hash_table *interface_namespace; +}; + +static const struct glsl_type * +process_array_type(const struct glsl_type *type, unsigned idx) +{ + const struct glsl_type *element_type = glsl_get_array_element(type); + unsigned length = glsl_get_length(type); + if (glsl_type_is_array(element_type)) { + const struct glsl_type *new_array_type = + process_array_type(element_type, idx); + return glsl_array_type(new_array_type, length, 0); + } else { + return glsl_array_type(glsl_get_struct_field(element_type, idx), + length, 0); + } +} + +static nir_deref_instr * +process_derefs(nir_builder *b, nir_deref_instr **p, nir_deref_instr *parent) +{ + bool found_ifc = false; + for (; *p; p++) { + if ((*p)->deref_type == nir_deref_type_array) { + parent = nir_build_deref_array(b, parent, (*p)->arr.index.ssa); + } else if ((*p)->deref_type == nir_deref_type_struct) { + if (!found_ifc) { + /* We found the interface block so just skip it */ + found_ifc = true; + continue; + } else { + parent = nir_build_deref_struct(b, parent, (*p)->strct.index); + } + } + } + + return parent; +} + +/* Disable packing on varyings used by interpolate functions. This must be + * called after lowering blocks to avoid disabling packing on the entire + * block. + */ +static void +disable_varying_packing_when_used_by_interpolate_functions(nir_intrinsic_instr *intr, + nir_variable *var) +{ + if (intr->intrinsic == nir_intrinsic_interp_deref_at_centroid || + intr->intrinsic == nir_intrinsic_interp_deref_at_sample || + intr->intrinsic == nir_intrinsic_interp_deref_at_offset) { + + /* This disables varying packing for this input. */ + var->data.must_be_shader_input = 1; + } +} + +static char * +create_ifc_field_name_str(void *mem_ctx, nir_variable *var, + const struct glsl_type *iface_t, unsigned f_idx) +{ + char *iface_field_name = + ralloc_asprintf(mem_ctx, "%s %s.%s.%s", + var->data.mode == nir_var_shader_in ? "in" : "out", + glsl_get_type_name(iface_t), var->name, + glsl_get_struct_elem_name(iface_t, f_idx)); + + return iface_field_name; +} + +static bool +flatten_named_interface_deref(void *mem_ctx, nir_builder *b, + nir_deref_instr *deref, + nir_intrinsic_instr *intr, + struct hash_table *interface_namespace, + bool is_src0) +{ + nir_variable_mode mask = nir_var_shader_in | nir_var_shader_out; + + if (!nir_deref_mode_is_one_of(deref, mask)) + return false; + + nir_variable *var = nir_deref_instr_get_variable(deref); + + const struct glsl_type * iface_t = glsl_without_array(var->type); + if (iface_t != var->interface_type) + return false; + + nir_deref_path path; + nir_deref_path_init(&path, deref, NULL); + + assert(path.path[0]->deref_type == nir_deref_type_var); + nir_deref_instr **p = &path.path[1]; + + char *iface_field_name = NULL; + for (; *p; p++) { + if ((*p)->deref_type == nir_deref_type_struct) { + iface_field_name = + create_ifc_field_name_str(mem_ctx, var, iface_t, + (*p)->strct.index); + break; + } + } + assert(iface_field_name); + + /* Find the variable in the set of flattened interface blocks */ + struct hash_entry *entry = + _mesa_hash_table_search(interface_namespace, iface_field_name); + assert(entry); + + nir_variable *found_var = (nir_variable *) entry->data; + + if (intr->intrinsic == nir_intrinsic_store_deref || + (intr->intrinsic == nir_intrinsic_copy_deref && is_src0)) + found_var->data.assigned = 1; + + b->cursor = nir_before_instr(&intr->instr); + nir_deref_instr *deref_var = nir_build_deref_var(b, found_var); + if (glsl_type_is_array(found_var->type) || + glsl_type_is_struct(found_var->type) || + glsl_type_is_matrix(found_var->type)) { + p = &path.path[1]; + deref_var = process_derefs(b, p, deref_var); + } + + disable_varying_packing_when_used_by_interpolate_functions(intr, + found_var); + + nir_deref_path_finish(&path); + + nir_def_rewrite_uses(&deref->def, &deref_var->def); + + return true; +} + +static bool +flatten_named_interface_derefs(nir_builder *b, nir_intrinsic_instr *intr, + void *cb_data) +{ + struct lower_named_block_state *state = + (struct lower_named_block_state *) cb_data; + + if (intr->intrinsic != nir_intrinsic_copy_deref && + intr->intrinsic != nir_intrinsic_load_deref && + intr->intrinsic != nir_intrinsic_store_deref && + intr->intrinsic != nir_intrinsic_interp_deref_at_centroid && + intr->intrinsic != nir_intrinsic_interp_deref_at_sample && + intr->intrinsic != nir_intrinsic_interp_deref_at_offset && + intr->intrinsic != nir_intrinsic_interp_deref_at_vertex) + return false; + + nir_deref_instr *deref = nir_src_as_deref(intr->src[0]); + bool progress = + flatten_named_interface_deref(state->mem_ctx, b, deref, intr, + state->interface_namespace, true); + + if (intr->intrinsic == nir_intrinsic_copy_deref) { + deref = nir_src_as_deref(intr->src[1]); + progress |= + flatten_named_interface_deref(state->mem_ctx, b, deref, intr, + state->interface_namespace, false); + } + + return progress; +} + +static void +lower_named_interface_blocks(struct gl_linked_shader *sh) +{ + void *mem_ctx = ralloc_context(NULL); + + struct hash_table *interface_namespace = + _mesa_hash_table_create(mem_ctx, _mesa_hash_string, + _mesa_key_string_equal); + + /* First pass: adjust instance block variables with an instance name + * to not have an instance name. + * + * The interface block variables are stored in the interface_namespace + * hash table so they can be used in the second pass. + */ + nir_foreach_variable_with_modes_safe(var, sh->Program->nir, + nir_var_shader_in | nir_var_shader_out) { + const struct glsl_type * iface_t = glsl_without_array(var->type); + if (iface_t != var->interface_type) + continue; + + for (unsigned i = 0; i < iface_t->length; i++) { + const char *field_name = glsl_get_struct_elem_name(iface_t, i); + char *iface_field_name = + create_ifc_field_name_str(mem_ctx, var, iface_t, i); + + struct hash_entry *entry = _mesa_hash_table_search(interface_namespace, + iface_field_name); + nir_variable *found_var = entry ? (nir_variable *) entry->data : NULL; + if (!found_var) { + const struct glsl_struct_field *field_data = + glsl_get_struct_field_data(iface_t, i); + + nir_variable *new_var = rzalloc(sh->Program->nir, nir_variable); + new_var->name = ralloc_strdup(new_var, field_name); + if (!glsl_type_is_array(var->type)) { + new_var->type = glsl_get_struct_field(iface_t, i); + } else { + new_var->type = process_array_type(var->type, i); + } + new_var->data.mode = var->data.mode; + new_var->data.location = field_data->location; + new_var->data.location_frac = field_data->component >= 0 ? + field_data->component : 0; + new_var->data.explicit_location = (new_var->data.location >= 0); + new_var->data.offset = field_data->offset; + new_var->data.explicit_offset = (field_data->offset >= 0); + new_var->data.xfb.buffer = field_data->xfb_buffer; + new_var->data.explicit_xfb_buffer = field_data->explicit_xfb_buffer; + new_var->data.interpolation = field_data->interpolation; + new_var->data.centroid = field_data->centroid; + new_var->data.sample = field_data->sample; + new_var->data.patch = field_data->patch; + new_var->data.stream = var->data.stream; + new_var->data.how_declared = var->data.how_declared; + new_var->data.from_named_ifc_block = 1; + + new_var->interface_type = var->type; + _mesa_hash_table_insert(interface_namespace, iface_field_name, + new_var); + + nir_shader_add_variable(sh->Program->nir, new_var); + } + } + } + + /* Second pass: redirect dereferences to the new vars. */ + struct lower_named_block_state state; + state.mem_ctx = mem_ctx; + state.interface_namespace = interface_namespace; + nir_shader_intrinsics_pass(sh->Program->nir, flatten_named_interface_derefs, + nir_metadata_block_index | + nir_metadata_dominance, &state); + + /* Third pass: Mark now lowered blks as ordinary globals to be dead code + * eliminated. + */ + nir_foreach_variable_with_modes(var, sh->Program->nir, + nir_var_shader_in | nir_var_shader_out) { + const struct glsl_type * iface_t = glsl_without_array(var->type); + if (!(iface_t == var->interface_type)) + continue; + + var->data.mode = nir_var_shader_temp; + } + nir_fixup_deref_modes(sh->Program->nir); + + ralloc_free(mem_ctx); +} + +void +gl_nir_lower_named_interface_blocks(struct gl_shader_program *prog) +{ + for (unsigned int i = 0; i < MESA_SHADER_STAGES; i++) { + if (prog->_LinkedShaders[i] != NULL) + lower_named_interface_blocks(prog->_LinkedShaders[i]); + } +} + diff --git a/src/compiler/glsl/meson.build b/src/compiler/glsl/meson.build index 3c95126834f..ee83c000be4 100644 --- a/src/compiler/glsl/meson.build +++ b/src/compiler/glsl/meson.build @@ -129,6 +129,7 @@ files_libglsl = files( 'gl_nir_lower_images.c', 'gl_nir_lower_blend_equation_advanced.c', 'gl_nir_lower_buffers.c', + 'gl_nir_lower_named_interface_blocks.c', 'gl_nir_lower_packed_varyings.c', 'gl_nir_lower_samplers.c', 'gl_nir_lower_samplers_as_deref.c',
