* USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
+#include "zink_context.h"
#include "zink_compiler.h"
+#include "zink_program.h"
#include "zink_screen.h"
#include "nir_to_spirv/nir_to_spirv.h"
#include "util/u_memory.h"
static bool
-lower_instr(nir_intrinsic_instr *instr, nir_builder *b)
+lower_discard_if_instr(nir_intrinsic_instr *instr, nir_builder *b)
{
- b->cursor = nir_before_instr(&instr->instr);
-
- if (instr->intrinsic == nir_intrinsic_load_ubo) {
- nir_ssa_def *old_idx = nir_ssa_for_src(b, instr->src[0], 1);
- nir_ssa_def *new_idx = nir_iadd(b, old_idx, nir_imm_int(b, 1));
- nir_instr_rewrite_src(&instr->instr, &instr->src[0],
- nir_src_for_ssa(new_idx));
+ if (instr->intrinsic == nir_intrinsic_discard_if) {
+ b->cursor = nir_before_instr(&instr->instr);
+
+ nir_if *if_stmt = nir_push_if(b, nir_ssa_for_src(b, instr->src[0], 1));
+ nir_intrinsic_instr *discard =
+ nir_intrinsic_instr_create(b->shader, nir_intrinsic_discard);
+ nir_builder_instr_insert(b, &discard->instr);
+ nir_pop_if(b, if_stmt);
+ nir_instr_remove(&instr->instr);
return true;
}
+ /* a shader like this (shaders@glsl-fs-discard-04):
+
+ uniform int j, k;
+
+ void main()
+ {
+ for (int i = 0; i < j; i++) {
+ if (i > k)
+ continue;
+ discard;
+ }
+ gl_FragColor = vec4(0.0, 1.0, 0.0, 0.0);
+ }
- if (instr->intrinsic == nir_intrinsic_load_uniform) {
- nir_ssa_def *ubo_idx = nir_imm_int(b, 0);
- nir_ssa_def *ubo_offset =
- nir_iadd(b, nir_imm_int(b, nir_intrinsic_base(instr)),
- nir_ssa_for_src(b, instr->src[0], 1));
-
- nir_intrinsic_instr *load =
- nir_intrinsic_instr_create(b->shader, nir_intrinsic_load_ubo);
- load->num_components = instr->num_components;
- load->src[0] = nir_src_for_ssa(ubo_idx);
- load->src[1] = nir_src_for_ssa(ubo_offset);
- nir_ssa_dest_init(&load->instr, &load->dest,
- load->num_components, instr->dest.ssa.bit_size,
- instr->dest.ssa.name);
- nir_builder_instr_insert(b, &load->instr);
- nir_ssa_def_rewrite_uses(&instr->dest.ssa, nir_src_for_ssa(&load->dest.ssa));
- nir_instr_remove(&instr->instr);
- return true;
- }
+
+ will generate nir like:
+
+ loop {
+ //snip
+ if ssa_11 {
+ block block_5:
+ / preds: block_4 /
+ vec1 32 ssa_17 = iadd ssa_50, ssa_31
+ / succs: block_7 /
+ } else {
+ block block_6:
+ / preds: block_4 /
+ intrinsic discard () () <-- not last instruction
+ vec1 32 ssa_23 = iadd ssa_50, ssa_31 <-- dead code loop itr increment
+ / succs: block_7 /
+ }
+ //snip
+ }
+
+ which means that we can't assert like this:
+
+ assert(instr->intrinsic != nir_intrinsic_discard ||
+ nir_block_last_instr(instr->instr.block) == &instr->instr);
+
+
+ and it's unnecessary anyway since post-vtn optimizing will dce the instructions following the discard
+ */
return false;
}
static bool
-lower_uniforms_to_ubo(nir_shader *shader)
+lower_discard_if(nir_shader *shader)
{
bool progress = false;
nir_foreach_block(block, function->impl) {
nir_foreach_instr_safe(instr, block) {
if (instr->type == nir_instr_type_intrinsic)
- progress |= lower_instr(nir_instr_as_intrinsic(instr),
- &builder);
+ progress |= lower_discard_if_instr(
+ nir_instr_as_intrinsic(instr),
+ &builder);
}
}
- nir_metadata_preserve(function->impl, nir_metadata_block_index |
- nir_metadata_dominance);
+ nir_metadata_preserve(function->impl, nir_metadata_dominance);
}
}
- if (progress) {
- assert(shader->num_uniforms > 0);
- const struct glsl_type *type = glsl_array_type(glsl_vec4_type(),
- shader->num_uniforms, 0);
- nir_variable *ubo = nir_variable_create(shader, nir_var_mem_ubo, type,
- "uniform_0");
- ubo->data.binding = 0;
-
- struct glsl_struct_field field = {
- .type = type,
- .name = "data",
- .location = -1,
- };
- ubo->interface_type =
- glsl_interface_type(&field, 1, GLSL_INTERFACE_PACKING_STD430,
- false, "__ubo0_interface");
- }
-
return progress;
}
-static void
-lower_store_output(nir_builder *b,
- struct nir_instr *instr)
-{
- if (instr->type != nir_instr_type_intrinsic)
- return;
-
- nir_intrinsic_instr *intr = nir_instr_as_intrinsic(instr);
- if (intr->intrinsic != nir_intrinsic_store_output)
- return;
-
- if (nir_intrinsic_base(intr) != VARYING_SLOT_POS)
- return;
-
- b->cursor = nir_before_instr(&intr->instr);
-
- nir_ssa_def *src = nir_ssa_for_src(b, intr->src[0], 4);
- nir_ssa_def *def = nir_vec4(b,
- nir_channel(b, src, 0),
- nir_channel(b, src, 1),
- nir_fmul(b,
- nir_fadd(b,
- nir_channel(b, src, 2),
- nir_channel(b, src, 3)),
- nir_imm_float(b, 0.5)),
- nir_channel(b, src, 3));
- nir_instr_rewrite_src(&intr->instr, &intr->src[0], nir_src_for_ssa(def));
-}
-
-static void
-position_to_vulkan(nir_shader *s)
-{
- if (s->info.stage != MESA_SHADER_VERTEX)
- return;
-
- nir_foreach_function(function, s) {
- if (function->impl) {
- nir_builder b;
- nir_builder_init(&b, function->impl);
-
- nir_foreach_block(block, function->impl) {
- nir_foreach_instr_safe(instr, block)
- lower_store_output(&b, instr);
- }
-
- nir_metadata_preserve(function->impl, nir_metadata_block_index |
- nir_metadata_dominance);
- }
- }
-}
-
static const struct nir_shader_compiler_options nir_options = {
.lower_all_io_to_temps = true,
.lower_ffma = true,
+ .lower_fdph = true,
.lower_flrp32 = true,
.lower_fpow = true,
.lower_fsat = true,
+ .lower_extract_byte = true,
+ .lower_extract_word = true,
+ .lower_mul_high = true,
+ .lower_rotate = true,
+ .lower_uadd_carry = true,
};
const void *
fprintf(stderr, "---8<---\n\n");
}
- return tgsi_to_nir(tokens, screen);
+ return tgsi_to_nir(tokens, screen, false);
}
static void
NIR_PASS(progress, s, nir_opt_algebraic);
NIR_PASS(progress, s, nir_opt_constant_folding);
NIR_PASS(progress, s, nir_opt_undef);
+ NIR_PASS(progress, s, zink_nir_lower_b2b);
} while (progress);
}
-static int
-glsl_type_size(const struct glsl_type *type, bool bindless)
+/* check for a genuine gl_PointSize output vs one from nir_lower_point_size_mov */
+static bool
+check_psiz(struct nir_shader *s)
+{
+ nir_foreach_shader_out_variable(var, s) {
+ if (var->data.location == VARYING_SLOT_PSIZ) {
+ /* genuine PSIZ outputs will have this set */
+ return !!var->data.explicit_location;
+ }
+ }
+ return false;
+}
+
+/* semi-copied from iris */
+static void
+update_so_info(struct zink_shader *sh,
+ uint64_t outputs_written, bool have_psiz)
{
- return glsl_count_attribute_slots(type, false);
+ uint8_t reverse_map[64] = {};
+ unsigned slot = 0;
+ while (outputs_written) {
+ int bit = u_bit_scan64(&outputs_written);
+ /* PSIZ from nir_lower_point_size_mov breaks stream output, so always skip it */
+ if (bit == VARYING_SLOT_PSIZ && !have_psiz)
+ continue;
+ reverse_map[slot++] = bit;
+ }
+
+ for (unsigned i = 0; i < sh->streamout.so_info.num_outputs; i++) {
+ struct pipe_stream_output *output = &sh->streamout.so_info.output[i];
+ /* Map Gallium's condensed "slots" back to real VARYING_SLOT_* enums */
+ sh->streamout.so_info_slots[i] = reverse_map[output->register_index];
+ }
}
-static uint32_t
-zink_binding(enum pipe_shader_type stage, VkDescriptorType type, int index)
+VkShaderModule
+zink_shader_compile(struct zink_screen *screen, struct zink_shader *zs)
{
- if (stage == PIPE_SHADER_COMPUTE) {
- unreachable("not supported");
- } else {
- uint32_t stage_offset = (uint32_t)stage * (PIPE_MAX_CONSTANT_BUFFERS +
- PIPE_MAX_SHADER_SAMPLER_VIEWS);
-
- switch (type) {
- case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
- assert(index < PIPE_MAX_CONSTANT_BUFFERS);
- return stage_offset + index;
-
- case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
- assert(index < PIPE_MAX_SHADER_SAMPLER_VIEWS);
- return stage_offset + PIPE_MAX_CONSTANT_BUFFERS + index;
-
- default:
- unreachable("unexpected type");
+ VkShaderModule mod = VK_NULL_HANDLE;
+ void *streamout = zs->streamout.so_info_slots ? &zs->streamout : NULL;
+ struct spirv_shader *spirv = nir_to_spirv(zs->nir, streamout);
+ assert(spirv);
+
+ if (zink_debug & ZINK_DEBUG_SPIRV) {
+ char buf[256];
+ static int i;
+ snprintf(buf, sizeof(buf), "dump%02d.spv", i++);
+ FILE *fp = fopen(buf, "wb");
+ if (fp) {
+ fwrite(spirv->words, sizeof(uint32_t), spirv->num_words, fp);
+ fclose(fp);
+ fprintf(stderr, "wrote '%s'...\n", buf);
}
}
+
+ VkShaderModuleCreateInfo smci = {};
+ smci.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
+ smci.codeSize = spirv->num_words * sizeof(uint32_t);
+ smci.pCode = spirv->words;
+
+ if (vkCreateShaderModule(screen->dev, &smci, NULL, &mod) != VK_SUCCESS)
+ mod = VK_NULL_HANDLE;
+
+ /* TODO: determine if there's any reason to cache spirv output? */
+ free(spirv->words);
+ free(spirv);
+ return mod;
}
struct zink_shader *
-zink_compile_nir(struct zink_screen *screen, struct nir_shader *nir)
+zink_shader_create(struct zink_screen *screen, struct nir_shader *nir,
+ const struct pipe_stream_output_info *so_info)
{
struct zink_shader *ret = CALLOC_STRUCT(zink_shader);
+ bool have_psiz = false;
- NIR_PASS_V(nir, nir_lower_io, nir_var_all, glsl_type_size, (nir_lower_io_options)0);
- NIR_PASS_V(nir, lower_uniforms_to_ubo);
- NIR_PASS_V(nir, position_to_vulkan);
+ ret->programs = _mesa_pointer_set_create(NULL);
+
+ NIR_PASS_V(nir, nir_lower_uniforms_to_ubo, 1);
+ NIR_PASS_V(nir, nir_lower_clip_halfz);
+ if (nir->info.stage == MESA_SHADER_VERTEX)
+ have_psiz = check_psiz(nir);
NIR_PASS_V(nir, nir_lower_regs_to_ssa);
- NIR_PASS_V(nir, nir_lower_bool_to_float);
optimize_nir(nir);
- NIR_PASS_V(nir, nir_remove_dead_variables, nir_var_function_temp);
+ NIR_PASS_V(nir, nir_remove_dead_variables, nir_var_function_temp, NULL);
+ NIR_PASS_V(nir, lower_discard_if);
+ NIR_PASS_V(nir, nir_lower_fragcolor);
+ NIR_PASS_V(nir, nir_convert_from_ssa, true);
if (zink_debug & ZINK_DEBUG_NIR) {
fprintf(stderr, "NIR shader:\n---8<---\n");
fprintf(stderr, "---8<---\n");
}
- enum pipe_shader_type stage = pipe_shader_type_from_mesa(nir->info.stage);
-
ret->num_bindings = 0;
- nir_foreach_variable(var, &nir->uniforms) {
- if (glsl_type_is_sampler(var->type)) {
- ret->bindings[ret->num_bindings].index = var->data.driver_location;
- var->data.binding = zink_binding(stage, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, var->data.driver_location);
- ret->bindings[ret->num_bindings].binding = var->data.binding;
- ret->bindings[ret->num_bindings].type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
- ret->num_bindings++;
- } else if (var->interface_type) {
+ nir_foreach_variable_with_modes(var, nir, nir_var_uniform |
+ nir_var_mem_ubo) {
+ if (var->data.mode == nir_var_mem_ubo) {
+ int binding = zink_binding(nir->info.stage,
+ VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
+ var->data.binding);
ret->bindings[ret->num_bindings].index = var->data.binding;
- var->data.binding = zink_binding(stage, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, var->data.binding);
- ret->bindings[ret->num_bindings].binding = var->data.binding;
+ ret->bindings[ret->num_bindings].binding = binding;
ret->bindings[ret->num_bindings].type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
ret->num_bindings++;
+ } else {
+ assert(var->data.mode == nir_var_uniform);
+ if (glsl_type_is_array(var->type) &&
+ glsl_type_is_sampler(glsl_get_array_element(var->type))) {
+ for (int i = 0; i < glsl_get_length(var->type); ++i) {
+ int binding = zink_binding(nir->info.stage,
+ VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
+ var->data.binding + i);
+ ret->bindings[ret->num_bindings].index = var->data.binding + i;
+ ret->bindings[ret->num_bindings].binding = binding;
+ ret->bindings[ret->num_bindings].type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
+ ret->num_bindings++;
+ }
+ } else if (glsl_type_is_sampler(var->type)) {
+ int binding = zink_binding(nir->info.stage,
+ VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
+ var->data.binding);
+ ret->bindings[ret->num_bindings].index = var->data.binding;
+ ret->bindings[ret->num_bindings].binding = binding;
+ ret->bindings[ret->num_bindings].type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
+ ret->num_bindings++;
+ }
}
}
- struct spirv_shader *spirv = nir_to_spirv(nir);
- assert(spirv);
-
- if (zink_debug & ZINK_DEBUG_SPIRV) {
- char buf[256];
- static int i;
- snprintf(buf, sizeof(buf), "dump%02d.spv", i++);
- FILE *fp = fopen(buf, "wb");
- fwrite(spirv->words, sizeof(uint32_t), spirv->num_words, fp);
- fclose(fp);
- fprintf(stderr, "wrote '%s'...\n", buf);
+ ret->nir = nir;
+ if (so_info) {
+ memcpy(&ret->streamout.so_info, so_info, sizeof(struct pipe_stream_output_info));
+ ret->streamout.so_info_slots = malloc(so_info->num_outputs * sizeof(unsigned int));
+ assert(ret->streamout.so_info_slots);
+ update_so_info(ret, nir->info.outputs_written, have_psiz);
}
- VkShaderModuleCreateInfo smci = {};
- smci.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
- smci.codeSize = spirv->num_words * sizeof(uint32_t);
- smci.pCode = spirv->words;
-
- if (vkCreateShaderModule(screen->dev, &smci, NULL, &ret->shader_module) != VK_SUCCESS)
- return NULL;
-
return ret;
}
void
-zink_shader_free(struct zink_screen *screen, struct zink_shader *shader)
+zink_shader_free(struct zink_context *ctx, struct zink_shader *shader)
{
- vkDestroyShaderModule(screen->dev, shader->shader_module, NULL);
+ struct zink_screen *screen = zink_screen(ctx->base.screen);
+ set_foreach(shader->programs, entry) {
+ struct zink_gfx_program *prog = (void*)entry->key;
+ _mesa_hash_table_remove_key(ctx->program_cache, prog->shaders);
+ prog->shaders[pipe_shader_type_from_mesa(shader->nir->info.stage)] = NULL;
+ zink_gfx_program_reference(screen, &prog, NULL);
+ }
+ _mesa_set_destroy(shader->programs, NULL);
+ free(shader->streamout.so_info_slots);
+ ralloc_free(shader->nir);
FREE(shader);
}
projects / mesa.git / blobdiff