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