draw: refactor resources to use arrays instead of explicit structs.

This should simplify the code and make it easier to refactor later.

Reviewed-by: Roland Scheidegger <sroland@vmware.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/23487>

diff --git a/src/gallium/auxiliary/draw/draw_context.c b/src/gallium/auxiliary/draw/draw_context.c
index 7d848f1..1745a4e 100644 (file)
--- a/src/gallium/auxiliary/draw/draw_context.c
+++ b/src/gallium/auxiliary/draw/draw_context.c
@@ -461,26 +461,8 @@ draw_set_mapped_constant_buffer(struct draw_context *draw,
 
    draw_do_flush(draw, DRAW_FLUSH_PARAMETER_CHANGE);
 
-   switch (shader_type) {
-   case PIPE_SHADER_VERTEX:
-      draw->pt.user.vs_constants[slot].ptr = buffer;
-      draw->pt.user.vs_constants[slot].size = size;
-      break;
-   case PIPE_SHADER_GEOMETRY:
-      draw->pt.user.gs_constants[slot].ptr = buffer;
-      draw->pt.user.gs_constants[slot].size = size;
-      break;
-   case PIPE_SHADER_TESS_CTRL:
-      draw->pt.user.tcs_constants[slot].ptr = buffer;
-      draw->pt.user.tcs_constants[slot].size = size;
-      break;
-   case PIPE_SHADER_TESS_EVAL:
-      draw->pt.user.tes_constants[slot].ptr = buffer;
-      draw->pt.user.tes_constants[slot].size = size;
-      break;
-   default:
-      assert(0 && "invalid shader type in draw_set_mapped_constant_buffer");
-   }
+   draw->pt.user.constants[shader_type][slot].ptr = buffer;
+   draw->pt.user.constants[shader_type][slot].size = size;
 }
 
 void
@@ -498,26 +480,8 @@ draw_set_mapped_shader_buffer(struct draw_context *draw,
 
    draw_do_flush(draw, DRAW_FLUSH_PARAMETER_CHANGE);
 
-   switch (shader_type) {
-   case PIPE_SHADER_VERTEX:
-      draw->pt.user.vs_ssbos[slot].ptr = buffer;
-      draw->pt.user.vs_ssbos[slot].size = size;
-      break;
-   case PIPE_SHADER_GEOMETRY:
-      draw->pt.user.gs_ssbos[slot].ptr = buffer;
-      draw->pt.user.gs_ssbos[slot].size = size;
-      break;
-   case PIPE_SHADER_TESS_CTRL:
-      draw->pt.user.tcs_ssbos[slot].ptr = buffer;
-      draw->pt.user.tcs_ssbos[slot].size = size;
-      break;
-   case PIPE_SHADER_TESS_EVAL:
-      draw->pt.user.tes_ssbos[slot].ptr = buffer;
-      draw->pt.user.tes_ssbos[slot].size = size;
-      break;
-   default:
-      assert(0 && "invalid shader type in draw_set_mapped_shader_buffer");
-   }
+   draw->pt.user.ssbos[shader_type][slot].ptr = buffer;
+   draw->pt.user.ssbos[shader_type][slot].size = size;
 }
 
 

diff --git a/src/gallium/auxiliary/draw/draw_gs.c b/src/gallium/auxiliary/draw/draw_gs.c
index 0e376fc..baa09ec 100644 (file)
--- a/src/gallium/auxiliary/draw/draw_gs.c
+++ b/src/gallium/auxiliary/draw/draw_gs.c
@@ -903,7 +903,7 @@ draw_create_geometry_shader(struct draw_context *draw,
       gs->run = llvm_gs_run;
 
       gs->jit_context = &draw->llvm->gs_jit_context;
-      gs->jit_resources = &draw->llvm->gs_jit_resources;
+      gs->jit_resources = &draw->llvm->jit_resources[PIPE_SHADER_GEOMETRY];
 
       llvm_gs->variant_key_size =
          draw_gs_llvm_variant_key_size(

diff --git a/src/gallium/auxiliary/draw/draw_llvm.c b/src/gallium/auxiliary/draw/draw_llvm.c
index ef5e8f4..6867f5a 100644 (file)
--- a/src/gallium/auxiliary/draw/draw_llvm.c
+++ b/src/gallium/auxiliary/draw/draw_llvm.c
@@ -2156,28 +2156,11 @@ draw_llvm_set_mapped_texture(struct draw_context *draw,
 {
    struct lp_jit_texture *jit_tex;
 
-   switch (shader_stage) {
-   case PIPE_SHADER_VERTEX:
-      assert(sview_idx < ARRAY_SIZE(draw->llvm->vs_jit_resources.textures));
-      jit_tex = &draw->llvm->vs_jit_resources.textures[sview_idx];
-      break;
-   case PIPE_SHADER_GEOMETRY:
-      assert(sview_idx < ARRAY_SIZE(draw->llvm->gs_jit_resources.textures));
-      jit_tex = &draw->llvm->gs_jit_resources.textures[sview_idx];
-      break;
-   case PIPE_SHADER_TESS_CTRL:
-      assert(sview_idx < ARRAY_SIZE(draw->llvm->tcs_jit_resources.textures));
-      jit_tex = &draw->llvm->tcs_jit_resources.textures[sview_idx];
-      break;
-   case PIPE_SHADER_TESS_EVAL:
-      assert(sview_idx < ARRAY_SIZE(draw->llvm->tes_jit_resources.textures));
-      jit_tex = &draw->llvm->tes_jit_resources.textures[sview_idx];
-      break;
-   default:
-      assert(0);
-      return;
-   }
+   assert (shader_stage >= PIPE_SHADER_VERTEX &&
+           shader_stage <= PIPE_SHADER_GEOMETRY);
+   assert(sview_idx < ARRAY_SIZE(draw->llvm->jit_resources[shader_stage].textures));
 
+   jit_tex = &draw->llvm->jit_resources[shader_stage].textures[sview_idx];
    jit_tex->width = width;
    jit_tex->height = height;
    jit_tex->depth = depth;
@@ -2208,27 +2191,11 @@ draw_llvm_set_mapped_image(struct draw_context *draw,
 {
    struct lp_jit_image *jit_image;
 
-   switch (shader_stage) {
-   case PIPE_SHADER_VERTEX:
-      assert(idx < ARRAY_SIZE(draw->llvm->vs_jit_resources.images));
-      jit_image = &draw->llvm->vs_jit_resources.images[idx];
-      break;
-   case PIPE_SHADER_GEOMETRY:
-      assert(idx < ARRAY_SIZE(draw->llvm->gs_jit_resources.images));
-      jit_image = &draw->llvm->gs_jit_resources.images[idx];
-      break;
-   case PIPE_SHADER_TESS_CTRL:
-      assert(idx < ARRAY_SIZE(draw->llvm->tcs_jit_resources.images));
-      jit_image = &draw->llvm->tcs_jit_resources.images[idx];
-      break;
-   case PIPE_SHADER_TESS_EVAL:
-      assert(idx < ARRAY_SIZE(draw->llvm->tes_jit_resources.images));
-      jit_image = &draw->llvm->tes_jit_resources.images[idx];
-      break;
-   default:
-      assert(0);
-      return;
-   }
+   assert (shader_stage >= PIPE_SHADER_VERTEX &&
+           shader_stage <= PIPE_SHADER_GEOMETRY);
+   assert(idx < ARRAY_SIZE(draw->llvm->jit_resources[shader_stage].images));
+
+   jit_image = &draw->llvm->jit_resources[shader_stage].images[idx];
 
    jit_image->width = width;
    jit_image->height = height;
@@ -2246,70 +2213,20 @@ void
 draw_llvm_set_sampler_state(struct draw_context *draw,
                             enum pipe_shader_type shader_type)
 {
-   switch (shader_type) {
-   case PIPE_SHADER_VERTEX:
-      for (unsigned i = 0; i < draw->num_samplers[PIPE_SHADER_VERTEX]; i++) {
-         struct lp_jit_sampler *jit_sam = &draw->llvm->vs_jit_resources.samplers[i];
-
-         if (draw->samplers[PIPE_SHADER_VERTEX][i]) {
-            const struct pipe_sampler_state *s
-               = draw->samplers[PIPE_SHADER_VERTEX][i];
-            jit_sam->min_lod = s->min_lod;
-            jit_sam->max_lod = s->max_lod;
-            jit_sam->lod_bias = s->lod_bias;
-            jit_sam->max_aniso = s->max_anisotropy;
-            COPY_4V(jit_sam->border_color, s->border_color.f);
-         }
-      }
-      break;
-   case PIPE_SHADER_GEOMETRY:
-      for (unsigned i = 0; i < draw->num_samplers[PIPE_SHADER_GEOMETRY]; i++) {
-         struct lp_jit_sampler *jit_sam = &draw->llvm->gs_jit_resources.samplers[i];
-
-         if (draw->samplers[PIPE_SHADER_GEOMETRY][i]) {
-            const struct pipe_sampler_state *s
-               = draw->samplers[PIPE_SHADER_GEOMETRY][i];
-            jit_sam->min_lod = s->min_lod;
-            jit_sam->max_lod = s->max_lod;
-            jit_sam->lod_bias = s->lod_bias;
-            jit_sam->max_aniso = s->max_anisotropy;
-            COPY_4V(jit_sam->border_color, s->border_color.f);
-         }
-      }
-      break;
-   case PIPE_SHADER_TESS_CTRL:
-      for (unsigned i = 0; i < draw->num_samplers[PIPE_SHADER_TESS_CTRL]; i++) {
-         struct lp_jit_sampler *jit_sam = &draw->llvm->tcs_jit_resources.samplers[i];
-
-         if (draw->samplers[PIPE_SHADER_TESS_CTRL][i]) {
-            const struct pipe_sampler_state *s
-               = draw->samplers[PIPE_SHADER_TESS_CTRL][i];
-            jit_sam->min_lod = s->min_lod;
-            jit_sam->max_lod = s->max_lod;
-            jit_sam->lod_bias = s->lod_bias;
-            jit_sam->max_aniso = s->max_anisotropy;
-            COPY_4V(jit_sam->border_color, s->border_color.f);
-         }
-      }
-      break;
-   case PIPE_SHADER_TESS_EVAL:
-      for (unsigned i = 0; i < draw->num_samplers[PIPE_SHADER_TESS_EVAL]; i++) {
-         struct lp_jit_sampler *jit_sam = &draw->llvm->tes_jit_resources.samplers[i];
-
-         if (draw->samplers[PIPE_SHADER_TESS_EVAL][i]) {
-            const struct pipe_sampler_state *s
-               = draw->samplers[PIPE_SHADER_TESS_EVAL][i];
-            jit_sam->min_lod = s->min_lod;
-            jit_sam->max_lod = s->max_lod;
-            jit_sam->lod_bias = s->lod_bias;
-            jit_sam->max_aniso = s->max_anisotropy;
-            COPY_4V(jit_sam->border_color, s->border_color.f);
-         }
+   assert (shader_type >= PIPE_SHADER_VERTEX &&
+           shader_type <= PIPE_SHADER_GEOMETRY);
+   for (unsigned i = 0; i < draw->num_samplers[shader_type]; i++) {
+      struct lp_jit_sampler *jit_sam = &draw->llvm->jit_resources[shader_type].samplers[i];
+
+      if (draw->samplers[shader_type][i]) {
+         const struct pipe_sampler_state *s
+            = draw->samplers[shader_type][i];
+         jit_sam->min_lod = s->min_lod;
+         jit_sam->max_lod = s->max_lod;
+         jit_sam->lod_bias = s->lod_bias;
+         jit_sam->max_aniso = s->max_anisotropy;
+         COPY_4V(jit_sam->border_color, s->border_color.f);
       }
-      break;
-   default:
-      assert(0);
-      break;
    }
 }
 

diff --git a/src/gallium/auxiliary/draw/draw_llvm.h b/src/gallium/auxiliary/draw/draw_llvm.h
index d10debc..2d4a32b 100644 (file)
--- a/src/gallium/auxiliary/draw/draw_llvm.h
+++ b/src/gallium/auxiliary/draw/draw_llvm.h
@@ -547,10 +547,7 @@ struct draw_llvm {
    struct draw_vs_jit_context vs_jit_context;
    struct draw_gs_jit_context gs_jit_context;
 
-   struct lp_jit_resources vs_jit_resources;
-   struct lp_jit_resources gs_jit_resources;
-   struct lp_jit_resources tcs_jit_resources;
-   struct lp_jit_resources tes_jit_resources;
+   struct lp_jit_resources jit_resources[PIPE_SHADER_GEOMETRY + 1];
 
    struct draw_llvm_variant_list_item vs_variants_list;
    int nr_variants;

diff --git a/src/gallium/auxiliary/draw/draw_private.h b/src/gallium/auxiliary/draw/draw_private.h
index 7be0db0..b425604 100644 (file)
--- a/src/gallium/auxiliary/draw/draw_private.h
+++ b/src/gallium/auxiliary/draw/draw_private.h
@@ -222,15 +222,8 @@ struct draw_context
          struct draw_vertex_buffer vbuffer[PIPE_MAX_ATTRIBS];
 
          /** constant buffers for each shader stage */
-         struct draw_buffer_info vs_constants[PIPE_MAX_CONSTANT_BUFFERS];
-         struct draw_buffer_info gs_constants[PIPE_MAX_CONSTANT_BUFFERS];
-         struct draw_buffer_info tcs_constants[PIPE_MAX_CONSTANT_BUFFERS];
-         struct draw_buffer_info tes_constants[PIPE_MAX_CONSTANT_BUFFERS];
-
-         struct draw_buffer_info vs_ssbos[PIPE_MAX_SHADER_BUFFERS];
-         struct draw_buffer_info gs_ssbos[PIPE_MAX_SHADER_BUFFERS];
-         struct draw_buffer_info tcs_ssbos[PIPE_MAX_SHADER_BUFFERS];
-         struct draw_buffer_info tes_ssbos[PIPE_MAX_SHADER_BUFFERS];
+         struct draw_buffer_info constants[PIPE_SHADER_GEOMETRY + 1][PIPE_MAX_CONSTANT_BUFFERS];
+         struct draw_buffer_info ssbos[PIPE_SHADER_GEOMETRY + 1][PIPE_MAX_SHADER_BUFFERS];
 
          /* pointer to planes */
          float (*planes)[DRAW_TOTAL_CLIP_PLANES][4];

diff --git a/src/gallium/auxiliary/draw/draw_pt_fetch_shade_pipeline.c b/src/gallium/auxiliary/draw/draw_pt_fetch_shade_pipeline.c
index fdda41d..ffcbf6e 100644 (file)
--- a/src/gallium/auxiliary/draw/draw_pt_fetch_shade_pipeline.c
+++ b/src/gallium/auxiliary/draw/draw_pt_fetch_shade_pipeline.c
@@ -270,7 +270,7 @@ fetch_pipeline_generic(struct draw_pt_middle_end *middle,
     */
    if (fpme->opt & PT_SHADE) {
       draw_vertex_shader_run(vshader,
-                             draw->pt.user.vs_constants,
+                             draw->pt.user.constants[PIPE_SHADER_VERTEX],
                              fetch_info,
                              vert_info,
                              &vs_vert_info);
@@ -285,7 +285,7 @@ fetch_pipeline_generic(struct draw_pt_middle_end *middle,
 
    if ((fpme->opt & PT_SHADE) && gshader) {
       draw_geometry_shader_run(gshader,
-                               draw->pt.user.gs_constants,
+                               draw->pt.user.constants[PIPE_SHADER_GEOMETRY],
                                vert_info,
                                prim_info,
                                &vshader->info,

diff --git a/src/gallium/auxiliary/draw/draw_pt_fetch_shade_pipeline_llvm.c b/src/gallium/auxiliary/draw/draw_pt_fetch_shade_pipeline_llvm.c
index ffefb3f..af74306 100644 (file)
--- a/src/gallium/auxiliary/draw/draw_pt_fetch_shade_pipeline_llvm.c
+++ b/src/gallium/auxiliary/draw/draw_pt_fetch_shade_pipeline_llvm.c
@@ -431,77 +431,30 @@ llvm_middle_end_bind_parameters(struct draw_pt_middle_end *middle)
    struct draw_llvm *llvm = fpme->llvm;
    unsigned i;
 
-   for (i = 0; i < ARRAY_SIZE(llvm->vs_jit_resources.constants); ++i) {
-      /*
-       * There could be a potential issue with rounding this up, as the
-       * shader expects 16-byte allocations, the fix is likely to move
-       * to LOAD intrinsic in the future and remove the vec4 constraint.
-       */
-      int num_consts = get_num_consts_robust(draw, draw->pt.user.vs_constants, i);
-      llvm->vs_jit_resources.constants[i].f = draw->pt.user.vs_constants[i].ptr;
-      llvm->vs_jit_resources.constants[i].num_elements = num_consts;
-      if (num_consts == 0) {
-         llvm->vs_jit_resources.constants[i].f = fake_const_buf;
-      }
-   }
-   for (i = 0; i < ARRAY_SIZE(llvm->vs_jit_resources.ssbos); ++i) {
-      int num_ssbos = draw->pt.user.vs_ssbos[i].size;
-      llvm->vs_jit_resources.ssbos[i].u = draw->pt.user.vs_ssbos[i].ptr;
-      llvm->vs_jit_resources.ssbos[i].num_elements = num_ssbos;
-      if (num_ssbos == 0) {
-         llvm->vs_jit_resources.ssbos[i].u = (const uint32_t *)fake_const_buf;
-      }
-   }
-
-   for (i = 0; i < ARRAY_SIZE(llvm->gs_jit_resources.constants); ++i) {
-      int num_consts = get_num_consts_robust(draw, draw->pt.user.gs_constants, i);
-      llvm->gs_jit_resources.constants[i].f = draw->pt.user.gs_constants[i].ptr;
-      llvm->gs_jit_resources.constants[i].num_elements = num_consts;
-      if (num_consts == 0) {
-         llvm->gs_jit_resources.constants[i].f = fake_const_buf;
-      }
-   }
-   for (i = 0; i < ARRAY_SIZE(llvm->gs_jit_resources.ssbos); ++i) {
-      int num_ssbos = draw->pt.user.gs_ssbos[i].size;
-      llvm->gs_jit_resources.ssbos[i].u = draw->pt.user.gs_ssbos[i].ptr;
-      llvm->gs_jit_resources.ssbos[i].num_elements = num_ssbos;
-      if (num_ssbos == 0) {
-         llvm->gs_jit_resources.ssbos[i].u = (const uint32_t *)fake_const_buf;
-      }
-   }
-
-   for (i = 0; i < ARRAY_SIZE(llvm->tcs_jit_resources.constants); ++i) {
-      int num_consts = get_num_consts_robust(draw, draw->pt.user.tcs_constants, i);
-      llvm->tcs_jit_resources.constants[i].f = draw->pt.user.tcs_constants[i].ptr;
-      llvm->tcs_jit_resources.constants[i].num_elements = num_consts;
-      if (num_consts == 0) {
-         llvm->tcs_jit_resources.constants[i].f = fake_const_buf;
+   for (enum pipe_shader_type shader_type = PIPE_SHADER_VERTEX; shader_type <= PIPE_SHADER_GEOMETRY; shader_type++) {
+      for (i = 0; i < ARRAY_SIZE(llvm->jit_resources[shader_type].constants); ++i) {
+         /*
+          * There could be a potential issue with rounding this up, as the
+          * shader expects 16-byte allocations, the fix is likely to move
+          * to LOAD intrinsic in the future and remove the vec4 constraint.
+          */
+         int num_consts = get_num_consts_robust(draw, draw->pt.user.constants[shader_type], i);
+         llvm->jit_resources[shader_type].constants[i].f = draw->pt.user.constants[shader_type][i].ptr;
+         llvm->jit_resources[shader_type].constants[i].num_elements = num_consts;
+         if (num_consts == 0) {
+            llvm->jit_resources[shader_type].constants[i].f = fake_const_buf;
+         }
       }
-   }
-   for (i = 0; i < ARRAY_SIZE(llvm->tcs_jit_resources.ssbos); ++i) {
-      int num_ssbos = draw->pt.user.tcs_ssbos[i].size;
-      llvm->tcs_jit_resources.ssbos[i].u = draw->pt.user.tcs_ssbos[i].ptr;
-      llvm->tcs_jit_resources.ssbos[i].num_elements = num_ssbos;
-      if (num_ssbos == 0) {
-         llvm->tcs_jit_resources.ssbos[i].u = (const uint32_t *)fake_const_buf;
+      for (i = 0; i < ARRAY_SIZE(llvm->jit_resources[shader_type].ssbos); ++i) {
+         int num_ssbos = draw->pt.user.ssbos[shader_type][i].size;
+         llvm->jit_resources[shader_type].ssbos[i].u = draw->pt.user.ssbos[shader_type][i].ptr;
+         llvm->jit_resources[shader_type].ssbos[i].num_elements = num_ssbos;
+         if (num_ssbos == 0) {
+            llvm->jit_resources[shader_type].ssbos[i].u = (const uint32_t *)fake_const_buf;
+         }
       }
-   }
 
-   for (i = 0; i < ARRAY_SIZE(llvm->tes_jit_resources.constants); ++i) {
-      int num_consts = get_num_consts_robust(draw, draw->pt.user.tes_constants, i);
-      llvm->tes_jit_resources.constants[i].f = draw->pt.user.tes_constants[i].ptr;
-      llvm->tes_jit_resources.constants[i].num_elements = num_consts;
-      if (num_consts == 0) {
-         llvm->tes_jit_resources.constants[i].f = fake_const_buf;
-      }
-   }
-   for (i = 0; i < ARRAY_SIZE(llvm->tes_jit_resources.ssbos); ++i) {
-      int num_ssbos = draw->pt.user.tes_ssbos[i].size;
-      llvm->tes_jit_resources.ssbos[i].u = draw->pt.user.tes_ssbos[i].ptr;
-      llvm->tes_jit_resources.ssbos[i].num_elements = num_ssbos;
-      if (num_ssbos == 0) {
-         llvm->tes_jit_resources.ssbos[i].u = (const uint32_t *)fake_const_buf;
-      }
+      llvm->jit_resources[shader_type].aniso_filter_table = lp_build_sample_aniso_filter_table();
    }
 
    llvm->vs_jit_context.planes =
@@ -511,11 +464,6 @@ llvm_middle_end_bind_parameters(struct draw_pt_middle_end *middle)
 
    llvm->vs_jit_context.viewports = draw->viewports;
    llvm->gs_jit_context.viewports = draw->viewports;
-
-   llvm->vs_jit_resources.aniso_filter_table = lp_build_sample_aniso_filter_table();
-   llvm->gs_jit_resources.aniso_filter_table = lp_build_sample_aniso_filter_table();
-   llvm->tcs_jit_resources.aniso_filter_table = lp_build_sample_aniso_filter_table();
-   llvm->tes_jit_resources.aniso_filter_table = lp_build_sample_aniso_filter_table();
 }
 
 
@@ -608,7 +556,7 @@ llvm_pipeline_generic(struct draw_pt_middle_end *middle,
       }
       /* Run vertex fetch shader */
       clipped = fpme->current_variant->jit_func(&fpme->llvm->vs_jit_context,
-                                                &fpme->llvm->vs_jit_resources,
+                                                &fpme->llvm->jit_resources[PIPE_SHADER_VERTEX],
                                                 llvm_vert_info.verts,
                                                 draw->pt.user.vbuffer,
                                                 fetch_info->count,
@@ -679,7 +627,7 @@ llvm_pipeline_generic(struct draw_pt_middle_end *middle,
    if ((opt & PT_SHADE) && gshader) {
       struct draw_vertex_shader *vshader = draw->vs.vertex_shader;
       draw_geometry_shader_run(gshader,
-                               draw->pt.user.gs_constants,
+                               draw->pt.user.constants[PIPE_SHADER_GEOMETRY],
                                vert_info,
                                prim_info,
                                tes_shader ? &tes_shader->info : &vshader->info,

diff --git a/src/gallium/auxiliary/draw/draw_tess.c b/src/gallium/auxiliary/draw/draw_tess.c
index b7997b6..15b2c14 100644 (file)
--- a/src/gallium/auxiliary/draw/draw_tess.c
+++ b/src/gallium/auxiliary/draw/draw_tess.c
@@ -455,7 +455,7 @@ draw_create_tess_ctrl_shader(struct draw_context *draw,
       tcs->tcs_output = align_malloc(sizeof(struct draw_tcs_outputs), 16);
       memset(tcs->tcs_output, 0, sizeof(struct draw_tcs_outputs));
 
-      tcs->jit_resources = &draw->llvm->tcs_jit_resources;
+      tcs->jit_resources = &draw->llvm->jit_resources[PIPE_SHADER_TESS_CTRL];
       llvm_tcs->variant_key_size =
          draw_tcs_llvm_variant_key_size(
                                         tcs->info.file_max[TGSI_FILE_SAMPLER]+1,
@@ -580,7 +580,7 @@ draw_create_tess_eval_shader(struct draw_context *draw,
       tes->tes_input = align_malloc(sizeof(struct draw_tes_inputs), 16);
       memset(tes->tes_input, 0, sizeof(struct draw_tes_inputs));
 
-      tes->jit_resources = &draw->llvm->tes_jit_resources;
+      tes->jit_resources = &draw->llvm->jit_resources[PIPE_SHADER_TESS_EVAL];
       llvm_tes->variant_key_size =
          draw_tes_llvm_variant_key_size(
                                         tes->info.file_max[TGSI_FILE_SAMPLER]+1,

diff --git a/src/gallium/auxiliary/draw/draw_vs_variant.c b/src/gallium/auxiliary/draw/draw_vs_variant.c
index 7294172..0aedefd 100644 (file)
--- a/src/gallium/auxiliary/draw/draw_vs_variant.c
+++ b/src/gallium/auxiliary/draw/draw_vs_variant.c
@@ -175,7 +175,7 @@ vsvg_run_elts(struct draw_vs_variant *variant,
    vsvg->base.vs->run_linear(vsvg->base.vs,
                              temp_buffer,
                              temp_buffer,
-                             vsvg->base.vs->draw->pt.user.vs_constants,
+                             vsvg->base.vs->draw->pt.user.constants[PIPE_SHADER_VERTEX],
                              count,
                              temp_vertex_stride,
                              temp_vertex_stride, NULL);
@@ -238,7 +238,7 @@ vsvg_run_linear(struct draw_vs_variant *variant,
    vsvg->base.vs->run_linear(vsvg->base.vs,
                              temp_buffer,
                              temp_buffer,
-                             vsvg->base.vs->draw->pt.user.vs_constants,
+                             vsvg->base.vs->draw->pt.user.constants[PIPE_SHADER_VERTEX],
                              count,
                              temp_vertex_stride,
                              temp_vertex_stride, NULL);