Squashed commit of the following (st-mesa-per-context-shaders branch):

commit 4f106f44a32eaddb6cf3fea6ba5ee9787bff609a
Author: Brian Paul <[email protected]>
Date:   Mon Dec 13 14:06:08 2010 -0700

    st/mesa: reorganize vertex program translation code

    Now it looks like the fragment and geometry program code.
    Also remove the serial number fields from programs.  It was used to
    determine when new translations were needed.  Now the variant key is
    used for that.  And the st_program_string_notify() callback removes all
    variants when the program's code is changed.

commit e12d6791c5e4bff60bb2e6c04414b1b4d1325f3e
Author: Brian Paul <[email protected]>
Date:   Mon Dec 13 13:38:12 2010 -0700

    st/mesa: implement geometry shader varients

    Only needed in order to support per-context gallium shaders.

commit c5751c673644808ab069259a852f24c4c0e92b9d
Author: Brian Paul <[email protected]>
Date:   Sun Dec 12 15:28:57 2010 -0700

    st/mesa: restore glDraw/CopyPixels using new fragment program variants

    Clean up the logic for fragment programs for glDraw/CopyPixels.  We now
    generate fragment program variants for glDraw/CopyPixels as needed which
    do texture sampling, pixel scale/bias, pixelmap lookups, etc.

commit 7b0bb99bab6547f503a0176b5c0aef1482b02c97
Author: Brian Paul <[email protected]>
Date:   Fri Dec 10 17:03:23 2010 -0700

    st/mesa: checkpoint: implement fragment program variants

    The fragment programs variants are per-context, as the vertex programs.

    NOTE: glDrawPixels is totally broken at this point.

commit 2cc926183f957f8abac18d71276dd5bbd1f27be2
Author: Brian Paul <[email protected]>
Date:   Fri Dec 10 14:59:32 2010 -0700

    st/mesa: make vertex shader variants per-context

    Gallium shaders are per-context but OpenGL shaders aren't.  So we need
    to make a different variant for each context.

    During context tear-down we need to walk over all shaders/programs and
    free all variants for the context being destroyed.

1 files changed, 558 insertions, 193 deletions

diff --git a/src/mesa/state_tracker/st_program.c b/src/mesa/state_tracker/st_program.c
index aae2913c202..202f7cb711e 100644
--- a/src/mesa/state_tracker/st_program.c
+++ b/src/mesa/state_tracker/st_program.c
@@ -32,7 +32,9 @@
 
 
 #include "main/imports.h"
+#include "main/hash.h"
 #include "main/mtypes.h"
+#include "program/prog_parameter.h"
 #include "program/prog_print.h"
 #include "program/programopt.h"
 
@@ -44,6 +46,8 @@
 #include "tgsi/tgsi_ureg.h"
 
 #include "st_debug.h"
+#include "st_cb_bitmap.h"
+#include "st_cb_drawpixels.h"
 #include "st_context.h"
 #include "st_program.h"
 #include "st_mesa_to_tgsi.h"
@@ -52,6 +56,29 @@
 
 
 /**
+ * Delete a vertex program varient.  Note the caller must unlink
+ * the varient from the linked list.
+ */
+static void
+delete_vp_varient(struct st_context *st, struct st_vp_varient *vpv)
+{
+   if (vpv->driver_shader) 
+      cso_delete_vertex_shader(st->cso_context, vpv->driver_shader);
+      
+#if FEATURE_feedback || FEATURE_rastpos
+   if (vpv->draw_shader)
+      draw_delete_vertex_shader( st->draw, vpv->draw_shader );
+#endif
+      
+   if (vpv->tgsi.tokens)
+      st_free_tokens(vpv->tgsi.tokens);
+      
+   FREE( vpv );
+}
+
+
+
+/**
  * Clean out any old compilations:
  */
 void
@@ -62,24 +89,76 @@ st_vp_release_varients( struct st_context *st,
 
    for (vpv = stvp->varients; vpv; ) {
       struct st_vp_varient *next = vpv->next;
+      delete_vp_varient(st, vpv);
+      vpv = next;
+   }
 
-      if (vpv->driver_shader) 
-         cso_delete_vertex_shader(st->cso_context, vpv->driver_shader);
-      
-#if FEATURE_feedback || FEATURE_rastpos
-      if (vpv->draw_shader)
-         draw_delete_vertex_shader( st->draw, vpv->draw_shader );
-#endif
+   stvp->varients = NULL;
+}
+
+
+
+/**
+ * Delete a fragment program varient.  Note the caller must unlink
+ * the varient from the linked list.
+ */
+static void
+delete_fp_varient(struct st_context *st, struct st_fp_varient *fpv)
+{
+   if (fpv->driver_shader) 
+      cso_delete_fragment_shader(st->cso_context, fpv->driver_shader);
       
-      if (vpv->tgsi.tokens)
-         st_free_tokens(vpv->tgsi.tokens);
+   FREE(fpv);
+}
+
+
+/**
+ * Free all varients of a fragment program.
+ */
+void
+st_fp_release_varients(struct st_context *st, struct st_fragment_program *stfp)
+{
+   struct st_fp_varient *fpv;
+
+   for (fpv = stfp->varients; fpv; ) {
+      struct st_fp_varient *next = fpv->next;
+      delete_fp_varient(st, fpv);
+      fpv = next;
+   }
+
+   stfp->varients = NULL;
+}
+
+
+/**
+ * Delete a geometry program varient.  Note the caller must unlink
+ * the varient from the linked list.
+ */
+static void
+delete_gp_varient(struct st_context *st, struct st_gp_varient *gpv)
+{
+   if (gpv->driver_shader) 
+      cso_delete_geometry_shader(st->cso_context, gpv->driver_shader);
       
-      FREE( vpv );
+   FREE(gpv);
+}
 
-      vpv = next;
+
+/**
+ * Free all varients of a geometry program.
+ */
+void
+st_gp_release_varients(struct st_context *st, struct st_geometry_program *stgp)
+{
+   struct st_gp_varient *gpv;
+
+   for (gpv = stgp->varients; gpv; ) {
+      struct st_gp_varient *next = gpv->next;
+      delete_gp_varient(st, gpv);
+      gpv = next;
    }
 
-   stvp->varients = NULL;
+   stgp->varients = NULL;
 }
 
 
@@ -92,7 +171,7 @@ st_vp_release_varients( struct st_context *st,
  * \param tokensOut  destination for TGSI tokens
  * \return  pointer to cached pipe_shader object.
  */
-void
+static void
 st_prepare_vertex_program(struct st_context *st,
                             struct st_vertex_program *stvp)
 {
@@ -196,7 +275,10 @@ st_prepare_vertex_program(struct st_context *st,
 }
 
 
-struct st_vp_varient *
+/**
+ * Translate a vertex program to create a new varient.
+ */
+static struct st_vp_varient *
 st_translate_vertex_program(struct st_context *st,
                             struct st_vertex_program *stvp,
                             const struct st_vp_varient_key *key)
@@ -207,6 +289,8 @@ st_translate_vertex_program(struct st_context *st,
    enum pipe_error error;
    unsigned num_outputs;
 
+   st_prepare_vertex_program( st, stvp );
+
    _mesa_remove_output_reads(&stvp->Base.Base, PROGRAM_OUTPUT);
    _mesa_remove_output_reads(&stvp->Base.Base, PROGRAM_VARYING);
 
@@ -277,201 +361,310 @@ fail:
 }
 
 
+/**
+ * Find/create a vertex program varient.
+ */
+struct st_vp_varient *
+st_get_vp_varient(struct st_context *st,
+                  struct st_vertex_program *stvp,
+                  const struct st_vp_varient_key *key)
+{
+   struct st_vp_varient *vpv;
+
+   /* Search for existing varient */
+   for (vpv = stvp->varients; vpv; vpv = vpv->next) {
+      if (memcmp(&vpv->key, key, sizeof(*key)) == 0) {
+         break;
+      }
+   }
+
+   if (!vpv) {
+      /* create now */
+      vpv = st_translate_vertex_program(st, stvp, key);
+      if (vpv) {
+         /* insert into list */
+         vpv->next = stvp->varients;
+         stvp->varients = vpv;
+      }
+   }
+
+   return vpv;
+}
+
 
 /**
- * Translate a Mesa fragment shader into a TGSI shader.
- * \return  pointer to cached pipe_shader object.
+ * Translate a Mesa fragment shader into a TGSI shader using extra info in
+ * the key.
+ * \return  new fragment program variant
  */
-void
+static struct st_fp_varient *
 st_translate_fragment_program(struct st_context *st,
-                              struct st_fragment_program *stfp )
+                              struct st_fragment_program *stfp,
+                              const struct st_fp_varient_key *key)
 {
    struct pipe_context *pipe = st->pipe;
-   GLuint outputMapping[FRAG_RESULT_MAX];
-   GLuint inputMapping[FRAG_ATTRIB_MAX];
-   GLuint interpMode[PIPE_MAX_SHADER_INPUTS];  /* XXX size? */
-   GLuint attr;
-   enum pipe_error error;
-   const GLbitfield inputsRead = stfp->Base.Base.InputsRead;
-   struct ureg_program *ureg;
+   struct st_fp_varient *varient = CALLOC_STRUCT(st_fp_varient);
 
-   ubyte input_semantic_name[PIPE_MAX_SHADER_INPUTS];
-   ubyte input_semantic_index[PIPE_MAX_SHADER_INPUTS];
-   uint fs_num_inputs = 0;
+   if (!varient)
+      return NULL;
 
-   ubyte fs_output_semantic_name[PIPE_MAX_SHADER_OUTPUTS];
-   ubyte fs_output_semantic_index[PIPE_MAX_SHADER_OUTPUTS];
-   uint fs_num_outputs = 0;
+   assert(!(key->bitmap && key->drawpixels));
 
-   _mesa_remove_output_reads(&stfp->Base.Base, PROGRAM_OUTPUT);
+   if (key->bitmap) {
+      /* glBitmap drawing */
+      struct gl_fragment_program *fp;
 
-   /*
-    * Convert Mesa program inputs to TGSI input register semantics.
-    */
-   for (attr = 0; attr < FRAG_ATTRIB_MAX; attr++) {
-      if (inputsRead & (1 << attr)) {
-         const GLuint slot = fs_num_inputs++;
+      st_make_bitmap_fragment_program(st, &stfp->Base,
+                                      &fp, &varient->bitmap_sampler);
 
-         inputMapping[attr] = slot;
+      varient->parameters = _mesa_clone_parameter_list(fp->Base.Parameters);
+      stfp = (struct st_fragment_program *) fp;
+   }
+   else if (key->drawpixels) {
+      /* glDrawPixels drawing */
+      struct gl_fragment_program *fp;
 
-         switch (attr) {
-         case FRAG_ATTRIB_WPOS:
-            input_semantic_name[slot] = TGSI_SEMANTIC_POSITION;
-            input_semantic_index[slot] = 0;
-            interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
-            break;
-         case FRAG_ATTRIB_COL0:
-            input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
-            input_semantic_index[slot] = 0;
-            interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
-            break;
-         case FRAG_ATTRIB_COL1:
-            input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
-            input_semantic_index[slot] = 1;
-            interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
-            break;
-         case FRAG_ATTRIB_FOGC:
-            input_semantic_name[slot] = TGSI_SEMANTIC_FOG;
-            input_semantic_index[slot] = 0;
-            interpMode[slot] = TGSI_INTERPOLATE_PERSPECTIVE;
-            break;
-         case FRAG_ATTRIB_FACE:
-            input_semantic_name[slot] = TGSI_SEMANTIC_FACE;
-            input_semantic_index[slot] = 0;
-            interpMode[slot] = TGSI_INTERPOLATE_CONSTANT;
-            break;
-            /* In most cases, there is nothing special about these
-             * inputs, so adopt a convention to use the generic
-             * semantic name and the mesa FRAG_ATTRIB_ number as the
-             * index. 
-             * 
-             * All that is required is that the vertex shader labels
-             * its own outputs similarly, and that the vertex shader
-             * generates at least every output required by the
-             * fragment shader plus fixed-function hardware (such as
-             * BFC).
-             * 
-             * There is no requirement that semantic indexes start at
-             * zero or be restricted to a particular range -- nobody
-             * should be building tables based on semantic index.
-             */
-         case FRAG_ATTRIB_PNTC:
-         case FRAG_ATTRIB_TEX0:
-         case FRAG_ATTRIB_TEX1:
-         case FRAG_ATTRIB_TEX2:
-         case FRAG_ATTRIB_TEX3:
-         case FRAG_ATTRIB_TEX4:
-         case FRAG_ATTRIB_TEX5:
-         case FRAG_ATTRIB_TEX6:
-         case FRAG_ATTRIB_TEX7:
-         case FRAG_ATTRIB_VAR0:
-         default:
-            /* Actually, let's try and zero-base this just for
-             * readability of the generated TGSI.
-             */
-            assert(attr >= FRAG_ATTRIB_TEX0);
-            input_semantic_index[slot] = (attr - FRAG_ATTRIB_TEX0);
-            input_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
-            if (attr == FRAG_ATTRIB_PNTC)
-               interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
-            else
-               interpMode[slot] = TGSI_INTERPOLATE_PERSPECTIVE;
-            break;
-         }
+      if (key->drawpixels_z || key->drawpixels_stencil) {
+         fp = st_make_drawpix_z_stencil_program(st, key->drawpixels_z,
+                                                key->drawpixels_stencil);
       }
       else {
-	 inputMapping[attr] = -1;
+         /* RGBA */
+         st_make_drawpix_fragment_program(st, &stfp->Base, &fp);
+         varient->parameters = _mesa_clone_parameter_list(fp->Base.Parameters);
       }
+      stfp = (struct st_fragment_program *) fp;
    }
 
-   /*
-    * Semantics and mapping for outputs
-    */
-   {
-      uint numColors = 0;
-      GLbitfield64 outputsWritten = stfp->Base.Base.OutputsWritten;
-
-      /* if z is written, emit that first */
-      if (outputsWritten & BITFIELD64_BIT(FRAG_RESULT_DEPTH)) {
-         fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_POSITION;
-         fs_output_semantic_index[fs_num_outputs] = 0;
-         outputMapping[FRAG_RESULT_DEPTH] = fs_num_outputs;
-         fs_num_outputs++;
-         outputsWritten &= ~(1 << FRAG_RESULT_DEPTH);
-      }
+   if (!stfp->tgsi.tokens) {
+      /* need to translate Mesa instructions to TGSI now */
+      GLuint outputMapping[FRAG_RESULT_MAX];
+      GLuint inputMapping[FRAG_ATTRIB_MAX];
+      GLuint interpMode[PIPE_MAX_SHADER_INPUTS];  /* XXX size? */
+      GLuint attr;
+      enum pipe_error error;
+      const GLbitfield inputsRead = stfp->Base.Base.InputsRead;
+      struct ureg_program *ureg;
 
-      if (outputsWritten & BITFIELD64_BIT(FRAG_RESULT_STENCIL)) {
-         fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_STENCIL;
-         fs_output_semantic_index[fs_num_outputs] = 0;
-         outputMapping[FRAG_RESULT_STENCIL] = fs_num_outputs;
-         fs_num_outputs++;
-         outputsWritten &= ~(1 << FRAG_RESULT_STENCIL);
-      }
+      ubyte input_semantic_name[PIPE_MAX_SHADER_INPUTS];
+      ubyte input_semantic_index[PIPE_MAX_SHADER_INPUTS];
+      uint fs_num_inputs = 0;
+
+      ubyte fs_output_semantic_name[PIPE_MAX_SHADER_OUTPUTS];
+      ubyte fs_output_semantic_index[PIPE_MAX_SHADER_OUTPUTS];
+      uint fs_num_outputs = 0;
+
+
+      _mesa_remove_output_reads(&stfp->Base.Base, PROGRAM_OUTPUT);
+
+      /*
+       * Convert Mesa program inputs to TGSI input register semantics.
+       */
+      for (attr = 0; attr < FRAG_ATTRIB_MAX; attr++) {
+         if (inputsRead & (1 << attr)) {
+            const GLuint slot = fs_num_inputs++;
+
+            inputMapping[attr] = slot;
 
-      /* handle remaning outputs (color) */
-      for (attr = 0; attr < FRAG_RESULT_MAX; attr++) {
-         if (outputsWritten & BITFIELD64_BIT(attr)) {
             switch (attr) {
-            case FRAG_RESULT_DEPTH:
-            case FRAG_RESULT_STENCIL:
-               /* handled above */
-               assert(0);
+            case FRAG_ATTRIB_WPOS:
+               input_semantic_name[slot] = TGSI_SEMANTIC_POSITION;
+               input_semantic_index[slot] = 0;
+               interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
+               break;
+            case FRAG_ATTRIB_COL0:
+               input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
+               input_semantic_index[slot] = 0;
+               interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
+               break;
+            case FRAG_ATTRIB_COL1:
+               input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
+               input_semantic_index[slot] = 1;
+               interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
+               break;
+            case FRAG_ATTRIB_FOGC:
+               input_semantic_name[slot] = TGSI_SEMANTIC_FOG;
+               input_semantic_index[slot] = 0;
+               interpMode[slot] = TGSI_INTERPOLATE_PERSPECTIVE;
                break;
+            case FRAG_ATTRIB_FACE:
+               input_semantic_name[slot] = TGSI_SEMANTIC_FACE;
+               input_semantic_index[slot] = 0;
+               interpMode[slot] = TGSI_INTERPOLATE_CONSTANT;
+               break;
+               /* In most cases, there is nothing special about these
+                * inputs, so adopt a convention to use the generic
+                * semantic name and the mesa FRAG_ATTRIB_ number as the
+                * index. 
+                * 
+                * All that is required is that the vertex shader labels
+                * its own outputs similarly, and that the vertex shader
+                * generates at least every output required by the
+                * fragment shader plus fixed-function hardware (such as
+                * BFC).
+                * 
+                * There is no requirement that semantic indexes start at
+                * zero or be restricted to a particular range -- nobody
+                * should be building tables based on semantic index.
+                */
+            case FRAG_ATTRIB_PNTC:
+            case FRAG_ATTRIB_TEX0:
+            case FRAG_ATTRIB_TEX1:
+            case FRAG_ATTRIB_TEX2:
+            case FRAG_ATTRIB_TEX3:
+            case FRAG_ATTRIB_TEX4:
+            case FRAG_ATTRIB_TEX5:
+            case FRAG_ATTRIB_TEX6:
+            case FRAG_ATTRIB_TEX7:
+            case FRAG_ATTRIB_VAR0:
             default:
-               assert(attr == FRAG_RESULT_COLOR ||
-                      (FRAG_RESULT_DATA0 <= attr && attr < FRAG_RESULT_MAX));
-               fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_COLOR;
-               fs_output_semantic_index[fs_num_outputs] = numColors;
-               outputMapping[attr] = fs_num_outputs;
-               numColors++;
+               /* Actually, let's try and zero-base this just for
+                * readability of the generated TGSI.
+                */
+               assert(attr >= FRAG_ATTRIB_TEX0);
+               input_semantic_index[slot] = (attr - FRAG_ATTRIB_TEX0);
+               input_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
+               if (attr == FRAG_ATTRIB_PNTC)
+                  interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
+               else
+                  interpMode[slot] = TGSI_INTERPOLATE_PERSPECTIVE;
                break;
             }
+         }
+         else {
+            inputMapping[attr] = -1;
+         }
+      }
+
+      /*
+       * Semantics and mapping for outputs
+       */
+      {
+         uint numColors = 0;
+         GLbitfield64 outputsWritten = stfp->Base.Base.OutputsWritten;
+
+         /* if z is written, emit that first */
+         if (outputsWritten & BITFIELD64_BIT(FRAG_RESULT_DEPTH)) {
+            fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_POSITION;
+            fs_output_semantic_index[fs_num_outputs] = 0;
+            outputMapping[FRAG_RESULT_DEPTH] = fs_num_outputs;
+            fs_num_outputs++;
+            outputsWritten &= ~(1 << FRAG_RESULT_DEPTH);
+         }
 
+         if (outputsWritten & BITFIELD64_BIT(FRAG_RESULT_STENCIL)) {
+            fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_STENCIL;
+            fs_output_semantic_index[fs_num_outputs] = 0;
+            outputMapping[FRAG_RESULT_STENCIL] = fs_num_outputs;
             fs_num_outputs++;
+            outputsWritten &= ~(1 << FRAG_RESULT_STENCIL);
+         }
+
+         /* handle remaning outputs (color) */
+         for (attr = 0; attr < FRAG_RESULT_MAX; attr++) {
+            if (outputsWritten & BITFIELD64_BIT(attr)) {
+               switch (attr) {
+               case FRAG_RESULT_DEPTH:
+               case FRAG_RESULT_STENCIL:
+                  /* handled above */
+                  assert(0);
+                  break;
+               default:
+                  assert(attr == FRAG_RESULT_COLOR ||
+                         (FRAG_RESULT_DATA0 <= attr && attr < FRAG_RESULT_MAX));
+                  fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_COLOR;
+                  fs_output_semantic_index[fs_num_outputs] = numColors;
+                  outputMapping[attr] = fs_num_outputs;
+                  numColors++;
+                  break;
+               }
+
+               fs_num_outputs++;
+            }
          }
       }
-   }
 
-   ureg = ureg_create( TGSI_PROCESSOR_FRAGMENT );
-   if (ureg == NULL)
-      return;
+      ureg = ureg_create( TGSI_PROCESSOR_FRAGMENT );
+      if (ureg == NULL)
+         return NULL;
 
-   if (ST_DEBUG & DEBUG_MESA) {
-      _mesa_print_program(&stfp->Base.Base);
-      _mesa_print_program_parameters(st->ctx, &stfp->Base.Base);
-      debug_printf("\n");
-   }
+      if (ST_DEBUG & DEBUG_MESA) {
+         _mesa_print_program(&stfp->Base.Base);
+         _mesa_print_program_parameters(st->ctx, &stfp->Base.Base);
+         debug_printf("\n");
+      }
 
-   error = 
-      st_translate_mesa_program(st->ctx,
-                                TGSI_PROCESSOR_FRAGMENT,
-                                ureg,
-                                &stfp->Base.Base,
-                                /* inputs */
-                                fs_num_inputs,
-                                inputMapping,
-                                input_semantic_name,
-                                input_semantic_index,
-                                interpMode,
-                                /* outputs */
-                                fs_num_outputs,
-                                outputMapping,
-                                fs_output_semantic_name,
-                                fs_output_semantic_index, FALSE );
+      error = st_translate_mesa_program(st->ctx,
+                                        TGSI_PROCESSOR_FRAGMENT,
+                                        ureg,
+                                        &stfp->Base.Base,
+                                        /* inputs */
+                                        fs_num_inputs,
+                                        inputMapping,
+                                        input_semantic_name,
+                                        input_semantic_index,
+                                        interpMode,
+                                        /* outputs */
+                                        fs_num_outputs,
+                                        outputMapping,
+                                        fs_output_semantic_name,
+                                        fs_output_semantic_index, FALSE );
+
+      stfp->tgsi.tokens = ureg_get_tokens( ureg, NULL );
+      ureg_destroy( ureg );
+   }
 
-   stfp->tgsi.tokens = ureg_get_tokens( ureg, NULL );
-   ureg_destroy( ureg );
-   stfp->driver_shader = pipe->create_fs_state(pipe, &stfp->tgsi);
+   /* fill in varient */
+   varient->driver_shader = pipe->create_fs_state(pipe, &stfp->tgsi);
+   varient->key = *key;
 
    if (ST_DEBUG & DEBUG_TGSI) {
       tgsi_dump( stfp->tgsi.tokens, 0/*TGSI_DUMP_VERBOSE*/ );
       debug_printf("\n");
    }
+
+   return varient;
 }
 
-void
+
+/**
+ * Translate fragment program if needed.
+ */
+struct st_fp_varient *
+st_get_fp_varient(struct st_context *st,
+                  struct st_fragment_program *stfp,
+                  const struct st_fp_varient_key *key)
+{
+   struct st_fp_varient *fpv;
+
+   /* Search for existing varient */
+   for (fpv = stfp->varients; fpv; fpv = fpv->next) {
+      if (memcmp(&fpv->key, key, sizeof(*key)) == 0) {
+         break;
+      }
+   }
+
+   if (!fpv) {
+      /* create new */
+      fpv = st_translate_fragment_program(st, stfp, key);
+      if (fpv) {
+         /* insert into list */
+         fpv->next = stfp->varients;
+         stfp->varients = fpv;
+      }
+   }
+
+   return fpv;
+}
+
+
+/**
+ * Translate a geometry program to create a new varient.
+ */
+static struct st_gp_varient *
 st_translate_geometry_program(struct st_context *st,
-                              struct st_geometry_program *stgp)
+                              struct st_geometry_program *stgp,
+                              const struct st_gp_varient_key *key)
 {
    GLuint inputMapping[GEOM_ATTRIB_MAX];
    GLuint outputMapping[GEOM_RESULT_MAX];
@@ -494,12 +687,19 @@ st_translate_geometry_program(struct st_context *st,
    GLuint maxSlot = 0;
    struct ureg_program *ureg;
 
+   struct st_gp_varient *gpv;
+
+   gpv = CALLOC_STRUCT(st_gp_varient);
+   if (!gpv)
+      return NULL;
+
    _mesa_remove_output_reads(&stgp->Base.Base, PROGRAM_OUTPUT);
    _mesa_remove_output_reads(&stgp->Base.Base, PROGRAM_VARYING);
 
    ureg = ureg_create( TGSI_PROCESSOR_GEOMETRY );
    if (ureg == NULL) {
-      return;
+      FREE(gpv);
+      return NULL;
    }
 
    /* which vertex output goes to the first geometry input */
@@ -529,7 +729,7 @@ st_translate_geometry_program(struct st_context *st,
          } else
             ++gs_builtin_inputs;
 
-#if 1
+#if 0
          debug_printf("input map at %d = %d\n",
                       slot + gs_array_offset, stgp->input_map[slot + gs_array_offset]);
 #endif
@@ -671,37 +871,35 @@ st_translate_geometry_program(struct st_context *st,
       st_free_tokens(stgp->tgsi.tokens);
       stgp->tgsi.tokens = NULL;
    }
-   if (stgp->driver_shader) {
-      cso_delete_geometry_shader(st->cso_context, stgp->driver_shader);
-      stgp->driver_shader = NULL;
-   }
 
    ureg_property_gs_input_prim(ureg, stgp->Base.InputType);
    ureg_property_gs_output_prim(ureg, stgp->Base.OutputType);
    ureg_property_gs_max_vertices(ureg, stgp->Base.VerticesOut);
 
-   error  = st_translate_mesa_program(st->ctx,
-                                      TGSI_PROCESSOR_GEOMETRY,
-                                      ureg,
-                                      &stgp->Base.Base,
-                                      /* inputs */
-                                      gs_num_inputs,
-                                      inputMapping,
-                                      stgp->input_semantic_name,
-                                      stgp->input_semantic_index,
-                                      NULL,
-                                      /* outputs */
-                                      gs_num_outputs,
-                                      outputMapping,
-                                      gs_output_semantic_name,
-                                      gs_output_semantic_index,
-                                      FALSE);
-
+   error = st_translate_mesa_program(st->ctx,
+                                     TGSI_PROCESSOR_GEOMETRY,
+                                     ureg,
+                                     &stgp->Base.Base,
+                                     /* inputs */
+                                     gs_num_inputs,
+                                     inputMapping,
+                                     stgp->input_semantic_name,
+                                     stgp->input_semantic_index,
+                                     NULL,
+                                     /* outputs */
+                                     gs_num_outputs,
+                                     outputMapping,
+                                     gs_output_semantic_name,
+                                     gs_output_semantic_index,
+                                     FALSE);
 
    stgp->num_inputs = gs_num_inputs;
    stgp->tgsi.tokens = ureg_get_tokens( ureg, NULL );
    ureg_destroy( ureg );
-   stgp->driver_shader = pipe->create_gs_state(pipe, &stgp->tgsi);
+
+   /* fill in new varient */
+   gpv->driver_shader = pipe->create_gs_state(pipe, &stgp->tgsi);
+   gpv->key = *key;
 
    if ((ST_DEBUG & DEBUG_TGSI) && (ST_DEBUG & DEBUG_MESA)) {
       _mesa_print_program(&stgp->Base.Base);
@@ -712,8 +910,44 @@ st_translate_geometry_program(struct st_context *st,
       tgsi_dump(stgp->tgsi.tokens, 0);
       debug_printf("\n");
    }
+
+   return gpv;
+}
+
+
+/**
+ * Get/create geometry program variant.
+ */
+struct st_gp_varient *
+st_get_gp_varient(struct st_context *st,
+                  struct st_geometry_program *stgp,
+                  const struct st_gp_varient_key *key)
+{
+   struct st_gp_varient *gpv;
+
+   /* Search for existing varient */
+   for (gpv = stgp->varients; gpv; gpv = gpv->next) {
+      if (memcmp(&gpv->key, key, sizeof(*key)) == 0) {
+         break;
+      }
+   }
+
+   if (!gpv) {
+      /* create new */
+      gpv = st_translate_geometry_program(st, stgp, key);
+      if (gpv) {
+         /* insert into list */
+         gpv->next = stgp->varients;
+         stgp->varients = gpv;
+      }
+   }
+
+   return gpv;
 }
 
+
+
+
 /**
  * Debug- print current shader text
  */
@@ -759,3 +993,134 @@ st_print_shaders(struct gl_context *ctx)
       }
    }
 }
+
+
+/**
+ * Vert/Geom/Frag programs have per-context variants.  Free all the
+ * variants attached to the given program which match the given context.
+ */
+static void
+destroy_program_variants(struct st_context *st, struct gl_program *program)
+{
+   if (!program)
+      return;
+
+   switch (program->Target) {
+   case GL_VERTEX_PROGRAM_ARB:
+      {
+         struct st_vertex_program *stvp = (struct st_vertex_program *) program;
+         struct st_vp_varient *vpv, **prev = &stvp->varients;
+
+         for (vpv = stvp->varients; vpv; ) {
+            struct st_vp_varient *next = vpv->next;
+            if (vpv->key.st == st) {
+               /* unlink from list */
+               *prev = next;
+               /* destroy this variant */
+               delete_vp_varient(st, vpv);
+            }
+            else {
+               prev = &vpv;
+            }
+            vpv = next;
+         }
+      }
+      break;
+   case GL_FRAGMENT_PROGRAM_ARB:
+      {
+         struct st_fragment_program *stfp =
+            (struct st_fragment_program *) program;
+         struct st_fp_varient *fpv, **prev = &stfp->varients;
+
+         for (fpv = stfp->varients; fpv; ) {
+            struct st_fp_varient *next = fpv->next;
+            if (fpv->key.st == st) {
+               /* unlink from list */
+               *prev = next;
+               /* destroy this variant */
+               delete_fp_varient(st, fpv);
+            }
+            else {
+               prev = &fpv;
+            }
+            fpv = next;
+         }
+      }
+      break;
+   default:
+      _mesa_problem(NULL, "Unexpected program target in "
+                    "destroy_program_variants_cb()");
+   }
+}
+
+
+/**
+ * Callback for _mesa_HashWalk.  Free all the shader's program variants
+ * which match the given context.
+ */
+static void
+destroy_shader_program_variants_cb(GLuint key, void *data, void *userData)
+{
+   struct st_context *st = (struct st_context *) userData;
+   struct gl_shader *shader = (struct gl_shader *) data;
+
+   switch (shader->Type) {
+   case GL_SHADER_PROGRAM_MESA:
+      {
+         struct gl_shader_program *shProg = (struct gl_shader_program *) data;
+         GLuint i;
+
+         for (i = 0; i < shProg->NumShaders; i++) {
+            destroy_program_variants(st, shProg->Shaders[i]->Program);
+         }
+
+         destroy_program_variants(st, (struct gl_program *)
+                                  shProg->VertexProgram);
+         destroy_program_variants(st, (struct gl_program *)
+                                  shProg->FragmentProgram);
+         destroy_program_variants(st, (struct gl_program *)
+                                  shProg->GeometryProgram);
+      }
+      break;
+   case GL_VERTEX_SHADER:
+   case GL_FRAGMENT_SHADER:
+   case GL_GEOMETRY_SHADER:
+      {
+         destroy_program_variants(st, shader->Program);
+      }
+      break;
+   default:
+      assert(0);
+   }
+}
+
+
+/**
+ * Callback for _mesa_HashWalk.  Free all the program variants which match
+ * the given context.
+ */
+static void
+destroy_program_variants_cb(GLuint key, void *data, void *userData)
+{
+   struct st_context *st = (struct st_context *) userData;
+   struct gl_program *program = (struct gl_program *) data;
+   destroy_program_variants(st, program);
+}
+
+
+/**
+ * Walk over all shaders and programs to delete any variants which
+ * belong to the given context.
+ * This is called during context tear-down.
+ */
+void
+st_destroy_program_variants(struct st_context *st)
+{
+   /* ARB vert/frag program */
+   _mesa_HashWalk(st->ctx->Shared->Programs,
+                  destroy_program_variants_cb, st);
+
+   /* GLSL vert/frag/geom shaders */
+   _mesa_HashWalk(st->ctx->Shared->ShaderObjects,
+                  destroy_shader_program_variants_cb, st);
+}