mesa: Always query our compute params against IR_NIR.

We only emit NIR IR, so no sense having this code for querying TGSI
instead.

Reviewed-by: Alyssa Rosenzweig <alyssa@rosenzweig.io>
Acked-by: Marek Olšák <marek.olsak@amd.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/23114>

diff --git a/src/mesa/state_tracker/st_extensions.c b/src/mesa/state_tracker/st_extensions.c
index 359fc62..3d6d7ac 100644 (file)
--- a/src/mesa/state_tracker/st_extensions.c
+++ b/src/mesa/state_tracker/st_extensions.c
@@ -82,7 +82,6 @@ void st_init_limits(struct pipe_screen *screen,
                     struct gl_constants *c, struct gl_extensions *extensions,
                     gl_api api)
 {
-   int supported_irs;
    unsigned sh;
    bool can_ubo = true;
    int temp;
@@ -186,11 +185,6 @@ void st_init_limits(struct pipe_screen *screen,
       if (sh == PIPE_SHADER_COMPUTE) {
          if (!screen->get_param(screen, PIPE_CAP_COMPUTE))
             continue;
-         supported_irs =
-            screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_SUPPORTED_IRS);
-         if (!(supported_irs & ((1 << PIPE_SHADER_IR_TGSI) |
-                                (1 << PIPE_SHADER_IR_NIR))))
-            continue;
       }
 
       pc->MaxTextureImageUnits =
@@ -1626,63 +1620,54 @@ void st_init_extensions(struct pipe_screen *screen,
       extensions->GREMEDY_string_marker = GL_TRUE;
 
    if (screen->get_param(screen, PIPE_CAP_COMPUTE)) {
-      int compute_supported_irs =
-         screen->get_shader_param(screen, PIPE_SHADER_COMPUTE,
-                                  PIPE_SHADER_CAP_SUPPORTED_IRS);
-      if (compute_supported_irs & ((1 << PIPE_SHADER_IR_TGSI) |
-                                   (1 << PIPE_SHADER_IR_NIR))) {
-         enum pipe_shader_ir ir =
-            (compute_supported_irs & PIPE_SHADER_IR_NIR) ?
-            PIPE_SHADER_IR_NIR : PIPE_SHADER_IR_TGSI;
-         uint64_t grid_size[3], block_size[3];
-         uint64_t max_local_size, max_threads_per_block;
-
-         screen->get_compute_param(screen, ir,
-                                   PIPE_COMPUTE_CAP_MAX_GRID_SIZE, grid_size);
-         screen->get_compute_param(screen, ir,
-                                   PIPE_COMPUTE_CAP_MAX_BLOCK_SIZE, block_size);
-         screen->get_compute_param(screen, ir,
-                                   PIPE_COMPUTE_CAP_MAX_THREADS_PER_BLOCK,
-                                   &max_threads_per_block);
-         screen->get_compute_param(screen, ir,
-                                   PIPE_COMPUTE_CAP_MAX_LOCAL_SIZE,
-                                   &max_local_size);
-
-         consts->MaxComputeWorkGroupInvocations = max_threads_per_block;
-         consts->MaxComputeSharedMemorySize = max_local_size;
+      uint64_t grid_size[3], block_size[3];
+      uint64_t max_local_size, max_threads_per_block;
+
+      screen->get_compute_param(screen, PIPE_SHADER_IR_NIR,
+                                 PIPE_COMPUTE_CAP_MAX_GRID_SIZE, grid_size);
+      screen->get_compute_param(screen, PIPE_SHADER_IR_NIR,
+                                 PIPE_COMPUTE_CAP_MAX_BLOCK_SIZE, block_size);
+      screen->get_compute_param(screen, PIPE_SHADER_IR_NIR,
+                                 PIPE_COMPUTE_CAP_MAX_THREADS_PER_BLOCK,
+                                 &max_threads_per_block);
+      screen->get_compute_param(screen, PIPE_SHADER_IR_NIR,
+                                 PIPE_COMPUTE_CAP_MAX_LOCAL_SIZE,
+                                 &max_local_size);
+
+      consts->MaxComputeWorkGroupInvocations = max_threads_per_block;
+      consts->MaxComputeSharedMemorySize = max_local_size;
+
+      for (i = 0; i < 3; i++) {
+         /* There are tests that fail if we report more that INT_MAX - 1. */
+         consts->MaxComputeWorkGroupCount[i] = MIN2(grid_size[i], INT_MAX - 1);
+         consts->MaxComputeWorkGroupSize[i] = block_size[i];
+      }
 
-         for (i = 0; i < 3; i++) {
-            /* There are tests that fail if we report more that INT_MAX - 1. */
-            consts->MaxComputeWorkGroupCount[i] = MIN2(grid_size[i], INT_MAX - 1);
-            consts->MaxComputeWorkGroupSize[i] = block_size[i];
-         }
+      extensions->ARB_compute_shader =
+         max_threads_per_block >= 1024 &&
+         extensions->ARB_shader_image_load_store &&
+         extensions->ARB_shader_atomic_counters;
 
-         extensions->ARB_compute_shader =
-            max_threads_per_block >= 1024 &&
-            extensions->ARB_shader_image_load_store &&
-            extensions->ARB_shader_atomic_counters;
-
-         if (extensions->ARB_compute_shader) {
-            uint64_t max_variable_threads_per_block = 0;
-
-            screen->get_compute_param(screen, ir,
-                                      PIPE_COMPUTE_CAP_MAX_VARIABLE_THREADS_PER_BLOCK,
-                                      &max_variable_threads_per_block);
-
-            for (i = 0; i < 3; i++) {
-               /* Clamp the values to avoid having a local work group size
-                * greater than the maximum number of invocations.
-                */
-               consts->MaxComputeVariableGroupSize[i] =
-                  MIN2(consts->MaxComputeWorkGroupSize[i],
-                       max_variable_threads_per_block);
-            }
-            consts->MaxComputeVariableGroupInvocations =
-               max_variable_threads_per_block;
+      if (extensions->ARB_compute_shader) {
+         uint64_t max_variable_threads_per_block = 0;
+
+         screen->get_compute_param(screen, PIPE_SHADER_IR_NIR,
+                                    PIPE_COMPUTE_CAP_MAX_VARIABLE_THREADS_PER_BLOCK,
+                                    &max_variable_threads_per_block);
 
-            extensions->ARB_compute_variable_group_size =
-               max_variable_threads_per_block > 0;
+         for (i = 0; i < 3; i++) {
+            /* Clamp the values to avoid having a local work group size
+               * greater than the maximum number of invocations.
+               */
+            consts->MaxComputeVariableGroupSize[i] =
+               MIN2(consts->MaxComputeWorkGroupSize[i],
+                     max_variable_threads_per_block);
          }
+         consts->MaxComputeVariableGroupInvocations =
+            max_variable_threads_per_block;
+
+         extensions->ARB_compute_variable_group_size =
+            max_variable_threads_per_block > 0;
       }
    }