zink: Check fopen result.
[mesa.git] / src / gallium / drivers / zink / zink_compiler.c
index a1428785bd47e421d3e295e3b0732c6c4e63797e..98ef706fb8fdd0ccc3ef60cec8b438495168834b 100644 (file)
 
 #include "util/u_memory.h"
 
-static bool
-lower_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));
-      return true;
-   }
-
-   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;
-   }
-
-   return false;
-}
-
-static bool
-lower_uniforms_to_ubo(nir_shader *shader)
-{
-   bool progress = false;
-
-   nir_foreach_function(function, shader) {
-      if (function->impl) {
-         nir_builder builder;
-         nir_builder_init(&builder, function->impl);
-         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);
-            }
-         }
-
-         nir_metadata_preserve(function->impl, nir_metadata_block_index |
-                                               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 bool
 lower_discard_if_instr(nir_intrinsic_instr *instr, nir_builder *b)
 {
@@ -164,6 +84,7 @@ lower_discard_if(nir_shader *shader)
 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,
@@ -187,7 +108,7 @@ zink_tgsi_to_nir(struct pipe_screen *screen, const struct tgsi_token *tokens)
       fprintf(stderr, "---8<---\n\n");
    }
 
-   return tgsi_to_nir(tokens, screen);
+   return tgsi_to_nir(tokens, screen, false);
 }
 
 static void
@@ -206,39 +127,16 @@ optimize_nir(struct nir_shader *s)
       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 uint32_t
-zink_binding(enum pipe_shader_type stage, VkDescriptorType type, int index)
-{
-   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");
-      }
-   }
-}
-
 struct zink_shader *
 zink_compile_nir(struct zink_screen *screen, struct nir_shader *nir)
 {
    struct zink_shader *ret = CALLOC_STRUCT(zink_shader);
 
-   NIR_PASS_V(nir, lower_uniforms_to_ubo);
+   NIR_PASS_V(nir, nir_lower_uniforms_to_ubo, 1);
    NIR_PASS_V(nir, nir_lower_clip_halfz);
    NIR_PASS_V(nir, nir_lower_regs_to_ssa);
    optimize_nir(nir);
@@ -252,14 +150,14 @@ zink_compile_nir(struct zink_screen *screen, struct nir_shader *nir)
       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 (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 {
@@ -267,16 +165,20 @@ zink_compile_nir(struct zink_screen *screen, struct nir_shader *nir)
          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) {
-               ret->bindings[ret->num_bindings].index = var->data.driver_location + i;
-               var->data.binding = zink_binding(stage, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, var->data.driver_location + i);
-               ret->bindings[ret->num_bindings].binding = var->data.binding;
+               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)) {
-            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;
+            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++;
          }
@@ -293,9 +195,11 @@ zink_compile_nir(struct zink_screen *screen, struct nir_shader *nir)
       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);
+      if (fp) {
+         fwrite(spirv->words, sizeof(uint32_t), spirv->num_words, fp);
+         fclose(fp);
+         fprintf(stderr, "wrote '%s'...\n", buf);
+      }
    }
 
    VkShaderModuleCreateInfo smci = {};