src/mesa/state_tracker/st_program.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sub license, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the
  15  * next paragraph) shall be included in all copies or substantial portions
  16  * of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  21  * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
  22  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  **************************************************************************/
  27  /*
  28   * Authors:
  29   *   Keith Whitwell <keith@tungstengraphics.com>
  30   *   Brian Paul
  31   */
  32
  33
  34 #include "main/imports.h"
  35 #include "main/hash.h"
  36 #include "main/mfeatures.h"
  37 #include "main/mtypes.h"
  38 #include "program/prog_parameter.h"
  39 #include "program/prog_print.h"
  40 #include "program/programopt.h"
  41
  42 #include "pipe/p_context.h"
  43 #include "pipe/p_defines.h"
  44 #include "pipe/p_shader_tokens.h"
  45 #include "draw/draw_context.h"
  46 #include "tgsi/tgsi_dump.h"
  47 #include "tgsi/tgsi_ureg.h"
  48
  49 #include "st_debug.h"
  50 #include "st_cb_bitmap.h"
  51 #include "st_cb_drawpixels.h"
  52 #include "st_context.h"
  53 #include "st_program.h"
  54 #include "st_mesa_to_tgsi.h"
  55 #include "cso_cache/cso_context.h"
  56
  57
  58
  59 /**
  60  * Delete a vertex program variant.  Note the caller must unlink
  61  * the variant from the linked list.
  62  */
  63 static void
  64 delete_vp_variant(struct st_context *st, struct st_vp_variant *vpv)
  65 {
  66    if (vpv->driver_shader)
  67       cso_delete_vertex_shader(st->cso_context, vpv->driver_shader);
  68
  69    if (vpv->draw_shader)
  70       draw_delete_vertex_shader( st->draw, vpv->draw_shader );
  71
  72    if (vpv->tgsi.tokens)
  73       st_free_tokens(vpv->tgsi.tokens);
  74
  75    free( vpv );
  76 }
  77
  78
  79
  80 /**
  81  * Clean out any old compilations:
  82  */
  83 void
  84 st_release_vp_variants( struct st_context *st,
  85                         struct st_vertex_program *stvp )
  86 {
  87    struct st_vp_variant *vpv;
  88
  89    for (vpv = stvp->variants; vpv; ) {
  90       struct st_vp_variant *next = vpv->next;
  91       delete_vp_variant(st, vpv);
  92       vpv = next;
  93    }
  94
  95    stvp->variants = NULL;
  96 }
  97
  98
  99
 100 /**
 101  * Delete a fragment program variant.  Note the caller must unlink
 102  * the variant from the linked list.
 103  */
 104 static void
 105 delete_fp_variant(struct st_context *st, struct st_fp_variant *fpv)
 106 {
 107    if (fpv->driver_shader)
 108       cso_delete_fragment_shader(st->cso_context, fpv->driver_shader);
 109    if (fpv->parameters)
 110       _mesa_free_parameter_list(fpv->parameters);
 111    if (fpv->tgsi.tokens)
 112       st_free_tokens(fpv->tgsi.tokens);
 113    free(fpv);
 114 }
 115
 116
 117 /**
 118  * Free all variants of a fragment program.
 119  */
 120 void
 121 st_release_fp_variants(struct st_context *st, struct st_fragment_program *stfp)
 122 {
 123    struct st_fp_variant *fpv;
 124
 125    for (fpv = stfp->variants; fpv; ) {
 126       struct st_fp_variant *next = fpv->next;
 127       delete_fp_variant(st, fpv);
 128       fpv = next;
 129    }
 130
 131    stfp->variants = NULL;
 132 }
 133
 134
 135 /**
 136  * Delete a geometry program variant.  Note the caller must unlink
 137  * the variant from the linked list.
 138  */
 139 static void
 140 delete_gp_variant(struct st_context *st, struct st_gp_variant *gpv)
 141 {
 142    if (gpv->driver_shader)
 143       cso_delete_geometry_shader(st->cso_context, gpv->driver_shader);
 144
 145    free(gpv);
 146 }
 147
 148
 149 /**
 150  * Free all variants of a geometry program.
 151  */
 152 void
 153 st_release_gp_variants(struct st_context *st, struct st_geometry_program *stgp)
 154 {
 155    struct st_gp_variant *gpv;
 156
 157    for (gpv = stgp->variants; gpv; ) {
 158       struct st_gp_variant *next = gpv->next;
 159       delete_gp_variant(st, gpv);
 160       gpv = next;
 161    }
 162
 163    stgp->variants = NULL;
 164 }
 165
 166
 167
 168
 169 /**
 170  * Translate a Mesa vertex shader into a TGSI shader.
 171  * \param outputMapping  to map vertex program output registers (VARYING_SLOT_x)
 172  *       to TGSI output slots
 173  * \param tokensOut  destination for TGSI tokens
 174  * \return  pointer to cached pipe_shader object.
 175  */
 176 void
 177 st_prepare_vertex_program(struct gl_context *ctx,
 178                             struct st_vertex_program *stvp)
 179 {
 180    struct st_context *st = st_context(ctx);
 181    GLuint attr;
 182
 183    stvp->num_inputs = 0;
 184    stvp->num_outputs = 0;
 185
 186    if (stvp->Base.IsPositionInvariant)
 187       _mesa_insert_mvp_code(ctx, &stvp->Base);
 188
 189    if (!stvp->glsl_to_tgsi)
 190       assert(stvp->Base.Base.NumInstructions > 1);
 191
 192    /*
 193     * Determine number of inputs, the mappings between VERT_ATTRIB_x
 194     * and TGSI generic input indexes, plus input attrib semantic info.
 195     */
 196    for (attr = 0; attr < VERT_ATTRIB_MAX; attr++) {
 197       if ((stvp->Base.Base.InputsRead & BITFIELD64_BIT(attr)) != 0) {
 198          stvp->input_to_index[attr] = stvp->num_inputs;
 199          stvp->index_to_input[stvp->num_inputs] = attr;
 200          stvp->num_inputs++;
 201       }
 202    }
 203    /* bit of a hack, presetup potentially unused edgeflag input */
 204    stvp->input_to_index[VERT_ATTRIB_EDGEFLAG] = stvp->num_inputs;
 205    stvp->index_to_input[stvp->num_inputs] = VERT_ATTRIB_EDGEFLAG;
 206
 207    /* Compute mapping of vertex program outputs to slots.
 208     */
 209    for (attr = 0; attr < VARYING_SLOT_MAX; attr++) {
 210       if ((stvp->Base.Base.OutputsWritten & BITFIELD64_BIT(attr)) == 0) {
 211          stvp->result_to_output[attr] = ~0;
 212       }
 213       else {
 214          unsigned slot = stvp->num_outputs++;
 215
 216          stvp->result_to_output[attr] = slot;
 217
 218          switch (attr) {
 219          case VARYING_SLOT_POS:
 220             stvp->output_semantic_name[slot] = TGSI_SEMANTIC_POSITION;
 221             stvp->output_semantic_index[slot] = 0;
 222             break;
 223          case VARYING_SLOT_COL0:
 224             stvp->output_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
 225             stvp->output_semantic_index[slot] = 0;
 226             break;
 227          case VARYING_SLOT_COL1:
 228             stvp->output_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
 229             stvp->output_semantic_index[slot] = 1;
 230             break;
 231          case VARYING_SLOT_BFC0:
 232             stvp->output_semantic_name[slot] = TGSI_SEMANTIC_BCOLOR;
 233             stvp->output_semantic_index[slot] = 0;
 234             break;
 235          case VARYING_SLOT_BFC1:
 236             stvp->output_semantic_name[slot] = TGSI_SEMANTIC_BCOLOR;
 237             stvp->output_semantic_index[slot] = 1;
 238             break;
 239          case VARYING_SLOT_FOGC:
 240             stvp->output_semantic_name[slot] = TGSI_SEMANTIC_FOG;
 241             stvp->output_semantic_index[slot] = 0;
 242             break;
 243          case VARYING_SLOT_PSIZ:
 244             stvp->output_semantic_name[slot] = TGSI_SEMANTIC_PSIZE;
 245             stvp->output_semantic_index[slot] = 0;
 246             break;
 247          case VARYING_SLOT_CLIP_DIST0:
 248             stvp->output_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
 249             stvp->output_semantic_index[slot] = 0;
 250             break;
 251          case VARYING_SLOT_CLIP_DIST1:
 252             stvp->output_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
 253             stvp->output_semantic_index[slot] = 1;
 254             break;
 255          case VARYING_SLOT_EDGE:
 256             assert(0);
 257             break;
 258          case VARYING_SLOT_CLIP_VERTEX:
 259             stvp->output_semantic_name[slot] = TGSI_SEMANTIC_CLIPVERTEX;
 260             stvp->output_semantic_index[slot] = 0;
 261             break;
 262
 263          case VARYING_SLOT_TEX0:
 264          case VARYING_SLOT_TEX1:
 265          case VARYING_SLOT_TEX2:
 266          case VARYING_SLOT_TEX3:
 267          case VARYING_SLOT_TEX4:
 268          case VARYING_SLOT_TEX5:
 269          case VARYING_SLOT_TEX6:
 270          case VARYING_SLOT_TEX7:
 271             stvp->output_semantic_name[slot] = st->needs_texcoord_semantic ?
 272                TGSI_SEMANTIC_TEXCOORD : TGSI_SEMANTIC_GENERIC;
 273             stvp->output_semantic_index[slot] = attr - VARYING_SLOT_TEX0;
 274             break;
 275
 276          case VARYING_SLOT_VAR0:
 277          default:
 278             assert(attr < VARYING_SLOT_MAX);
 279             stvp->output_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
 280             stvp->output_semantic_index[slot] = st->needs_texcoord_semantic ?
 281                (attr - VARYING_SLOT_VAR0) : (attr - VARYING_SLOT_TEX0);
 282             break;
 283          }
 284       }
 285    }
 286    /* similar hack to above, presetup potentially unused edgeflag output */
 287    stvp->result_to_output[VARYING_SLOT_EDGE] = stvp->num_outputs;
 288    stvp->output_semantic_name[stvp->num_outputs] = TGSI_SEMANTIC_EDGEFLAG;
 289    stvp->output_semantic_index[stvp->num_outputs] = 0;
 290 }
 291
 292
 293 /**
 294  * Translate a vertex program to create a new variant.
 295  */
 296 static struct st_vp_variant *
 297 st_translate_vertex_program(struct st_context *st,
 298                             struct st_vertex_program *stvp,
 299                             const struct st_vp_variant_key *key)
 300 {
 301    struct st_vp_variant *vpv = CALLOC_STRUCT(st_vp_variant);
 302    struct pipe_context *pipe = st->pipe;
 303    struct ureg_program *ureg;
 304    enum pipe_error error;
 305    unsigned num_outputs;
 306
 307    st_prepare_vertex_program(st->ctx, stvp);
 308
 309    if (!stvp->glsl_to_tgsi)
 310    {
 311       _mesa_remove_output_reads(&stvp->Base.Base, PROGRAM_OUTPUT);
 312    }
 313
 314    ureg = ureg_create( TGSI_PROCESSOR_VERTEX );
 315    if (ureg == NULL) {
 316       free(vpv);
 317       return NULL;
 318    }
 319
 320    vpv->key = *key;
 321
 322    vpv->num_inputs = stvp->num_inputs;
 323    num_outputs = stvp->num_outputs;
 324    if (key->passthrough_edgeflags) {
 325       vpv->num_inputs++;
 326       num_outputs++;
 327    }
 328
 329    if (ST_DEBUG & DEBUG_MESA) {
 330       _mesa_print_program(&stvp->Base.Base);
 331       _mesa_print_program_parameters(st->ctx, &stvp->Base.Base);
 332       debug_printf("\n");
 333    }
 334
 335    if (stvp->glsl_to_tgsi)
 336       error = st_translate_program(st->ctx,
 337                                    TGSI_PROCESSOR_VERTEX,
 338                                    ureg,
 339                                    stvp->glsl_to_tgsi,
 340                                    &stvp->Base.Base,
 341                                    /* inputs */
 342                                    stvp->num_inputs,
 343                                    stvp->input_to_index,
 344                                    NULL, /* input semantic name */
 345                                    NULL, /* input semantic index */
 346                                    NULL, /* interp mode */
 347                                    NULL, /* is centroid */
 348                                    /* outputs */
 349                                    stvp->num_outputs,
 350                                    stvp->result_to_output,
 351                                    stvp->output_semantic_name,
 352                                    stvp->output_semantic_index,
 353                                    key->passthrough_edgeflags,
 354                                    key->clamp_color);
 355    else
 356       error = st_translate_mesa_program(st->ctx,
 357                                         TGSI_PROCESSOR_VERTEX,
 358                                         ureg,
 359                                         &stvp->Base.Base,
 360                                         /* inputs */
 361                                         vpv->num_inputs,
 362                                         stvp->input_to_index,
 363                                         NULL, /* input semantic name */
 364                                         NULL, /* input semantic index */
 365                                         NULL,
 366                                         /* outputs */
 367                                         num_outputs,
 368                                         stvp->result_to_output,
 369                                         stvp->output_semantic_name,
 370                                         stvp->output_semantic_index,
 371                                         key->passthrough_edgeflags,
 372                                         key->clamp_color);
 373
 374    if (error)
 375       goto fail;
 376
 377    vpv->tgsi.tokens = ureg_get_tokens( ureg, NULL );
 378    if (!vpv->tgsi.tokens)
 379       goto fail;
 380
 381    ureg_destroy( ureg );
 382
 383    if (stvp->glsl_to_tgsi) {
 384       st_translate_stream_output_info(stvp->glsl_to_tgsi,
 385                                       stvp->result_to_output,
 386                                       &vpv->tgsi.stream_output);
 387    }
 388
 389    vpv->driver_shader = pipe->create_vs_state(pipe, &vpv->tgsi);
 390
 391    if (ST_DEBUG & DEBUG_TGSI) {
 392       tgsi_dump( vpv->tgsi.tokens, 0 );
 393       debug_printf("\n");
 394    }
 395
 396    return vpv;
 397
 398 fail:
 399    debug_printf("%s: failed to translate Mesa program:\n", __FUNCTION__);
 400    _mesa_print_program(&stvp->Base.Base);
 401    debug_assert(0);
 402
 403    ureg_destroy( ureg );
 404    return NULL;
 405 }
 406
 407
 408 /**
 409  * Find/create a vertex program variant.
 410  */
 411 struct st_vp_variant *
 412 st_get_vp_variant(struct st_context *st,
 413                   struct st_vertex_program *stvp,
 414                   const struct st_vp_variant_key *key)
 415 {
 416    struct st_vp_variant *vpv;
 417
 418    /* Search for existing variant */
 419    for (vpv = stvp->variants; vpv; vpv = vpv->next) {
 420       if (memcmp(&vpv->key, key, sizeof(*key)) == 0) {
 421          break;
 422       }
 423    }
 424
 425    if (!vpv) {
 426       /* create now */
 427       vpv = st_translate_vertex_program(st, stvp, key);
 428       if (vpv) {
 429          /* insert into list */
 430          vpv->next = stvp->variants;
 431          stvp->variants = vpv;
 432       }
 433    }
 434
 435    return vpv;
 436 }
 437
 438
 439 static unsigned
 440 st_translate_interp(enum glsl_interp_qualifier glsl_qual, bool is_color)
 441 {
 442    switch (glsl_qual) {
 443    case INTERP_QUALIFIER_NONE:
 444       if (is_color)
 445          return TGSI_INTERPOLATE_COLOR;
 446       return TGSI_INTERPOLATE_PERSPECTIVE;
 447    case INTERP_QUALIFIER_SMOOTH:
 448       return TGSI_INTERPOLATE_PERSPECTIVE;
 449    case INTERP_QUALIFIER_FLAT:
 450       return TGSI_INTERPOLATE_CONSTANT;
 451    case INTERP_QUALIFIER_NOPERSPECTIVE:
 452       return TGSI_INTERPOLATE_LINEAR;
 453    default:
 454       assert(0 && "unexpected interp mode in st_translate_interp()");
 455       return TGSI_INTERPOLATE_PERSPECTIVE;
 456    }
 457 }
 458
 459
 460 /**
 461  * Translate a Mesa fragment shader into a TGSI shader using extra info in
 462  * the key.
 463  * \return  new fragment program variant
 464  */
 465 static struct st_fp_variant *
 466 st_translate_fragment_program(struct st_context *st,
 467                               struct st_fragment_program *stfp,
 468                               const struct st_fp_variant_key *key)
 469 {
 470    struct pipe_context *pipe = st->pipe;
 471    struct st_fp_variant *variant = CALLOC_STRUCT(st_fp_variant);
 472    GLboolean deleteFP = GL_FALSE;
 473
 474    GLuint outputMapping[FRAG_RESULT_MAX];
 475    GLuint inputMapping[VARYING_SLOT_MAX];
 476    GLuint interpMode[PIPE_MAX_SHADER_INPUTS];  /* XXX size? */
 477    GLuint attr;
 478    GLbitfield64 inputsRead;
 479    struct ureg_program *ureg;
 480
 481    GLboolean write_all = GL_FALSE;
 482
 483    ubyte input_semantic_name[PIPE_MAX_SHADER_INPUTS];
 484    ubyte input_semantic_index[PIPE_MAX_SHADER_INPUTS];
 485    GLboolean is_centroid[PIPE_MAX_SHADER_INPUTS];
 486    uint fs_num_inputs = 0;
 487
 488    ubyte fs_output_semantic_name[PIPE_MAX_SHADER_OUTPUTS];
 489    ubyte fs_output_semantic_index[PIPE_MAX_SHADER_OUTPUTS];
 490    uint fs_num_outputs = 0;
 491
 492    if (!variant)
 493       return NULL;
 494
 495    assert(!(key->bitmap && key->drawpixels));
 496
 497    if (key->bitmap) {
 498       /* glBitmap drawing */
 499       struct gl_fragment_program *fp; /* we free this temp program below */
 500
 501       st_make_bitmap_fragment_program(st, &stfp->Base,
 502                                       &fp, &variant->bitmap_sampler);
 503
 504       variant->parameters = _mesa_clone_parameter_list(fp->Base.Parameters);
 505       stfp = st_fragment_program(fp);
 506       deleteFP = GL_TRUE;
 507    }
 508    else if (key->drawpixels) {
 509       /* glDrawPixels drawing */
 510       struct gl_fragment_program *fp; /* we free this temp program below */
 511
 512       if (key->drawpixels_z || key->drawpixels_stencil) {
 513          fp = st_make_drawpix_z_stencil_program(st, key->drawpixels_z,
 514                                                 key->drawpixels_stencil);
 515       }
 516       else {
 517          /* RGBA */
 518          st_make_drawpix_fragment_program(st, &stfp->Base, &fp);
 519          variant->parameters = _mesa_clone_parameter_list(fp->Base.Parameters);
 520          deleteFP = GL_TRUE;
 521       }
 522       stfp = st_fragment_program(fp);
 523    }
 524
 525    if (!stfp->glsl_to_tgsi)
 526       _mesa_remove_output_reads(&stfp->Base.Base, PROGRAM_OUTPUT);
 527
 528    /*
 529     * Convert Mesa program inputs to TGSI input register semantics.
 530     */
 531    inputsRead = stfp->Base.Base.InputsRead;
 532    for (attr = 0; attr < VARYING_SLOT_MAX; attr++) {
 533       if ((inputsRead & BITFIELD64_BIT(attr)) != 0) {
 534          const GLuint slot = fs_num_inputs++;
 535
 536          inputMapping[attr] = slot;
 537          is_centroid[slot] = (stfp->Base.IsCentroid & BITFIELD64_BIT(attr)) != 0;
 538
 539          switch (attr) {
 540          case VARYING_SLOT_POS:
 541             input_semantic_name[slot] = TGSI_SEMANTIC_POSITION;
 542             input_semantic_index[slot] = 0;
 543             interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
 544             break;
 545          case VARYING_SLOT_COL0:
 546             input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
 547             input_semantic_index[slot] = 0;
 548             interpMode[slot] = st_translate_interp(stfp->Base.InterpQualifier[attr],
 549                                                    TRUE);
 550             break;
 551          case VARYING_SLOT_COL1:
 552             input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
 553             input_semantic_index[slot] = 1;
 554             interpMode[slot] = st_translate_interp(stfp->Base.InterpQualifier[attr],
 555                                                    TRUE);
 556             break;
 557          case VARYING_SLOT_FOGC:
 558             input_semantic_name[slot] = TGSI_SEMANTIC_FOG;
 559             input_semantic_index[slot] = 0;
 560             interpMode[slot] = TGSI_INTERPOLATE_PERSPECTIVE;
 561             break;
 562          case VARYING_SLOT_FACE:
 563             input_semantic_name[slot] = TGSI_SEMANTIC_FACE;
 564             input_semantic_index[slot] = 0;
 565             interpMode[slot] = TGSI_INTERPOLATE_CONSTANT;
 566             break;
 567          case VARYING_SLOT_CLIP_DIST0:
 568             input_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
 569             input_semantic_index[slot] = 0;
 570             interpMode[slot] = TGSI_INTERPOLATE_PERSPECTIVE;
 571             break;
 572          case VARYING_SLOT_CLIP_DIST1:
 573             input_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
 574             input_semantic_index[slot] = 1;
 575             interpMode[slot] = TGSI_INTERPOLATE_PERSPECTIVE;
 576             break;
 577             /* In most cases, there is nothing special about these
 578              * inputs, so adopt a convention to use the generic
 579              * semantic name and the mesa VARYING_SLOT_ number as the
 580              * index.
 581              *
 582              * All that is required is that the vertex shader labels
 583              * its own outputs similarly, and that the vertex shader
 584              * generates at least every output required by the
 585              * fragment shader plus fixed-function hardware (such as
 586              * BFC).
 587              *
 588              * However, some drivers may need us to identify the PNTC and TEXi
 589              * varyings if, for example, their capability to replace them with
 590              * sprite coordinates is limited.
 591              */
 592          case VARYING_SLOT_PNTC:
 593             if (st->needs_texcoord_semantic) {
 594                input_semantic_name[slot] = TGSI_SEMANTIC_PCOORD;
 595                input_semantic_index[slot] = 0;
 596                interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
 597                break;
 598             }
 599             /* fall through */
 600          case VARYING_SLOT_TEX0:
 601          case VARYING_SLOT_TEX1:
 602          case VARYING_SLOT_TEX2:
 603          case VARYING_SLOT_TEX3:
 604          case VARYING_SLOT_TEX4:
 605          case VARYING_SLOT_TEX5:
 606          case VARYING_SLOT_TEX6:
 607          case VARYING_SLOT_TEX7:
 608             if (st->needs_texcoord_semantic) {
 609                input_semantic_name[slot] = TGSI_SEMANTIC_TEXCOORD;
 610                input_semantic_index[slot] = attr - VARYING_SLOT_TEX0;
 611                interpMode[slot] =
 612                   st_translate_interp(stfp->Base.InterpQualifier[attr], FALSE);
 613                break;
 614             }
 615             /* fall through */
 616          case VARYING_SLOT_VAR0:
 617          default:
 618             /* Semantic indices should be zero-based because drivers may choose
 619              * to assign a fixed slot determined by that index.
 620              * This is useful because ARB_separate_shader_objects uses location
 621              * qualifiers for linkage, and if the semantic index corresponds to
 622              * these locations, linkage passes in the driver become unecessary.
 623              *
 624              * If needs_texcoord_semantic is true, no semantic indices will be
 625              * consumed for the TEXi varyings, and we can base the locations of
 626              * the user varyings on VAR0.  Otherwise, we use TEX0 as base index.
 627              */
 628             assert(attr >= VARYING_SLOT_TEX0);
 629             input_semantic_index[slot] = st->needs_texcoord_semantic ?
 630                (attr - VARYING_SLOT_VAR0) : (attr - VARYING_SLOT_TEX0);
 631             input_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
 632             if (attr == VARYING_SLOT_PNTC)
 633                interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
 634             else
 635                interpMode[slot] = st_translate_interp(stfp->Base.InterpQualifier[attr],
 636                                                       FALSE);
 637             break;
 638          }
 639       }
 640       else {
 641          inputMapping[attr] = -1;
 642       }
 643    }
 644
 645    /*
 646     * Semantics and mapping for outputs
 647     */
 648    {
 649       uint numColors = 0;
 650       GLbitfield64 outputsWritten = stfp->Base.Base.OutputsWritten;
 651
 652       /* if z is written, emit that first */
 653       if (outputsWritten & BITFIELD64_BIT(FRAG_RESULT_DEPTH)) {
 654          fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_POSITION;
 655          fs_output_semantic_index[fs_num_outputs] = 0;
 656          outputMapping[FRAG_RESULT_DEPTH] = fs_num_outputs;
 657          fs_num_outputs++;
 658          outputsWritten &= ~(1 << FRAG_RESULT_DEPTH);
 659       }
 660
 661       if (outputsWritten & BITFIELD64_BIT(FRAG_RESULT_STENCIL)) {
 662          fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_STENCIL;
 663          fs_output_semantic_index[fs_num_outputs] = 0;
 664          outputMapping[FRAG_RESULT_STENCIL] = fs_num_outputs;
 665          fs_num_outputs++;
 666          outputsWritten &= ~(1 << FRAG_RESULT_STENCIL);
 667       }
 668
 669       /* handle remaining outputs (color) */
 670       for (attr = 0; attr < FRAG_RESULT_MAX; attr++) {
 671          if (outputsWritten & BITFIELD64_BIT(attr)) {
 672             switch (attr) {
 673             case FRAG_RESULT_DEPTH:
 674             case FRAG_RESULT_STENCIL:
 675                /* handled above */
 676                assert(0);
 677                break;
 678             case FRAG_RESULT_COLOR:
 679                write_all = GL_TRUE; /* fallthrough */
 680             default:
 681                assert(attr == FRAG_RESULT_COLOR ||
 682                       (FRAG_RESULT_DATA0 <= attr && attr < FRAG_RESULT_MAX));
 683                fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_COLOR;
 684                fs_output_semantic_index[fs_num_outputs] = numColors;
 685                outputMapping[attr] = fs_num_outputs;
 686                numColors++;
 687                break;
 688             }
 689
 690             fs_num_outputs++;
 691          }
 692       }
 693    }
 694
 695    ureg = ureg_create( TGSI_PROCESSOR_FRAGMENT );
 696    if (ureg == NULL) {
 697       free(variant);
 698       return NULL;
 699    }
 700
 701    if (ST_DEBUG & DEBUG_MESA) {
 702       _mesa_print_program(&stfp->Base.Base);
 703       _mesa_print_program_parameters(st->ctx, &stfp->Base.Base);
 704       debug_printf("\n");
 705    }
 706    if (write_all == GL_TRUE)
 707       ureg_property_fs_color0_writes_all_cbufs(ureg, 1);
 708
 709    if (stfp->Base.FragDepthLayout != FRAG_DEPTH_LAYOUT_NONE) {
 710       switch (stfp->Base.FragDepthLayout) {
 711       case FRAG_DEPTH_LAYOUT_ANY:
 712          ureg_property_fs_depth_layout(ureg, TGSI_FS_DEPTH_LAYOUT_ANY);
 713          break;
 714       case FRAG_DEPTH_LAYOUT_GREATER:
 715          ureg_property_fs_depth_layout(ureg, TGSI_FS_DEPTH_LAYOUT_GREATER);
 716          break;
 717       case FRAG_DEPTH_LAYOUT_LESS:
 718          ureg_property_fs_depth_layout(ureg, TGSI_FS_DEPTH_LAYOUT_LESS);
 719          break;
 720       case FRAG_DEPTH_LAYOUT_UNCHANGED:
 721          ureg_property_fs_depth_layout(ureg, TGSI_FS_DEPTH_LAYOUT_UNCHANGED);
 722          break;
 723       default:
 724          assert(0);
 725       }
 726    }
 727
 728    if (stfp->glsl_to_tgsi)
 729       st_translate_program(st->ctx,
 730                            TGSI_PROCESSOR_FRAGMENT,
 731                            ureg,
 732                            stfp->glsl_to_tgsi,
 733                            &stfp->Base.Base,
 734                            /* inputs */
 735                            fs_num_inputs,
 736                            inputMapping,
 737                            input_semantic_name,
 738                            input_semantic_index,
 739                            interpMode,
 740                            is_centroid,
 741                            /* outputs */
 742                            fs_num_outputs,
 743                            outputMapping,
 744                            fs_output_semantic_name,
 745                            fs_output_semantic_index, FALSE,
 746                            key->clamp_color );
 747    else
 748       st_translate_mesa_program(st->ctx,
 749                                 TGSI_PROCESSOR_FRAGMENT,
 750                                 ureg,
 751                                 &stfp->Base.Base,
 752                                 /* inputs */
 753                                 fs_num_inputs,
 754                                 inputMapping,
 755                                 input_semantic_name,
 756                                 input_semantic_index,
 757                                 interpMode,
 758                                 /* outputs */
 759                                 fs_num_outputs,
 760                                 outputMapping,
 761                                 fs_output_semantic_name,
 762                                 fs_output_semantic_index, FALSE,
 763                                 key->clamp_color);
 764
 765    variant->tgsi.tokens = ureg_get_tokens( ureg, NULL );
 766    ureg_destroy( ureg );
 767
 768    /* fill in variant */
 769    variant->driver_shader = pipe->create_fs_state(pipe, &variant->tgsi);
 770    variant->key = *key;
 771
 772    if (ST_DEBUG & DEBUG_TGSI) {
 773       tgsi_dump( variant->tgsi.tokens, 0/*TGSI_DUMP_VERBOSE*/ );
 774       debug_printf("\n");
 775    }
 776
 777    if (deleteFP) {
 778       /* Free the temporary program made above */
 779       struct gl_fragment_program *fp = &stfp->Base;
 780       _mesa_reference_fragprog(st->ctx, &fp, NULL);
 781    }
 782
 783    return variant;
 784 }
 785
 786
 787 /**
 788  * Translate fragment program if needed.
 789  */
 790 struct st_fp_variant *
 791 st_get_fp_variant(struct st_context *st,
 792                   struct st_fragment_program *stfp,
 793                   const struct st_fp_variant_key *key)
 794 {
 795    struct st_fp_variant *fpv;
 796
 797    /* Search for existing variant */
 798    for (fpv = stfp->variants; fpv; fpv = fpv->next) {
 799       if (memcmp(&fpv->key, key, sizeof(*key)) == 0) {
 800          break;
 801       }
 802    }
 803
 804    if (!fpv) {
 805       /* create new */
 806       fpv = st_translate_fragment_program(st, stfp, key);
 807       if (fpv) {
 808          /* insert into list */
 809          fpv->next = stfp->variants;
 810          stfp->variants = fpv;
 811       }
 812    }
 813
 814    return fpv;
 815 }
 816
 817
 818 /**
 819  * Translate a geometry program to create a new variant.
 820  */
 821 static struct st_gp_variant *
 822 st_translate_geometry_program(struct st_context *st,
 823                               struct st_geometry_program *stgp,
 824                               const struct st_gp_variant_key *key)
 825 {
 826    GLuint inputMapping[VARYING_SLOT_MAX];
 827    GLuint outputMapping[VARYING_SLOT_MAX];
 828    struct pipe_context *pipe = st->pipe;
 829    GLuint attr;
 830    GLbitfield64 inputsRead;
 831    GLuint vslot = 0;
 832    GLuint num_generic = 0;
 833
 834    uint gs_num_inputs = 0;
 835    uint gs_builtin_inputs = 0;
 836    uint gs_array_offset = 0;
 837
 838    ubyte gs_output_semantic_name[PIPE_MAX_SHADER_OUTPUTS];
 839    ubyte gs_output_semantic_index[PIPE_MAX_SHADER_OUTPUTS];
 840    uint gs_num_outputs = 0;
 841
 842    GLint i;
 843    GLuint maxSlot = 0;
 844    struct ureg_program *ureg;
 845
 846    struct st_gp_variant *gpv;
 847
 848    gpv = CALLOC_STRUCT(st_gp_variant);
 849    if (!gpv)
 850       return NULL;
 851
 852    _mesa_remove_output_reads(&stgp->Base.Base, PROGRAM_OUTPUT);
 853
 854    ureg = ureg_create( TGSI_PROCESSOR_GEOMETRY );
 855    if (ureg == NULL) {
 856       free(gpv);
 857       return NULL;
 858    }
 859
 860    /* which vertex output goes to the first geometry input */
 861    vslot = 0;
 862
 863    memset(inputMapping, 0, sizeof(inputMapping));
 864    memset(outputMapping, 0, sizeof(outputMapping));
 865
 866    /*
 867     * Convert Mesa program inputs to TGSI input register semantics.
 868     */
 869    inputsRead = stgp->Base.Base.InputsRead;
 870    for (attr = 0; attr < VARYING_SLOT_MAX; attr++) {
 871       if ((inputsRead & BITFIELD64_BIT(attr)) != 0) {
 872          const GLuint slot = gs_num_inputs;
 873
 874          gs_num_inputs++;
 875
 876          inputMapping[attr] = slot;
 877
 878          stgp->input_map[slot + gs_array_offset] = vslot - gs_builtin_inputs;
 879          stgp->input_to_index[attr] = vslot;
 880          stgp->index_to_input[vslot] = attr;
 881          ++vslot;
 882
 883          if (attr != VARYING_SLOT_PRIMITIVE_ID) {
 884             gs_array_offset += 2;
 885          } else
 886             ++gs_builtin_inputs;
 887
 888 #if 0
 889          debug_printf("input map at %d = %d\n",
 890                       slot + gs_array_offset, stgp->input_map[slot + gs_array_offset]);
 891 #endif
 892
 893          switch (attr) {
 894          case VARYING_SLOT_PRIMITIVE_ID:
 895             stgp->input_semantic_name[slot] = TGSI_SEMANTIC_PRIMID;
 896             stgp->input_semantic_index[slot] = 0;
 897             break;
 898          case VARYING_SLOT_POS:
 899             stgp->input_semantic_name[slot] = TGSI_SEMANTIC_POSITION;
 900             stgp->input_semantic_index[slot] = 0;
 901             break;
 902          case VARYING_SLOT_COL0:
 903             stgp->input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
 904             stgp->input_semantic_index[slot] = 0;
 905             break;
 906          case VARYING_SLOT_COL1:
 907             stgp->input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
 908             stgp->input_semantic_index[slot] = 1;
 909             break;
 910          case VARYING_SLOT_FOGC:
 911             stgp->input_semantic_name[slot] = TGSI_SEMANTIC_FOG;
 912             stgp->input_semantic_index[slot] = 0;
 913             break;
 914          case VARYING_SLOT_TEX0:
 915             stgp->input_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
 916             stgp->input_semantic_index[slot] = num_generic++;
 917             break;
 918          case VARYING_SLOT_VAR0:
 919             /* fall-through */
 920          default:
 921             stgp->input_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
 922             stgp->input_semantic_index[slot] = num_generic++;
 923          }
 924       }
 925    }
 926
 927    /* initialize output semantics to defaults */
 928    for (i = 0; i < PIPE_MAX_SHADER_OUTPUTS; i++) {
 929       gs_output_semantic_name[i] = TGSI_SEMANTIC_GENERIC;
 930       gs_output_semantic_index[i] = 0;
 931    }
 932
 933    num_generic = 0;
 934    /*
 935     * Determine number of outputs, the (default) output register
 936     * mapping and the semantic information for each output.
 937     */
 938    for (attr = 0; attr < VARYING_SLOT_MAX; attr++) {
 939       if (stgp->Base.Base.OutputsWritten & BITFIELD64_BIT(attr)) {
 940          GLuint slot;
 941
 942          slot = gs_num_outputs;
 943          gs_num_outputs++;
 944          outputMapping[attr] = slot;
 945
 946          switch (attr) {
 947          case VARYING_SLOT_POS:
 948             assert(slot == 0);
 949             gs_output_semantic_name[slot] = TGSI_SEMANTIC_POSITION;
 950             gs_output_semantic_index[slot] = 0;
 951             break;
 952          case VARYING_SLOT_COL0:
 953             gs_output_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
 954             gs_output_semantic_index[slot] = 0;
 955             break;
 956          case VARYING_SLOT_COL1:
 957             gs_output_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
 958             gs_output_semantic_index[slot] = 1;
 959             break;
 960          case VARYING_SLOT_BFC0:
 961             gs_output_semantic_name[slot] = TGSI_SEMANTIC_BCOLOR;
 962             gs_output_semantic_index[slot] = 0;
 963             break;
 964          case VARYING_SLOT_BFC1:
 965             gs_output_semantic_name[slot] = TGSI_SEMANTIC_BCOLOR;
 966             gs_output_semantic_index[slot] = 1;
 967             break;
 968          case VARYING_SLOT_FOGC:
 969             gs_output_semantic_name[slot] = TGSI_SEMANTIC_FOG;
 970             gs_output_semantic_index[slot] = 0;
 971             break;
 972          case VARYING_SLOT_PSIZ:
 973             gs_output_semantic_name[slot] = TGSI_SEMANTIC_PSIZE;
 974             gs_output_semantic_index[slot] = 0;
 975             break;
 976          case VARYING_SLOT_TEX0:
 977          case VARYING_SLOT_TEX1:
 978          case VARYING_SLOT_TEX2:
 979          case VARYING_SLOT_TEX3:
 980          case VARYING_SLOT_TEX4:
 981          case VARYING_SLOT_TEX5:
 982          case VARYING_SLOT_TEX6:
 983          case VARYING_SLOT_TEX7:
 984             /* fall-through */
 985          case VARYING_SLOT_VAR0:
 986             /* fall-through */
 987          default:
 988             assert(slot < Elements(gs_output_semantic_name));
 989             /* use default semantic info */
 990             gs_output_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
 991             gs_output_semantic_index[slot] = num_generic++;
 992          }
 993       }
 994    }
 995
 996    assert(gs_output_semantic_name[0] == TGSI_SEMANTIC_POSITION);
 997
 998    /* find max output slot referenced to compute gs_num_outputs */
 999    for (attr = 0; attr < VARYING_SLOT_MAX; attr++) {
1000       if (outputMapping[attr] != ~0 && outputMapping[attr] > maxSlot)
1001          maxSlot = outputMapping[attr];
1002    }
1003    gs_num_outputs = maxSlot + 1;
1004
1005 #if 0 /* debug */
1006    {
1007       GLuint i;
1008       printf("outputMapping? %d\n", outputMapping ? 1 : 0);
1009       if (outputMapping) {
1010          printf("attr -> slot\n");
1011          for (i = 0; i < 16;  i++) {
1012             printf(" %2d       %3d\n", i, outputMapping[i]);
1013          }
1014       }
1015       printf("slot    sem_name  sem_index\n");
1016       for (i = 0; i < gs_num_outputs; i++) {
1017          printf(" %2d         %d         %d\n",
1018                 i,
1019                 gs_output_semantic_name[i],
1020                 gs_output_semantic_index[i]);
1021       }
1022    }
1023 #endif
1024
1025    /* free old shader state, if any */
1026    if (stgp->tgsi.tokens) {
1027       st_free_tokens(stgp->tgsi.tokens);
1028       stgp->tgsi.tokens = NULL;
1029    }
1030
1031    ureg_property_gs_input_prim(ureg, stgp->Base.InputType);
1032    ureg_property_gs_output_prim(ureg, stgp->Base.OutputType);
1033    ureg_property_gs_max_vertices(ureg, stgp->Base.VerticesOut);
1034
1035    st_translate_mesa_program(st->ctx,
1036                              TGSI_PROCESSOR_GEOMETRY,
1037                              ureg,
1038                              &stgp->Base.Base,
1039                              /* inputs */
1040                              gs_num_inputs,
1041                              inputMapping,
1042                              stgp->input_semantic_name,
1043                              stgp->input_semantic_index,
1044                              NULL,
1045                              /* outputs */
1046                              gs_num_outputs,
1047                              outputMapping,
1048                              gs_output_semantic_name,
1049                              gs_output_semantic_index,
1050                              FALSE,
1051                              FALSE);
1052
1053    stgp->num_inputs = gs_num_inputs;
1054    stgp->tgsi.tokens = ureg_get_tokens( ureg, NULL );
1055    ureg_destroy( ureg );
1056
1057    if (stgp->glsl_to_tgsi) {
1058       st_translate_stream_output_info(stgp->glsl_to_tgsi,
1059                                       outputMapping,
1060                                       &stgp->tgsi.stream_output);
1061    }
1062
1063    /* fill in new variant */
1064    gpv->driver_shader = pipe->create_gs_state(pipe, &stgp->tgsi);
1065    gpv->key = *key;
1066
1067    if ((ST_DEBUG & DEBUG_TGSI) && (ST_DEBUG & DEBUG_MESA)) {
1068       _mesa_print_program(&stgp->Base.Base);
1069       debug_printf("\n");
1070    }
1071
1072    if (ST_DEBUG & DEBUG_TGSI) {
1073       tgsi_dump(stgp->tgsi.tokens, 0);
1074       debug_printf("\n");
1075    }
1076
1077    return gpv;
1078 }
1079
1080
1081 /**
1082  * Get/create geometry program variant.
1083  */
1084 struct st_gp_variant *
1085 st_get_gp_variant(struct st_context *st,
1086                   struct st_geometry_program *stgp,
1087                   const struct st_gp_variant_key *key)
1088 {
1089    struct st_gp_variant *gpv;
1090
1091    /* Search for existing variant */
1092    for (gpv = stgp->variants; gpv; gpv = gpv->next) {
1093       if (memcmp(&gpv->key, key, sizeof(*key)) == 0) {
1094          break;
1095       }
1096    }
1097
1098    if (!gpv) {
1099       /* create new */
1100       gpv = st_translate_geometry_program(st, stgp, key);
1101       if (gpv) {
1102          /* insert into list */
1103          gpv->next = stgp->variants;
1104          stgp->variants = gpv;
1105       }
1106    }
1107
1108    return gpv;
1109 }
1110
1111
1112
1113
1114 /**
1115  * Debug- print current shader text
1116  */
1117 void
1118 st_print_shaders(struct gl_context *ctx)
1119 {
1120    struct gl_shader_program *shProg[3] = {
1121       ctx->Shader.CurrentVertexProgram,
1122       ctx->Shader.CurrentGeometryProgram,
1123       ctx->Shader.CurrentFragmentProgram,
1124    };
1125    unsigned j;
1126
1127    for (j = 0; j < 3; j++) {
1128       unsigned i;
1129
1130       if (shProg[j] == NULL)
1131          continue;
1132
1133       for (i = 0; i < shProg[j]->NumShaders; i++) {
1134          struct gl_shader *sh;
1135
1136          switch (shProg[j]->Shaders[i]->Type) {
1137          case GL_VERTEX_SHADER:
1138             sh = (i != 0) ? NULL : shProg[j]->Shaders[i];
1139             break;
1140          case GL_GEOMETRY_SHADER_ARB:
1141             sh = (i != 1) ? NULL : shProg[j]->Shaders[i];
1142             break;
1143          case GL_FRAGMENT_SHADER:
1144             sh = (i != 2) ? NULL : shProg[j]->Shaders[i];
1145             break;
1146          default:
1147             assert(0);
1148             sh = NULL;
1149             break;
1150          }
1151
1152          if (sh != NULL) {
1153             printf("GLSL shader %u of %u:\n", i, shProg[j]->NumShaders);
1154             printf("%s\n", sh->Source);
1155          }
1156       }
1157    }
1158 }
1159
1160
1161 /**
1162  * Vert/Geom/Frag programs have per-context variants.  Free all the
1163  * variants attached to the given program which match the given context.
1164  */
1165 static void
1166 destroy_program_variants(struct st_context *st, struct gl_program *program)
1167 {
1168    if (!program || program == &_mesa_DummyProgram)
1169       return;
1170
1171    switch (program->Target) {
1172    case GL_VERTEX_PROGRAM_ARB:
1173       {
1174          struct st_vertex_program *stvp = (struct st_vertex_program *) program;
1175          struct st_vp_variant *vpv, **prevPtr = &stvp->variants;
1176
1177          for (vpv = stvp->variants; vpv; ) {
1178             struct st_vp_variant *next = vpv->next;
1179             if (vpv->key.st == st) {
1180                /* unlink from list */
1181                *prevPtr = next;
1182                /* destroy this variant */
1183                delete_vp_variant(st, vpv);
1184             }
1185             else {
1186                prevPtr = &vpv->next;
1187             }
1188             vpv = next;
1189          }
1190       }
1191       break;
1192    case GL_FRAGMENT_PROGRAM_ARB:
1193       {
1194          struct st_fragment_program *stfp =
1195             (struct st_fragment_program *) program;
1196          struct st_fp_variant *fpv, **prevPtr = &stfp->variants;
1197
1198          for (fpv = stfp->variants; fpv; ) {
1199             struct st_fp_variant *next = fpv->next;
1200             if (fpv->key.st == st) {
1201                /* unlink from list */
1202                *prevPtr = next;
1203                /* destroy this variant */
1204                delete_fp_variant(st, fpv);
1205             }
1206             else {
1207                prevPtr = &fpv->next;
1208             }
1209             fpv = next;
1210          }
1211       }
1212       break;
1213    case MESA_GEOMETRY_PROGRAM:
1214       {
1215          struct st_geometry_program *stgp =
1216             (struct st_geometry_program *) program;
1217          struct st_gp_variant *gpv, **prevPtr = &stgp->variants;
1218
1219          for (gpv = stgp->variants; gpv; ) {
1220             struct st_gp_variant *next = gpv->next;
1221             if (gpv->key.st == st) {
1222                /* unlink from list */
1223                *prevPtr = next;
1224                /* destroy this variant */
1225                delete_gp_variant(st, gpv);
1226             }
1227             else {
1228                prevPtr = &gpv->next;
1229             }
1230             gpv = next;
1231          }
1232       }
1233       break;
1234    default:
1235       _mesa_problem(NULL, "Unexpected program target 0x%x in "
1236                     "destroy_program_variants_cb()", program->Target);
1237    }
1238 }
1239
1240
1241 /**
1242  * Callback for _mesa_HashWalk.  Free all the shader's program variants
1243  * which match the given context.
1244  */
1245 static void
1246 destroy_shader_program_variants_cb(GLuint key, void *data, void *userData)
1247 {
1248    struct st_context *st = (struct st_context *) userData;
1249    struct gl_shader *shader = (struct gl_shader *) data;
1250
1251    switch (shader->Type) {
1252    case GL_SHADER_PROGRAM_MESA:
1253       {
1254          struct gl_shader_program *shProg = (struct gl_shader_program *) data;
1255          GLuint i;
1256
1257          for (i = 0; i < shProg->NumShaders; i++) {
1258             destroy_program_variants(st, shProg->Shaders[i]->Program);
1259          }
1260
1261          for (i = 0; i < Elements(shProg->_LinkedShaders); i++) {
1262             if (shProg->_LinkedShaders[i])
1263                destroy_program_variants(st, shProg->_LinkedShaders[i]->Program);
1264          }
1265       }
1266       break;
1267    case GL_VERTEX_SHADER:
1268    case GL_FRAGMENT_SHADER:
1269    case GL_GEOMETRY_SHADER:
1270       {
1271          destroy_program_variants(st, shader->Program);
1272       }
1273       break;
1274    default:
1275       assert(0);
1276    }
1277 }
1278
1279
1280 /**
1281  * Callback for _mesa_HashWalk.  Free all the program variants which match
1282  * the given context.
1283  */
1284 static void
1285 destroy_program_variants_cb(GLuint key, void *data, void *userData)
1286 {
1287    struct st_context *st = (struct st_context *) userData;
1288    struct gl_program *program = (struct gl_program *) data;
1289    destroy_program_variants(st, program);
1290 }
1291
1292
1293 /**
1294  * Walk over all shaders and programs to delete any variants which
1295  * belong to the given context.
1296  * This is called during context tear-down.
1297  */
1298 void
1299 st_destroy_program_variants(struct st_context *st)
1300 {
1301    /* ARB vert/frag program */
1302    _mesa_HashWalk(st->ctx->Shared->Programs,
1303                   destroy_program_variants_cb, st);
1304
1305    /* GLSL vert/frag/geom shaders */
1306    _mesa_HashWalk(st->ctx->Shared->ShaderObjects,
1307                   destroy_shader_program_variants_cb, st);
1308 }
1309
1310
1311 /**
1312  * For debugging, print/dump the current vertex program.
1313  */
1314 void
1315 st_print_current_vertex_program(void)
1316 {
1317    GET_CURRENT_CONTEXT(ctx);
1318
1319    if (ctx->VertexProgram._Current) {
1320       struct st_vertex_program *stvp =
1321          (struct st_vertex_program *) ctx->VertexProgram._Current;
1322       struct st_vp_variant *stv;
1323
1324       debug_printf("Vertex program %u\n", stvp->Base.Base.Id);
1325
1326       for (stv = stvp->variants; stv; stv = stv->next) {
1327          debug_printf("variant %p\n", stv);
1328          tgsi_dump(stv->tgsi.tokens, 0);
1329       }
1330    }
1331 }