Merge Mesa 20.0.8

With Mesa 20.1 even after the kernel change to do wbinvd on all cpus
sthen@ reported that hard hangs still occurred on his Haswell system
with inteldrm.

Mark Kane also reported seeing hangs on Ivy Bridge on bugs@.

Some systems/workloads seem to be more prone to triggering this than
others as I have not seen any hangs on Ivy Bridge and the only hangs
I saw on Haswell when running piglit went away with the wbinvd change.

It seems something is wrong with drm memory attributes or coherency in
the kernel and newer Mesa versions expect behaviour we don't have.

12 files changed, 63 insertions, 3109 deletions

diff --git a/lib/mesa/src/gallium/auxiliary/draw/draw_context.c b/lib/mesa/src/gallium/auxiliary/draw/draw_context.c
index 3b2b2d030..fb0b22eae 100644
--- a/lib/mesa/src/gallium/auxiliary/draw/draw_context.c
+++ b/lib/mesa/src/gallium/auxiliary/draw/draw_context.c
@@ -44,7 +44,6 @@
 #include "draw_prim_assembler.h"
 #include "draw_vs.h"
 #include "draw_gs.h"
-#include "draw_tess.h"
 
 #ifdef LLVM_AVAILABLE
 #include "gallivm/lp_bld_init.h"
@@ -455,9 +454,7 @@ draw_set_mapped_constant_buffer(struct draw_context *draw,
                                 unsigned size )
 {
    debug_assert(shader_type == PIPE_SHADER_VERTEX ||
-                shader_type == PIPE_SHADER_GEOMETRY ||
-                shader_type == PIPE_SHADER_TESS_CTRL ||
-                shader_type == PIPE_SHADER_TESS_EVAL);
+                shader_type == PIPE_SHADER_GEOMETRY);
    debug_assert(slot < PIPE_MAX_CONSTANT_BUFFERS);
 
    draw_do_flush(draw, DRAW_FLUSH_PARAMETER_CHANGE);
@@ -471,14 +468,6 @@ draw_set_mapped_constant_buffer(struct draw_context *draw,
       draw->pt.user.gs_constants[slot] = buffer;
       draw->pt.user.gs_constants_size[slot] = size;
       break;
-   case PIPE_SHADER_TESS_CTRL:
-      draw->pt.user.tcs_constants[slot] = buffer;
-      draw->pt.user.tcs_constants_size[slot] = size;
-      break;
-   case PIPE_SHADER_TESS_EVAL:
-      draw->pt.user.tes_constants[slot] = buffer;
-      draw->pt.user.tes_constants_size[slot] = size;
-      break;
    default:
       assert(0 && "invalid shader type in draw_set_mapped_constant_buffer");
    }
@@ -492,9 +481,7 @@ draw_set_mapped_shader_buffer(struct draw_context *draw,
                               unsigned size )
 {
    debug_assert(shader_type == PIPE_SHADER_VERTEX ||
-                shader_type == PIPE_SHADER_GEOMETRY ||
-                shader_type == PIPE_SHADER_TESS_CTRL ||
-                shader_type == PIPE_SHADER_TESS_EVAL);
+                shader_type == PIPE_SHADER_GEOMETRY);
    debug_assert(slot < PIPE_MAX_SHADER_BUFFERS);
 
    draw_do_flush(draw, DRAW_FLUSH_PARAMETER_CHANGE);
@@ -508,14 +495,6 @@ draw_set_mapped_shader_buffer(struct draw_context *draw,
       draw->pt.user.gs_ssbos[slot] = buffer;
       draw->pt.user.gs_ssbos_size[slot] = size;
       break;
-   case PIPE_SHADER_TESS_CTRL:
-      draw->pt.user.tcs_ssbos[slot] = buffer;
-      draw->pt.user.tcs_ssbos_size[slot] = size;
-      break;
-   case PIPE_SHADER_TESS_EVAL:
-      draw->pt.user.tes_ssbos[slot] = buffer;
-      draw->pt.user.tes_ssbos_size[slot] = size;
-      break;
    default:
       assert(0 && "invalid shader type in draw_set_mapped_shader_buffer");
    }
@@ -643,8 +622,6 @@ draw_get_shader_info(const struct draw_context *draw)
 
    if (draw->gs.geometry_shader) {
       return &draw->gs.geometry_shader->info;
-   } else if (draw->tes.tess_eval_shader) {
-      return &draw->tes.tess_eval_shader->info;
    } else {
       return &draw->vs.vertex_shader->info;
    }
@@ -769,37 +746,6 @@ draw_total_gs_outputs(const struct draw_context *draw)
    return info->num_outputs + draw->extra_shader_outputs.num;
 }
 
-/**
- * Return total number of the tess ctrl shader outputs.
- */
-uint
-draw_total_tcs_outputs(const struct draw_context *draw)
-{
-   const struct tgsi_shader_info *info;
-
-   if (!draw->tcs.tess_ctrl_shader)
-      return 0;
-
-   info = &draw->tcs.tess_ctrl_shader->info;
-
-   return info->num_outputs;
-}
-
-/**
- * Return total number of the tess eval shader outputs.
- */
-uint
-draw_total_tes_outputs(const struct draw_context *draw)
-{
-   const struct tgsi_shader_info *info;
-
-   if (!draw->tes.tess_eval_shader)
-      return 0;
-
-   info = &draw->tes.tess_eval_shader->info;
-
-   return info->num_outputs + draw->extra_shader_outputs.num;
-}
 
 /**
  * Provide TGSI sampler objects for vertex/geometry shaders that use
@@ -811,22 +757,11 @@ draw_texture_sampler(struct draw_context *draw,
                      enum pipe_shader_type shader,
                      struct tgsi_sampler *sampler)
 {
-   switch (shader) {
-   case PIPE_SHADER_VERTEX:
+   if (shader == PIPE_SHADER_VERTEX) {
       draw->vs.tgsi.sampler = sampler;
-      break;
-   case PIPE_SHADER_GEOMETRY:
+   } else {
+      debug_assert(shader == PIPE_SHADER_GEOMETRY);
       draw->gs.tgsi.sampler = sampler;
-      break;
-   case PIPE_SHADER_TESS_CTRL:
-      draw->tcs.tgsi.sampler = sampler;
-      break;
-   case PIPE_SHADER_TESS_EVAL:
-      draw->tes.tgsi.sampler = sampler;
-      break;
-   default:
-      assert(0);
-      break;
    }
 }
 
@@ -840,22 +775,11 @@ draw_image(struct draw_context *draw,
            enum pipe_shader_type shader,
            struct tgsi_image *image)
 {
-   switch (shader) {
-   case PIPE_SHADER_VERTEX:
+   if (shader == PIPE_SHADER_VERTEX) {
       draw->vs.tgsi.image = image;
-      break;
-   case PIPE_SHADER_GEOMETRY:
+   } else {
+      debug_assert(shader == PIPE_SHADER_GEOMETRY);
       draw->gs.tgsi.image = image;
-      break;
-   case PIPE_SHADER_TESS_CTRL:
-      draw->tcs.tgsi.image = image;
-      break;
-   case PIPE_SHADER_TESS_EVAL:
-      draw->tes.tgsi.image = image;
-      break;
-   default:
-      assert(0);
-      break;
    }
 }
 
@@ -869,22 +793,11 @@ draw_buffer(struct draw_context *draw,
             enum pipe_shader_type shader,
             struct tgsi_buffer *buffer)
 {
-   switch (shader) {
-   case PIPE_SHADER_VERTEX:
+   if (shader == PIPE_SHADER_VERTEX) {
       draw->vs.tgsi.buffer = buffer;
-      break;
-   case PIPE_SHADER_GEOMETRY:
+   } else {
+      debug_assert(shader == PIPE_SHADER_GEOMETRY);
       draw->gs.tgsi.buffer = buffer;
-      break;
-   case PIPE_SHADER_TESS_CTRL:
-      draw->tcs.tgsi.buffer = buffer;
-      break;
-   case PIPE_SHADER_TESS_EVAL:
-      draw->tes.tgsi.buffer = buffer;
-      break;
-   default:
-      assert(0);
-      break;
    }
 }
 
@@ -961,8 +874,6 @@ draw_current_shader_position_output(const struct draw_context *draw)
 {
    if (draw->gs.geometry_shader)
       return draw->gs.position_output;
-   if (draw->tes.tess_eval_shader)
-      return draw->tes.position_output;
    return draw->vs.position_output;
 }
 
@@ -976,8 +887,6 @@ draw_current_shader_viewport_index_output(const struct draw_context *draw)
 {
    if (draw->gs.geometry_shader)
       return draw->gs.geometry_shader->viewport_index_output;
-   else if (draw->tes.tess_eval_shader)
-      return draw->tes.tess_eval_shader->viewport_index_output;
    return draw->vs.vertex_shader->viewport_index_output;
 }
 
@@ -1005,8 +914,6 @@ draw_current_shader_clipvertex_output(const struct draw_context *draw)
 {
    if (draw->gs.geometry_shader)
       return draw->gs.position_output;
-   if (draw->tes.tess_eval_shader)
-      return draw->tes.position_output;
    return draw->vs.clipvertex_output;
 }
 
@@ -1016,8 +923,6 @@ draw_current_shader_ccdistance_output(const struct draw_context *draw, int index
    debug_assert(index < PIPE_MAX_CLIP_OR_CULL_DISTANCE_ELEMENT_COUNT);
    if (draw->gs.geometry_shader)
       return draw->gs.geometry_shader->ccdistance_output[index];
-   if (draw->tes.tess_eval_shader)
-      return draw->tes.tess_eval_shader->ccdistance_output[index];
    return draw->vs.ccdistance_output[index];
 }
 
@@ -1027,8 +932,6 @@ draw_current_shader_num_written_clipdistances(const struct draw_context *draw)
 {
    if (draw->gs.geometry_shader)
       return draw->gs.geometry_shader->info.num_written_clipdistance;
-   if (draw->tes.tess_eval_shader)
-      return draw->tes.tess_eval_shader->info.num_written_clipdistance;
    return draw->vs.vertex_shader->info.num_written_clipdistance;
 }
 
@@ -1037,8 +940,6 @@ draw_current_shader_num_written_culldistances(const struct draw_context *draw)
 {
    if (draw->gs.geometry_shader)
       return draw->gs.geometry_shader->info.num_written_culldistance;
-   if (draw->tes.tess_eval_shader)
-      return draw->tes.tess_eval_shader->info.num_written_culldistance;
    return draw->vs.vertex_shader->info.num_written_culldistance;
 }
 
@@ -1236,8 +1137,6 @@ draw_get_shader_param(enum pipe_shader_type shader, enum pipe_shader_cap param)
       switch(shader) {
       case PIPE_SHADER_VERTEX:
       case PIPE_SHADER_GEOMETRY:
-      case PIPE_SHADER_TESS_CTRL:
-      case PIPE_SHADER_TESS_EVAL:
          return gallivm_get_shader_param(param);
       default:
          return 0;
@@ -1320,14 +1219,3 @@ draw_will_inject_frontface(const struct draw_context *draw)
            (rast->fill_front != PIPE_POLYGON_MODE_FILL ||
             rast->fill_back != PIPE_POLYGON_MODE_FILL));
 }
-
-void
-draw_set_tess_state(struct draw_context *draw,
-		    const float default_outer_level[4],
-		    const float default_inner_level[2])
-{
-   for (unsigned i = 0; i < 4; i++)
-      draw->default_outer_tess_level[i] = default_outer_level[i];
-   for (unsigned i = 0; i < 2; i++)
-      draw->default_inner_tess_level[i] = default_inner_level[i];
-}
diff --git a/lib/mesa/src/gallium/auxiliary/draw/draw_context.h b/lib/mesa/src/gallium/auxiliary/draw/draw_context.h
index 659b81fd0..c58c12cc4 100644
--- a/lib/mesa/src/gallium/auxiliary/draw/draw_context.h
+++ b/lib/mesa/src/gallium/auxiliary/draw/draw_context.h
@@ -45,8 +45,6 @@ struct draw_context;
 struct draw_stage;
 struct draw_vertex_shader;
 struct draw_geometry_shader;
-struct draw_tess_ctrl_shader;
-struct draw_tess_eval_shader;
 struct draw_fragment_shader;
 struct tgsi_sampler;
 struct tgsi_image;
@@ -154,12 +152,6 @@ draw_total_vs_outputs(const struct draw_context *draw);
 uint
 draw_total_gs_outputs(const struct draw_context *draw);
 
-uint
-draw_total_tcs_outputs(const struct draw_context *draw);
-
-uint
-draw_total_tes_outputs(const struct draw_context *draw);
-
 void
 draw_texture_sampler(struct draw_context *draw,
                      enum pipe_shader_type shader_type,
@@ -250,26 +242,6 @@ void draw_bind_geometry_shader(struct draw_context *draw,
 void draw_delete_geometry_shader(struct draw_context *draw,
                                  struct draw_geometry_shader *dvs);
 
-/*
- * Tess shader functions
- */
-struct draw_tess_ctrl_shader *
-draw_create_tess_ctrl_shader(struct draw_context *draw,
-                            const struct pipe_shader_state *shader);
-void draw_bind_tess_ctrl_shader(struct draw_context *draw,
-                                struct draw_tess_ctrl_shader *dvs);
-void draw_delete_tess_ctrl_shader(struct draw_context *draw,
-                                  struct draw_tess_ctrl_shader *dvs);
-struct draw_tess_eval_shader *
-draw_create_tess_eval_shader(struct draw_context *draw,
-                            const struct pipe_shader_state *shader);
-void draw_bind_tess_eval_shader(struct draw_context *draw,
-                                struct draw_tess_eval_shader *dvs);
-void draw_delete_tess_eval_shader(struct draw_context *draw,
-                                  struct draw_tess_eval_shader *dvs);
-void draw_set_tess_state(struct draw_context *draw,
-                         const float default_outer_level[4],
-                         const float default_inner_level[2]);
 
 /*
  * Vertex data functions
diff --git a/lib/mesa/src/gallium/auxiliary/draw/draw_gs_tmp.h b/lib/mesa/src/gallium/auxiliary/draw/draw_gs_tmp.h
index 5a5b9e22a..bf276d382 100644
--- a/lib/mesa/src/gallium/auxiliary/draw/draw_gs_tmp.h
+++ b/lib/mesa/src/gallium/auxiliary/draw/draw_gs_tmp.h
@@ -12,6 +12,7 @@
    const boolean quads_flatshade_last = FALSE;                    \
    const boolean last_vertex_last = !gs->draw->rasterizer->flatshade_first;  \
    do {                                                           \
+      debug_assert(input_prims->primitive_count == 1);            \
       switch (prim) {                                             \
       case PIPE_PRIM_QUADS:                                       \
       case PIPE_PRIM_QUAD_STRIP:                                  \
diff --git a/lib/mesa/src/gallium/auxiliary/draw/draw_llvm.c b/lib/mesa/src/gallium/auxiliary/draw/draw_llvm.c
index 2fdbd5571..ca5cd6a37 100644
--- a/lib/mesa/src/gallium/auxiliary/draw/draw_llvm.c
+++ b/lib/mesa/src/gallium/auxiliary/draw/draw_llvm.c
@@ -37,7 +37,6 @@
 #include "gallivm/lp_bld_gather.h"
 #include "gallivm/lp_bld_logic.h"
 #include "gallivm/lp_bld_const.h"
-#include "gallivm/lp_bld_coro.h"
 #include "gallivm/lp_bld_swizzle.h"
 #include "gallivm/lp_bld_struct.h"
 #include "gallivm/lp_bld_type.h"
@@ -81,33 +80,6 @@ draw_gs_llvm_iface(const struct lp_build_gs_iface *iface)
    return (const struct draw_gs_llvm_iface *)iface;
 }
 
-struct draw_tcs_llvm_iface {
-   struct lp_build_tcs_iface base;
-
-   struct draw_tcs_llvm_variant *variant;
-   LLVMValueRef input;
-   LLVMValueRef output;
-};
-
-static inline const struct draw_tcs_llvm_iface *
-draw_tcs_llvm_iface(const struct lp_build_tcs_iface *iface)
-{
-   return (const struct draw_tcs_llvm_iface *)iface;
-}
-
-struct draw_tes_llvm_iface {
-   struct lp_build_tes_iface base;
-
-   struct draw_tes_llvm_variant *variant;
-   LLVMValueRef input;
-};
-
-static inline const struct draw_tes_llvm_iface *
-draw_tes_llvm_iface(const struct lp_build_tes_iface *iface)
-{
-   return (const struct draw_tes_llvm_iface *)iface;
-}
-
 /**
  * Create LLVM type for draw_vertex_buffer.
  */
@@ -525,166 +497,6 @@ create_jit_vertex_header(struct gallivm_state *gallivm, int data_elems)
    return vertex_header;
 }
 
-/**
- * Create LLVM type for struct draw_tcs_jit_context
- */
-static LLVMTypeRef
-create_tcs_jit_context_type(struct gallivm_state *gallivm,
-                            unsigned vector_length,
-                            LLVMTypeRef texture_type, LLVMTypeRef sampler_type,
-                            LLVMTypeRef image_type,
-                            const char *struct_name)
-{
-   LLVMTargetDataRef target = gallivm->target;
-   LLVMTypeRef float_type = LLVMFloatTypeInContext(gallivm->context);
-   LLVMTypeRef int_type = LLVMInt32TypeInContext(gallivm->context);
-   LLVMTypeRef elem_types[DRAW_TCS_JIT_CTX_NUM_FIELDS];
-   LLVMTypeRef context_type;
-
-   elem_types[0] = LLVMArrayType(LLVMPointerType(float_type, 0), /* constants */
-                                 LP_MAX_TGSI_CONST_BUFFERS);
-   elem_types[1] = LLVMArrayType(int_type, /* num_constants */
-                                 LP_MAX_TGSI_CONST_BUFFERS);
-   elem_types[2] = LLVMInt32TypeInContext(gallivm->context);
-   elem_types[3] = LLVMInt32TypeInContext(gallivm->context);
-
-   elem_types[4] = LLVMArrayType(texture_type,
-                                 PIPE_MAX_SHADER_SAMPLER_VIEWS); /* textures */
-   elem_types[5] = LLVMArrayType(sampler_type,
-                                 PIPE_MAX_SAMPLERS); /* samplers */
-   elem_types[6] = LLVMArrayType(image_type,
-                                 PIPE_MAX_SHADER_IMAGES); /* images */
-
-   elem_types[7] = LLVMArrayType(LLVMPointerType(int_type, 0), /* ssbos */
-                                 LP_MAX_TGSI_SHADER_BUFFERS);
-   elem_types[8] = LLVMArrayType(int_type, /* num_ssbos */
-                                 LP_MAX_TGSI_SHADER_BUFFERS);
-
-   context_type = LLVMStructTypeInContext(gallivm->context, elem_types,
-                                          ARRAY_SIZE(elem_types), 0);
-
-   (void) target; /* silence unused var warning for non-debug build */
-   LP_CHECK_MEMBER_OFFSET(struct draw_tcs_jit_context, constants,
-                          target, context_type, DRAW_TCS_JIT_CTX_CONSTANTS);
-   LP_CHECK_MEMBER_OFFSET(struct draw_tcs_jit_context, num_constants,
-                          target, context_type, DRAW_TCS_JIT_CTX_NUM_CONSTANTS);
-   LP_CHECK_MEMBER_OFFSET(struct draw_tcs_jit_context, textures,
-                          target, context_type,
-                          DRAW_TCS_JIT_CTX_TEXTURES);
-   LP_CHECK_MEMBER_OFFSET(struct draw_tcs_jit_context, samplers,
-                          target, context_type,
-                          DRAW_TCS_JIT_CTX_SAMPLERS);
-   LP_CHECK_MEMBER_OFFSET(struct draw_tcs_jit_context, ssbos,
-                          target, context_type, DRAW_TCS_JIT_CTX_SSBOS);
-   LP_CHECK_MEMBER_OFFSET(struct draw_tcs_jit_context, num_ssbos,
-                          target, context_type, DRAW_TCS_JIT_CTX_NUM_SSBOS);
-   LP_CHECK_MEMBER_OFFSET(struct draw_tcs_jit_context, images,
-                          target, context_type, DRAW_TCS_JIT_CTX_IMAGES);
-   LP_CHECK_STRUCT_SIZE(struct draw_tcs_jit_context,
-                        target, context_type);
-
-   return context_type;
-}
-
-static LLVMTypeRef
-create_tcs_jit_input_type(struct gallivm_state *gallivm)
-{
-   LLVMTypeRef float_type = LLVMFloatTypeInContext(gallivm->context);
-   LLVMTypeRef input_array;
-
-   input_array = LLVMArrayType(float_type, TGSI_NUM_CHANNELS); /* num channels */
-   input_array = LLVMArrayType(input_array, NUM_TCS_INPUTS); /* num attrs per vertex */
-   input_array = LLVMPointerType(input_array, 0); /* num vertices per prim */
-
-   return input_array;
-}
-
-static LLVMTypeRef
-create_tcs_jit_output_type(struct gallivm_state *gallivm)
-{
-   LLVMTypeRef float_type = LLVMFloatTypeInContext(gallivm->context);
-   LLVMTypeRef output_array;
-
-   output_array = LLVMArrayType(float_type, TGSI_NUM_CHANNELS); /* num channels */
-   output_array = LLVMArrayType(output_array, PIPE_MAX_SHADER_INPUTS); /* num attrs per vertex */
-   output_array = LLVMPointerType(output_array, 0); /* num vertices per prim */
-
-   return output_array;
-}
-
-static LLVMTypeRef
-create_tes_jit_input_type(struct gallivm_state *gallivm)
-{
-   LLVMTypeRef float_type = LLVMFloatTypeInContext(gallivm->context);
-   LLVMTypeRef input_array;
-
-   input_array = LLVMArrayType(float_type, TGSI_NUM_CHANNELS); /* num channels */
-   input_array = LLVMArrayType(input_array, PIPE_MAX_SHADER_INPUTS); /* num attrs per vertex */
-   input_array = LLVMPointerType(input_array, 0); /* num vertices per prim */
-
-   return input_array;
-}
-
-/**
- * Create LLVM type for struct draw_tes_jit_context
- */
-static LLVMTypeRef
-create_tes_jit_context_type(struct gallivm_state *gallivm,
-                            unsigned vector_length,
-                            LLVMTypeRef texture_type, LLVMTypeRef sampler_type,
-                            LLVMTypeRef image_type,
-                            const char *struct_name)
-{
-   LLVMTargetDataRef target = gallivm->target;
-   LLVMTypeRef float_type = LLVMFloatTypeInContext(gallivm->context);
-   LLVMTypeRef int_type = LLVMInt32TypeInContext(gallivm->context);
-   LLVMTypeRef elem_types[DRAW_TCS_JIT_CTX_NUM_FIELDS];
-   LLVMTypeRef context_type;
-
-   elem_types[0] = LLVMArrayType(LLVMPointerType(float_type, 0), /* constants */
-                                 LP_MAX_TGSI_CONST_BUFFERS);
-   elem_types[1] = LLVMArrayType(int_type, /* num_constants */
-                                 LP_MAX_TGSI_CONST_BUFFERS);
-   elem_types[2] = LLVMInt32TypeInContext(gallivm->context);
-   elem_types[3] = LLVMInt32TypeInContext(gallivm->context);
-
-   elem_types[4] = LLVMArrayType(texture_type,
-                                 PIPE_MAX_SHADER_SAMPLER_VIEWS); /* textures */
-   elem_types[5] = LLVMArrayType(sampler_type,
-                                 PIPE_MAX_SAMPLERS); /* samplers */
-   elem_types[6] = LLVMArrayType(image_type,
-                                 PIPE_MAX_SHADER_IMAGES); /* images */
-
-   elem_types[7] = LLVMArrayType(LLVMPointerType(int_type, 0), /* ssbos */
-                                 LP_MAX_TGSI_SHADER_BUFFERS);
-   elem_types[8] = LLVMArrayType(int_type, /* num_ssbos */
-                                 LP_MAX_TGSI_SHADER_BUFFERS);
-
-   context_type = LLVMStructTypeInContext(gallivm->context, elem_types,
-                                          ARRAY_SIZE(elem_types), 0);
-
-   (void) target; /* silence unused var warning for non-debug build */
-   LP_CHECK_MEMBER_OFFSET(struct draw_tes_jit_context, constants,
-                          target, context_type, DRAW_TCS_JIT_CTX_CONSTANTS);
-   LP_CHECK_MEMBER_OFFSET(struct draw_tes_jit_context, num_constants,
-                          target, context_type, DRAW_TCS_JIT_CTX_NUM_CONSTANTS);
-   LP_CHECK_MEMBER_OFFSET(struct draw_tes_jit_context, textures,
-                          target, context_type,
-                          DRAW_TCS_JIT_CTX_TEXTURES);
-   LP_CHECK_MEMBER_OFFSET(struct draw_tes_jit_context, samplers,
-                          target, context_type,
-                          DRAW_TCS_JIT_CTX_SAMPLERS);
-   LP_CHECK_MEMBER_OFFSET(struct draw_tes_jit_context, ssbos,
-                          target, context_type, DRAW_TCS_JIT_CTX_SSBOS);
-   LP_CHECK_MEMBER_OFFSET(struct draw_tes_jit_context, num_ssbos,
-                          target, context_type, DRAW_TCS_JIT_CTX_NUM_SSBOS);
-   LP_CHECK_MEMBER_OFFSET(struct draw_tes_jit_context, images,
-                          target, context_type, DRAW_TCS_JIT_CTX_IMAGES);
-   LP_CHECK_STRUCT_SIZE(struct draw_tes_jit_context,
-                        target, context_type);
-
-   return context_type;
-}
 
 /**
  * Create LLVM types for various structures.
@@ -779,12 +591,6 @@ draw_llvm_create(struct draw_context *draw, LLVMContextRef context)
    llvm->nr_gs_variants = 0;
    make_empty_list(&llvm->gs_variants_list);
 
-   llvm->nr_tcs_variants = 0;
-   make_empty_list(&llvm->tcs_variants_list);
-
-   llvm->nr_tes_variants = 0;
-   make_empty_list(&llvm->tes_variants_list);
-
    return llvm;
 
 fail:
@@ -1070,7 +876,7 @@ fetch_vector(struct gallivm_state *gallivm,
    }
 
    /* out-of-bound fetches return all zeros */
-   for (i = 0; i < format_desc->nr_channels; i++) {
+   for (i = 0; i < TGSI_NUM_CHANNELS; i++) {
       inputs[i] = LLVMBuildBitCast(builder, inputs[i], blduivec.vec_type, "");
       inputs[i] = LLVMBuildAnd(builder, inputs[i], valid_mask, "");
       inputs[i] = LLVMBuildBitCast(builder, inputs[i],
@@ -1123,8 +929,8 @@ store_aos(struct gallivm_state *gallivm,
  * {
  *   return (x >> 16) |              // vertex_id
  *          ((x & 0x3fff) << 18) |   // clipmask
- *          ((x & 0x4000) << 3) |    // edgeflag
- *          ((x & 0x8000) << 1);     // pad
+ *          ((x & 0x4000) << 3) |    // pad
+ *          ((x & 0x8000) << 1);     // edgeflag
  * }
  */
 static LLVMValueRef
@@ -1142,11 +948,11 @@ adjust_mask(struct gallivm_state *gallivm,
    clipmask  = LLVMBuildAnd(builder, mask, lp_build_const_int32(gallivm, 0x3fff), "");
    clipmask  = LLVMBuildShl(builder, clipmask, lp_build_const_int32(gallivm, 18), "");
    if (0) {
-      pad = LLVMBuildAnd(builder, mask, lp_build_const_int32(gallivm, 0x8000), "");
-      pad = LLVMBuildShl(builder, pad, lp_build_const_int32(gallivm, 1), "");
+      pad = LLVMBuildAnd(builder, mask, lp_build_const_int32(gallivm, 0x4000), "");
+      pad = LLVMBuildShl(builder, pad, lp_build_const_int32(gallivm, 3), "");
    }
-   edgeflag = LLVMBuildAnd(builder, mask, lp_build_const_int32(gallivm, 0x4000), "");
-   edgeflag = LLVMBuildShl(builder, edgeflag, lp_build_const_int32(gallivm, 3), "");
+   edgeflag = LLVMBuildAnd(builder, mask, lp_build_const_int32(gallivm, 0x8000), "");
+   edgeflag = LLVMBuildShl(builder, edgeflag, lp_build_const_int32(gallivm, 1), "");
 
    mask = LLVMBuildOr(builder, vertex_id, clipmask, "");
    if (0) {
@@ -1751,17 +1557,10 @@ draw_gs_llvm_emit_vertex(const struct lp_build_gs_iface *gs_base,
       indices[i] = LLVMBuildAdd(builder, indices[i], currently_emitted, "");
    }
 
-   LLVMValueRef stream_idx = LLVMBuildExtractElement(builder, stream_id, lp_build_const_int32(gallivm, 0), "");
-   LLVMValueRef cnd = LLVMBuildICmp(builder, LLVMIntULT, stream_idx, lp_build_const_int32(gallivm, variant->shader->base.num_vertex_streams), "");
-   struct lp_build_if_state if_ctx;
-   lp_build_if(&if_ctx, gallivm, cnd);
-   io = lp_build_pointer_get(builder, io, LLVMBuildExtractElement(builder, stream_id, lp_build_const_int32(gallivm, 0), ""));
-
    convert_to_aos(gallivm, io, indices,
                   outputs, clipmask,
                   gs_info->num_outputs, gs_type,
                   FALSE);
-   lp_build_endif(&if_ctx);
 }
 
 static void
@@ -1798,7 +1597,7 @@ draw_gs_llvm_end_primitive(const struct lp_build_gs_iface *gs_base,
 static void
 draw_gs_llvm_epilogue(const struct lp_build_gs_iface *gs_base,
                       LLVMValueRef total_emitted_vertices_vec,
-                      LLVMValueRef emitted_prims_vec, unsigned stream)
+                      LLVMValueRef emitted_prims_vec)
 {
    const struct draw_gs_llvm_iface *gs_iface = draw_gs_llvm_iface(gs_base);
    struct draw_gs_llvm_variant *variant = gs_iface->variant;
@@ -1808,10 +1607,10 @@ draw_gs_llvm_epilogue(const struct lp_build_gs_iface *gs_base,
       draw_gs_jit_emitted_vertices(gallivm, variant->context_ptr);
    LLVMValueRef emitted_prims_ptr =
       draw_gs_jit_emitted_prims(gallivm, variant->context_ptr);
-   LLVMValueRef stream_val = lp_build_const_int32(gallivm, stream);
+   LLVMValueRef zero = lp_build_const_int32(gallivm, 0);
    
-   emitted_verts_ptr = LLVMBuildGEP(builder, emitted_verts_ptr, &stream_val, 1, "");
-   emitted_prims_ptr = LLVMBuildGEP(builder, emitted_prims_ptr, &stream_val, 1, "");
+   emitted_verts_ptr = LLVMBuildGEP(builder, emitted_verts_ptr, &zero, 0, "");
+   emitted_prims_ptr = LLVMBuildGEP(builder, emitted_prims_ptr, &zero, 0, "");
 
    LLVMBuildStore(builder, total_emitted_vertices_vec, emitted_verts_ptr);
    LLVMBuildStore(builder, emitted_prims_vec, emitted_prims_ptr);
@@ -1861,9 +1660,9 @@ draw_llvm_generate(struct draw_llvm *llvm, struct draw_llvm_variant *variant)
     * (though this would be fixable here, but couldn't just broadcast
     * the values).
     */
-   const boolean bypass_viewport = key->has_gs_or_tes || key->bypass_viewport ||
+   const boolean bypass_viewport = key->has_gs || key->bypass_viewport ||
                                    vs_info->writes_viewport_index;
-   const boolean enable_cliptest = !key->has_gs_or_tes && (key->clip_xy ||
+   const boolean enable_cliptest = !key->has_gs && (key->clip_xy ||
                                                     key->clip_z ||
                                                     key->clip_user ||
                                                     key->need_edgeflags);
@@ -2299,7 +2098,7 @@ draw_llvm_make_variant_key(struct draw_llvm *llvm, char *store)
    /* XXX assumes edgeflag output not at 0 */
    key->need_edgeflags = (llvm->draw->vs.edgeflag_output ? TRUE : FALSE);
    key->ucp_enable = llvm->draw->rasterizer->clip_plane_enable;
-   key->has_gs_or_tes = llvm->draw->gs.geometry_shader != NULL || llvm->draw->tes.tess_eval_shader != NULL;
+   key->has_gs = llvm->draw->gs.geometry_shader != NULL;
    key->num_outputs = draw_total_vs_outputs(llvm->draw);
 
    /* All variants of this shader will have the same value for
@@ -2379,7 +2178,7 @@ draw_llvm_dump_variant_key(struct draw_llvm_variant_key *key)
    debug_printf("bypass_viewport = %u\n", key->bypass_viewport);
    debug_printf("clip_halfz = %u\n", key->clip_halfz);
    debug_printf("need_edgeflags = %u\n", key->need_edgeflags);
-   debug_printf("has_gs_or_tes = %u\n", key->has_gs_or_tes);
+   debug_printf("has_gs = %u\n", key->has_gs);
    debug_printf("ucp_enable = %u\n", key->ucp_enable);
 
    for (i = 0 ; i < key->nr_vertex_elements; i++) {
@@ -2412,24 +2211,18 @@ draw_llvm_set_mapped_texture(struct draw_context *draw,
    unsigned j;
    struct draw_jit_texture *jit_tex;
 
-   switch (shader_stage) {
-   case PIPE_SHADER_VERTEX:
+   assert(shader_stage == PIPE_SHADER_VERTEX ||
+          shader_stage == PIPE_SHADER_GEOMETRY);
+
+   if (shader_stage == PIPE_SHADER_VERTEX) {
       assert(sview_idx < ARRAY_SIZE(draw->llvm->jit_context.textures));
+
       jit_tex = &draw->llvm->jit_context.textures[sview_idx];
-      break;
-   case PIPE_SHADER_GEOMETRY:
+   } else if (shader_stage == PIPE_SHADER_GEOMETRY) {
       assert(sview_idx < ARRAY_SIZE(draw->llvm->gs_jit_context.textures));
+
       jit_tex = &draw->llvm->gs_jit_context.textures[sview_idx];
-      break;
-   case PIPE_SHADER_TESS_CTRL:
-      assert(sview_idx < ARRAY_SIZE(draw->llvm->tcs_jit_context.textures));
-      jit_tex = &draw->llvm->tcs_jit_context.textures[sview_idx];
-      break;
-   case PIPE_SHADER_TESS_EVAL:
-      assert(sview_idx < ARRAY_SIZE(draw->llvm->tes_jit_context.textures));
-      jit_tex = &draw->llvm->tes_jit_context.textures[sview_idx];
-      break;
-   default:
+   } else {
       assert(0);
       return;
    }
@@ -2459,24 +2252,18 @@ draw_llvm_set_mapped_image(struct draw_context *draw,
 {
    struct draw_jit_image *jit_image;
 
-   switch (shader_stage) {
-   case PIPE_SHADER_VERTEX:
+   assert(shader_stage == PIPE_SHADER_VERTEX ||
+          shader_stage == PIPE_SHADER_GEOMETRY);
+
+   if (shader_stage == PIPE_SHADER_VERTEX) {
       assert(idx < ARRAY_SIZE(draw->llvm->jit_context.images));
+
       jit_image = &draw->llvm->jit_context.images[idx];
-      break;
-   case PIPE_SHADER_GEOMETRY:
+   } else if (shader_stage == PIPE_SHADER_GEOMETRY) {
       assert(idx < ARRAY_SIZE(draw->llvm->gs_jit_context.images));
+
       jit_image = &draw->llvm->gs_jit_context.images[idx];
-      break;
-   case PIPE_SHADER_TESS_CTRL:
-      assert(idx < ARRAY_SIZE(draw->llvm->tcs_jit_context.images));
-      jit_image = &draw->llvm->tcs_jit_context.images[idx];
-      break;
-   case PIPE_SHADER_TESS_EVAL:
-      assert(idx < ARRAY_SIZE(draw->llvm->tes_jit_context.images));
-      jit_image = &draw->llvm->tes_jit_context.images[idx];
-      break;
-   default:
+   } else {
       assert(0);
       return;
    }
@@ -2497,8 +2284,7 @@ draw_llvm_set_sampler_state(struct draw_context *draw,
 {
    unsigned i;
 
-   switch (shader_type) {
-   case PIPE_SHADER_VERTEX:
+   if (shader_type == PIPE_SHADER_VERTEX) {
       for (i = 0; i < draw->num_samplers[PIPE_SHADER_VERTEX]; i++) {
          struct draw_jit_sampler *jit_sam = &draw->llvm->jit_context.samplers[i];
 
@@ -2511,8 +2297,7 @@ draw_llvm_set_sampler_state(struct draw_context *draw,
             COPY_4V(jit_sam->border_color, s->border_color.f);
          }
       }
-      break;
-   case PIPE_SHADER_GEOMETRY:
+   } else if (shader_type == PIPE_SHADER_GEOMETRY) {
       for (i = 0; i < draw->num_samplers[PIPE_SHADER_GEOMETRY]; i++) {
          struct draw_jit_sampler *jit_sam = &draw->llvm->gs_jit_context.samplers[i];
 
@@ -2525,38 +2310,6 @@ draw_llvm_set_sampler_state(struct draw_context *draw,
             COPY_4V(jit_sam->border_color, s->border_color.f);
          }
       }
-      break;
-   case PIPE_SHADER_TESS_CTRL:
-      for (i = 0; i < draw->num_samplers[PIPE_SHADER_TESS_CTRL]; i++) {
-         struct draw_jit_sampler *jit_sam = &draw->llvm->tcs_jit_context.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;
-            COPY_4V(jit_sam->border_color, s->border_color.f);
-         }
-      }
-      break;
-   case PIPE_SHADER_TESS_EVAL:
-      for (i = 0; i < draw->num_samplers[PIPE_SHADER_TESS_EVAL]; i++) {
-         struct draw_jit_sampler *jit_sam = &draw->llvm->tes_jit_context.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;
-            COPY_4V(jit_sam->border_color, s->border_color.f);
-         }
-      }
-      break;
-   default:
-      assert(0);
-      break;
    }
 }
 
@@ -2676,7 +2429,7 @@ draw_gs_llvm_generate(struct draw_llvm *llvm,
 
    arg_types[0] = get_gs_context_ptr_type(variant);    /* context */
    arg_types[1] = variant->input_array_type;           /* input */
-   arg_types[2] = LLVMPointerType(variant->vertex_header_ptr_type, 0);     /* vertex_header */
+   arg_types[2] = variant->vertex_header_ptr_type;     /* vertex_header */
    arg_types[3] = int32_type;                          /* num_prims */
    arg_types[4] = int32_type;                          /* instance_id */
    arg_types[5] = LLVMPointerType(
@@ -2939,1087 +2692,3 @@ draw_gs_llvm_dump_variant_key(struct draw_gs_llvm_variant_key *key)
       debug_printf("images[%i].format = %s\n", i, util_format_name(image[i].image_state.format));
 
 }
-
-static void
-create_tcs_jit_types(struct draw_tcs_llvm_variant *var)
-{
-   struct gallivm_state *gallivm = var->gallivm;
-   LLVMTypeRef texture_type, sampler_type, image_type, context_type;
-
-   texture_type = create_jit_texture_type(gallivm, "texture");
-   sampler_type = create_jit_sampler_type(gallivm, "sampler");
-   image_type = create_jit_image_type(gallivm, "image");
-
-   context_type = create_tcs_jit_context_type(gallivm,
-                                              0,
-                                              texture_type, sampler_type,
-                                              image_type,
-                                              "draw_tcs_jit_context");
-   var->input_array_type = create_tcs_jit_input_type(gallivm);
-   var->output_array_type = create_tcs_jit_output_type(gallivm);
-   var->context_ptr_type = LLVMPointerType(context_type, 0);
-}
-
-static LLVMTypeRef
-get_tcs_context_ptr_type(struct draw_tcs_llvm_variant *variant)
-{
-   if (!variant->context_ptr_type)
-      create_tcs_jit_types(variant);
-   return variant->context_ptr_type;
-}
-
-static LLVMValueRef
-draw_tcs_llvm_emit_fetch_input(const struct lp_build_tcs_iface *tes_iface,
-                               struct lp_build_context *bld,
-                               boolean is_vindex_indirect,
-                               LLVMValueRef vertex_index,
-                               boolean is_aindex_indirect,
-                               LLVMValueRef attrib_index,
-                               LLVMValueRef swizzle_index)
-{
-   const struct draw_tcs_llvm_iface *tcs = draw_tcs_llvm_iface(tes_iface);
-   struct gallivm_state *gallivm = bld->gallivm;
-   LLVMBuilderRef builder = gallivm->builder;
-   LLVMValueRef indices[3];
-   LLVMValueRef res;
-   struct lp_type type = bld->type;
-
-   if (is_vindex_indirect || is_aindex_indirect) {
-      int i;
-
-      res = bld->zero;
-      for (i = 0; i < type.length; ++i) {
-         LLVMValueRef idx = lp_build_const_int32(gallivm, i);
-         LLVMValueRef vert_chan_index = vertex_index;
-         LLVMValueRef attr_chan_index = attrib_index;
-         LLVMValueRef channel_vec;
-
-         if (is_vindex_indirect) {
-            vert_chan_index = LLVMBuildExtractElement(builder,
-                                                      vertex_index, idx, "");
-         }
-         if (is_aindex_indirect) {
-            attr_chan_index = LLVMBuildExtractElement(builder,
-                                                      attrib_index, idx, "");
-         }
-
-         indices[0] = vert_chan_index;
-         indices[1] = attr_chan_index;
-         indices[2] = swizzle_index;
-
-         channel_vec = LLVMBuildGEP(builder, tcs->input, indices, 3, "");
-         channel_vec = LLVMBuildLoad(builder, channel_vec, "");
-
-         res = LLVMBuildInsertElement(builder, res, channel_vec, idx, "");
-      }
-   } else {
-      indices[0] = vertex_index;
-      indices[1] = attrib_index;
-      indices[2] = swizzle_index;
-
-      res = LLVMBuildGEP(builder, tcs->input, indices, 3, "");
-      res = LLVMBuildLoad(builder, res, "");
-      res = lp_build_broadcast_scalar(bld, res);
-   }
-   return res;
-}
-
-static LLVMValueRef
-draw_tcs_llvm_emit_fetch_output(const struct lp_build_tcs_iface *tes_iface,
-                                struct lp_build_context *bld,
-                                boolean is_vindex_indirect,
-                                LLVMValueRef vertex_index,
-                                boolean is_aindex_indirect,
-                                LLVMValueRef attrib_index,
-                                LLVMValueRef swizzle_index,
-                                uint32_t name)
-{
-   const struct draw_tcs_llvm_iface *tcs = draw_tcs_llvm_iface(tes_iface);
-   struct gallivm_state *gallivm = bld->gallivm;
-   LLVMBuilderRef builder = gallivm->builder;
-   LLVMValueRef indices[3];
-   LLVMValueRef res;
-   struct lp_type type = bld->type;
-
-   if (is_vindex_indirect || is_aindex_indirect) {
-      int i;
-
-      res = bld->zero;
-      for (i = 0; i < type.length; ++i) {
-         LLVMValueRef idx = lp_build_const_int32(gallivm, i);
-         LLVMValueRef vert_chan_index = vertex_index;
-         LLVMValueRef attr_chan_index = attrib_index;
-         LLVMValueRef channel_vec;
-
-         if (is_vindex_indirect) {
-            vert_chan_index = LLVMBuildExtractElement(builder,
-                                                      vertex_index, idx, "");
-         }
-         if (is_aindex_indirect) {
-            attr_chan_index = LLVMBuildExtractElement(builder,
-                                                      attrib_index, idx, "");
-         }
-
-         indices[0] = vert_chan_index;
-         indices[1] = attr_chan_index;
-         indices[2] = swizzle_index;
-
-         channel_vec = LLVMBuildGEP(builder, tcs->output, indices, 3, "");
-         channel_vec = LLVMBuildLoad(builder, channel_vec, "");
-
-         res = LLVMBuildInsertElement(builder, res, channel_vec, idx, "");
-      }
-   } else {
-      indices[0] = vertex_index ? vertex_index : lp_build_const_int32(gallivm, 0);
-      indices[1] = attrib_index;
-      indices[2] = swizzle_index;
-
-      res = LLVMBuildGEP(builder, tcs->output, indices, 3, "");
-      res = LLVMBuildLoad(builder, res, "");
-      res = lp_build_broadcast_scalar(bld, res);
-   }
-   return res;
-}
-
-static void
-draw_tcs_llvm_emit_store_output(const struct lp_build_tcs_iface *tes_iface,
-                                struct lp_build_context *bld,
-                                unsigned name,
-                                boolean is_vindex_indirect,
-                                LLVMValueRef vertex_index,
-                                boolean is_aindex_indirect,
-                                LLVMValueRef attrib_index,
-                                LLVMValueRef swizzle_index,
-                                LLVMValueRef value,
-                                LLVMValueRef mask_vec)
-{
-   const struct draw_tcs_llvm_iface *tcs = draw_tcs_llvm_iface(tes_iface);
-   struct gallivm_state *gallivm = bld->gallivm;
-   LLVMBuilderRef builder = gallivm->builder;
-   LLVMValueRef indices[3];
-   LLVMValueRef res;
-   struct lp_type type = bld->type;
-
-   if (is_vindex_indirect || is_aindex_indirect) {
-      int i;
-
-      for (i = 0; i < type.length; ++i) {
-         LLVMValueRef idx = lp_build_const_int32(gallivm, i);
-         LLVMValueRef vert_chan_index = vertex_index ? vertex_index : lp_build_const_int32(gallivm, 0);
-         LLVMValueRef attr_chan_index = attrib_index;
-         LLVMValueRef channel_vec;
-
-         if (is_vindex_indirect) {
-            vert_chan_index = LLVMBuildExtractElement(builder,
-                                                      vertex_index, idx, "");
-         }
-         if (is_aindex_indirect) {
-            attr_chan_index = LLVMBuildExtractElement(builder,
-                                                      attrib_index, idx, "");
-         }
-
-         indices[0] = vert_chan_index;
-         indices[1] = attr_chan_index;
-         indices[2] = swizzle_index;
-
-         channel_vec = LLVMBuildGEP(builder, tcs->output, indices, 3, "");
-
-         res = LLVMBuildExtractElement(builder, value, idx, "");
-
-         struct lp_build_if_state ifthen;
-         LLVMValueRef cond = LLVMBuildICmp(gallivm->builder, LLVMIntNE, mask_vec, lp_build_const_int_vec(gallivm, bld->type, 0), "");
-         cond = LLVMBuildExtractElement(gallivm->builder, cond, idx, "");
-         lp_build_if(&ifthen, gallivm, cond);
-         LLVMBuildStore(builder, res, channel_vec);
-         lp_build_endif(&ifthen);
-      }
-   } else {
-      indices[0] = vertex_index ? vertex_index : lp_build_const_int32(gallivm, 0);
-      indices[1] = attrib_index;
-      indices[2] = swizzle_index;
-
-      res = LLVMBuildGEP(builder, tcs->output, indices, 3, "");
-      for (unsigned i = 0; i < type.length; ++i) {
-         LLVMValueRef idx = lp_build_const_int32(gallivm, i);
-         LLVMValueRef val = LLVMBuildExtractElement(builder, value, idx, "");
-
-         struct lp_build_if_state ifthen;
-         LLVMValueRef cond = LLVMBuildICmp(gallivm->builder, LLVMIntNE, mask_vec, lp_build_const_int_vec(gallivm, bld->type, 0), "");
-         cond = LLVMBuildExtractElement(gallivm->builder, cond, idx, "");
-         lp_build_if(&ifthen, gallivm, cond);
-         LLVMBuildStore(builder, val, res);
-         lp_build_endif(&ifthen);
-      }
-   }
-}
-
-
-static LLVMValueRef
-generate_tcs_mask_value(struct draw_tcs_llvm_variant *variant,
-                        struct lp_type tcs_type, LLVMValueRef limit, LLVMValueRef loop_counter)
-{
-   struct gallivm_state *gallivm = variant->gallivm;
-   LLVMBuilderRef builder = gallivm->builder;
-   struct lp_type mask_type = lp_int_type(tcs_type);
-   LLVMValueRef num_vecs;
-   LLVMValueRef mask_val = lp_build_const_vec(gallivm, mask_type, 0);
-   unsigned i;
-
-   num_vecs = lp_build_broadcast(gallivm, lp_build_vec_type(gallivm, mask_type), limit);
-   for (i = 0; i < tcs_type.length; i++) {
-      LLVMValueRef idx = lp_build_const_int32(gallivm, i);
-      mask_val = LLVMBuildInsertElement(builder, mask_val, LLVMBuildAdd(builder, loop_counter, idx, ""), idx, "");
-   }
-   mask_val = lp_build_compare(gallivm, mask_type,
-                               PIPE_FUNC_GREATER, num_vecs, mask_val);
-
-   return mask_val;
-}
-
-static void
-draw_tcs_llvm_generate(struct draw_llvm *llvm,
-                       struct draw_tcs_llvm_variant *variant)
-{
-   struct gallivm_state *gallivm = variant->gallivm;
-   LLVMContextRef context = gallivm->context;
-   LLVMTypeRef int32_type = LLVMInt32TypeInContext(context);
-   LLVMTypeRef arg_types[6];
-   LLVMTypeRef func_type, coro_func_type;
-   LLVMValueRef variant_func, variant_coro;
-   LLVMValueRef context_ptr;
-   LLVMValueRef input_array, output_array, prim_id, patch_vertices_in;
-   LLVMValueRef mask_val;
-   LLVMBasicBlockRef block;
-   LLVMBuilderRef builder;
-   struct lp_build_context bld, bldvec;
-   struct lp_build_sampler_soa *sampler = 0;
-   struct lp_build_image_soa *image = NULL;
-   struct lp_bld_tgsi_system_values system_values;
-   char func_name[64], func_name_coro[64];
-   unsigned i;
-   struct draw_tcs_llvm_iface tcs_iface;
-   struct lp_build_mask_context mask;
-   LLVMValueRef consts_ptr, num_consts_ptr;
-   LLVMValueRef ssbos_ptr, num_ssbos_ptr;
-   struct lp_type tcs_type;
-   unsigned vector_length = variant->shader->base.vector_length;
-
-   memset(&system_values, 0, sizeof(system_values));
-
-   snprintf(func_name, sizeof(func_name), "draw_llvm_tcs_variant%u",
-            variant->shader->variants_cached);
-
-   snprintf(func_name_coro, sizeof(func_name_coro), "draw_llvm_tcs_coro_variant%u",
-            variant->shader->variants_cached);
-
-   arg_types[0] = get_tcs_context_ptr_type(variant);    /* context */
-   arg_types[1] = variant->input_array_type;           /* input */
-   arg_types[2] = variant->output_array_type;
-   arg_types[3] = int32_type;
-   arg_types[4] = int32_type;
-   arg_types[5] = int32_type; /* coroutine only */
-
-   func_type = LLVMFunctionType(int32_type, arg_types, ARRAY_SIZE(arg_types) - 1, 0);
-
-   coro_func_type = LLVMFunctionType(LLVMPointerType(LLVMInt8TypeInContext(gallivm->context), 0), arg_types, ARRAY_SIZE(arg_types), 0);
-
-   variant_func = LLVMAddFunction(gallivm->module, func_name, func_type);
-
-   variant_coro = LLVMAddFunction(gallivm->module, func_name_coro, coro_func_type);
-
-   variant->function = variant_func;
-   LLVMSetFunctionCallConv(variant_func, LLVMCCallConv);
-
-   LLVMSetFunctionCallConv(variant_coro, LLVMCCallConv);
-
-   for (i = 0; i < ARRAY_SIZE(arg_types); ++i) {
-      if (LLVMGetTypeKind(arg_types[i]) == LLVMPointerTypeKind) {
-         lp_add_function_attr(variant_coro, i + 1, LP_FUNC_ATTR_NOALIAS);
-         lp_add_function_attr(variant_func, i + 1, LP_FUNC_ATTR_NOALIAS);
-      }
-   }
-
-   context_ptr               = LLVMGetParam(variant_func, 0);
-   input_array               = LLVMGetParam(variant_func, 1);
-   output_array              = LLVMGetParam(variant_func, 2);
-   prim_id                   = LLVMGetParam(variant_func, 3);
-   patch_vertices_in         = LLVMGetParam(variant_func, 4);
-
-   lp_build_name(context_ptr, "context");
-   lp_build_name(input_array, "input");
-   lp_build_name(output_array, "output");
-   lp_build_name(prim_id, "prim_id");
-   lp_build_name(patch_vertices_in, "patch_vertices_in");
-
-   block = LLVMAppendBasicBlockInContext(gallivm->context, variant_func, "entry");
-   builder = gallivm->builder;
-   LLVMPositionBuilderAtEnd(builder, block);
-
-   lp_build_context_init(&bld, gallivm, lp_type_int(32));
-
-   memset(&tcs_type, 0, sizeof tcs_type);
-   tcs_type.floating = TRUE; /* floating point values */
-   tcs_type.sign = TRUE;     /* values are signed */
-   tcs_type.norm = FALSE;    /* values are not limited to [0,1] or [-1,1] */
-   tcs_type.width = 32;      /* 32-bit float */
-   tcs_type.length = vector_length;
-
-   lp_build_context_init(&bldvec, variant->gallivm, lp_int_type(tcs_type));
-
-   LLVMValueRef count = lp_build_const_int32(gallivm, variant->shader->base.vertices_out);
-   LLVMValueRef step = lp_build_const_int32(gallivm, vector_length);
-
-   struct lp_build_loop_state loop_state[2];
-   LLVMValueRef num_inner_loop;
-   unsigned count_align = util_align_npot(variant->shader->base.vertices_out, tcs_type.length);
-   num_inner_loop = lp_build_const_int32(gallivm, count_align / tcs_type.length);
-   LLVMTypeRef hdl_ptr_type = LLVMPointerType(LLVMInt8TypeInContext(gallivm->context), 0);
-   LLVMValueRef coro_hdls = LLVMBuildArrayAlloca(gallivm->builder, hdl_ptr_type, num_inner_loop, "coro_hdls");
-   unsigned end_coroutine = INT_MAX;
-   lp_build_loop_begin(&loop_state[1], gallivm,
-                       lp_build_const_int32(gallivm, 0)); /* coroutine reentry loop */
-   lp_build_loop_begin(&loop_state[0], gallivm,
-                       lp_build_const_int32(gallivm, 0)); /* inner loop */
-   {
-      LLVMValueRef args[6];
-      args[0] = context_ptr;
-      args[1] = input_array;
-      args[2] = output_array;
-      args[3] = prim_id;
-      args[4] = patch_vertices_in;
-      args[5] = loop_state[0].counter;
-      LLVMValueRef coro_entry = LLVMBuildGEP(builder, coro_hdls, &loop_state[0].counter, 1, "");
-      LLVMValueRef coro_hdl = LLVMBuildLoad(builder, coro_entry, "coro_hdl");
-
-      struct lp_build_if_state ifstate;
-      LLVMValueRef cmp = LLVMBuildICmp(builder, LLVMIntEQ, loop_state[1].counter,
-                                       lp_build_const_int32(gallivm, 0), "");
-      /* first time here - call the coroutine function entry point */
-      lp_build_if(&ifstate, gallivm, cmp);
-      LLVMValueRef coro_ret = LLVMBuildCall(builder, variant_coro, args, 6, "");
-      LLVMBuildStore(builder, coro_ret, coro_entry);
-      lp_build_else(&ifstate);
-      /* subsequent calls for this invocation - check if done. */
-      LLVMValueRef coro_done = lp_build_coro_done(gallivm, coro_hdl);
-      struct lp_build_if_state ifstate2;
-      lp_build_if(&ifstate2, gallivm, coro_done);
-      /* if done destroy and force loop exit */
-      lp_build_coro_destroy(gallivm, coro_hdl);
-      lp_build_loop_force_set_counter(&loop_state[1], lp_build_const_int32(gallivm, end_coroutine - 1));
-      lp_build_else(&ifstate2);
-      /* otherwise resume the coroutine */
-      lp_build_coro_resume(gallivm, coro_hdl);
-      lp_build_endif(&ifstate2);
-      lp_build_endif(&ifstate);
-      lp_build_loop_force_reload_counter(&loop_state[1]);
-   }
-   lp_build_loop_end_cond(&loop_state[0],
-                          num_inner_loop,
-                          NULL,  LLVMIntUGE);
-   lp_build_loop_end_cond(&loop_state[1],
-                          lp_build_const_int32(gallivm, end_coroutine),
-                          NULL, LLVMIntEQ);
-   LLVMBuildRet(builder, lp_build_zero(gallivm, lp_type_uint(32)));
-
-   block = LLVMAppendBasicBlockInContext(gallivm->context, variant_coro, "entry");
-   LLVMPositionBuilderAtEnd(builder, block);
-
-   context_ptr = LLVMGetParam(variant_coro, 0);
-   input_array = LLVMGetParam(variant_coro, 1);
-   output_array = LLVMGetParam(variant_coro, 2);
-   prim_id = LLVMGetParam(variant_coro, 3);
-   patch_vertices_in = LLVMGetParam(variant_coro, 4);
-
-   consts_ptr = draw_tcs_jit_context_constants(variant->gallivm, context_ptr);
-   num_consts_ptr =
-      draw_tcs_jit_context_num_constants(variant->gallivm, context_ptr);
-
-   ssbos_ptr = draw_tcs_jit_context_ssbos(variant->gallivm, context_ptr);
-   num_ssbos_ptr =
-      draw_tcs_jit_context_num_ssbos(variant->gallivm, context_ptr);
-   sampler = draw_llvm_sampler_soa_create(variant->key.samplers);
-   image = draw_llvm_image_soa_create(draw_tcs_llvm_variant_key_images(&variant->key));
-
-   LLVMValueRef counter = LLVMGetParam(variant_coro, 5);
-   LLVMValueRef invocvec = LLVMGetUndef(LLVMVectorType(int32_type, vector_length));
-   for (i = 0; i < vector_length; i++) {
-      LLVMValueRef idx = LLVMBuildAdd(builder, LLVMBuildMul(builder, counter, step, ""), lp_build_const_int32(gallivm, i), "");
-      invocvec = LLVMBuildInsertElement(builder, invocvec, idx, idx, "");
-   }
-
-   system_values.invocation_id = invocvec;
-   system_values.prim_id = lp_build_broadcast_scalar(&bldvec, prim_id);
-   system_values.vertices_in = lp_build_broadcast_scalar(&bldvec, patch_vertices_in);
-   tcs_iface.input = input_array;
-   tcs_iface.output = output_array;
-   tcs_iface.base.emit_fetch_input = draw_tcs_llvm_emit_fetch_input;
-   tcs_iface.base.emit_fetch_output = draw_tcs_llvm_emit_fetch_output;
-   tcs_iface.base.emit_store_output = draw_tcs_llvm_emit_store_output;
-
-
-   {
-      LLVMValueRef coro_id = lp_build_coro_id(gallivm);
-      LLVMValueRef coro_hdl = lp_build_coro_begin_alloc_mem(gallivm, coro_id);
-
-      mask_val = generate_tcs_mask_value(variant, tcs_type, count, LLVMBuildMul(builder, counter, step, ""));
-      lp_build_mask_begin(&mask, gallivm, tcs_type, mask_val);
-
-      struct lp_build_coro_suspend_info coro_info;
-
-      LLVMBasicBlockRef sus_block = LLVMAppendBasicBlockInContext(gallivm->context, variant_coro, "suspend");
-      LLVMBasicBlockRef clean_block = LLVMAppendBasicBlockInContext(gallivm->context, variant_coro, "cleanup");
-
-      coro_info.suspend = sus_block;
-      coro_info.cleanup = clean_block;
-
-      struct lp_build_tgsi_params params;
-      memset(&params, 0, sizeof(params));
-
-      params.type = tcs_type;
-      params.mask = &mask;
-      params.consts_ptr = consts_ptr;
-      params.const_sizes_ptr = num_consts_ptr;
-      params.system_values = &system_values;
-      params.context_ptr = context_ptr;
-      params.sampler = sampler;
-      params.info = &llvm->draw->tcs.tess_ctrl_shader->info;
-      params.ssbo_ptr = ssbos_ptr;
-      params.ssbo_sizes_ptr = num_ssbos_ptr;
-      params.image = image;
-      params.coro = &coro_info;
-      params.tcs_iface = &tcs_iface.base;
-
-      lp_build_nir_soa(variant->gallivm,
-                       llvm->draw->tcs.tess_ctrl_shader->state.ir.nir,
-                       &params, NULL);
-
-      lp_build_mask_end(&mask);
-
-      lp_build_coro_suspend_switch(gallivm, &coro_info, NULL, true);
-      LLVMPositionBuilderAtEnd(builder, clean_block);
-
-      lp_build_coro_free_mem(gallivm, coro_id, coro_hdl);
-
-      LLVMBuildBr(builder, sus_block);
-      LLVMPositionBuilderAtEnd(builder, sus_block);
-
-      lp_build_coro_end(gallivm, coro_hdl);
-      LLVMBuildRet(builder, coro_hdl);
-   }
-
-   sampler->destroy(sampler);
-   image->destroy(image);
-   gallivm_verify_function(gallivm, variant_func);
-   gallivm_verify_function(gallivm, variant_coro);
-}
-
-struct draw_tcs_llvm_variant *
-draw_tcs_llvm_create_variant(struct draw_llvm *llvm,
-                             unsigned num_outputs,
-                             const struct draw_tcs_llvm_variant_key *key)
-{
-   struct draw_tcs_llvm_variant *variant;
-   struct llvm_tess_ctrl_shader *shader = llvm_tess_ctrl_shader(llvm->draw->tcs.tess_ctrl_shader);
-   char module_name[64];
-
-   variant = MALLOC(sizeof *variant +
-                    shader->variant_key_size - sizeof variant->key);
-   if (!variant)
-      return NULL;
-
-   variant->llvm = llvm;
-   variant->shader = shader;
-
-   snprintf(module_name, sizeof(module_name), "draw_llvm_tcs_variant%u",
-            variant->shader->variants_cached);
-
-   variant->gallivm = gallivm_create(module_name, llvm->context);
-
-   create_tcs_jit_types(variant);
-
-   memcpy(&variant->key, key, shader->variant_key_size);
-
-   if (gallivm_debug & (GALLIVM_DEBUG_TGSI | GALLIVM_DEBUG_IR)) {
-      nir_print_shader(llvm->draw->tcs.tess_ctrl_shader->state.ir.nir, stderr);
-      draw_tcs_llvm_dump_variant_key(&variant->key);
-   }
-
-   draw_tcs_llvm_generate(llvm, variant);
-
-   gallivm_compile_module(variant->gallivm);
-
-   variant->jit_func = (draw_tcs_jit_func)
-      gallivm_jit_function(variant->gallivm, variant->function);
-
-   gallivm_free_ir(variant->gallivm);
-
-   variant->list_item_global.base = variant;
-   variant->list_item_local.base = variant;
-   /*variant->no = */shader->variants_created++;
-   variant->list_item_global.base = variant;
-
-   return variant;
-}
-
-void
-draw_tcs_llvm_destroy_variant(struct draw_tcs_llvm_variant *variant)
-{
-   struct draw_llvm *llvm = variant->llvm;
-
-   if (gallivm_debug & (GALLIVM_DEBUG_TGSI | GALLIVM_DEBUG_IR)) {
-      debug_printf("Deleting TCS variant: %u tcs variants,\t%u total variants\n",
-                    variant->shader->variants_cached, llvm->nr_tcs_variants);
-   }
-
-   gallivm_destroy(variant->gallivm);
-
-   remove_from_list(&variant->list_item_local);
-   variant->shader->variants_cached--;
-   remove_from_list(&variant->list_item_global);
-   llvm->nr_tcs_variants--;
-   FREE(variant);
-}
-
-struct draw_tcs_llvm_variant_key *
-draw_tcs_llvm_make_variant_key(struct draw_llvm *llvm, char *store)
-{
-   unsigned i;
-   struct draw_tcs_llvm_variant_key *key;
-   struct draw_sampler_static_state *draw_sampler;
-   struct draw_image_static_state *draw_image;
-
-   key = (struct draw_tcs_llvm_variant_key *)store;
-
-   memset(key, 0, offsetof(struct draw_tcs_llvm_variant_key, samplers[0]));
-
-   /* All variants of this shader will have the same value for
-    * nr_samplers.  Not yet trying to compact away holes in the
-    * sampler array.
-    */
-   key->nr_samplers = llvm->draw->tcs.tess_ctrl_shader->info.file_max[TGSI_FILE_SAMPLER] + 1;
-   if (llvm->draw->tcs.tess_ctrl_shader->info.file_max[TGSI_FILE_SAMPLER_VIEW] != -1) {
-      key->nr_sampler_views =
-         llvm->draw->tcs.tess_ctrl_shader->info.file_max[TGSI_FILE_SAMPLER_VIEW] + 1;
-   }
-   else {
-      key->nr_sampler_views = key->nr_samplers;
-   }
-
-   key->nr_images = llvm->draw->tcs.tess_ctrl_shader->info.file_max[TGSI_FILE_IMAGE] + 1;
-
-   draw_sampler = key->samplers;
-
-   memset(draw_sampler, 0, MAX2(key->nr_samplers, key->nr_sampler_views) * sizeof *draw_sampler);
-
-   for (i = 0 ; i < key->nr_samplers; i++) {
-      lp_sampler_static_sampler_state(&draw_sampler[i].sampler_state,
-                                      llvm->draw->samplers[PIPE_SHADER_TESS_CTRL][i]);
-   }
-   for (i = 0 ; i < key->nr_sampler_views; i++) {
-      lp_sampler_static_texture_state(&draw_sampler[i].texture_state,
-                                      llvm->draw->sampler_views[PIPE_SHADER_TESS_CTRL][i]);
-   }
-
-   draw_image = draw_tcs_llvm_variant_key_images(key);
-   memset(draw_image, 0,
-          key->nr_images * sizeof *draw_image);
-   for (i = 0; i < key->nr_images; i++) {
-      lp_sampler_static_texture_state_image(&draw_image[i].image_state,
-                                            llvm->draw->images[PIPE_SHADER_TESS_CTRL][i]);
-   }
-   return key;
-}
-
-void
-draw_tcs_llvm_dump_variant_key(struct draw_tcs_llvm_variant_key *key)
-{
-   unsigned i;
-   struct draw_sampler_static_state *sampler = key->samplers;
-   struct draw_image_static_state *image = draw_tcs_llvm_variant_key_images(key);
-   for (i = 0 ; i < key->nr_sampler_views; i++) {
-      debug_printf("sampler[%i].src_format = %s\n", i,
-                   util_format_name(sampler[i].texture_state.format));
-   }
-
-   for (i = 0 ; i < key->nr_images; i++)
-      debug_printf("images[%i].format = %s\n", i, util_format_name(image[i].image_state.format));
-
-}
-
-static void
-create_tes_jit_types(struct draw_tes_llvm_variant *var)
-{
-   struct gallivm_state *gallivm = var->gallivm;
-   LLVMTypeRef texture_type, sampler_type, image_type, context_type;
-
-   texture_type = create_jit_texture_type(gallivm, "texture");
-   sampler_type = create_jit_sampler_type(gallivm, "sampler");
-   image_type = create_jit_image_type(gallivm, "image");
-
-   context_type = create_tes_jit_context_type(gallivm,
-                                              0,
-                                              texture_type, sampler_type,
-                                              image_type,
-                                              "draw_tes_jit_context");
-   var->context_ptr_type = LLVMPointerType(context_type, 0);
-
-   var->input_array_type = create_tes_jit_input_type(gallivm);
-}
-
-static LLVMTypeRef
-get_tes_context_ptr_type(struct draw_tes_llvm_variant *variant)
-{
-   if (!variant->context_ptr_type)
-      create_tes_jit_types(variant);
-   return variant->context_ptr_type;
-}
-
-static LLVMValueRef
-generate_tes_mask_value(struct draw_tes_llvm_variant *variant,
-                        struct lp_type tes_type, LLVMValueRef limit, LLVMValueRef loop_counter)
-{
-   struct gallivm_state *gallivm = variant->gallivm;
-   LLVMBuilderRef builder = gallivm->builder;
-   struct lp_type mask_type = lp_int_type(tes_type);
-   LLVMValueRef num_prims;
-   LLVMValueRef mask_val = lp_build_const_vec(gallivm, mask_type, 0);
-   unsigned i;
-
-   num_prims = lp_build_broadcast(gallivm, lp_build_vec_type(gallivm, mask_type), limit);
-   for (i = 0; i < tes_type.length; i++) {
-      LLVMValueRef idx = lp_build_const_int32(gallivm, i);
-      mask_val = LLVMBuildInsertElement(builder, mask_val, LLVMBuildAdd(builder, loop_counter, idx, ""), idx, "");
-   }
-   mask_val = lp_build_compare(gallivm, mask_type,
-                               PIPE_FUNC_GREATER, num_prims, mask_val);
-
-   return mask_val;
-}
-
-static LLVMValueRef
-draw_tes_llvm_fetch_vertex_input(const struct lp_build_tes_iface *tes_iface,
-                                 struct lp_build_context *bld,
-                                 boolean is_vindex_indirect,
-                                 LLVMValueRef vertex_index,
-                                 boolean is_aindex_indirect,
-                                 LLVMValueRef attrib_index,
-                                 LLVMValueRef swizzle_index)
-{
-   const struct draw_tes_llvm_iface *tes = draw_tes_llvm_iface(tes_iface);
-   struct gallivm_state *gallivm = bld->gallivm;
-   LLVMBuilderRef builder = gallivm->builder;
-   LLVMValueRef indices[3];
-   LLVMValueRef res;
-   struct lp_type type = bld->type;
-
-   if (is_vindex_indirect || is_aindex_indirect) {
-      int i;
-
-      res = bld->zero;
-
-      for (i = 0; i < type.length; ++i) {
-         LLVMValueRef idx = lp_build_const_int32(gallivm, i);
-         LLVMValueRef vert_chan_index = vertex_index;
-         LLVMValueRef attr_chan_index = attrib_index;
-         LLVMValueRef channel_vec;
-
-         if (is_vindex_indirect) {
-            vert_chan_index = LLVMBuildExtractElement(builder,
-                                                      vertex_index, idx, "");
-         }
-         if (is_aindex_indirect) {
-            attr_chan_index = LLVMBuildExtractElement(builder,
-                                                      attrib_index, idx, "");
-         }
-
-         indices[0] = vert_chan_index;
-         indices[1] = attr_chan_index;
-         indices[2] = swizzle_index;
-
-         channel_vec = LLVMBuildGEP(builder, tes->input, indices, 3, "");
-         channel_vec = LLVMBuildLoad(builder, channel_vec, "");
-
-         res = LLVMBuildInsertElement(builder, res, channel_vec, idx, "");
-      }
-   } else {
-      indices[0] = vertex_index;
-      indices[1] = attrib_index;
-      indices[2] = swizzle_index;
-
-      res = LLVMBuildGEP(builder, tes->input, indices, 3, "");
-      res = LLVMBuildLoad(builder, res, "");
-      res = lp_build_broadcast_scalar(bld, res);
-   }
-   return res;
-}
-
-static LLVMValueRef
-draw_tes_llvm_fetch_patch_input(const struct lp_build_tes_iface *tes_iface,
-                                struct lp_build_context *bld,
-                                boolean is_aindex_indirect,
-                                LLVMValueRef attrib_index,
-                                LLVMValueRef swizzle_index)
-{
-   const struct draw_tes_llvm_iface *tes = draw_tes_llvm_iface(tes_iface);
-   struct gallivm_state *gallivm = bld->gallivm;
-   LLVMBuilderRef builder = gallivm->builder;
-   LLVMValueRef indices[3];
-   LLVMValueRef res;
-   struct lp_type type = bld->type;
-
-   if (is_aindex_indirect) {
-      int i;
-
-      res = bld->zero;
-
-      for (i = 0; i < type.length; ++i) {
-         LLVMValueRef idx = lp_build_const_int32(gallivm, i);
-         LLVMValueRef attr_chan_index = attrib_index;
-         LLVMValueRef channel_vec;
-
-         if (is_aindex_indirect) {
-            attr_chan_index = LLVMBuildExtractElement(builder,
-                                                      attrib_index, idx, "");
-         }
-
-         indices[0] = lp_build_const_int32(gallivm, 0);
-         indices[1] = attr_chan_index;
-         indices[2] = swizzle_index;
-
-         channel_vec = LLVMBuildGEP(builder, tes->input, indices, 3, "");
-         channel_vec = LLVMBuildLoad(builder, channel_vec, "");
-
-         res = LLVMBuildInsertElement(builder, res, channel_vec, idx, "");
-      }
-   } else {
-      indices[0] = lp_build_const_int32(gallivm, 0);
-      indices[1] = attrib_index;
-      indices[2] = swizzle_index;
-
-      res = LLVMBuildGEP(builder, tes->input, indices, 3, "");
-      res = LLVMBuildLoad(builder, res, "");
-      res = lp_build_broadcast_scalar(bld, res);
-   }
-   return res;
-}
-
-static void
-draw_tes_llvm_generate(struct draw_llvm *llvm,
-                       struct draw_tes_llvm_variant *variant)
-{
-   struct gallivm_state *gallivm = variant->gallivm;
-   LLVMContextRef context = gallivm->context;
-   LLVMTypeRef int32_type = LLVMInt32TypeInContext(context);
-   LLVMTypeRef flt_type = LLVMFloatTypeInContext(context);
-   LLVMTypeRef arg_types[10];
-   LLVMTypeRef func_type;
-   LLVMValueRef variant_func;
-   LLVMValueRef context_ptr;
-   LLVMValueRef tess_coord[2], io_ptr, input_array, num_tess_coord;
-   LLVMValueRef tess_inner, tess_outer, prim_id, patch_vertices_in;
-   LLVMBasicBlockRef block;
-   LLVMBuilderRef builder;
-   LLVMValueRef mask_val;
-   struct lp_build_context bld, bldvec;
-   struct lp_build_sampler_soa *sampler = 0;
-   struct lp_build_image_soa *image = NULL;
-   struct lp_bld_tgsi_system_values system_values;
-   char func_name[64];
-   unsigned i;
-   struct draw_tes_llvm_iface tes_iface;
-   LLVMValueRef outputs[PIPE_MAX_SHADER_OUTPUTS][TGSI_NUM_CHANNELS];
-   struct lp_build_mask_context mask;
-   LLVMValueRef consts_ptr, num_consts_ptr;
-   LLVMValueRef ssbos_ptr, num_ssbos_ptr;
-   LLVMValueRef step;
-   struct lp_type tes_type;
-   unsigned vector_length = variant->shader->base.vector_length;
-
-   memset(&system_values, 0, sizeof(system_values));
-   memset(&outputs, 0, sizeof(outputs));
-
-   snprintf(func_name, sizeof(func_name), "draw_llvm_tes_variant%u",
-            variant->shader->variants_cached);
-
-   arg_types[0] = get_tes_context_ptr_type(variant);    /* context */
-   arg_types[1] = variant->input_array_type;           /* input */
-   arg_types[2] = variant->vertex_header_ptr_type;
-   arg_types[3] = int32_type;
-   arg_types[4] = int32_type;
-   arg_types[5] = LLVMPointerType(flt_type, 0);
-   arg_types[6] = LLVMPointerType(flt_type, 0);
-   arg_types[7] = LLVMPointerType(LLVMArrayType(flt_type, 4), 0);
-   arg_types[8] = LLVMPointerType(LLVMArrayType(flt_type, 2), 0);
-   arg_types[9] = int32_type;
-
-   func_type = LLVMFunctionType(int32_type, arg_types, ARRAY_SIZE(arg_types), 0);
-   variant_func = LLVMAddFunction(gallivm->module, func_name, func_type);
-
-   variant->function = variant_func;
-   LLVMSetFunctionCallConv(variant_func, LLVMCCallConv);
-
-   for (i = 0; i < ARRAY_SIZE(arg_types); ++i)
-      if (LLVMGetTypeKind(arg_types[i]) == LLVMPointerTypeKind)
-         lp_add_function_attr(variant_func, i + 1, LP_FUNC_ATTR_NOALIAS);
-
-   context_ptr               = LLVMGetParam(variant_func, 0);
-   input_array               = LLVMGetParam(variant_func, 1);
-   io_ptr                    = LLVMGetParam(variant_func, 2);
-   prim_id                   = LLVMGetParam(variant_func, 3);
-   num_tess_coord            = LLVMGetParam(variant_func, 4);
-   tess_coord[0]             = LLVMGetParam(variant_func, 5);
-   tess_coord[1]             = LLVMGetParam(variant_func, 6);
-   tess_outer                = LLVMGetParam(variant_func, 7);
-   tess_inner                = LLVMGetParam(variant_func, 8);
-   patch_vertices_in         = LLVMGetParam(variant_func, 9);
-
-   lp_build_name(context_ptr, "context");
-   lp_build_name(input_array, "input");
-   lp_build_name(io_ptr, "io");
-   lp_build_name(prim_id, "prim_id");
-   lp_build_name(num_tess_coord, "num_tess_coord");
-   lp_build_name(tess_coord[0], "tess_coord[0]");
-   lp_build_name(tess_coord[1], "tess_coord[1]");
-   lp_build_name(tess_outer, "tess_outer");
-   lp_build_name(tess_inner, "tess_inner");
-   lp_build_name(patch_vertices_in, "patch_vertices_in");
-
-   tes_iface.base.fetch_vertex_input = draw_tes_llvm_fetch_vertex_input;
-   tes_iface.base.fetch_patch_input = draw_tes_llvm_fetch_patch_input;
-   tes_iface.input = input_array;
-   tes_iface.variant = variant;
-
-   block = LLVMAppendBasicBlockInContext(gallivm->context, variant_func, "entry");
-   builder = gallivm->builder;
-   LLVMPositionBuilderAtEnd(builder, block);
-
-   lp_build_context_init(&bld, gallivm, lp_type_int(32));
-
-   memset(&tes_type, 0, sizeof tes_type);
-   tes_type.floating = TRUE; /* floating point values */
-   tes_type.sign = TRUE;     /* values are signed */
-   tes_type.norm = FALSE;    /* values are not limited to [0,1] or [-1,1] */
-   tes_type.width = 32;      /* 32-bit float */
-   tes_type.length = vector_length;
-
-   lp_build_context_init(&bldvec, variant->gallivm, lp_int_type(tes_type));
-   consts_ptr = draw_tes_jit_context_constants(variant->gallivm, context_ptr);
-   num_consts_ptr =
-      draw_tes_jit_context_num_constants(variant->gallivm, context_ptr);
-
-   ssbos_ptr = draw_tes_jit_context_ssbos(variant->gallivm, context_ptr);
-   num_ssbos_ptr =
-      draw_tes_jit_context_num_ssbos(variant->gallivm, context_ptr);
-   sampler = draw_llvm_sampler_soa_create(variant->key.samplers);
-   image = draw_llvm_image_soa_create(draw_tes_llvm_variant_key_images(&variant->key));
-   step = lp_build_const_int32(gallivm, vector_length);
-
-   system_values.tess_outer = LLVMBuildLoad(builder, tess_outer, "");
-   system_values.tess_inner = LLVMBuildLoad(builder, tess_inner, "");
-
-   system_values.prim_id = lp_build_broadcast_scalar(&bldvec, prim_id);
-
-   system_values.vertices_in = lp_build_broadcast_scalar(&bldvec, patch_vertices_in);
-   struct lp_build_loop_state lp_loop;
-   lp_build_loop_begin(&lp_loop, gallivm, bld.zero);
-   {
-      LLVMValueRef io;
-
-      io = LLVMBuildGEP(builder, io_ptr, &lp_loop.counter, 1, "");
-      mask_val = generate_tes_mask_value(variant, tes_type, num_tess_coord, lp_loop.counter);
-      lp_build_mask_begin(&mask, gallivm, tes_type, mask_val);
-
-      system_values.tess_coord = LLVMGetUndef(LLVMArrayType(LLVMVectorType(flt_type, vector_length), 3));
-      for (i = 0; i < 3; i++) {
-         LLVMValueRef tess_coord_chan = LLVMGetUndef(LLVMVectorType(flt_type, vector_length));
-         for (unsigned j = 0; j < vector_length; j++) {
-            LLVMValueRef idx = LLVMBuildAdd(builder, lp_loop.counter, lp_build_const_int32(gallivm, j), "");
-            LLVMValueRef tc_val;
-            if (i == 2) {
-               if (variant->shader->base.prim_mode == PIPE_PRIM_TRIANGLES) {
-                  tc_val = lp_build_const_float(gallivm, 1.0);
-                  tc_val = LLVMBuildFSub(builder, tc_val, lp_build_pointer_get(builder, tess_coord[0], idx), "");
-                  tc_val = LLVMBuildFSub(builder, tc_val, lp_build_pointer_get(builder, tess_coord[1], idx), "");
-               } else
-                  tc_val = lp_build_const_float(gallivm, 0.0);
-            } else
-               tc_val = lp_build_pointer_get(builder, tess_coord[i], idx);
-
-            tess_coord_chan = LLVMBuildInsertElement(builder, tess_coord_chan, tc_val, lp_build_const_int32(gallivm, j), "");
-         }
-         system_values.tess_coord = LLVMBuildInsertValue(builder, system_values.tess_coord, tess_coord_chan, i, "");
-      }
-
-      struct lp_build_tgsi_params params;
-      memset(&params, 0, sizeof(params));
-
-      params.type = tes_type;
-      params.mask = &mask;
-      params.consts_ptr = consts_ptr;
-      params.const_sizes_ptr = num_consts_ptr;
-      params.system_values = &system_values;
-      params.context_ptr = context_ptr;
-      params.sampler = sampler;
-      params.info = &llvm->draw->tes.tess_eval_shader->info;
-      params.ssbo_ptr = ssbos_ptr;
-      params.ssbo_sizes_ptr = num_ssbos_ptr;
-      params.image = image;
-      params.tes_iface = &tes_iface.base;
-
-      lp_build_nir_soa(variant->gallivm,
-                       llvm->draw->tes.tess_eval_shader->state.ir.nir,
-                       &params,
-                       outputs);
-
-      lp_build_mask_end(&mask);
-      LLVMValueRef clipmask = lp_build_const_int_vec(gallivm,
-                                                     lp_int_type(tes_type), 0);
-
-      convert_to_aos(gallivm, io, NULL, outputs, clipmask,
-                     params.info->num_outputs, tes_type, FALSE);
-   }
-   lp_build_loop_end_cond(&lp_loop, num_tess_coord, step, LLVMIntUGE);
-   sampler->destroy(sampler);
-   image->destroy(image);
-
-   LLVMBuildRet(builder, lp_build_zero(gallivm, lp_type_uint(32)));
-   gallivm_verify_function(gallivm, variant_func);
-}
-
-struct draw_tes_llvm_variant *
-draw_tes_llvm_create_variant(struct draw_llvm *llvm,
-                             unsigned num_outputs,
-                             const struct draw_tes_llvm_variant_key *key)
-{
-   struct draw_tes_llvm_variant *variant;
-   struct llvm_tess_eval_shader *shader = llvm_tess_eval_shader(llvm->draw->tes.tess_eval_shader);
-   LLVMTypeRef vertex_header;
-   char module_name[64];
-
-   variant = MALLOC(sizeof *variant +
-                    shader->variant_key_size - sizeof variant->key);
-   if (!variant)
-      return NULL;
-
-   variant->llvm = llvm;
-   variant->shader = shader;
-
-   snprintf(module_name, sizeof(module_name), "draw_llvm_tes_variant%u",
-            variant->shader->variants_cached);
-
-   variant->gallivm = gallivm_create(module_name, llvm->context);
-
-   create_tes_jit_types(variant);
-
-   memcpy(&variant->key, key, shader->variant_key_size);
-
-   vertex_header = create_jit_vertex_header(variant->gallivm, num_outputs);
-
-   variant->vertex_header_ptr_type = LLVMPointerType(vertex_header, 0);
-
-   if (gallivm_debug & (GALLIVM_DEBUG_TGSI | GALLIVM_DEBUG_IR)) {
-      nir_print_shader(llvm->draw->tes.tess_eval_shader->state.ir.nir, stderr);
-      draw_tes_llvm_dump_variant_key(&variant->key);
-   }
-
-   draw_tes_llvm_generate(llvm, variant);
-
-   gallivm_compile_module(variant->gallivm);
-
-   variant->jit_func = (draw_tes_jit_func)
-      gallivm_jit_function(variant->gallivm, variant->function);
-
-   gallivm_free_ir(variant->gallivm);
-
-   variant->list_item_global.base = variant;
-   variant->list_item_local.base = variant;
-   /*variant->no = */shader->variants_created++;
-   variant->list_item_global.base = variant;
-
-   return variant;
-}
-
-void
-draw_tes_llvm_destroy_variant(struct draw_tes_llvm_variant *variant)
-{
-   struct draw_llvm *llvm = variant->llvm;
-
-   if (gallivm_debug & (GALLIVM_DEBUG_TGSI | GALLIVM_DEBUG_IR)) {
-      debug_printf("Deleting TES variant: %u tes variants,\t%u total variants\n",
-                    variant->shader->variants_cached, llvm->nr_tes_variants);
-   }
-
-   gallivm_destroy(variant->gallivm);
-
-   remove_from_list(&variant->list_item_local);
-   variant->shader->variants_cached--;
-   remove_from_list(&variant->list_item_global);
-   llvm->nr_tes_variants--;
-   FREE(variant);
-}
-
-struct draw_tes_llvm_variant_key *
-draw_tes_llvm_make_variant_key(struct draw_llvm *llvm, char *store)
-{
-   unsigned i;
-   struct draw_tes_llvm_variant_key *key;
-   struct draw_sampler_static_state *draw_sampler;
-   struct draw_image_static_state *draw_image;
-
-   key = (struct draw_tes_llvm_variant_key *)store;
-
-   memset(key, 0, offsetof(struct draw_tes_llvm_variant_key, samplers[0]));
-
-   /* All variants of this shader will have the same value for
-    * nr_samplers.  Not yet trying to compact away holes in the
-    * sampler array.
-    */
-   key->nr_samplers = llvm->draw->tes.tess_eval_shader->info.file_max[TGSI_FILE_SAMPLER] + 1;
-   if (llvm->draw->tes.tess_eval_shader->info.file_max[TGSI_FILE_SAMPLER_VIEW] != -1) {
-      key->nr_sampler_views =
-         llvm->draw->tes.tess_eval_shader->info.file_max[TGSI_FILE_SAMPLER_VIEW] + 1;
-   }
-   else {
-      key->nr_sampler_views = key->nr_samplers;
-   }
-
-   key->nr_images = llvm->draw->tes.tess_eval_shader->info.file_max[TGSI_FILE_IMAGE] + 1;
-
-   draw_sampler = key->samplers;
-
-   memset(draw_sampler, 0, MAX2(key->nr_samplers, key->nr_sampler_views) * sizeof *draw_sampler);
-
-   for (i = 0 ; i < key->nr_samplers; i++) {
-      lp_sampler_static_sampler_state(&draw_sampler[i].sampler_state,
-                                      llvm->draw->samplers[PIPE_SHADER_TESS_EVAL][i]);
-   }
-   for (i = 0 ; i < key->nr_sampler_views; i++) {
-      lp_sampler_static_texture_state(&draw_sampler[i].texture_state,
-                                      llvm->draw->sampler_views[PIPE_SHADER_TESS_EVAL][i]);
-   }
-
-   draw_image = draw_tes_llvm_variant_key_images(key);
-   memset(draw_image, 0,
-          key->nr_images * sizeof *draw_image);
-   for (i = 0; i < key->nr_images; i++) {
-      lp_sampler_static_texture_state_image(&draw_image[i].image_state,
-                                            llvm->draw->images[PIPE_SHADER_TESS_EVAL][i]);
-   }
-   return key;
-}
-
-void
-draw_tes_llvm_dump_variant_key(struct draw_tes_llvm_variant_key *key)
-{
-   unsigned i;
-   struct draw_sampler_static_state *sampler = key->samplers;
-   struct draw_image_static_state *image = draw_tes_llvm_variant_key_images(key);
-   for (i = 0 ; i < key->nr_sampler_views; i++) {
-      debug_printf("sampler[%i].src_format = %s\n", i,
-                   util_format_name(sampler[i].texture_state.format));
-   }
-
-   for (i = 0 ; i < key->nr_images; i++)
-      debug_printf("images[%i].format = %s\n", i, util_format_name(image[i].image_state.format));
-
-}
diff --git a/lib/mesa/src/gallium/auxiliary/draw/draw_llvm.h b/lib/mesa/src/gallium/auxiliary/draw/draw_llvm.h
index b1c498631..6edc89b63 100644
--- a/lib/mesa/src/gallium/auxiliary/draw/draw_llvm.h
+++ b/lib/mesa/src/gallium/auxiliary/draw/draw_llvm.h
@@ -32,7 +32,6 @@
 
 #include "draw/draw_vs.h"
 #include "draw/draw_gs.h"
-#include "draw/draw_tess.h"
 
 #include "gallivm/lp_bld_sample.h"
 #include "gallivm/lp_bld_limits.h"
@@ -44,8 +43,6 @@
 struct draw_llvm;
 struct llvm_vertex_shader;
 struct llvm_geometry_shader;
-struct llvm_tess_ctrl_shader;
-struct llvm_tess_eval_shader;
 
 struct draw_jit_texture
 {
@@ -320,103 +317,6 @@ enum {
 #define draw_gs_jit_context_num_ssbos(_gallivm, _ptr) \
    lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_GS_JIT_CTX_NUM_SSBOS, "num_ssbos")
 
-
-struct draw_tcs_jit_context {
-   const float *constants[LP_MAX_TGSI_CONST_BUFFERS];
-   int num_constants[LP_MAX_TGSI_CONST_BUFFERS];
-
-   int dummy1;
-   int dummy2;
-   /* There two need to be exactly at DRAW_JIT_CTX_TEXTURES and
-    * DRAW_JIT_CTX_SAMPLERS positions in the struct */
-   struct draw_jit_texture textures[PIPE_MAX_SHADER_SAMPLER_VIEWS];
-   struct draw_jit_sampler samplers[PIPE_MAX_SAMPLERS];
-   struct draw_jit_image images[PIPE_MAX_SHADER_IMAGES];
-
-   const uint32_t *ssbos[LP_MAX_TGSI_SHADER_BUFFERS];
-   int num_ssbos[LP_MAX_TGSI_SHADER_BUFFERS];
-};
-
-enum {
-   DRAW_TCS_JIT_CTX_CONSTANTS = 0,
-   DRAW_TCS_JIT_CTX_NUM_CONSTANTS = 1,
-   DRAW_TCS_JIT_CTX_TEXTURES = DRAW_JIT_CTX_TEXTURES,
-   DRAW_TCS_JIT_CTX_SAMPLERS = DRAW_JIT_CTX_SAMPLERS,
-   DRAW_TCS_JIT_CTX_IMAGES = DRAW_JIT_CTX_IMAGES,
-   DRAW_TCS_JIT_CTX_SSBOS = 7,
-   DRAW_TCS_JIT_CTX_NUM_SSBOS = 8,
-   DRAW_TCS_JIT_CTX_NUM_FIELDS = 9,
-};
-
-#define draw_tcs_jit_context_constants(_gallivm, _ptr) \
-   lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_TCS_JIT_CTX_CONSTANTS, "constants")
-
-#define draw_tcs_jit_context_num_constants(_gallivm, _ptr) \
-   lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_TCS_JIT_CTX_NUM_CONSTANTS, "num_constants")
-
-#define draw_tcs_jit_context_textures(_gallivm, _ptr) \
-   lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_TCS_JIT_CTX_TEXTURES, "textures")
-
-#define draw_tcs_jit_context_samplers(_gallivm, _ptr) \
-   lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_TCS_JIT_CTX_SAMPLERS, "samplers")
-
-#define draw_tcs_jit_context_images(_gallivm, _ptr)                      \
-   lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_TCS_JIT_CTX_IMAGES, "images")
-
-#define draw_tcs_jit_context_ssbos(_gallivm, _ptr) \
-   lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_TCS_JIT_CTX_SSBOS, "ssbos")
-
-#define draw_tcs_jit_context_num_ssbos(_gallivm, _ptr) \
-   lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_TCS_JIT_CTX_NUM_SSBOS, "num_ssbos")
-
-struct draw_tes_jit_context {
-   const float *constants[LP_MAX_TGSI_CONST_BUFFERS];
-   int num_constants[LP_MAX_TGSI_CONST_BUFFERS];
-
-   int dummy1;
-   int dummy2;
-   /* There two need to be exactly at DRAW_JIT_CTX_TEXTURES and
-    * DRAW_JIT_CTX_SAMPLERS positions in the struct */
-   struct draw_jit_texture textures[PIPE_MAX_SHADER_SAMPLER_VIEWS];
-   struct draw_jit_sampler samplers[PIPE_MAX_SAMPLERS];
-   struct draw_jit_image images[PIPE_MAX_SHADER_IMAGES];
-
-   const uint32_t *ssbos[LP_MAX_TGSI_SHADER_BUFFERS];
-   int num_ssbos[LP_MAX_TGSI_SHADER_BUFFERS];
-};
-
-enum {
-   DRAW_TES_JIT_CTX_CONSTANTS = 0,
-   DRAW_TES_JIT_CTX_NUM_CONSTANTS = 1,
-   DRAW_TES_JIT_CTX_TEXTURES = DRAW_JIT_CTX_TEXTURES,
-   DRAW_TES_JIT_CTX_SAMPLERS = DRAW_JIT_CTX_SAMPLERS,
-   DRAW_TES_JIT_CTX_IMAGES = DRAW_JIT_CTX_IMAGES,
-   DRAW_TES_JIT_CTX_SSBOS = 7,
-   DRAW_TES_JIT_CTX_NUM_SSBOS = 8,
-   DRAW_TES_JIT_CTX_NUM_FIELDS = 9,
-};
-
-#define draw_tes_jit_context_constants(_gallivm, _ptr) \
-   lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_TES_JIT_CTX_CONSTANTS, "constants")
-
-#define draw_tes_jit_context_num_constants(_gallivm, _ptr) \
-   lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_TES_JIT_CTX_NUM_CONSTANTS, "num_constants")
-
-#define draw_tes_jit_context_textures(_gallivm, _ptr) \
-   lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_TES_JIT_CTX_TEXTURES, "textures")
-
-#define draw_tes_jit_context_samplers(_gallivm, _ptr) \
-   lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_TES_JIT_CTX_SAMPLERS, "samplers")
-
-#define draw_tes_jit_context_images(_gallivm, _ptr)                      \
-   lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_TES_JIT_CTX_IMAGES, "images")
-
-#define draw_tes_jit_context_ssbos(_gallivm, _ptr) \
-   lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_TES_JIT_CTX_SSBOS, "ssbos")
-
-#define draw_tes_jit_context_num_ssbos(_gallivm, _ptr) \
-   lp_build_struct_get_ptr(_gallivm, _ptr, DRAW_TES_JIT_CTX_NUM_SSBOS, "num_ssbos")
-
 typedef boolean
 (*draw_jit_vert_func)(struct draw_jit_context *context,
                       struct vertex_header *io,
@@ -435,27 +335,12 @@ typedef boolean
 typedef int
 (*draw_gs_jit_func)(struct draw_gs_jit_context *context,
                     float inputs[6][PIPE_MAX_SHADER_INPUTS][TGSI_NUM_CHANNELS][TGSI_NUM_CHANNELS],
-                    struct vertex_header **output,
+                    struct vertex_header *output,
                     unsigned num_prims,
                     unsigned instance_id,
                     int *prim_ids,
                     unsigned invocation_id);
 
-typedef int
-(*draw_tcs_jit_func)(struct draw_tcs_jit_context *context,
-                     float inputs[32][NUM_TCS_INPUTS][TGSI_NUM_CHANNELS],
-                     float outputs[32][PIPE_MAX_SHADER_INPUTS][TGSI_NUM_CHANNELS],
-                     uint32_t prim_id, uint32_t patch_vertices_in);
-
-typedef int
-(*draw_tes_jit_func)(struct draw_tes_jit_context *context,
-                     float inputs[32][PIPE_MAX_SHADER_INPUTS][TGSI_NUM_CHANNELS],
-                     struct vertex_header *io,
-                     uint32_t prim_id, uint32_t num_tess_coord,
-                     float *tess_coord_x, float *tess_coord_y, float *tess_outer,
-                     float *tess_inner, uint32_t patch_vertices_in);
-
-
 struct draw_llvm_variant_key
 {
    unsigned nr_vertex_elements:8;
@@ -469,7 +354,7 @@ struct draw_llvm_variant_key
    unsigned clip_halfz:1;
    unsigned bypass_viewport:1;
    unsigned need_edgeflags:1;
-   unsigned has_gs_or_tes:1;
+   unsigned has_gs:1;
    unsigned num_outputs:8;
    unsigned ucp_enable:PIPE_MAX_CLIP_PLANES;
    /* note padding here - must use memset */
@@ -497,24 +382,6 @@ struct draw_gs_llvm_variant_key
    /* Followed by variable number of images.*/
 };
 
-struct draw_tcs_llvm_variant_key
-{
-   unsigned nr_samplers:8;
-   unsigned nr_sampler_views:8;
-   unsigned nr_images:8;
-   struct draw_sampler_static_state samplers[1];
-   /* Followed by variable number of images.*/
-};
-
-struct draw_tes_llvm_variant_key
-{
-   unsigned nr_samplers:8;
-   unsigned nr_sampler_views:8;
-   unsigned nr_images:8;
-   struct draw_sampler_static_state samplers[1];
-   /* Followed by variable number of images.*/
-};
-
 #define DRAW_LLVM_MAX_VARIANT_KEY_SIZE \
    (sizeof(struct draw_llvm_variant_key) +	\
     PIPE_MAX_SHADER_SAMPLER_VIEWS * sizeof(struct draw_sampler_static_state) +	\
@@ -526,16 +393,6 @@ struct draw_tes_llvm_variant_key
     PIPE_MAX_SHADER_IMAGES * sizeof(struct draw_image_static_state) + \
     PIPE_MAX_SHADER_SAMPLER_VIEWS * sizeof(struct draw_sampler_static_state))
 
-#define DRAW_TCS_LLVM_MAX_VARIANT_KEY_SIZE \
-   (sizeof(struct draw_tcs_llvm_variant_key) +	\
-    PIPE_MAX_SHADER_IMAGES * sizeof(struct draw_image_static_state) + \
-    PIPE_MAX_SHADER_SAMPLER_VIEWS * sizeof(struct draw_sampler_static_state))
-
-#define DRAW_TES_LLVM_MAX_VARIANT_KEY_SIZE \
-   (sizeof(struct draw_tes_llvm_variant_key) +	\
-    PIPE_MAX_SHADER_IMAGES * sizeof(struct draw_image_static_state) + \
-    PIPE_MAX_SHADER_SAMPLER_VIEWS * sizeof(struct draw_sampler_static_state))
-
 
 static inline size_t
 draw_llvm_variant_key_size(unsigned nr_vertex_elements,
@@ -556,21 +413,6 @@ draw_gs_llvm_variant_key_size(unsigned nr_samplers, unsigned nr_images)
            (nr_samplers - 1) * sizeof(struct draw_sampler_static_state));
 }
 
-static inline size_t
-draw_tcs_llvm_variant_key_size(unsigned nr_samplers, unsigned nr_images)
-{
-   return (sizeof(struct draw_tcs_llvm_variant_key) +
-           (nr_images) * sizeof(struct draw_sampler_static_state) +
-           (nr_samplers - 1) * sizeof(struct draw_sampler_static_state));
-}
-
-static inline size_t
-draw_tes_llvm_variant_key_size(unsigned nr_samplers, unsigned nr_images)
-{
-   return (sizeof(struct draw_tes_llvm_variant_key) +
-           (nr_images) * sizeof(struct draw_sampler_static_state) +
-           (nr_samplers - 1) * sizeof(struct draw_sampler_static_state));
-}
 
 static inline struct draw_sampler_static_state *
 draw_llvm_variant_key_samplers(struct draw_llvm_variant_key *key)
@@ -595,20 +437,6 @@ draw_gs_llvm_variant_key_images(struct draw_gs_llvm_variant_key *key)
       &key->samplers[key->nr_samplers];
 }
 
-static inline struct draw_image_static_state *
-draw_tcs_llvm_variant_key_images(struct draw_tcs_llvm_variant_key *key)
-{
-   return (struct draw_image_static_state *)
-      &key->samplers[key->nr_samplers];
-}
-
-static inline struct draw_image_static_state *
-draw_tes_llvm_variant_key_images(struct draw_tes_llvm_variant_key *key)
-{
-   return (struct draw_image_static_state *)
-      &key->samplers[key->nr_samplers];
-}
-
 struct draw_llvm_variant_list_item
 {
    struct draw_llvm_variant *base;
@@ -621,17 +449,6 @@ struct draw_gs_llvm_variant_list_item
    struct draw_gs_llvm_variant_list_item *next, *prev;
 };
 
-struct draw_tcs_llvm_variant_list_item
-{
-   struct draw_tcs_llvm_variant *base;
-   struct draw_tcs_llvm_variant_list_item *next, *prev;
-};
-
-struct draw_tes_llvm_variant_list_item
-{
-   struct draw_tes_llvm_variant *base;
-   struct draw_tes_llvm_variant_list_item *next, *prev;
-};
 
 struct draw_llvm_variant
 {
@@ -682,57 +499,6 @@ struct draw_gs_llvm_variant
    struct draw_gs_llvm_variant_key key;
 };
 
-struct draw_tcs_llvm_variant
-{
-   struct gallivm_state *gallivm;
-
-   /* LLVM JIT builder types */
-   LLVMTypeRef context_ptr_type;
-   LLVMTypeRef input_array_type;
-   LLVMTypeRef output_array_type;
-
-   LLVMValueRef context_ptr;
-   LLVMValueRef io_ptr;
-   LLVMValueRef num_prims;
-   LLVMValueRef function;
-   draw_tcs_jit_func jit_func;
-
-   struct llvm_tess_ctrl_shader *shader;
-
-   struct draw_llvm *llvm;
-   struct draw_tcs_llvm_variant_list_item list_item_global;
-   struct draw_tcs_llvm_variant_list_item list_item_local;
-
-   /* key is variable-sized, must be last */
-   struct draw_tcs_llvm_variant_key key;
-};
-
-struct draw_tes_llvm_variant
-{
-   struct gallivm_state *gallivm;
-
-   /* LLVM JIT builder types */
-   LLVMTypeRef context_ptr_type;
-   LLVMTypeRef vertex_header_ptr_type;
-   LLVMTypeRef input_array_type;
-   LLVMTypeRef patch_input_array_type;
-
-   LLVMValueRef context_ptr;
-   LLVMValueRef io_ptr;
-   LLVMValueRef num_prims;
-   LLVMValueRef function;
-   draw_tes_jit_func jit_func;
-
-   struct llvm_tess_eval_shader *shader;
-
-   struct draw_llvm *llvm;
-   struct draw_tes_llvm_variant_list_item list_item_global;
-   struct draw_tes_llvm_variant_list_item list_item_local;
-
-   /* key is variable-sized, must be last */
-   struct draw_tes_llvm_variant_key key;
-};
-
 struct llvm_vertex_shader {
    struct draw_vertex_shader base;
 
@@ -751,23 +517,6 @@ struct llvm_geometry_shader {
    unsigned variants_cached;
 };
 
-struct llvm_tess_ctrl_shader {
-   struct draw_tess_ctrl_shader base;
-
-   unsigned variant_key_size;
-   struct draw_tcs_llvm_variant_list_item variants;
-   unsigned variants_created;
-   unsigned variants_cached;
-};
-
-struct llvm_tess_eval_shader {
-   struct draw_tess_eval_shader base;
-
-   unsigned variant_key_size;
-   struct draw_tes_llvm_variant_list_item variants;
-   unsigned variants_created;
-   unsigned variants_cached;
-};
 
 struct draw_llvm {
    struct draw_context *draw;
@@ -777,20 +526,12 @@ struct draw_llvm {
 
    struct draw_jit_context jit_context;
    struct draw_gs_jit_context gs_jit_context;
-   struct draw_tcs_jit_context tcs_jit_context;
-   struct draw_tes_jit_context tes_jit_context;
 
    struct draw_llvm_variant_list_item vs_variants_list;
    int nr_variants;
 
    struct draw_gs_llvm_variant_list_item gs_variants_list;
    int nr_gs_variants;
-
-   struct draw_tcs_llvm_variant_list_item tcs_variants_list;
-   int nr_tcs_variants;
-
-   struct draw_tes_llvm_variant_list_item tes_variants_list;
-   int nr_tes_variants;
 };
 
 
@@ -806,17 +547,8 @@ llvm_geometry_shader(struct draw_geometry_shader *gs)
    return (struct llvm_geometry_shader *)gs;
 }
 
-static inline struct llvm_tess_ctrl_shader *
-llvm_tess_ctrl_shader(struct draw_tess_ctrl_shader *tcs)
-{
-   return (struct llvm_tess_ctrl_shader *)tcs;
-}
 
-static inline struct llvm_tess_eval_shader *
-llvm_tess_eval_shader(struct draw_tess_eval_shader *tes)
-{
-   return (struct llvm_tess_eval_shader *)tes;
-}
+
 
 struct draw_llvm *
 draw_llvm_create(struct draw_context *draw, LLVMContextRef llvm_context);
@@ -853,34 +585,6 @@ draw_gs_llvm_make_variant_key(struct draw_llvm *llvm, char *store);
 void
 draw_gs_llvm_dump_variant_key(struct draw_gs_llvm_variant_key *key);
 
-struct draw_tcs_llvm_variant *
-draw_tcs_llvm_create_variant(struct draw_llvm *llvm,
-                             unsigned num_vertex_header_attribs,
-                             const struct draw_tcs_llvm_variant_key *key);
-
-void
-draw_tcs_llvm_destroy_variant(struct draw_tcs_llvm_variant *variant);
-
-struct draw_tcs_llvm_variant_key *
-draw_tcs_llvm_make_variant_key(struct draw_llvm *llvm, char *store);
-
-void
-draw_tcs_llvm_dump_variant_key(struct draw_tcs_llvm_variant_key *key);
-
-struct draw_tes_llvm_variant *
-draw_tes_llvm_create_variant(struct draw_llvm *llvm,
-                             unsigned num_vertex_header_attribs,
-                             const struct draw_tes_llvm_variant_key *key);
-
-void
-draw_tes_llvm_destroy_variant(struct draw_tes_llvm_variant *variant);
-
-struct draw_tes_llvm_variant_key *
-draw_tes_llvm_make_variant_key(struct draw_llvm *llvm, char *store);
-
-void
-draw_tes_llvm_dump_variant_key(struct draw_tes_llvm_variant_key *key);
-
 struct lp_build_sampler_soa *
 draw_llvm_sampler_soa_create(const struct draw_sampler_static_state *static_state);
 
diff --git a/lib/mesa/src/gallium/auxiliary/draw/draw_pipe_user_cull.c b/lib/mesa/src/gallium/auxiliary/draw/draw_pipe_user_cull.c
deleted file mode 100644
index fcc177e04..000000000
--- a/lib/mesa/src/gallium/auxiliary/draw/draw_pipe_user_cull.c
+++ /dev/null
@@ -1,197 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2007 VMware, Inc.
- * All Rights Reserved.
- *
- * 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, sub license, 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 NON-INFRINGEMENT.
- * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS 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.
- *
- **************************************************************************/
-
-/**
- * \brief  Drawing stage for user culling
- */
-
-#include "util/u_math.h"
-#include "util/u_memory.h"
-#include "pipe/p_defines.h"
-#include "draw_pipe.h"
-
-struct user_cull_stage {
-   struct draw_stage stage;
-};
-
-static inline struct user_cull_stage *user_cull_stage( struct draw_stage *stage )
-{
-   return (struct user_cull_stage *)stage;
-}
-
-static inline boolean
-cull_distance_is_out(float dist)
-{
-   return (dist < 0.0f) || util_is_inf_or_nan(dist);
-}
-
-/*
- * If the shader writes the culldistance then we can
- * perform distance based culling. Distance based
- * culling doesn't require a face and can be performed
- * on primitives without faces (e.g. points and lines)
- */
-static void user_cull_point( struct draw_stage *stage,
-                        struct prim_header *header )
-{
-   const unsigned num_written_culldistances =
-      draw_current_shader_num_written_culldistances(stage->draw);
-   const unsigned num_written_clipdistances =
-      draw_current_shader_num_written_clipdistances(stage->draw);
-   unsigned i;
-
-   debug_assert(num_written_culldistances);
-
-   for (i = 0; i < num_written_culldistances; ++i) {
-      unsigned cull_idx = (num_written_clipdistances + i) / 4;
-      unsigned out_idx =
-         draw_current_shader_ccdistance_output(stage->draw, cull_idx);
-      unsigned idx = (num_written_clipdistances + i) % 4;
-      float cull1 = header->v[0]->data[out_idx][idx];
-      boolean vert1_out = cull_distance_is_out(cull1);
-      if (vert1_out)
-         return;
-   }
-   stage->next->point( stage->next, header );
-}
-
-/*
- * If the shader writes the culldistance then we can
- * perform distance based culling. Distance based
- * culling doesn't require a face and can be performed
- * on primitives without faces (e.g. points and lines)
- */
-static void user_cull_line( struct draw_stage *stage,
-                       struct prim_header *header )
-{
-   const unsigned num_written_culldistances =
-      draw_current_shader_num_written_culldistances(stage->draw);
-   const unsigned num_written_clipdistances =
-      draw_current_shader_num_written_clipdistances(stage->draw);
-   unsigned i;
-
-   debug_assert(num_written_culldistances);
-
-   for (i = 0; i < num_written_culldistances; ++i) {
-      unsigned cull_idx = (num_written_clipdistances + i) / 4;
-      unsigned out_idx =
-         draw_current_shader_ccdistance_output(stage->draw, cull_idx);
-      unsigned idx = (num_written_clipdistances + i) % 4;
-      float cull1 = header->v[0]->data[out_idx][idx];
-      float cull2 = header->v[1]->data[out_idx][idx];
-      boolean vert1_out = cull_distance_is_out(cull1);
-      boolean vert2_out = cull_distance_is_out(cull2);
-      if (vert1_out && vert2_out)
-         return;
-   }
-   stage->next->line( stage->next, header );
-}
-
-/*
- * Triangles can be culled either using the cull distance
- * shader outputs or the regular face culling. If required
- * this function performs both, starting with distance culling.
- */
-static void user_cull_tri( struct draw_stage *stage,
-                           struct prim_header *header )
-{
-   const unsigned num_written_culldistances =
-      draw_current_shader_num_written_culldistances(stage->draw);
-   const unsigned num_written_clipdistances =
-      draw_current_shader_num_written_clipdistances(stage->draw);
-   unsigned i;
-
-   debug_assert(num_written_culldistances);
-
-   /* Do the distance culling */
-   for (i = 0; i < num_written_culldistances; ++i) {
-      unsigned cull_idx = (num_written_clipdistances + i) / 4;
-      unsigned out_idx =
-         draw_current_shader_ccdistance_output(stage->draw, cull_idx);
-      unsigned idx = (num_written_clipdistances + i) % 4;
-      float cull1 = header->v[0]->data[out_idx][idx];
-      float cull2 = header->v[1]->data[out_idx][idx];
-      float cull3 = header->v[2]->data[out_idx][idx];
-      boolean vert1_out = cull_distance_is_out(cull1);
-      boolean vert2_out = cull_distance_is_out(cull2);
-      boolean vert3_out = cull_distance_is_out(cull3);
-      if (vert1_out && vert2_out && vert3_out) {
-         return;
-      }
-   }
-   stage->next->tri( stage->next, header );
-}
-
-static void user_cull_flush( struct draw_stage *stage, unsigned flags )
-{
-   stage->point = user_cull_point;
-   stage->line = user_cull_line;
-   stage->tri = user_cull_tri;
-   stage->next->flush( stage->next, flags );
-}
-
-static void user_cull_reset_stipple_counter( struct draw_stage *stage )
-{
-   stage->next->reset_stipple_counter( stage->next );
-}
-
-static void user_cull_destroy( struct draw_stage *stage )
-{
-   draw_free_temp_verts( stage );
-   FREE( stage );
-}
-
-/**
- * Create a new polygon culling stage.
- */
-struct draw_stage *draw_user_cull_stage( struct draw_context *draw )
-{
-   struct user_cull_stage *user_cull = CALLOC_STRUCT(user_cull_stage);
-   if (!user_cull)
-      goto fail;
-
-   user_cull->stage.draw = draw;
-   user_cull->stage.name = "user_cull";
-   user_cull->stage.next = NULL;
-   user_cull->stage.point = user_cull_point;
-   user_cull->stage.line = user_cull_line;
-   user_cull->stage.tri = user_cull_tri;
-   user_cull->stage.flush = user_cull_flush;
-   user_cull->stage.reset_stipple_counter = user_cull_reset_stipple_counter;
-   user_cull->stage.destroy = user_cull_destroy;
-
-   if (!draw_alloc_temp_verts( &user_cull->stage, 0 ))
-      goto fail;
-
-   return &user_cull->stage;
-
-fail:
-   if (user_cull)
-      user_cull->stage.destroy( &user_cull->stage );
-
-   return NULL;
-}
diff --git a/lib/mesa/src/gallium/auxiliary/draw/draw_pipe_validate.c b/lib/mesa/src/gallium/auxiliary/draw/draw_pipe_validate.c
index 940ca5644..846cd4db3 100644
--- a/lib/mesa/src/gallium/auxiliary/draw/draw_pipe_validate.c
+++ b/lib/mesa/src/gallium/auxiliary/draw/draw_pipe_validate.c
@@ -100,9 +100,6 @@ draw_need_pipeline(const struct draw_context *draw,
       /* point sprites */
       if (rasterizer->sprite_coord_enable && draw->pipeline.point_sprite)
          return TRUE;
-
-      if (draw_current_shader_num_written_culldistances(draw))
-         return TRUE;
    }
    else if (reduced_prim == PIPE_PRIM_TRIANGLES) {
       /* polygon stipple */
@@ -255,7 +252,8 @@ static struct draw_stage *validate_pipeline( struct draw_stage *stage )
     * to less work emitting vertices, smaller vertex buffers, etc.
     * It's difficult to say whether this will be true in general.
     */
-   if (need_det || rast->cull_face != PIPE_FACE_NONE) {
+   if (need_det || rast->cull_face != PIPE_FACE_NONE ||
+       draw_current_shader_num_written_culldistances(draw)) {
       draw->pipeline.cull->next = next;
       next = draw->pipeline.cull;
    }
@@ -268,11 +266,6 @@ static struct draw_stage *validate_pipeline( struct draw_stage *stage )
       next = draw->pipeline.clip;
    }
 
-   if (draw_current_shader_num_written_culldistances(draw)) {
-      draw->pipeline.user_cull->next = next;
-      next = draw->pipeline.user_cull;
-   }
-
    draw->pipeline.first = next;
 
    if (0) {
diff --git a/lib/mesa/src/gallium/auxiliary/draw/draw_private.h b/lib/mesa/src/gallium/auxiliary/draw/draw_private.h
index a5a1b4e9b..0fd0caab3 100644
--- a/lib/mesa/src/gallium/auxiliary/draw/draw_private.h
+++ b/lib/mesa/src/gallium/auxiliary/draw/draw_private.h
@@ -122,7 +122,6 @@ struct draw_context
       struct draw_stage *flatshade;
       struct draw_stage *clip;
       struct draw_stage *cull;
-      struct draw_stage *user_cull;
       struct draw_stage *twoside;
       struct draw_stage *offset;
       struct draw_stage *unfilled;
@@ -158,7 +157,7 @@ struct draw_context
       unsigned prim;
       unsigned opt;     /**< bitmask of PT_x flags */
       unsigned eltSize; /* saved eltSize for flushing */
-      ubyte vertices_per_patch;
+
       boolean rebind_parameters;
 
       struct {
@@ -207,20 +206,12 @@ struct draw_context
          unsigned vs_constants_size[PIPE_MAX_CONSTANT_BUFFERS];
          const void *gs_constants[PIPE_MAX_CONSTANT_BUFFERS];
          unsigned gs_constants_size[PIPE_MAX_CONSTANT_BUFFERS];
-         const void *tcs_constants[PIPE_MAX_CONSTANT_BUFFERS];
-         unsigned tcs_constants_size[PIPE_MAX_CONSTANT_BUFFERS];
-         const void *tes_constants[PIPE_MAX_CONSTANT_BUFFERS];
-         unsigned tes_constants_size[PIPE_MAX_CONSTANT_BUFFERS];
 
          /** shader buffers (for vertex/geometry shader) */
          const void *vs_ssbos[PIPE_MAX_SHADER_BUFFERS];
          unsigned vs_ssbos_size[PIPE_MAX_SHADER_BUFFERS];
          const void *gs_ssbos[PIPE_MAX_SHADER_BUFFERS];
          unsigned gs_ssbos_size[PIPE_MAX_SHADER_BUFFERS];
-         const void *tcs_ssbos[PIPE_MAX_SHADER_BUFFERS];
-         unsigned tcs_ssbos_size[PIPE_MAX_SHADER_BUFFERS];
-         const void *tes_ssbos[PIPE_MAX_SHADER_BUFFERS];
-         unsigned tes_ssbos_size[PIPE_MAX_SHADER_BUFFERS];
 
          /* pointer to planes */
          float (*planes)[DRAW_TOTAL_CLIP_PLANES][4]; 
@@ -312,34 +303,6 @@ struct draw_context
 
    } gs;
 
-   /* Tessellation state */
-   struct {
-      struct draw_tess_ctrl_shader *tess_ctrl_shader;
-
-      /** Fields for TGSI interpreter / execution */
-      struct {
-         struct tgsi_exec_machine *machine;
-
-         struct tgsi_sampler *sampler;
-         struct tgsi_image *image;
-         struct tgsi_buffer *buffer;
-      } tgsi;
-   } tcs;
-
-   struct {
-      struct draw_tess_eval_shader *tess_eval_shader;
-      uint position_output;
-
-      /** Fields for TGSI interpreter / execution */
-      struct {
-         struct tgsi_exec_machine *machine;
-
-         struct tgsi_sampler *sampler;
-         struct tgsi_image *image;
-         struct tgsi_buffer *buffer;
-      } tgsi;
-   } tes;
-
    /** Fragment shader state */
    struct {
       struct draw_fragment_shader *fragment_shader;
@@ -386,8 +349,6 @@ struct draw_context
    struct pipe_query_data_pipeline_statistics statistics;
    boolean collect_statistics;
 
-   float default_outer_tess_level[4];
-   float default_inner_tess_level[2];
    bool collect_primgen;
 
    struct draw_assembler *ia;
diff --git a/lib/mesa/src/gallium/auxiliary/draw/draw_pt.c b/lib/mesa/src/gallium/auxiliary/draw/draw_pt.c
index 986f87e01..24ac05427 100644
--- a/lib/mesa/src/gallium/auxiliary/draw/draw_pt.c
+++ b/lib/mesa/src/gallium/auxiliary/draw/draw_pt.c
@@ -32,7 +32,6 @@
 
 #include "draw/draw_context.h"
 #include "draw/draw_gs.h"
-#include "draw/draw_tess.h"
 #include "draw/draw_private.h"
 #include "draw/draw_pt.h"
 #include "draw/draw_vbuf.h"
@@ -67,24 +66,16 @@ draw_pt_arrays(struct draw_context *draw,
     */
    {
       unsigned first, incr;
-
-      if (prim == PIPE_PRIM_PATCHES) {
-         first = draw->pt.vertices_per_patch;
-         incr = draw->pt.vertices_per_patch;
-      } else
-         draw_pt_split_prim(prim, &first, &incr);
+      draw_pt_split_prim(prim, &first, &incr);
       count = draw_pt_trim_count(count, first, incr);
       if (count < first)
          return TRUE;
    }
 
    if (!draw->force_passthrough) {
-      unsigned out_prim = prim;
-
-      if (draw->gs.geometry_shader)
-         out_prim = draw->gs.geometry_shader->output_primitive;
-      else if (draw->tes.tess_eval_shader)
-         out_prim = get_tes_output_prim(draw->tes.tess_eval_shader);
+      unsigned gs_out_prim = (draw->gs.geometry_shader ? 
+                              draw->gs.geometry_shader->output_primitive :
+                              prim);
 
       if (!draw->render) {
          opt |= PT_PIPELINE;
@@ -92,7 +83,7 @@ draw_pt_arrays(struct draw_context *draw,
 
       if (draw_need_pipeline(draw,
                              draw->rasterizer,
-                             out_prim)) {
+                             gs_out_prim)) {
          opt |= PT_PIPELINE;
       }
 
@@ -496,8 +487,6 @@ draw_vbo(struct draw_context *draw,
    draw->pt.user.eltSize = info->index_size ? draw->pt.user.eltSizeIB : 0;
    draw->pt.user.drawid = info->drawid;
 
-   draw->pt.vertices_per_patch = info->vertices_per_patch;
-
    if (0)
       debug_printf("draw_vbo(mode=%u start=%u count=%u):\n",
                    info->mode, info->start, count);
diff --git a/lib/mesa/src/gallium/auxiliary/draw/draw_pt_fetch_shade_pipeline_llvm.c b/lib/mesa/src/gallium/auxiliary/draw/draw_pt_fetch_shade_pipeline_llvm.c
index d403e81c2..c19eda2ed 100644
--- a/lib/mesa/src/gallium/auxiliary/draw/draw_pt_fetch_shade_pipeline_llvm.c
+++ b/lib/mesa/src/gallium/auxiliary/draw/draw_pt_fetch_shade_pipeline_llvm.c
@@ -30,7 +30,6 @@
 #include "util/u_prim.h"
 #include "draw/draw_context.h"
 #include "draw/draw_gs.h"
-#include "draw/draw_tess.h"
 #include "draw/draw_vbuf.h"
 #include "draw/draw_vertex.h"
 #include "draw/draw_pt.h"
@@ -139,146 +138,6 @@ llvm_middle_end_prepare_gs(struct llvm_middle_end *fpme)
    gs->current_variant = variant;
 }
 
-static void
-llvm_middle_end_prepare_tcs(struct llvm_middle_end *fpme)
-{
-   struct draw_context *draw = fpme->draw;
-   struct draw_llvm *llvm = fpme->llvm;
-   struct draw_tess_ctrl_shader *tcs = draw->tcs.tess_ctrl_shader;
-   struct draw_tcs_llvm_variant_key *key;
-   struct draw_tcs_llvm_variant *variant = NULL;
-   struct draw_tcs_llvm_variant_list_item *li;
-   struct llvm_tess_ctrl_shader *shader = llvm_tess_ctrl_shader(tcs);
-   char store[DRAW_TCS_LLVM_MAX_VARIANT_KEY_SIZE];
-   unsigned i;
-
-   key = draw_tcs_llvm_make_variant_key(llvm, store);
-
-   /* Search shader's list of variants for the key */
-   li = first_elem(&shader->variants);
-   while (!at_end(&shader->variants, li)) {
-      if (memcmp(&li->base->key, key, shader->variant_key_size) == 0) {
-         variant = li->base;
-         break;
-      }
-      li = next_elem(li);
-   }
-
-   if (variant) {
-      /* found the variant, move to head of global list (for LRU) */
-      move_to_head(&llvm->tcs_variants_list, &variant->list_item_global);
-   }
-   else {
-      /* Need to create new variant */
-
-      /* First check if we've created too many variants.  If so, free
-       * 3.125% of the LRU to avoid using too much memory.
-       */
-      if (llvm->nr_tcs_variants >= DRAW_MAX_SHADER_VARIANTS) {
-         if (gallivm_debug & GALLIVM_DEBUG_PERF) {
-            debug_printf("Evicting TCS: %u tcs variants,\t%u total variants\n",
-                      shader->variants_cached, llvm->nr_tcs_variants);
-         }
-
-         /*
-          * XXX: should we flush here ?
-          */
-         for (i = 0; i < DRAW_MAX_SHADER_VARIANTS / 32; i++) {
-            struct draw_tcs_llvm_variant_list_item *item;
-            if (is_empty_list(&llvm->tcs_variants_list)) {
-               break;
-            }
-            item = last_elem(&llvm->tcs_variants_list);
-            assert(item);
-            assert(item->base);
-            draw_tcs_llvm_destroy_variant(item->base);
-         }
-      }
-
-      variant = draw_tcs_llvm_create_variant(llvm, 0, key);
-
-      if (variant) {
-         insert_at_head(&shader->variants, &variant->list_item_local);
-         insert_at_head(&llvm->tcs_variants_list,
-                        &variant->list_item_global);
-         llvm->nr_tcs_variants++;
-         shader->variants_cached++;
-      }
-   }
-
-   tcs->current_variant = variant;
-}
-
-static void
-llvm_middle_end_prepare_tes(struct llvm_middle_end *fpme)
-{
-   struct draw_context *draw = fpme->draw;
-   struct draw_llvm *llvm = fpme->llvm;
-   struct draw_tess_eval_shader *tes = draw->tes.tess_eval_shader;
-   struct draw_tes_llvm_variant_key *key;
-   struct draw_tes_llvm_variant *variant = NULL;
-   struct draw_tes_llvm_variant_list_item *li;
-   struct llvm_tess_eval_shader *shader = llvm_tess_eval_shader(tes);
-   char store[DRAW_TES_LLVM_MAX_VARIANT_KEY_SIZE];
-   unsigned i;
-
-   key = draw_tes_llvm_make_variant_key(llvm, store);
-
-   /* Search shader's list of variants for the key */
-   li = first_elem(&shader->variants);
-   while (!at_end(&shader->variants, li)) {
-      if (memcmp(&li->base->key, key, shader->variant_key_size) == 0) {
-         variant = li->base;
-         break;
-      }
-      li = next_elem(li);
-   }
-
-   if (variant) {
-      /* found the variant, move to head of global list (for LRU) */
-      move_to_head(&llvm->tes_variants_list, &variant->list_item_global);
-   }
-   else {
-      /* Need to create new variant */
-
-      /* First check if we've created too many variants.  If so, free
-       * 3.125% of the LRU to avoid using too much memory.
-       */
-      if (llvm->nr_tes_variants >= DRAW_MAX_SHADER_VARIANTS) {
-         if (gallivm_debug & GALLIVM_DEBUG_PERF) {
-            debug_printf("Evicting TES: %u tes variants,\t%u total variants\n",
-                      shader->variants_cached, llvm->nr_tes_variants);
-         }
-
-         /*
-          * XXX: should we flush here ?
-          */
-         for (i = 0; i < DRAW_MAX_SHADER_VARIANTS / 32; i++) {
-            struct draw_tes_llvm_variant_list_item *item;
-            if (is_empty_list(&llvm->tes_variants_list)) {
-               break;
-            }
-            item = last_elem(&llvm->tes_variants_list);
-            assert(item);
-            assert(item->base);
-            draw_tes_llvm_destroy_variant(item->base);
-         }
-      }
-
-      variant = draw_tes_llvm_create_variant(llvm, tes->info.num_outputs, key);
-
-      if (variant) {
-         insert_at_head(&shader->variants, &variant->list_item_local);
-         insert_at_head(&llvm->tes_variants_list,
-                        &variant->list_item_global);
-         llvm->nr_tes_variants++;
-         shader->variants_cached++;
-      }
-   }
-
-   tes->current_variant = variant;
-}
-
 /**
  * Prepare/validate middle part of the vertex pipeline.
  * NOTE: if you change this function, also look at the non-LLVM
@@ -295,9 +154,7 @@ llvm_middle_end_prepare( struct draw_pt_middle_end *middle,
    struct draw_llvm *llvm = fpme->llvm;
    struct draw_vertex_shader *vs = draw->vs.vertex_shader;
    struct draw_geometry_shader *gs = draw->gs.geometry_shader;
-   struct draw_tess_ctrl_shader *tcs = draw->tcs.tess_ctrl_shader;
-   struct draw_tess_eval_shader *tes = draw->tes.tess_eval_shader;
-   const unsigned out_prim = gs ? gs->output_primitive : tes ? get_tes_output_prim(tes) :
+   const unsigned out_prim = gs ? gs->output_primitive :
       u_assembled_prim(in_prim);
    unsigned point_clip = draw->rasterizer->fill_front == PIPE_POLYGON_MODE_POINT ||
                          out_prim == PIPE_PRIM_POINTS;
@@ -413,12 +270,6 @@ llvm_middle_end_prepare( struct draw_pt_middle_end *middle,
    if (gs) {
       llvm_middle_end_prepare_gs(fpme);
    }
-   if (tcs) {
-      llvm_middle_end_prepare_tcs(fpme);
-   }
-   if (tes) {
-      llvm_middle_end_prepare_tes(fpme);
-   }
 }
 
 
@@ -478,42 +329,6 @@ llvm_middle_end_bind_parameters(struct draw_pt_middle_end *middle)
       }
    }
 
-   for (i = 0; i < ARRAY_SIZE(llvm->tcs_jit_context.constants); ++i) {
-      int num_consts =
-         DIV_ROUND_UP(draw->pt.user.tcs_constants_size[i], (sizeof(float) * 4));
-      llvm->tcs_jit_context.constants[i] = draw->pt.user.tcs_constants[i];
-      llvm->tcs_jit_context.num_constants[i] = num_consts;
-      if (num_consts == 0) {
-         llvm->tcs_jit_context.constants[i] = fake_const_buf;
-      }
-   }
-   for (i = 0; i < ARRAY_SIZE(llvm->tcs_jit_context.ssbos); ++i) {
-      int num_ssbos = draw->pt.user.tcs_ssbos_size[i];
-      llvm->tcs_jit_context.ssbos[i] = draw->pt.user.tcs_ssbos[i];
-      llvm->tcs_jit_context.num_ssbos[i] = num_ssbos;
-      if (num_ssbos == 0) {
-         llvm->tcs_jit_context.ssbos[i] = (const uint32_t *)fake_const_buf;
-      }
-   }
-
-   for (i = 0; i < ARRAY_SIZE(llvm->tes_jit_context.constants); ++i) {
-      int num_consts =
-         DIV_ROUND_UP(draw->pt.user.tes_constants_size[i], (sizeof(float) * 4));
-      llvm->tes_jit_context.constants[i] = draw->pt.user.tes_constants[i];
-      llvm->tes_jit_context.num_constants[i] = num_consts;
-      if (num_consts == 0) {
-         llvm->tes_jit_context.constants[i] = fake_const_buf;
-      }
-   }
-   for (i = 0; i < ARRAY_SIZE(llvm->tes_jit_context.ssbos); ++i) {
-      int num_ssbos = draw->pt.user.tes_ssbos_size[i];
-      llvm->tes_jit_context.ssbos[i] = draw->pt.user.tes_ssbos[i];
-      llvm->tes_jit_context.num_ssbos[i] = num_ssbos;
-      if (num_ssbos == 0) {
-         llvm->tes_jit_context.ssbos[i] = (const uint32_t *)fake_const_buf;
-      }
-   }
-
    llvm->jit_context.planes =
       (float (*)[DRAW_TOTAL_CLIP_PLANES][4]) draw->pt.user.planes[0];
    llvm->gs_jit_context.planes =
@@ -562,14 +377,8 @@ llvm_pipeline_generic(struct draw_pt_middle_end *middle,
    struct llvm_middle_end *fpme = llvm_middle_end(middle);
    struct draw_context *draw = fpme->draw;
    struct draw_geometry_shader *gshader = draw->gs.geometry_shader;
-   struct draw_tess_ctrl_shader *tcs_shader = draw->tcs.tess_ctrl_shader;
-   struct draw_tess_eval_shader *tes_shader = draw->tes.tess_eval_shader;
-   struct draw_prim_info tcs_prim_info;
-   struct draw_prim_info tes_prim_info;
    struct draw_prim_info gs_prim_info[TGSI_MAX_VERTEX_STREAMS];
    struct draw_vertex_info llvm_vert_info;
-   struct draw_vertex_info tcs_vert_info;
-   struct draw_vertex_info tes_vert_info;
    struct draw_vertex_info gs_vert_info[TGSI_MAX_VERTEX_STREAMS];
    struct draw_vertex_info *vert_info;
    struct draw_prim_info ia_prim_info;
@@ -580,7 +389,6 @@ llvm_pipeline_generic(struct draw_pt_middle_end *middle,
    boolean clipped = 0;
    unsigned start_or_maxelt, vid_base;
    const unsigned *elts;
-   ushort *tes_elts_out = NULL;
 
    assert(fetch_info->count > 0);
    llvm_vert_info.count = fetch_info->count;
@@ -596,11 +404,8 @@ llvm_pipeline_generic(struct draw_pt_middle_end *middle,
 
    if (draw->collect_statistics) {
       draw->statistics.ia_vertices += prim_info->count;
-      if (prim_info->prim == PIPE_PRIM_PATCHES)
-         draw->statistics.ia_primitives += prim_info->count / draw->pt.vertices_per_patch;
-      else
-         draw->statistics.ia_primitives +=
-            u_decomposed_prims_for_vertices(prim_info->prim, prim_info->count);
+      draw->statistics.ia_primitives +=
+         u_decomposed_prims_for_vertices(prim_info->prim, prim_info->count);
       draw->statistics.vs_invocations += fetch_info->count;
    }
 
@@ -631,56 +436,6 @@ llvm_pipeline_generic(struct draw_pt_middle_end *middle,
    fetch_info = NULL;
    vert_info = &llvm_vert_info;
 
-   if (opt & PT_SHADE) {
-      struct draw_vertex_shader *vshader = draw->vs.vertex_shader;
-      if (tcs_shader) {
-         draw_tess_ctrl_shader_run(tcs_shader,
-                                   draw->pt.user.tcs_constants,
-                                   draw->pt.user.tcs_constants_size,
-                                   vert_info,
-                                   prim_info,
-                                   &vshader->info,
-                                   &tcs_vert_info,
-                                   &tcs_prim_info);
-         FREE(vert_info->verts);
-         vert_info = &tcs_vert_info;
-         prim_info = &tcs_prim_info;
-
-      } else if (tes_shader) {
-         unsigned num_prims = prim_info->count / draw->pt.vertices_per_patch;
-         tcs_prim_info = *prim_info;
-         tcs_prim_info.primitive_count = num_prims;
-         prim_info = &tcs_prim_info;
-      }
-
-      if (tes_shader) {
-         draw_tess_eval_shader_run(tes_shader,
-                                   draw->pt.user.tes_constants,
-                                   draw->pt.user.tes_constants_size,
-                                   tcs_shader ? tcs_shader->vertices_out : draw->pt.vertices_per_patch,
-                                   vert_info,
-                                   prim_info,
-                                   tcs_shader ? &tcs_shader->info : &vshader->info,
-                                   &tes_vert_info,
-                                   &tes_prim_info, &tes_elts_out);
-
-         FREE(vert_info->verts);
-         vert_info = &tes_vert_info;
-         prim_info = &tes_prim_info;
-         free_prim_info = TRUE;
-
-         /*
-          * pt emit can only handle ushort number of vertices (see
-          * render->allocate_vertices).
-          * vsplit guarantees there's never more than 4096, however GS can
-          * easily blow this up (by a factor of 256 (or even 1024) max).
-          */
-         if (vert_info->count > 65535) {
-            opt |= PT_PIPELINE;
-         }
-      }
-   }
-
    if ((opt & PT_SHADE) && gshader) {
       struct draw_vertex_shader *vshader = draw->vs.vertex_shader;
       draw_geometry_shader_run(gshader,
@@ -688,18 +443,13 @@ llvm_pipeline_generic(struct draw_pt_middle_end *middle,
                                draw->pt.user.gs_constants_size,
                                vert_info,
                                prim_info,
-                               tes_shader ? &tes_shader->info : &vshader->info,
+                               &vshader->info,
                                gs_vert_info,
                                gs_prim_info);
 
       FREE(vert_info->verts);
-      if (free_prim_info) {
-         FREE(prim_info->primitive_lengths);
-         FREE(tes_elts_out);
-      }
       vert_info = &gs_vert_info[0];
       prim_info = &gs_prim_info[0];
-      free_prim_info = FALSE;
       /*
        * pt emit can only handle ushort number of vertices (see
        * render->allocate_vertices).
@@ -727,14 +477,13 @@ llvm_pipeline_generic(struct draw_pt_middle_end *middle,
 
       FREE(vert_info->verts);
       if (free_prim_info) {
-         FREE(tes_elts_out);
          FREE(prim_info->primitive_lengths);
       }
       return;
    }
 
    /* stream output needs to be done before clipping */
-   draw_pt_so_emit( fpme->so_emit, gshader ? gshader->num_vertex_streams : 1, vert_info, prim_info );
+   draw_pt_so_emit( fpme->so_emit, 1, vert_info, prim_info );
 
    draw_stats_clipper_primitives(draw, prim_info);
 
@@ -743,7 +492,7 @@ llvm_pipeline_generic(struct draw_pt_middle_end *middle,
     * will try to access non-existent position output.
     */
    if (draw_current_shader_position_output(draw) != -1) {
-      if ((opt & PT_SHADE) && (gshader || tes_shader ||
+      if ((opt & PT_SHADE) && (gshader ||
                                draw->vs.vertex_shader->info.writes_viewport_index)) {
          clipped = draw_pt_post_vs_run( fpme->post_vs, vert_info, prim_info );
       }
@@ -763,7 +512,6 @@ llvm_pipeline_generic(struct draw_pt_middle_end *middle,
    }
    FREE(vert_info->verts);
    if (free_prim_info) {
-      FREE(tes_elts_out);
       FREE(prim_info->primitive_lengths);
    }
 }
diff --git a/lib/mesa/src/gallium/auxiliary/draw/draw_tess.c b/lib/mesa/src/gallium/auxiliary/draw/draw_tess.c
deleted file mode 100644
index 07d5ef960..000000000
--- a/lib/mesa/src/gallium/auxiliary/draw/draw_tess.c
+++ /dev/null
@@ -1,644 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2020 Red Hat.
- * All Rights Reserved.
- *
- * 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 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 "draw_tess.h"
-#ifdef LLVM_AVAILABLE
-#include "draw_llvm.h"
-#endif
-
-#include "tessellator/p_tessellator.h"
-#include "nir/nir_to_tgsi_info.h"
-#include "util/u_prim.h"
-#include "util/u_math.h"
-#include "util/u_memory.h"
-#include "util/ralloc.h"
-static inline int
-draw_tes_get_input_index(int semantic, int index,
-                         const struct tgsi_shader_info *input_info)
-{
-   int i;
-   const ubyte *input_semantic_names = input_info->output_semantic_name;
-   const ubyte *input_semantic_indices = input_info->output_semantic_index;
-   for (i = 0; i < PIPE_MAX_SHADER_OUTPUTS; i++) {
-      if (input_semantic_names[i] == semantic &&
-          input_semantic_indices[i] == index)
-         return i;
-   }
-   return -1;
-}
-
-#ifdef LLVM_AVAILABLE
-#define DEBUG_INPUTS 0
-static void
-llvm_fetch_tcs_input(struct draw_tess_ctrl_shader *shader,
-                     const struct draw_prim_info *input_prim_info,
-                     unsigned prim_id,
-                     unsigned num_vertices)
-{
-   const float (*input_ptr)[4];
-   float (*input_data)[32][NUM_TCS_INPUTS][TGSI_NUM_CHANNELS] = &shader->tcs_input->data;
-   unsigned slot, i;
-   int vs_slot;
-   unsigned input_vertex_stride = shader->input_vertex_stride;
-
-   input_ptr = shader->input;
-   for (i = 0; i < num_vertices; i++) {
-      const float (*input)[4];
-      int vertex_idx = prim_id * num_vertices + i;
-      if (input_prim_info->linear == FALSE)
-         vertex_idx = input_prim_info->elts[vertex_idx];
-#if DEBUG_INPUTS
-      debug_printf("%d) tcs vertex index = %d (prim idx = %d)\n",
-                   i, prim_id, 0);
-#endif
-      input = (const float (*)[4])((const char *)input_ptr + (vertex_idx * input_vertex_stride));
-      for (slot = 0, vs_slot = 0; slot < shader->info.num_inputs; ++slot) {
-         vs_slot = draw_tes_get_input_index(
-                                            shader->info.input_semantic_name[slot],
-                                            shader->info.input_semantic_index[slot],
-                                            shader->input_info);
-         if (vs_slot < 0) {
-            debug_printf("VS/TCS signature mismatch!\n");
-            (*input_data)[i][slot][0] = 0;
-            (*input_data)[i][slot][1] = 0;
-            (*input_data)[i][slot][2] = 0;
-            (*input_data)[i][slot][3] = 0;
-         } else {
-            (*input_data)[i][slot][0] = input[vs_slot][0];
-            (*input_data)[i][slot][1] = input[vs_slot][1];
-            (*input_data)[i][slot][2] = input[vs_slot][2];
-            (*input_data)[i][slot][3] = input[vs_slot][3];
-#if DEBUG_INPUTS
-            debug_printf("\t\t%p = %f %f %f %f\n", &(*input_data)[i][slot][0],
-                         (*input_data)[i][slot][0],
-                         (*input_data)[i][slot][1],
-                         (*input_data)[i][slot][2],
-                         (*input_data)[i][slot][3]);
-#endif
-            ++vs_slot;
-         }
-      }
-   }
-}
-
-#define DEBUG_OUTPUTS 0
-static void
-llvm_store_tcs_output(struct draw_tess_ctrl_shader *shader,
-                      unsigned prim_id,
-                      struct draw_vertex_info *output_verts,
-                      unsigned vert_start)
-{
-   float (*output_ptr)[4];
-   float (*output_data)[32][PIPE_MAX_SHADER_INPUTS][TGSI_NUM_CHANNELS] = &shader->tcs_output->data;
-   unsigned slot, i;
-   unsigned num_vertices = shader->vertices_out;
-
-   char *output = (char *)output_verts->verts->data;
-   output += vert_start * output_verts->stride;
-
-   for (i = 0; i < num_vertices; i++) {
-
-#if DEBUG_OUTPUTS
-      debug_printf("%d) tcs store vertex index = %d (prim idx = %d)\n",
-                   i, prim_id, 0);
-#endif
-      output_ptr = (float(*)[4])(output + (i * output_verts->stride));
-
-      for (slot = 0; slot < shader->info.num_outputs; ++slot) {
-         output_ptr[slot][0] = (*output_data)[i][slot][0];
-         output_ptr[slot][1] = (*output_data)[i][slot][1];
-         output_ptr[slot][2] = (*output_data)[i][slot][2];
-         output_ptr[slot][3] = (*output_data)[i][slot][3];
-#if DEBUG_OUTPUTS
-         debug_printf("\t\t%p = %f %f %f %f\n",
-                      &output_ptr[slot][0],
-                      output_ptr[slot][0],
-                      output_ptr[slot][1],
-                      output_ptr[slot][2],
-                      output_ptr[slot][3]);
-#endif
-      }
-   }
-}
-
-static void
-llvm_tcs_run(struct draw_tess_ctrl_shader *shader, uint32_t prim_id)
-{
-   shader->current_variant->jit_func(shader->jit_context, shader->tcs_input->data, shader->tcs_output->data, prim_id,
-      shader->draw->pt.vertices_per_patch);
-}
-#endif
-
-/**
- * Execute tess ctrl shader.
- */
-int draw_tess_ctrl_shader_run(struct draw_tess_ctrl_shader *shader,
-                              const void *constants[PIPE_MAX_CONSTANT_BUFFERS],
-                              const unsigned constants_size[PIPE_MAX_CONSTANT_BUFFERS],
-                              const struct draw_vertex_info *input_verts,
-                              const struct draw_prim_info *input_prim,
-                              const struct tgsi_shader_info *input_info,
-                              struct draw_vertex_info *output_verts,
-                              struct draw_prim_info *output_prims )
-{
-   const float (*input)[4] = (const float (*)[4])input_verts->verts->data;
-   unsigned num_outputs = draw_total_tcs_outputs(shader->draw);
-   unsigned input_stride = input_verts->vertex_size;
-   unsigned vertex_size = sizeof(struct vertex_header) + num_outputs * 4 * sizeof(float);
-   unsigned num_patches = input_prim->count / shader->draw->pt.vertices_per_patch;
-
-   output_verts->vertex_size = vertex_size;
-   output_verts->stride = output_verts->vertex_size;
-   output_verts->verts = NULL;
-   output_verts->count = 0;
-   shader->input = input;
-   shader->input_vertex_stride = input_stride;
-   shader->input_info = input_info;
-
-   output_prims->linear = TRUE;
-   output_prims->start = 0;
-   output_prims->elts = NULL;
-   output_prims->count = 0;
-   output_prims->prim = PIPE_PRIM_PATCHES;
-   output_prims->flags = 0;
-   output_prims->primitive_lengths = NULL;
-   output_prims->primitive_count = 0;
-
-   if (shader->draw->collect_statistics) {
-      shader->draw->statistics.hs_invocations += num_patches;
-   }
-#ifdef LLVM_AVAILABLE
-   for (unsigned i = 0; i < num_patches; i++) {
-      uint32_t vert_start = output_verts->count;
-
-      output_verts->count += shader->vertices_out;
-
-      llvm_fetch_tcs_input(shader, input_prim, i, shader->draw->pt.vertices_per_patch);
-
-      llvm_tcs_run(shader, i);
-
-      uint32_t old_verts = util_align_npot(vert_start, 16);
-      uint32_t new_verts = util_align_npot(output_verts->count, 16);
-      uint32_t old_size = output_verts->vertex_size * old_verts;
-      uint32_t new_size = output_verts->vertex_size * new_verts;
-      output_verts->verts = REALLOC(output_verts->verts, old_size, new_size);
-
-      llvm_store_tcs_output(shader, i, output_verts, vert_start);
-   }
-#endif
-
-   output_prims->primitive_count = num_patches;
-   return 0;
-}
-
-#ifdef LLVM_AVAILABLE
-#define DEBUG_INPUTS 0
-static void
-llvm_fetch_tes_input(struct draw_tess_eval_shader *shader,
-                     const struct draw_prim_info *input_prim_info,
-                     unsigned prim_id,
-                     unsigned num_vertices)
-{
-   const float (*input_ptr)[4];
-   float (*input_data)[32][PIPE_MAX_SHADER_INPUTS][TGSI_NUM_CHANNELS] = &shader->tes_input->data;
-   unsigned slot, i;
-   int vs_slot;
-   unsigned input_vertex_stride = shader->input_vertex_stride;
-
-   input_ptr = shader->input;
-   for (i = 0; i < num_vertices; i++) {
-      const float (*input)[4];
-      int vertex_idx = prim_id * num_vertices + i;
-
-      if (input_prim_info->linear == FALSE)
-         vertex_idx = input_prim_info->elts[vertex_idx];
-#if DEBUG_INPUTS
-      debug_printf("%d) tes vertex index = %d (prim idx = %d)\n",
-                   i, prim_id, 0);
-#endif
-      input = (const float (*)[4])((const char *)input_ptr + (vertex_idx * input_vertex_stride));
-      for (slot = 0, vs_slot = 0; slot < shader->info.num_inputs; ++slot) {
-         vs_slot = draw_tes_get_input_index(
-                                            shader->info.input_semantic_name[slot],
-                                            shader->info.input_semantic_index[slot],
-                                            shader->input_info);
-         if (vs_slot < 0) {
-            debug_printf("TCS/TES signature mismatch!\n");
-            (*input_data)[i][slot][0] = 0;
-            (*input_data)[i][slot][1] = 0;
-            (*input_data)[i][slot][2] = 0;
-            (*input_data)[i][slot][3] = 0;
-         } else {
-            (*input_data)[i][slot][0] = input[vs_slot][0];
-            (*input_data)[i][slot][1] = input[vs_slot][1];
-            (*input_data)[i][slot][2] = input[vs_slot][2];
-            (*input_data)[i][slot][3] = input[vs_slot][3];
-#if DEBUG_INPUTS
-            debug_printf("\t\t%p = %f %f %f %f\n",
-                         &input[vs_slot][0],
-                         (*input_data)[i][slot][0],
-                         (*input_data)[i][slot][1],
-                         (*input_data)[i][slot][2],
-                         (*input_data)[i][slot][3]);
-#endif
-            ++vs_slot;
-         }
-      }
-   }
-}
-
-static void
-llvm_fetch_tess_factors(struct draw_tess_eval_shader *shader,
-                        unsigned patch_id,
-                        unsigned num_vertices,
-                        struct pipe_tessellation_factors *factors)
-{
-   int outer_slot = draw_tes_get_input_index(
-      TGSI_SEMANTIC_TESSOUTER, 0, shader->input_info);
-   int inner_slot = draw_tes_get_input_index(
-      TGSI_SEMANTIC_TESSINNER, 0, shader->input_info);
-   const float (*input_ptr)[4];
-   const float (*input)[4];
-   input_ptr = shader->input;
-   input = (const float (*)[4])((const char *)input_ptr + ((patch_id * num_vertices) * shader->input_vertex_stride));
-
-   if (outer_slot != -1) {
-      for (unsigned i = 0; i < 4; i++)
-         factors->outer_tf[i] = input[outer_slot][i];
-   } else {
-      for (unsigned i = 0; i < 4; i++)
-         factors->outer_tf[i] = shader->draw->default_outer_tess_level[i];
-   }
-   if (inner_slot != -1) {
-      for (unsigned i = 0; i < 2; i++)
-         factors->inner_tf[i] = input[inner_slot][i];
-   } else {
-      for (unsigned i = 0; i < 2; i++)
-         factors->inner_tf[i] = shader->draw->default_inner_tess_level[i];
-   }
-}
-
-static void
-llvm_tes_run(struct draw_tess_eval_shader *shader,
-             uint32_t prim_id,
-             uint32_t patch_vertices_in,
-             struct pipe_tessellator_data *tess_data,
-             struct pipe_tessellation_factors *tess_factors,
-             struct vertex_header *output)
-{
-   shader->current_variant->jit_func(shader->jit_context, shader->tes_input->data, output, prim_id,
-                                     tess_data->num_domain_points, tess_data->domain_points_u, tess_data->domain_points_v,
-                                     tess_factors->outer_tf, tess_factors->inner_tf, patch_vertices_in);
-}
-#endif
-
-/**
- * Execute tess eval shader.
- */
-int draw_tess_eval_shader_run(struct draw_tess_eval_shader *shader,
-                              const void *constants[PIPE_MAX_CONSTANT_BUFFERS],
-                              const unsigned constants_size[PIPE_MAX_CONSTANT_BUFFERS],
-                              unsigned num_input_vertices_per_patch,
-                              const struct draw_vertex_info *input_verts,
-                              const struct draw_prim_info *input_prim,
-                              const struct tgsi_shader_info *input_info,
-                              struct draw_vertex_info *output_verts,
-                              struct draw_prim_info *output_prims,
-                              ushort **elts_out)
-{
-   const float (*input)[4] = (const float (*)[4])input_verts->verts->data;
-   unsigned num_outputs = draw_total_tes_outputs(shader->draw);
-   unsigned input_stride = input_verts->vertex_size;
-   unsigned vertex_size = sizeof(struct vertex_header) + num_outputs * 4 * sizeof(float);
-   ushort *elts = NULL;
-   output_verts->vertex_size = vertex_size;
-   output_verts->stride = output_verts->vertex_size;
-   output_verts->count = 0;
-   output_verts->verts = NULL;
-
-   output_prims->linear = FALSE;
-   output_prims->start = 0;
-   output_prims->elts = NULL;
-   output_prims->count = 0;
-   output_prims->prim = get_tes_output_prim(shader);
-   output_prims->flags = 0;
-   output_prims->primitive_lengths = NULL;
-   output_prims->primitive_count = 0;
-
-   shader->input = input;
-   shader->input_vertex_stride = input_stride;
-   shader->input_info = input_info;
-
-   if (shader->draw->collect_statistics) {
-      shader->draw->statistics.ds_invocations += input_prim->primitive_count;
-   }
-#ifdef LLVM_AVAILABLE
-   struct pipe_tessellation_factors factors;
-   struct pipe_tessellator_data data = { 0 };
-   struct pipe_tessellator *ptess = p_tess_init(shader->prim_mode,
-                                                shader->spacing,
-                                                !shader->vertex_order_cw,
-                                                shader->point_mode);
-   for (unsigned i = 0; i < input_prim->primitive_count; i++) {
-      uint32_t vert_start = output_verts->count;
-      uint32_t prim_start = output_prims->primitive_count;
-      uint32_t elt_start = output_prims->count;
-
-      llvm_fetch_tess_factors(shader, i, num_input_vertices_per_patch, &factors);
-
-      /* tessellate with the factors for this primitive */
-      p_tessellate(ptess, &factors, &data);
-
-      if (data.num_domain_points == 0)
-         continue;
-
-      uint32_t old_verts = vert_start;
-      uint32_t new_verts = vert_start + util_align_npot(data.num_domain_points, 4);
-      uint32_t old_size = output_verts->vertex_size * old_verts;
-      uint32_t new_size = output_verts->vertex_size * new_verts;
-      output_verts->verts = REALLOC(output_verts->verts, old_size, new_size);
-
-      output_verts->count += data.num_domain_points;
-
-      output_prims->count += data.num_indices;
-      elts = REALLOC(elts, elt_start * sizeof(uint16_t),
-                     output_prims->count * sizeof(uint16_t));
-
-      for (unsigned i = 0; i < data.num_indices; i++)
-         elts[elt_start + i] = vert_start + data.indices[i];
-
-      llvm_fetch_tes_input(shader, input_prim, i, num_input_vertices_per_patch);
-      /* run once per primitive? */
-      char *output = (char *)output_verts->verts;
-      output += vert_start * vertex_size;
-      llvm_tes_run(shader, i, num_input_vertices_per_patch, &data, &factors, (struct vertex_header *)output);
-
-      uint32_t prim_len = u_prim_vertex_count(output_prims->prim)->min;
-      output_prims->primitive_count += data.num_indices / prim_len;
-      output_prims->primitive_lengths = REALLOC(output_prims->primitive_lengths, prim_start * sizeof(uint32_t),
-                                                output_prims->primitive_count * sizeof(uint32_t));
-      for (unsigned i = prim_start; i < output_prims->primitive_count; i++) {
-         output_prims->primitive_lengths[i] = prim_len;
-      }
-   }
-   p_tess_destroy(ptess);
-#endif
-
-   *elts_out = elts;
-   output_prims->elts = elts;
-   return 0;
-}
-
-struct draw_tess_ctrl_shader *
-draw_create_tess_ctrl_shader(struct draw_context *draw,
-                             const struct pipe_shader_state *state)
-{
-#ifdef LLVM_AVAILABLE
-   boolean use_llvm = draw->llvm != NULL;
-   struct llvm_tess_ctrl_shader *llvm_tcs = NULL;
-#endif
-   struct draw_tess_ctrl_shader *tcs;
-
-#ifdef LLVM_AVAILABLE
-   if (use_llvm) {
-      llvm_tcs = CALLOC_STRUCT(llvm_tess_ctrl_shader);
-
-      if (!llvm_tcs)
-         return NULL;
-
-      tcs = &llvm_tcs->base;
-
-      make_empty_list(&llvm_tcs->variants);
-   } else
-#endif
-   {
-      tcs = CALLOC_STRUCT(draw_tess_ctrl_shader);
-   }
-
-   if (!tcs)
-      return NULL;
-
-   tcs->draw = draw;
-   tcs->state = *state;
-
-   nir_tgsi_scan_shader(state->ir.nir, &tcs->info, true);
-
-   tcs->vector_length = 4;
-   tcs->vertices_out = tcs->info.properties[TGSI_PROPERTY_TCS_VERTICES_OUT];
-#ifdef LLVM_AVAILABLE
-   if (use_llvm) {
-
-      tcs->tcs_input = align_malloc(sizeof(struct draw_tcs_inputs), 16);
-      memset(tcs->tcs_input, 0, sizeof(struct draw_tcs_inputs));
-
-      tcs->tcs_output = align_malloc(sizeof(struct draw_tcs_outputs), 16);
-      memset(tcs->tcs_output, 0, sizeof(struct draw_tcs_outputs));
-
-      tcs->jit_context = &draw->llvm->tcs_jit_context;
-      llvm_tcs->variant_key_size =
-         draw_tcs_llvm_variant_key_size(
-                                        MAX2(tcs->info.file_max[TGSI_FILE_SAMPLER]+1,
-                                             tcs->info.file_max[TGSI_FILE_SAMPLER_VIEW]+1),
-                                        tcs->info.file_max[TGSI_FILE_IMAGE]+1);
-   }
-#endif
-   return tcs;
-}
-
-void draw_bind_tess_ctrl_shader(struct draw_context *draw,
-                                struct draw_tess_ctrl_shader *dtcs)
-{
-   draw_do_flush(draw, DRAW_FLUSH_STATE_CHANGE);
-   if (dtcs) {
-      draw->tcs.tess_ctrl_shader = dtcs;
-   } else {
-      draw->tcs.tess_ctrl_shader = NULL;
-   }
-}
-
-void draw_delete_tess_ctrl_shader(struct draw_context *draw,
-                                  struct draw_tess_ctrl_shader *dtcs)
-{
-   if (!dtcs)
-      return;
-
-#ifdef LLVM_AVAILABLE
-   if (draw->llvm) {
-      struct llvm_tess_ctrl_shader *shader = llvm_tess_ctrl_shader(dtcs);
-
-      struct draw_tcs_llvm_variant_list_item *li;
-
-      li = first_elem(&shader->variants);
-      while(!at_end(&shader->variants, li)) {
-         struct draw_tcs_llvm_variant_list_item *next = next_elem(li);
-         draw_tcs_llvm_destroy_variant(li->base);
-         li = next;
-      }
-
-      assert(shader->variants_cached == 0);
-      align_free(dtcs->tcs_input);
-      align_free(dtcs->tcs_output);
-   }
-#endif
-
-   if (dtcs->state.ir.nir)
-      ralloc_free(dtcs->state.ir.nir);
-   FREE(dtcs);
-}
-
-#ifdef LLVM_AVAILABLE
-void draw_tcs_set_current_variant(struct draw_tess_ctrl_shader *shader,
-                                  struct draw_tcs_llvm_variant *variant)
-{
-   shader->current_variant = variant;
-}
-#endif
-
-struct draw_tess_eval_shader *
-draw_create_tess_eval_shader(struct draw_context *draw,
-                             const struct pipe_shader_state *state)
-{
-#ifdef LLVM_AVAILABLE
-   boolean use_llvm = draw->llvm != NULL;
-   struct llvm_tess_eval_shader *llvm_tes = NULL;
-#endif
-   struct draw_tess_eval_shader *tes;
-
-#ifdef LLVM_AVAILABLE
-   if (use_llvm) {
-      llvm_tes = CALLOC_STRUCT(llvm_tess_eval_shader);
-
-      if (!llvm_tes)
-         return NULL;
-
-      tes = &llvm_tes->base;
-      make_empty_list(&llvm_tes->variants);
-   } else
-#endif
-   {
-      tes = CALLOC_STRUCT(draw_tess_eval_shader);
-   }
-
-   if (!tes)
-      return NULL;
-
-   tes->draw = draw;
-   tes->state = *state;
-
-   nir_tgsi_scan_shader(state->ir.nir, &tes->info, true);
-
-   tes->prim_mode = tes->info.properties[TGSI_PROPERTY_TES_PRIM_MODE];
-   tes->spacing = tes->info.properties[TGSI_PROPERTY_TES_SPACING];
-   tes->vertex_order_cw = tes->info.properties[TGSI_PROPERTY_TES_VERTEX_ORDER_CW];
-   tes->point_mode = tes->info.properties[TGSI_PROPERTY_TES_POINT_MODE];
-
-   tes->vector_length = 4;
-
-   tes->position_output = -1;
-   for (unsigned i = 0; i < tes->info.num_outputs; i++) {
-      if (tes->info.output_semantic_name[i] == TGSI_SEMANTIC_POSITION &&
-          tes->info.output_semantic_index[i] == 0)
-         tes->position_output = i;
-      if (tes->info.output_semantic_name[i] == TGSI_SEMANTIC_VIEWPORT_INDEX)
-         tes->viewport_index_output = i;
-      if (tes->info.output_semantic_name[i] == TGSI_SEMANTIC_CLIPDIST) {
-         debug_assert(tes->info.output_semantic_index[i] <
-                      PIPE_MAX_CLIP_OR_CULL_DISTANCE_ELEMENT_COUNT);
-         tes->ccdistance_output[tes->info.output_semantic_index[i]] = i;
-      }
-   }
-
-#ifdef LLVM_AVAILABLE
-   if (use_llvm) {
-
-      tes->tes_input = align_malloc(sizeof(struct draw_tes_inputs), 16);
-      memset(tes->tes_input, 0, sizeof(struct draw_tes_inputs));
-
-      tes->jit_context = &draw->llvm->tes_jit_context;
-      llvm_tes->variant_key_size =
-         draw_tes_llvm_variant_key_size(
-                                        MAX2(tes->info.file_max[TGSI_FILE_SAMPLER]+1,
-                                             tes->info.file_max[TGSI_FILE_SAMPLER_VIEW]+1),
-                                        tes->info.file_max[TGSI_FILE_IMAGE]+1);
-   }
-#endif
-   return tes;
-}
-
-void draw_bind_tess_eval_shader(struct draw_context *draw,
-                                struct draw_tess_eval_shader *dtes)
-{
-   draw_do_flush(draw, DRAW_FLUSH_STATE_CHANGE);
-   if (dtes) {
-      draw->tes.tess_eval_shader = dtes;
-      draw->tes.position_output = dtes->position_output;
-   } else {
-      draw->tes.tess_eval_shader = NULL;
-   }
-}
-
-void draw_delete_tess_eval_shader(struct draw_context *draw,
-                                  struct draw_tess_eval_shader *dtes)
-{
-   if (!dtes)
-      return;
-
-#ifdef LLVM_AVAILABLE
-   if (draw->llvm) {
-      struct llvm_tess_eval_shader *shader = llvm_tess_eval_shader(dtes);
-      struct draw_tes_llvm_variant_list_item *li;
-
-      li = first_elem(&shader->variants);
-      while(!at_end(&shader->variants, li)) {
-         struct draw_tes_llvm_variant_list_item *next = next_elem(li);
-         draw_tes_llvm_destroy_variant(li->base);
-         li = next;
-      }
-
-      assert(shader->variants_cached == 0);
-      align_free(dtes->tes_input);
-   }
-#endif
-   if (dtes->state.ir.nir)
-      ralloc_free(dtes->state.ir.nir);
-   FREE(dtes);
-}
-
-#ifdef LLVM_AVAILABLE
-void draw_tes_set_current_variant(struct draw_tess_eval_shader *shader,
-                                  struct draw_tes_llvm_variant *variant)
-{
-   shader->current_variant = variant;
-}
-#endif
-
-enum pipe_prim_type get_tes_output_prim(struct draw_tess_eval_shader *shader)
-{
-   if (shader->point_mode)
-      return PIPE_PRIM_POINTS;
-   else if (shader->prim_mode == PIPE_PRIM_LINES)
-      return PIPE_PRIM_LINES;
-   else
-      return PIPE_PRIM_TRIANGLES;
-}
diff --git a/lib/mesa/src/gallium/auxiliary/draw/draw_tess.h b/lib/mesa/src/gallium/auxiliary/draw/draw_tess.h
deleted file mode 100644
index 29ae0847a..000000000
--- a/lib/mesa/src/gallium/auxiliary/draw/draw_tess.h
+++ /dev/null
@@ -1,130 +0,0 @@
-/**************************************************************************
- *
- * Copyright 2020 Red Hat.
- * All Rights Reserved.
- *
- * 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 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.
- *
- **************************************************************************/
-
-#ifndef DRAW_TESS_H
-#define DRAW_TESS_H
-
-#include "draw_context.h"
-#include "draw_private.h"
-
-struct draw_context;
-#ifdef LLVM_AVAILABLE
-
-#define NUM_PATCH_INPUTS 32
-#define NUM_TCS_INPUTS (PIPE_MAX_SHADER_INPUTS - NUM_PATCH_INPUTS)
-
-struct draw_tcs_inputs {
-  /* num vertices per prim */
-  float data[32][NUM_TCS_INPUTS][4];
-};
-
-struct draw_tcs_outputs {
-  /* num vertices per prim */
-  float data[32][PIPE_MAX_SHADER_INPUTS][4];
-};
-
-struct draw_tes_inputs {
-  /* num vertices per prim */
-  float data[32][PIPE_MAX_SHADER_INPUTS][4];
-};
-
-#endif
-
-struct draw_tess_ctrl_shader {
-   struct draw_context *draw;
-
-   struct pipe_shader_state state;
-   struct tgsi_shader_info info;
-
-   unsigned vector_length;
-   unsigned vertices_out;
-
-   unsigned input_vertex_stride;
-   const float (*input)[4];
-   const struct tgsi_shader_info *input_info;
-#ifdef LLVM_AVAILABLE
-   struct draw_tcs_inputs *tcs_input;
-   struct draw_tcs_outputs *tcs_output;
-   struct draw_tcs_jit_context *jit_context;
-   struct draw_tcs_llvm_variant *current_variant;
-#endif
-};
-
-struct draw_tess_eval_shader {
-   struct draw_context *draw;
-   struct pipe_shader_state state;
-   struct tgsi_shader_info info;
-
-   unsigned prim_mode;
-   unsigned spacing;
-   unsigned vertex_order_cw;
-   unsigned point_mode;
-
-   unsigned position_output;
-   unsigned viewport_index_output;
-   unsigned ccdistance_output[PIPE_MAX_CLIP_OR_CULL_DISTANCE_ELEMENT_COUNT];
-   unsigned vector_length;
-
-   unsigned input_vertex_stride;
-   const float (*input)[4];
-   const struct tgsi_shader_info *input_info;
-
-#ifdef LLVM_AVAILABLE
-   struct draw_tes_inputs *tes_input;
-   struct draw_tes_jit_context *jit_context;
-   struct draw_tes_llvm_variant *current_variant;
-#endif
-};
-
-enum pipe_prim_type get_tes_output_prim(struct draw_tess_eval_shader *shader);
-
-int draw_tess_ctrl_shader_run(struct draw_tess_ctrl_shader *shader,
-                              const void *constants[PIPE_MAX_CONSTANT_BUFFERS],
-                              const unsigned constants_size[PIPE_MAX_CONSTANT_BUFFERS],
-                              const struct draw_vertex_info *input_verts,
-                              const struct draw_prim_info *input_prim,
-                              const struct tgsi_shader_info *input_info,
-                              struct draw_vertex_info *output_verts,
-                              struct draw_prim_info *output_prims );
-
-int draw_tess_eval_shader_run(struct draw_tess_eval_shader *shader,
-                              const void *constants[PIPE_MAX_CONSTANT_BUFFERS],
-                              const unsigned constants_size[PIPE_MAX_CONSTANT_BUFFERS],
-                              unsigned num_input_vertices_per_patch,
-                              const struct draw_vertex_info *input_verts,
-                              const struct draw_prim_info *input_prim,
-                              const struct tgsi_shader_info *input_info,
-                              struct draw_vertex_info *output_verts,
-                              struct draw_prim_info *output_prims,
-                              ushort **elts_out);
-
-#ifdef LLVM_AVAILABLE
-void draw_tcs_set_current_variant(struct draw_tess_ctrl_shader *shader,
-                                  struct draw_tcs_llvm_variant *variant);
-void draw_tes_set_current_variant(struct draw_tess_eval_shader *shader,
-                                  struct draw_tes_llvm_variant *variant);
-#endif
-
-#endif