src/gallium/frontends/lavapipe/lvp_lower_vulkan_resource.c - platform/external/mesa3d - Git at Google

 /*
  * Copyright © 2019 Red Hat.
  *
  * 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.
  */

 #include "lvp_private.h"
 #include "nir.h"
 #include "nir_builder.h"
 #include "lvp_lower_vulkan_resource.h"

 static bool
 lower_vulkan_resource_index(const nir_instr *instr, const void *data_cb)
 {
    if (instr->type == nir_instr_type_intrinsic) {
       nir_intrinsic_instr *intrin = nir_instr_as_intrinsic(instr);
       switch (intrin->intrinsic) {
       case nir_intrinsic_vulkan_resource_index:
       case nir_intrinsic_vulkan_resource_reindex:
       case nir_intrinsic_load_vulkan_descriptor:
       case nir_intrinsic_get_ssbo_size:
          return true;
       default:
          return false;
       }
    }
    if (instr->type == nir_instr_type_tex) {
       return true;
    }
    return false;
 }

 static nir_ssa_def *lower_vri_intrin_vri(struct nir_builder *b,
                                            nir_instr *instr, void *data_cb)
 {
    nir_intrinsic_instr *intrin = nir_instr_as_intrinsic(instr);
    unsigned desc_set_idx = nir_intrinsic_desc_set(intrin);
    unsigned binding_idx = nir_intrinsic_binding(intrin);
    struct lvp_pipeline_layout *layout = data_cb;
    struct lvp_descriptor_set_binding_layout *binding = &layout->set[desc_set_idx].layout->binding[binding_idx];
    int value = 0;
    bool is_ubo = (binding->type == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER ||
                   binding->type == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC);

    for (unsigned s = 0; s < desc_set_idx; s++) {
      if (is_ubo)
        value += layout->set[s].layout->stage[b->shader->info.stage].const_buffer_count;
      else
        value += layout->set[s].layout->stage[b->shader->info.stage].shader_buffer_count;
    }
    if (is_ubo)
      value += binding->stage[b->shader->info.stage].const_buffer_index + 1;
    else
      value += binding->stage[b->shader->info.stage].shader_buffer_index;

    /* The SSA size for indices is the same as for pointers.  We use
     * nir_addr_format_32bit_index_offset so we need a vec2.  We don't need all
     * that data so just stuff a 0 in the second component.
     */
    if (nir_src_is_const(intrin->src[0])) {
       value += nir_src_comp_as_int(intrin->src[0], 0);
       return nir_imm_ivec2(b, value, 0);
    } else
       return nir_vec2(b, nir_iadd_imm(b, intrin->src[0].ssa, value),
                          nir_imm_int(b, 0));
 }

 static nir_ssa_def *lower_vri_intrin_vrri(struct nir_builder *b,
                                           nir_instr *instr, void *data_cb)
 {
    nir_intrinsic_instr *intrin = nir_instr_as_intrinsic(instr);
    nir_ssa_def *old_index = nir_ssa_for_src(b, intrin->src[0], 1);
    nir_ssa_def *delta = nir_ssa_for_src(b, intrin->src[1], 1);
    return nir_vec2(b, nir_iadd(b, old_index, delta),
                       nir_imm_int(b, 0));
 }

 static nir_ssa_def *lower_vri_intrin_lvd(struct nir_builder *b,
                                          nir_instr *instr, void *data_cb)
 {
    nir_intrinsic_instr *intrin = nir_instr_as_intrinsic(instr);
    nir_ssa_def *index = nir_ssa_for_src(b, intrin->src[0], 1);
    return nir_vec2(b, index, nir_imm_int(b, 0));
 }

 static int lower_vri_instr_tex_deref(nir_tex_instr *tex,
                                      nir_tex_src_type deref_src_type,
                                      gl_shader_stage stage,
                                      struct lvp_pipeline_layout *layout)
 {
    int deref_src_idx = nir_tex_instr_src_index(tex, deref_src_type);

    if (deref_src_idx < 0)
       return -1;

    nir_deref_instr *deref_instr = nir_src_as_deref(tex->src[deref_src_idx].src);
    nir_variable *var = nir_deref_instr_get_variable(deref_instr);
    unsigned desc_set_idx = var->data.descriptor_set;
    unsigned binding_idx = var->data.binding;
    int value = 0;
    struct lvp_descriptor_set_binding_layout *binding = &layout->set[desc_set_idx].layout->binding[binding_idx];
    nir_tex_instr_remove_src(tex, deref_src_idx);
    for (unsigned s = 0; s < desc_set_idx; s++) {
       if (deref_src_type == nir_tex_src_sampler_deref)
          value += layout->set[s].layout->stage[stage].sampler_count;
       else
          value += layout->set[s].layout->stage[stage].sampler_view_count;
    }
    if (deref_src_type == nir_tex_src_sampler_deref)
       value += binding->stage[stage].sampler_index;
    else
       value += binding->stage[stage].sampler_view_index;

    if (deref_instr->deref_type == nir_deref_type_array) {
       if (nir_src_is_const(deref_instr->arr.index))
          value += nir_src_as_uint(deref_instr->arr.index);
       else {
          if (deref_src_type == nir_tex_src_sampler_deref)
             nir_tex_instr_add_src(tex, nir_tex_src_sampler_offset, deref_instr->arr.index);
          else
             nir_tex_instr_add_src(tex, nir_tex_src_texture_offset, deref_instr->arr.index);
       }
    }
    if (deref_src_type == nir_tex_src_sampler_deref)
       tex->sampler_index = value;
    else
       tex->texture_index = value;
    return value;
 }

 static void lower_vri_instr_tex(struct nir_builder *b,
                                 nir_tex_instr *tex, void *data_cb)
 {
    struct lvp_pipeline_layout *layout = data_cb;
    int tex_value = 0;

    lower_vri_instr_tex_deref(tex, nir_tex_src_sampler_deref, b->shader->info.stage, layout);
    tex_value = lower_vri_instr_tex_deref(tex, nir_tex_src_texture_deref, b->shader->info.stage, layout);
    if (tex_value >= 0)
       b->shader->info.textures_used |= (1 << tex_value);
 }

 static nir_ssa_def *lower_vri_instr(struct nir_builder *b,
                                     nir_instr *instr, void *data_cb)
 {
    if (instr->type == nir_instr_type_intrinsic) {
       nir_intrinsic_instr *intrin = nir_instr_as_intrinsic(instr);
       switch (intrin->intrinsic) {
       case nir_intrinsic_vulkan_resource_index:
          return lower_vri_intrin_vri(b, instr, data_cb);

       case nir_intrinsic_vulkan_resource_reindex:
          return lower_vri_intrin_vrri(b, instr, data_cb);

       case nir_intrinsic_load_vulkan_descriptor:
          return lower_vri_intrin_lvd(b, instr, data_cb);

       case nir_intrinsic_get_ssbo_size: {
          /* The result of the load_vulkan_descriptor is a vec2(index, offset)
           * but we only want the index in get_ssbo_size.
           */
          b->cursor = nir_before_instr(&intrin->instr);
          nir_ssa_def *index = nir_ssa_for_src(b, intrin->src[0], 1);
          nir_instr_rewrite_src(&intrin->instr, &intrin->src[0],
                                nir_src_for_ssa(index));
          return NULL;
       }

       default:
          return NULL;
       }
    }
    if (instr->type == nir_instr_type_tex)
       lower_vri_instr_tex(b, nir_instr_as_tex(instr), data_cb);
    return NULL;
 }

 void lvp_lower_pipeline_layout(const struct lvp_device *device,
                                struct lvp_pipeline_layout *layout,
                                nir_shader *shader)
 {
    nir_shader_lower_instructions(shader, lower_vulkan_resource_index, lower_vri_instr, layout);
    nir_foreach_uniform_variable(var, shader) {
       const struct glsl_type *type = var->type;
       enum glsl_base_type base_type =
          glsl_get_base_type(glsl_without_array(type));
       unsigned desc_set_idx = var->data.descriptor_set;
       unsigned binding_idx = var->data.binding;
       struct lvp_descriptor_set_binding_layout *binding = &layout->set[desc_set_idx].layout->binding[binding_idx];
       int value = 0;
       var->data.descriptor_set = 0;
       if (base_type == GLSL_TYPE_SAMPLER) {
          if (binding->type == VK_DESCRIPTOR_TYPE_SAMPLER) {
             for (unsigned s = 0; s < desc_set_idx; s++)
                value += layout->set[s].layout->stage[shader->info.stage].sampler_count;
             value += binding->stage[shader->info.stage].sampler_index;
          } else {
             for (unsigned s = 0; s < desc_set_idx; s++)
                value += layout->set[s].layout->stage[shader->info.stage].sampler_view_count;
             value += binding->stage[shader->info.stage].sampler_view_index;
          }
          var->data.binding = value;
       }
       if (base_type == GLSL_TYPE_IMAGE) {
          var->data.descriptor_set = 0;
          for (unsigned s = 0; s < desc_set_idx; s++)
            value += layout->set[s].layout->stage[shader->info.stage].image_count;
          value += binding->stage[shader->info.stage].image_index;
          var->data.binding = value;
       }
    }
 }
	/*
	* Copyright © 2019 Red Hat.
	*
	* 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.
	*/

	#include "lvp_private.h"
	#include "nir.h"
	#include "nir_builder.h"
	#include "lvp_lower_vulkan_resource.h"

	static bool
	lower_vulkan_resource_index(const nir_instr instr, const void data_cb)
	{
	if (instr->type == nir_instr_type_intrinsic) {
	nir_intrinsic_instr *intrin = nir_instr_as_intrinsic(instr);
	switch (intrin->intrinsic) {
	case nir_intrinsic_vulkan_resource_index:
	case nir_intrinsic_vulkan_resource_reindex:
	case nir_intrinsic_load_vulkan_descriptor:
	case nir_intrinsic_get_ssbo_size:
	return true;
	default:
	return false;
	}
	}
	if (instr->type == nir_instr_type_tex) {
	return true;
	}
	return false;
	}

	static nir_ssa_def lower_vri_intrin_vri(struct nir_builder b,
	nir_instr instr, void data_cb)
	{
	nir_intrinsic_instr *intrin = nir_instr_as_intrinsic(instr);
	unsigned desc_set_idx = nir_intrinsic_desc_set(intrin);
	unsigned binding_idx = nir_intrinsic_binding(intrin);
	struct lvp_pipeline_layout *layout = data_cb;
	struct lvp_descriptor_set_binding_layout *binding = &layout->set[desc_set_idx].layout->binding[binding_idx];
	int value = 0;
	bool is_ubo = (binding->type == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER \|\|
	binding->type == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC);

	for (unsigned s = 0; s < desc_set_idx; s++) {
	if (is_ubo)
	value += layout->set[s].layout->stage[b->shader->info.stage].const_buffer_count;
	else
	value += layout->set[s].layout->stage[b->shader->info.stage].shader_buffer_count;
	}
	if (is_ubo)
	value += binding->stage[b->shader->info.stage].const_buffer_index + 1;
	else
	value += binding->stage[b->shader->info.stage].shader_buffer_index;

	/* The SSA size for indices is the same as for pointers. We use
	* nir_addr_format_32bit_index_offset so we need a vec2. We don't need all
	* that data so just stuff a 0 in the second component.
	*/
	if (nir_src_is_const(intrin->src[0])) {
	value += nir_src_comp_as_int(intrin->src[0], 0);
	return nir_imm_ivec2(b, value, 0);
	} else
	return nir_vec2(b, nir_iadd_imm(b, intrin->src[0].ssa, value),
	nir_imm_int(b, 0));
	}

	static nir_ssa_def lower_vri_intrin_vrri(struct nir_builder b,
	nir_instr instr, void data_cb)
	{
	nir_intrinsic_instr *intrin = nir_instr_as_intrinsic(instr);
	nir_ssa_def *old_index = nir_ssa_for_src(b, intrin->src[0], 1);
	nir_ssa_def *delta = nir_ssa_for_src(b, intrin->src[1], 1);
	return nir_vec2(b, nir_iadd(b, old_index, delta),
	nir_imm_int(b, 0));
	}

	static nir_ssa_def lower_vri_intrin_lvd(struct nir_builder b,
	nir_instr instr, void data_cb)
	{
	nir_intrinsic_instr *intrin = nir_instr_as_intrinsic(instr);
	nir_ssa_def *index = nir_ssa_for_src(b, intrin->src[0], 1);
	return nir_vec2(b, index, nir_imm_int(b, 0));
	}

	static int lower_vri_instr_tex_deref(nir_tex_instr *tex,
	nir_tex_src_type deref_src_type,
	gl_shader_stage stage,
	struct lvp_pipeline_layout *layout)
	{
	int deref_src_idx = nir_tex_instr_src_index(tex, deref_src_type);

	if (deref_src_idx < 0)
	return -1;

	nir_deref_instr *deref_instr = nir_src_as_deref(tex->src[deref_src_idx].src);
	nir_variable *var = nir_deref_instr_get_variable(deref_instr);
	unsigned desc_set_idx = var->data.descriptor_set;
	unsigned binding_idx = var->data.binding;
	int value = 0;
	struct lvp_descriptor_set_binding_layout *binding = &layout->set[desc_set_idx].layout->binding[binding_idx];
	nir_tex_instr_remove_src(tex, deref_src_idx);
	for (unsigned s = 0; s < desc_set_idx; s++) {
	if (deref_src_type == nir_tex_src_sampler_deref)
	value += layout->set[s].layout->stage[stage].sampler_count;
	else
	value += layout->set[s].layout->stage[stage].sampler_view_count;
	}
	if (deref_src_type == nir_tex_src_sampler_deref)
	value += binding->stage[stage].sampler_index;
	else
	value += binding->stage[stage].sampler_view_index;

	if (deref_instr->deref_type == nir_deref_type_array) {
	if (nir_src_is_const(deref_instr->arr.index))
	value += nir_src_as_uint(deref_instr->arr.index);
	else {
	if (deref_src_type == nir_tex_src_sampler_deref)
	nir_tex_instr_add_src(tex, nir_tex_src_sampler_offset, deref_instr->arr.index);
	else
	nir_tex_instr_add_src(tex, nir_tex_src_texture_offset, deref_instr->arr.index);
	}
	}
	if (deref_src_type == nir_tex_src_sampler_deref)
	tex->sampler_index = value;
	else
	tex->texture_index = value;
	return value;
	}

	static void lower_vri_instr_tex(struct nir_builder *b,
	nir_tex_instr tex, void data_cb)
	{
	struct lvp_pipeline_layout *layout = data_cb;
	int tex_value = 0;

	lower_vri_instr_tex_deref(tex, nir_tex_src_sampler_deref, b->shader->info.stage, layout);
	tex_value = lower_vri_instr_tex_deref(tex, nir_tex_src_texture_deref, b->shader->info.stage, layout);
	if (tex_value >= 0)
	b->shader->info.textures_used \|= (1 << tex_value);
	}

	static nir_ssa_def lower_vri_instr(struct nir_builder b,
	nir_instr instr, void data_cb)
	{
	if (instr->type == nir_instr_type_intrinsic) {
	nir_intrinsic_instr *intrin = nir_instr_as_intrinsic(instr);
	switch (intrin->intrinsic) {
	case nir_intrinsic_vulkan_resource_index:
	return lower_vri_intrin_vri(b, instr, data_cb);

	case nir_intrinsic_vulkan_resource_reindex:
	return lower_vri_intrin_vrri(b, instr, data_cb);

	case nir_intrinsic_load_vulkan_descriptor:
	return lower_vri_intrin_lvd(b, instr, data_cb);

	case nir_intrinsic_get_ssbo_size: {
	/* The result of the load_vulkan_descriptor is a vec2(index, offset)
	* but we only want the index in get_ssbo_size.
	*/
	b->cursor = nir_before_instr(&intrin->instr);
	nir_ssa_def *index = nir_ssa_for_src(b, intrin->src[0], 1);
	nir_instr_rewrite_src(&intrin->instr, &intrin->src[0],
	nir_src_for_ssa(index));
	return NULL;
	}

	default:
	return NULL;
	}
	}
	if (instr->type == nir_instr_type_tex)
	lower_vri_instr_tex(b, nir_instr_as_tex(instr), data_cb);
	return NULL;
	}

	void lvp_lower_pipeline_layout(const struct lvp_device *device,
	struct lvp_pipeline_layout *layout,
	nir_shader *shader)
	{
	nir_shader_lower_instructions(shader, lower_vulkan_resource_index, lower_vri_instr, layout);
	nir_foreach_uniform_variable(var, shader) {
	const struct glsl_type *type = var->type;
	enum glsl_base_type base_type =
	glsl_get_base_type(glsl_without_array(type));
	unsigned desc_set_idx = var->data.descriptor_set;
	unsigned binding_idx = var->data.binding;
	struct lvp_descriptor_set_binding_layout *binding = &layout->set[desc_set_idx].layout->binding[binding_idx];
	int value = 0;
	var->data.descriptor_set = 0;
	if (base_type == GLSL_TYPE_SAMPLER) {
	if (binding->type == VK_DESCRIPTOR_TYPE_SAMPLER) {
	for (unsigned s = 0; s < desc_set_idx; s++)
	value += layout->set[s].layout->stage[shader->info.stage].sampler_count;
	value += binding->stage[shader->info.stage].sampler_index;
	} else {
	for (unsigned s = 0; s < desc_set_idx; s++)
	value += layout->set[s].layout->stage[shader->info.stage].sampler_view_count;
	value += binding->stage[shader->info.stage].sampler_view_index;
	}
	var->data.binding = value;
	}
	if (base_type == GLSL_TYPE_IMAGE) {
	var->data.descriptor_set = 0;
	for (unsigned s = 0; s < desc_set_idx; s++)
	value += layout->set[s].layout->stage[shader->info.stage].image_count;
	value += binding->stage[shader->info.stage].image_index;
	var->data.binding = value;
	}
	}
	}