src/mesa/state_tracker/st_program.c

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