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 "compiler/nir/nir.h"
  42
  43 #include "pipe/p_context.h"
  44 #include "pipe/p_defines.h"
  45 #include "pipe/p_shader_tokens.h"
  46 #include "draw/draw_context.h"
  47 #include "tgsi/tgsi_dump.h"
  48 #include "tgsi/tgsi_emulate.h"
  49 #include "tgsi/tgsi_parse.h"
  50 #include "tgsi/tgsi_ureg.h"
  51
  52 #include "st_debug.h"
  53 #include "st_cb_bitmap.h"
  54 #include "st_cb_drawpixels.h"
  55 #include "st_context.h"
  56 #include "st_tgsi_lower_yuv.h"
  57 #include "st_program.h"
  58 #include "st_mesa_to_tgsi.h"
  59 #include "st_atifs_to_tgsi.h"
  60 #include "st_nir.h"
  61 #include "cso_cache/cso_context.h"
  62
  63
  64
  65 /**
  66  * Delete a vertex program variant.  Note the caller must unlink
  67  * the variant from the linked list.
  68  */
  69 static void
  70 delete_vp_variant(struct st_context *st, struct st_vp_variant *vpv)
  71 {
  72    if (vpv->driver_shader)
  73       cso_delete_vertex_shader(st->cso_context, vpv->driver_shader);
  74
  75    if (vpv->draw_shader)
  76       draw_delete_vertex_shader( st->draw, vpv->draw_shader );
  77
  78    if (((vpv->tgsi.type == PIPE_SHADER_IR_TGSI)) && vpv->tgsi.tokens)
  79       ureg_free_tokens(vpv->tgsi.tokens);
  80
  81    free( vpv );
  82 }
  83
  84
  85
  86 /**
  87  * Clean out any old compilations:
  88  */
  89 void
  90 st_release_vp_variants( struct st_context *st,
  91                         struct st_vertex_program *stvp )
  92 {
  93    struct st_vp_variant *vpv;
  94
  95    for (vpv = stvp->variants; vpv; ) {
  96       struct st_vp_variant *next = vpv->next;
  97       delete_vp_variant(st, vpv);
  98       vpv = next;
  99    }
 100
 101    stvp->variants = NULL;
 102
 103    if ((stvp->tgsi.type == PIPE_SHADER_IR_TGSI) && stvp->tgsi.tokens) {
 104       tgsi_free_tokens(stvp->tgsi.tokens);
 105       stvp->tgsi.tokens = NULL;
 106    }
 107 }
 108
 109
 110
 111 /**
 112  * Delete a fragment program variant.  Note the caller must unlink
 113  * the variant from the linked list.
 114  */
 115 static void
 116 delete_fp_variant(struct st_context *st, struct st_fp_variant *fpv)
 117 {
 118    if (fpv->driver_shader)
 119       cso_delete_fragment_shader(st->cso_context, fpv->driver_shader);
 120    free(fpv);
 121 }
 122
 123
 124 /**
 125  * Free all variants of a fragment program.
 126  */
 127 void
 128 st_release_fp_variants(struct st_context *st, struct st_fragment_program *stfp)
 129 {
 130    struct st_fp_variant *fpv;
 131
 132    for (fpv = stfp->variants; fpv; ) {
 133       struct st_fp_variant *next = fpv->next;
 134       delete_fp_variant(st, fpv);
 135       fpv = next;
 136    }
 137
 138    stfp->variants = NULL;
 139
 140    if ((stfp->tgsi.type == PIPE_SHADER_IR_TGSI) && stfp->tgsi.tokens) {
 141       ureg_free_tokens(stfp->tgsi.tokens);
 142       stfp->tgsi.tokens = NULL;
 143    }
 144 }
 145
 146
 147 /**
 148  * Delete a basic program variant.  Note the caller must unlink
 149  * the variant from the linked list.
 150  */
 151 static void
 152 delete_basic_variant(struct st_context *st, struct st_basic_variant *v,
 153                      GLenum target)
 154 {
 155    if (v->driver_shader) {
 156       switch (target) {
 157       case GL_TESS_CONTROL_PROGRAM_NV:
 158          cso_delete_tessctrl_shader(st->cso_context, v->driver_shader);
 159          break;
 160       case GL_TESS_EVALUATION_PROGRAM_NV:
 161          cso_delete_tesseval_shader(st->cso_context, v->driver_shader);
 162          break;
 163       case GL_GEOMETRY_PROGRAM_NV:
 164          cso_delete_geometry_shader(st->cso_context, v->driver_shader);
 165          break;
 166       case GL_COMPUTE_PROGRAM_NV:
 167          cso_delete_compute_shader(st->cso_context, v->driver_shader);
 168          break;
 169       default:
 170          assert(!"this shouldn't occur");
 171       }
 172    }
 173
 174    free(v);
 175 }
 176
 177
 178 /**
 179  * Free all basic program variants.
 180  */
 181 void
 182 st_release_basic_variants(struct st_context *st, GLenum target,
 183                           struct st_basic_variant **variants,
 184                           struct pipe_shader_state *tgsi)
 185 {
 186    struct st_basic_variant *v;
 187
 188    for (v = *variants; v; ) {
 189       struct st_basic_variant *next = v->next;
 190       delete_basic_variant(st, v, target);
 191       v = next;
 192    }
 193
 194    *variants = NULL;
 195
 196    if (tgsi->tokens) {
 197       ureg_free_tokens(tgsi->tokens);
 198       tgsi->tokens = NULL;
 199    }
 200 }
 201
 202
 203 /**
 204  * Free all variants of a compute program.
 205  */
 206 void
 207 st_release_cp_variants(struct st_context *st, struct st_compute_program *stcp)
 208 {
 209    struct st_basic_variant **variants = &stcp->variants;
 210    struct st_basic_variant *v;
 211
 212    for (v = *variants; v; ) {
 213       struct st_basic_variant *next = v->next;
 214       delete_basic_variant(st, v, stcp->Base.Target);
 215       v = next;
 216    }
 217
 218    *variants = NULL;
 219
 220    if (stcp->tgsi.prog) {
 221       ureg_free_tokens(stcp->tgsi.prog);
 222       stcp->tgsi.prog = NULL;
 223    }
 224 }
 225
 226
 227 /**
 228  * Translate a vertex program.
 229  */
 230 bool
 231 st_translate_vertex_program(struct st_context *st,
 232                             struct st_vertex_program *stvp)
 233 {
 234    struct ureg_program *ureg;
 235    enum pipe_error error;
 236    unsigned num_outputs = 0;
 237    unsigned attr;
 238    unsigned input_to_index[VERT_ATTRIB_MAX] = {0};
 239    unsigned output_slot_to_attr[VARYING_SLOT_MAX] = {0};
 240    ubyte output_semantic_name[VARYING_SLOT_MAX] = {0};
 241    ubyte output_semantic_index[VARYING_SLOT_MAX] = {0};
 242
 243    stvp->num_inputs = 0;
 244
 245    if (stvp->Base.IsPositionInvariant)
 246       _mesa_insert_mvp_code(st->ctx, &stvp->Base);
 247
 248    /*
 249     * Determine number of inputs, the mappings between VERT_ATTRIB_x
 250     * and TGSI generic input indexes, plus input attrib semantic info.
 251     */
 252    for (attr = 0; attr < VERT_ATTRIB_MAX; attr++) {
 253       if ((stvp->Base.info.inputs_read & BITFIELD64_BIT(attr)) != 0) {
 254          input_to_index[attr] = stvp->num_inputs;
 255          stvp->index_to_input[stvp->num_inputs] = attr;
 256          stvp->num_inputs++;
 257          if ((stvp->Base.DoubleInputsRead & BITFIELD64_BIT(attr)) != 0) {
 258             /* add placeholder for second part of a double attribute */
 259             stvp->index_to_input[stvp->num_inputs] = ST_DOUBLE_ATTRIB_PLACEHOLDER;
 260             stvp->num_inputs++;
 261          }
 262       }
 263    }
 264    /* bit of a hack, presetup potentially unused edgeflag input */
 265    input_to_index[VERT_ATTRIB_EDGEFLAG] = stvp->num_inputs;
 266    stvp->index_to_input[stvp->num_inputs] = VERT_ATTRIB_EDGEFLAG;
 267
 268    /* Compute mapping of vertex program outputs to slots.
 269     */
 270    for (attr = 0; attr < VARYING_SLOT_MAX; attr++) {
 271       if ((stvp->Base.OutputsWritten & BITFIELD64_BIT(attr)) == 0) {
 272          stvp->result_to_output[attr] = ~0;
 273       }
 274       else {
 275          unsigned slot = num_outputs++;
 276
 277          stvp->result_to_output[attr] = slot;
 278          output_slot_to_attr[slot] = attr;
 279
 280          switch (attr) {
 281          case VARYING_SLOT_POS:
 282             output_semantic_name[slot] = TGSI_SEMANTIC_POSITION;
 283             output_semantic_index[slot] = 0;
 284             break;
 285          case VARYING_SLOT_COL0:
 286             output_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
 287             output_semantic_index[slot] = 0;
 288             break;
 289          case VARYING_SLOT_COL1:
 290             output_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
 291             output_semantic_index[slot] = 1;
 292             break;
 293          case VARYING_SLOT_BFC0:
 294             output_semantic_name[slot] = TGSI_SEMANTIC_BCOLOR;
 295             output_semantic_index[slot] = 0;
 296             break;
 297          case VARYING_SLOT_BFC1:
 298             output_semantic_name[slot] = TGSI_SEMANTIC_BCOLOR;
 299             output_semantic_index[slot] = 1;
 300             break;
 301          case VARYING_SLOT_FOGC:
 302             output_semantic_name[slot] = TGSI_SEMANTIC_FOG;
 303             output_semantic_index[slot] = 0;
 304             break;
 305          case VARYING_SLOT_PSIZ:
 306             output_semantic_name[slot] = TGSI_SEMANTIC_PSIZE;
 307             output_semantic_index[slot] = 0;
 308             break;
 309          case VARYING_SLOT_CLIP_DIST0:
 310             output_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
 311             output_semantic_index[slot] = 0;
 312             break;
 313          case VARYING_SLOT_CLIP_DIST1:
 314             output_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
 315             output_semantic_index[slot] = 1;
 316             break;
 317          case VARYING_SLOT_CULL_DIST0:
 318          case VARYING_SLOT_CULL_DIST1:
 319             /* these should have been lowered by GLSL */
 320             assert(0);
 321             break;
 322          case VARYING_SLOT_EDGE:
 323             assert(0);
 324             break;
 325          case VARYING_SLOT_CLIP_VERTEX:
 326             output_semantic_name[slot] = TGSI_SEMANTIC_CLIPVERTEX;
 327             output_semantic_index[slot] = 0;
 328             break;
 329          case VARYING_SLOT_LAYER:
 330             output_semantic_name[slot] = TGSI_SEMANTIC_LAYER;
 331             output_semantic_index[slot] = 0;
 332             break;
 333          case VARYING_SLOT_VIEWPORT:
 334             output_semantic_name[slot] = TGSI_SEMANTIC_VIEWPORT_INDEX;
 335             output_semantic_index[slot] = 0;
 336             break;
 337
 338          case VARYING_SLOT_TEX0:
 339          case VARYING_SLOT_TEX1:
 340          case VARYING_SLOT_TEX2:
 341          case VARYING_SLOT_TEX3:
 342          case VARYING_SLOT_TEX4:
 343          case VARYING_SLOT_TEX5:
 344          case VARYING_SLOT_TEX6:
 345          case VARYING_SLOT_TEX7:
 346             if (st->needs_texcoord_semantic) {
 347                output_semantic_name[slot] = TGSI_SEMANTIC_TEXCOORD;
 348                output_semantic_index[slot] = attr - VARYING_SLOT_TEX0;
 349                break;
 350             }
 351             /* fall through */
 352          case VARYING_SLOT_VAR0:
 353          default:
 354             assert(attr >= VARYING_SLOT_VAR0 ||
 355                    (attr >= VARYING_SLOT_TEX0 && attr <= VARYING_SLOT_TEX7));
 356             output_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
 357             output_semantic_index[slot] =
 358                st_get_generic_varying_index(st, attr);
 359             break;
 360          }
 361       }
 362    }
 363    /* similar hack to above, presetup potentially unused edgeflag output */
 364    stvp->result_to_output[VARYING_SLOT_EDGE] = num_outputs;
 365    output_semantic_name[num_outputs] = TGSI_SEMANTIC_EDGEFLAG;
 366    output_semantic_index[num_outputs] = 0;
 367
 368    /* ARB_vp: */
 369    if (!stvp->glsl_to_tgsi && !stvp->shader_program) {
 370       _mesa_remove_output_reads(&stvp->Base, PROGRAM_OUTPUT);
 371
 372       /* This determines which states will be updated when the assembly
 373        * shader is bound.
 374        */
 375       stvp->affected_states = ST_NEW_VS_STATE |
 376                               ST_NEW_RASTERIZER |
 377                               ST_NEW_VERTEX_ARRAYS;
 378
 379       if (stvp->Base.Parameters->NumParameters)
 380          stvp->affected_states |= ST_NEW_VS_CONSTANTS;
 381
 382       /* No samplers are allowed in ARB_vp. */
 383    }
 384
 385    if (stvp->shader_program) {
 386       nir_shader *nir = st_glsl_to_nir(st, &stvp->Base, stvp->shader_program,
 387                                        MESA_SHADER_VERTEX);
 388
 389       stvp->tgsi.type = PIPE_SHADER_IR_NIR;
 390       stvp->tgsi.ir.nir = nir;
 391
 392       st_translate_stream_output_info2(&stvp->shader_program->LinkedTransformFeedback,
 393                                        stvp->result_to_output,
 394                                        &stvp->tgsi.stream_output);
 395       return true;
 396    }
 397
 398    ureg = ureg_create_with_screen(PIPE_SHADER_VERTEX, st->pipe->screen);
 399    if (ureg == NULL)
 400       return false;
 401
 402    if (stvp->Base.ClipDistanceArraySize)
 403       ureg_property(ureg, TGSI_PROPERTY_NUM_CLIPDIST_ENABLED,
 404                     stvp->Base.ClipDistanceArraySize);
 405    if (stvp->Base.CullDistanceArraySize)
 406       ureg_property(ureg, TGSI_PROPERTY_NUM_CULLDIST_ENABLED,
 407                     stvp->Base.CullDistanceArraySize);
 408
 409    if (ST_DEBUG & DEBUG_MESA) {
 410       _mesa_print_program(&stvp->Base);
 411       _mesa_print_program_parameters(st->ctx, &stvp->Base);
 412       debug_printf("\n");
 413    }
 414
 415    if (stvp->glsl_to_tgsi) {
 416       error = st_translate_program(st->ctx,
 417                                    PIPE_SHADER_VERTEX,
 418                                    ureg,
 419                                    stvp->glsl_to_tgsi,
 420                                    &stvp->Base,
 421                                    /* inputs */
 422                                    stvp->num_inputs,
 423                                    input_to_index,
 424                                    NULL, /* inputSlotToAttr */
 425                                    NULL, /* input semantic name */
 426                                    NULL, /* input semantic index */
 427                                    NULL, /* interp mode */
 428                                    /* outputs */
 429                                    num_outputs,
 430                                    stvp->result_to_output,
 431                                    output_slot_to_attr,
 432                                    output_semantic_name,
 433                                    output_semantic_index);
 434
 435       st_translate_stream_output_info(stvp->glsl_to_tgsi,
 436                                       stvp->result_to_output,
 437                                       &stvp->tgsi.stream_output);
 438
 439       free_glsl_to_tgsi_visitor(stvp->glsl_to_tgsi);
 440       stvp->glsl_to_tgsi = NULL;
 441    } else
 442       error = st_translate_mesa_program(st->ctx,
 443                                         PIPE_SHADER_VERTEX,
 444                                         ureg,
 445                                         &stvp->Base,
 446                                         /* inputs */
 447                                         stvp->num_inputs,
 448                                         input_to_index,
 449                                         NULL, /* input semantic name */
 450                                         NULL, /* input semantic index */
 451                                         NULL,
 452                                         /* outputs */
 453                                         num_outputs,
 454                                         stvp->result_to_output,
 455                                         output_semantic_name,
 456                                         output_semantic_index);
 457
 458    if (error) {
 459       debug_printf("%s: failed to translate Mesa program:\n", __func__);
 460       _mesa_print_program(&stvp->Base);
 461       debug_assert(0);
 462       return false;
 463    }
 464
 465    stvp->tgsi.tokens = ureg_get_tokens(ureg, NULL);
 466    ureg_destroy(ureg);
 467    return stvp->tgsi.tokens != NULL;
 468 }
 469
 470 static struct st_vp_variant *
 471 st_create_vp_variant(struct st_context *st,
 472                      struct st_vertex_program *stvp,
 473                      const struct st_vp_variant_key *key)
 474 {
 475    struct st_vp_variant *vpv = CALLOC_STRUCT(st_vp_variant);
 476    struct pipe_context *pipe = st->pipe;
 477
 478    vpv->key = *key;
 479    vpv->tgsi.stream_output = stvp->tgsi.stream_output;
 480    vpv->num_inputs = stvp->num_inputs;
 481
 482    if (stvp->tgsi.type == PIPE_SHADER_IR_NIR) {
 483       vpv->tgsi.type = PIPE_SHADER_IR_NIR;
 484       vpv->tgsi.ir.nir = nir_shader_clone(NULL, stvp->tgsi.ir.nir);
 485       if (key->clamp_color)
 486          NIR_PASS_V(vpv->tgsi.ir.nir, nir_lower_clamp_color_outputs);
 487       if (key->passthrough_edgeflags)
 488          NIR_PASS_V(vpv->tgsi.ir.nir, nir_lower_passthrough_edgeflags);
 489
 490       st_finalize_nir(st, &stvp->Base, vpv->tgsi.ir.nir);
 491
 492       vpv->driver_shader = pipe->create_vs_state(pipe, &vpv->tgsi);
 493       /* driver takes ownership of IR: */
 494       vpv->tgsi.ir.nir = NULL;
 495       return vpv;
 496    }
 497
 498    vpv->tgsi.tokens = tgsi_dup_tokens(stvp->tgsi.tokens);
 499
 500    /* Emulate features. */
 501    if (key->clamp_color || key->passthrough_edgeflags) {
 502       const struct tgsi_token *tokens;
 503       unsigned flags =
 504          (key->clamp_color ? TGSI_EMU_CLAMP_COLOR_OUTPUTS : 0) |
 505          (key->passthrough_edgeflags ? TGSI_EMU_PASSTHROUGH_EDGEFLAG : 0);
 506
 507       tokens = tgsi_emulate(vpv->tgsi.tokens, flags);
 508
 509       if (tokens) {
 510          tgsi_free_tokens(vpv->tgsi.tokens);
 511          vpv->tgsi.tokens = tokens;
 512
 513          if (key->passthrough_edgeflags)
 514             vpv->num_inputs++;
 515       } else
 516          fprintf(stderr, "mesa: cannot emulate deprecated features\n");
 517    }
 518
 519    if (ST_DEBUG & DEBUG_TGSI) {
 520       tgsi_dump(vpv->tgsi.tokens, 0);
 521       debug_printf("\n");
 522    }
 523
 524    vpv->driver_shader = pipe->create_vs_state(pipe, &vpv->tgsi);
 525    return vpv;
 526 }
 527
 528
 529 /**
 530  * Find/create a vertex program variant.
 531  */
 532 struct st_vp_variant *
 533 st_get_vp_variant(struct st_context *st,
 534                   struct st_vertex_program *stvp,
 535                   const struct st_vp_variant_key *key)
 536 {
 537    struct st_vp_variant *vpv;
 538
 539    /* Search for existing variant */
 540    for (vpv = stvp->variants; vpv; vpv = vpv->next) {
 541       if (memcmp(&vpv->key, key, sizeof(*key)) == 0) {
 542          break;
 543       }
 544    }
 545
 546    if (!vpv) {
 547       /* create now */
 548       vpv = st_create_vp_variant(st, stvp, key);
 549       if (vpv) {
 550          /* insert into list */
 551          vpv->next = stvp->variants;
 552          stvp->variants = vpv;
 553       }
 554    }
 555
 556    return vpv;
 557 }
 558
 559
 560 /**
 561  * Translate a Mesa fragment shader into a TGSI shader.
 562  */
 563 bool
 564 st_translate_fragment_program(struct st_context *st,
 565                               struct st_fragment_program *stfp)
 566 {
 567    GLuint outputMapping[2 * FRAG_RESULT_MAX];
 568    GLuint inputMapping[VARYING_SLOT_MAX];
 569    GLuint inputSlotToAttr[VARYING_SLOT_MAX];
 570    GLuint interpMode[PIPE_MAX_SHADER_INPUTS];  /* XXX size? */
 571    GLuint attr;
 572    GLbitfield64 inputsRead;
 573    struct ureg_program *ureg;
 574
 575    GLboolean write_all = GL_FALSE;
 576
 577    ubyte input_semantic_name[PIPE_MAX_SHADER_INPUTS];
 578    ubyte input_semantic_index[PIPE_MAX_SHADER_INPUTS];
 579    uint fs_num_inputs = 0;
 580
 581    ubyte fs_output_semantic_name[PIPE_MAX_SHADER_OUTPUTS];
 582    ubyte fs_output_semantic_index[PIPE_MAX_SHADER_OUTPUTS];
 583    uint fs_num_outputs = 0;
 584
 585    memset(inputSlotToAttr, ~0, sizeof(inputSlotToAttr));
 586
 587    /* Non-GLSL programs: */
 588    if (!stfp->glsl_to_tgsi && !stfp->shader_program) {
 589       _mesa_remove_output_reads(&stfp->Base, PROGRAM_OUTPUT);
 590       if (st->ctx->Const.GLSLFragCoordIsSysVal)
 591          _mesa_program_fragment_position_to_sysval(&stfp->Base);
 592
 593       /* This determines which states will be updated when the assembly
 594        * shader is bound.
 595        *
 596        * fragment.position and glDrawPixels always use constants.
 597        */
 598       stfp->affected_states = ST_NEW_FS_STATE |
 599                               ST_NEW_SAMPLE_SHADING |
 600                               ST_NEW_FS_CONSTANTS;
 601
 602       if (stfp->ati_fs) {
 603          /* Just set them for ATI_fs unconditionally. */
 604          stfp->affected_states |= ST_NEW_FS_SAMPLER_VIEWS |
 605                                   ST_NEW_RENDER_SAMPLERS;
 606       } else {
 607          /* ARB_fp */
 608          if (stfp->Base.SamplersUsed)
 609             stfp->affected_states |= ST_NEW_FS_SAMPLER_VIEWS |
 610                                      ST_NEW_RENDER_SAMPLERS;
 611       }
 612    }
 613
 614    /*
 615     * Convert Mesa program inputs to TGSI input register semantics.
 616     */
 617    inputsRead = stfp->Base.info.inputs_read;
 618    for (attr = 0; attr < VARYING_SLOT_MAX; attr++) {
 619       if ((inputsRead & BITFIELD64_BIT(attr)) != 0) {
 620          const GLuint slot = fs_num_inputs++;
 621
 622          inputMapping[attr] = slot;
 623          inputSlotToAttr[slot] = attr;
 624
 625          switch (attr) {
 626          case VARYING_SLOT_POS:
 627             input_semantic_name[slot] = TGSI_SEMANTIC_POSITION;
 628             input_semantic_index[slot] = 0;
 629             interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
 630             break;
 631          case VARYING_SLOT_COL0:
 632             input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
 633             input_semantic_index[slot] = 0;
 634             interpMode[slot] = stfp->glsl_to_tgsi ?
 635                TGSI_INTERPOLATE_COUNT : TGSI_INTERPOLATE_COLOR;
 636             break;
 637          case VARYING_SLOT_COL1:
 638             input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
 639             input_semantic_index[slot] = 1;
 640             interpMode[slot] = stfp->glsl_to_tgsi ?
 641                TGSI_INTERPOLATE_COUNT : TGSI_INTERPOLATE_COLOR;
 642             break;
 643          case VARYING_SLOT_FOGC:
 644             input_semantic_name[slot] = TGSI_SEMANTIC_FOG;
 645             input_semantic_index[slot] = 0;
 646             interpMode[slot] = TGSI_INTERPOLATE_PERSPECTIVE;
 647             break;
 648          case VARYING_SLOT_FACE:
 649             input_semantic_name[slot] = TGSI_SEMANTIC_FACE;
 650             input_semantic_index[slot] = 0;
 651             interpMode[slot] = TGSI_INTERPOLATE_CONSTANT;
 652             break;
 653          case VARYING_SLOT_PRIMITIVE_ID:
 654             input_semantic_name[slot] = TGSI_SEMANTIC_PRIMID;
 655             input_semantic_index[slot] = 0;
 656             interpMode[slot] = TGSI_INTERPOLATE_CONSTANT;
 657             break;
 658          case VARYING_SLOT_LAYER:
 659             input_semantic_name[slot] = TGSI_SEMANTIC_LAYER;
 660             input_semantic_index[slot] = 0;
 661             interpMode[slot] = TGSI_INTERPOLATE_CONSTANT;
 662             break;
 663          case VARYING_SLOT_VIEWPORT:
 664             input_semantic_name[slot] = TGSI_SEMANTIC_VIEWPORT_INDEX;
 665             input_semantic_index[slot] = 0;
 666             interpMode[slot] = TGSI_INTERPOLATE_CONSTANT;
 667             break;
 668          case VARYING_SLOT_CLIP_DIST0:
 669             input_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
 670             input_semantic_index[slot] = 0;
 671             interpMode[slot] = TGSI_INTERPOLATE_PERSPECTIVE;
 672             break;
 673          case VARYING_SLOT_CLIP_DIST1:
 674             input_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
 675             input_semantic_index[slot] = 1;
 676             interpMode[slot] = TGSI_INTERPOLATE_PERSPECTIVE;
 677             break;
 678          case VARYING_SLOT_CULL_DIST0:
 679          case VARYING_SLOT_CULL_DIST1:
 680             /* these should have been lowered by GLSL */
 681             assert(0);
 682             break;
 683             /* In most cases, there is nothing special about these
 684              * inputs, so adopt a convention to use the generic
 685              * semantic name and the mesa VARYING_SLOT_ number as the
 686              * index.
 687              *
 688              * All that is required is that the vertex shader labels
 689              * its own outputs similarly, and that the vertex shader
 690              * generates at least every output required by the
 691              * fragment shader plus fixed-function hardware (such as
 692              * BFC).
 693              *
 694              * However, some drivers may need us to identify the PNTC and TEXi
 695              * varyings if, for example, their capability to replace them with
 696              * sprite coordinates is limited.
 697              */
 698          case VARYING_SLOT_PNTC:
 699             if (st->needs_texcoord_semantic) {
 700                input_semantic_name[slot] = TGSI_SEMANTIC_PCOORD;
 701                input_semantic_index[slot] = 0;
 702                interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
 703                break;
 704             }
 705             /* fall through */
 706          case VARYING_SLOT_TEX0:
 707          case VARYING_SLOT_TEX1:
 708          case VARYING_SLOT_TEX2:
 709          case VARYING_SLOT_TEX3:
 710          case VARYING_SLOT_TEX4:
 711          case VARYING_SLOT_TEX5:
 712          case VARYING_SLOT_TEX6:
 713          case VARYING_SLOT_TEX7:
 714             if (st->needs_texcoord_semantic) {
 715                input_semantic_name[slot] = TGSI_SEMANTIC_TEXCOORD;
 716                input_semantic_index[slot] = attr - VARYING_SLOT_TEX0;
 717                interpMode[slot] = stfp->glsl_to_tgsi ?
 718                   TGSI_INTERPOLATE_COUNT : TGSI_INTERPOLATE_PERSPECTIVE;
 719                break;
 720             }
 721             /* fall through */
 722          case VARYING_SLOT_VAR0:
 723          default:
 724             /* Semantic indices should be zero-based because drivers may choose
 725              * to assign a fixed slot determined by that index.
 726              * This is useful because ARB_separate_shader_objects uses location
 727              * qualifiers for linkage, and if the semantic index corresponds to
 728              * these locations, linkage passes in the driver become unecessary.
 729              *
 730              * If needs_texcoord_semantic is true, no semantic indices will be
 731              * consumed for the TEXi varyings, and we can base the locations of
 732              * the user varyings on VAR0.  Otherwise, we use TEX0 as base index.
 733              */
 734             assert(attr >= VARYING_SLOT_VAR0 || attr == VARYING_SLOT_PNTC ||
 735                    (attr >= VARYING_SLOT_TEX0 && attr <= VARYING_SLOT_TEX7));
 736             input_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
 737             input_semantic_index[slot] = st_get_generic_varying_index(st, attr);
 738             if (attr == VARYING_SLOT_PNTC)
 739                interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
 740             else {
 741                interpMode[slot] = stfp->glsl_to_tgsi ?
 742                   TGSI_INTERPOLATE_COUNT : TGSI_INTERPOLATE_PERSPECTIVE;
 743             }
 744             break;
 745          }
 746       }
 747       else {
 748          inputMapping[attr] = -1;
 749       }
 750    }
 751
 752    /*
 753     * Semantics and mapping for outputs
 754     */
 755    {
 756       GLbitfield64 outputsWritten = stfp->Base.OutputsWritten;
 757
 758       /* if z is written, emit that first */
 759       if (outputsWritten & BITFIELD64_BIT(FRAG_RESULT_DEPTH)) {
 760          fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_POSITION;
 761          fs_output_semantic_index[fs_num_outputs] = 0;
 762          outputMapping[FRAG_RESULT_DEPTH] = fs_num_outputs;
 763          fs_num_outputs++;
 764          outputsWritten &= ~(1 << FRAG_RESULT_DEPTH);
 765       }
 766
 767       if (outputsWritten & BITFIELD64_BIT(FRAG_RESULT_STENCIL)) {
 768          fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_STENCIL;
 769          fs_output_semantic_index[fs_num_outputs] = 0;
 770          outputMapping[FRAG_RESULT_STENCIL] = fs_num_outputs;
 771          fs_num_outputs++;
 772          outputsWritten &= ~(1 << FRAG_RESULT_STENCIL);
 773       }
 774
 775       if (outputsWritten & BITFIELD64_BIT(FRAG_RESULT_SAMPLE_MASK)) {
 776          fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_SAMPLEMASK;
 777          fs_output_semantic_index[fs_num_outputs] = 0;
 778          outputMapping[FRAG_RESULT_SAMPLE_MASK] = fs_num_outputs;
 779          fs_num_outputs++;
 780          outputsWritten &= ~(1 << FRAG_RESULT_SAMPLE_MASK);
 781       }
 782
 783       /* handle remaining outputs (color) */
 784       for (attr = 0; attr < ARRAY_SIZE(outputMapping); attr++) {
 785          const GLbitfield64 written = attr < FRAG_RESULT_MAX ? outputsWritten :
 786             stfp->Base.SecondaryOutputsWritten;
 787          const unsigned loc = attr % FRAG_RESULT_MAX;
 788
 789          if (written & BITFIELD64_BIT(loc)) {
 790             switch (loc) {
 791             case FRAG_RESULT_DEPTH:
 792             case FRAG_RESULT_STENCIL:
 793             case FRAG_RESULT_SAMPLE_MASK:
 794                /* handled above */
 795                assert(0);
 796                break;
 797             case FRAG_RESULT_COLOR:
 798                write_all = GL_TRUE; /* fallthrough */
 799             default: {
 800                int index;
 801                assert(loc == FRAG_RESULT_COLOR ||
 802                       (FRAG_RESULT_DATA0 <= loc && loc < FRAG_RESULT_MAX));
 803
 804                index = (loc == FRAG_RESULT_COLOR) ? 0 : (loc - FRAG_RESULT_DATA0);
 805
 806                if (attr >= FRAG_RESULT_MAX) {
 807                   /* Secondary color for dual source blending. */
 808                   assert(index == 0);
 809                   index++;
 810                }
 811
 812                fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_COLOR;
 813                fs_output_semantic_index[fs_num_outputs] = index;
 814                outputMapping[attr] = fs_num_outputs;
 815                break;
 816             }
 817             }
 818
 819             fs_num_outputs++;
 820          }
 821       }
 822    }
 823
 824    if (stfp->shader_program) {
 825       nir_shader *nir = st_glsl_to_nir(st, &stfp->Base, stfp->shader_program,
 826                                        MESA_SHADER_FRAGMENT);
 827
 828       stfp->tgsi.type = PIPE_SHADER_IR_NIR;
 829       stfp->tgsi.ir.nir = nir;
 830
 831       return true;
 832    }
 833
 834    ureg = ureg_create_with_screen(PIPE_SHADER_FRAGMENT, st->pipe->screen);
 835    if (ureg == NULL)
 836       return false;
 837
 838    if (ST_DEBUG & DEBUG_MESA) {
 839       _mesa_print_program(&stfp->Base);
 840       _mesa_print_program_parameters(st->ctx, &stfp->Base);
 841       debug_printf("\n");
 842    }
 843    if (write_all == GL_TRUE)
 844       ureg_property(ureg, TGSI_PROPERTY_FS_COLOR0_WRITES_ALL_CBUFS, 1);
 845
 846    if (stfp->Base.info.fs.depth_layout != FRAG_DEPTH_LAYOUT_NONE) {
 847       switch (stfp->Base.info.fs.depth_layout) {
 848       case FRAG_DEPTH_LAYOUT_ANY:
 849          ureg_property(ureg, TGSI_PROPERTY_FS_DEPTH_LAYOUT,
 850                        TGSI_FS_DEPTH_LAYOUT_ANY);
 851          break;
 852       case FRAG_DEPTH_LAYOUT_GREATER:
 853          ureg_property(ureg, TGSI_PROPERTY_FS_DEPTH_LAYOUT,
 854                        TGSI_FS_DEPTH_LAYOUT_GREATER);
 855          break;
 856       case FRAG_DEPTH_LAYOUT_LESS:
 857          ureg_property(ureg, TGSI_PROPERTY_FS_DEPTH_LAYOUT,
 858                        TGSI_FS_DEPTH_LAYOUT_LESS);
 859          break;
 860       case FRAG_DEPTH_LAYOUT_UNCHANGED:
 861          ureg_property(ureg, TGSI_PROPERTY_FS_DEPTH_LAYOUT,
 862                        TGSI_FS_DEPTH_LAYOUT_UNCHANGED);
 863          break;
 864       default:
 865          assert(0);
 866       }
 867    }
 868
 869    if (stfp->glsl_to_tgsi) {
 870       st_translate_program(st->ctx,
 871                            PIPE_SHADER_FRAGMENT,
 872                            ureg,
 873                            stfp->glsl_to_tgsi,
 874                            &stfp->Base,
 875                            /* inputs */
 876                            fs_num_inputs,
 877                            inputMapping,
 878                            inputSlotToAttr,
 879                            input_semantic_name,
 880                            input_semantic_index,
 881                            interpMode,
 882                            /* outputs */
 883                            fs_num_outputs,
 884                            outputMapping,
 885                            NULL,
 886                            fs_output_semantic_name,
 887                            fs_output_semantic_index);
 888
 889       free_glsl_to_tgsi_visitor(stfp->glsl_to_tgsi);
 890       stfp->glsl_to_tgsi = NULL;
 891    } else if (stfp->ati_fs)
 892       st_translate_atifs_program(ureg,
 893                                  stfp->ati_fs,
 894                                  &stfp->Base,
 895                                  /* inputs */
 896                                  fs_num_inputs,
 897                                  inputMapping,
 898                                  input_semantic_name,
 899                                  input_semantic_index,
 900                                  interpMode,
 901                                  /* outputs */
 902                                  fs_num_outputs,
 903                                  outputMapping,
 904                                  fs_output_semantic_name,
 905                                  fs_output_semantic_index);
 906    else
 907       st_translate_mesa_program(st->ctx,
 908                                 PIPE_SHADER_FRAGMENT,
 909                                 ureg,
 910                                 &stfp->Base,
 911                                 /* inputs */
 912                                 fs_num_inputs,
 913                                 inputMapping,
 914                                 input_semantic_name,
 915                                 input_semantic_index,
 916                                 interpMode,
 917                                 /* outputs */
 918                                 fs_num_outputs,
 919                                 outputMapping,
 920                                 fs_output_semantic_name,
 921                                 fs_output_semantic_index);
 922
 923    stfp->tgsi.tokens = ureg_get_tokens(ureg, NULL);
 924    ureg_destroy(ureg);
 925    return stfp->tgsi.tokens != NULL;
 926 }
 927
 928 static struct st_fp_variant *
 929 st_create_fp_variant(struct st_context *st,
 930                      struct st_fragment_program *stfp,
 931                      const struct st_fp_variant_key *key)
 932 {
 933    struct pipe_context *pipe = st->pipe;
 934    struct st_fp_variant *variant = CALLOC_STRUCT(st_fp_variant);
 935    struct pipe_shader_state tgsi = {0};
 936    struct gl_program_parameter_list *params = stfp->Base.Parameters;
 937    static const gl_state_index texcoord_state[STATE_LENGTH] =
 938       { STATE_INTERNAL, STATE_CURRENT_ATTRIB, VERT_ATTRIB_TEX0 };
 939    static const gl_state_index scale_state[STATE_LENGTH] =
 940       { STATE_INTERNAL, STATE_PT_SCALE };
 941    static const gl_state_index bias_state[STATE_LENGTH] =
 942       { STATE_INTERNAL, STATE_PT_BIAS };
 943
 944    if (!variant)
 945       return NULL;
 946
 947    if (stfp->tgsi.type == PIPE_SHADER_IR_NIR) {
 948       tgsi.type = PIPE_SHADER_IR_NIR;
 949       tgsi.ir.nir = nir_shader_clone(NULL, stfp->tgsi.ir.nir);
 950
 951       if (key->clamp_color)
 952          NIR_PASS_V(tgsi.ir.nir, nir_lower_clamp_color_outputs);
 953
 954       if (key->persample_shading) {
 955           nir_shader *shader = tgsi.ir.nir;
 956           nir_foreach_variable(var, &shader->inputs)
 957              var->data.sample = true;
 958       }
 959
 960       assert(!(key->bitmap && key->drawpixels));
 961
 962       /* glBitmap */
 963       if (key->bitmap) {
 964          nir_lower_bitmap_options options = {0};
 965
 966          variant->bitmap_sampler = ffs(~stfp->Base.SamplersUsed) - 1;
 967          options.sampler = variant->bitmap_sampler;
 968          options.swizzle_xxxx = (st->bitmap.tex_format == PIPE_FORMAT_L8_UNORM);
 969
 970          NIR_PASS_V(tgsi.ir.nir, nir_lower_bitmap, &options);
 971       }
 972
 973       /* glDrawPixels (color only) */
 974       if (key->drawpixels) {
 975          nir_lower_drawpixels_options options = {{0}};
 976          unsigned samplers_used = stfp->Base.SamplersUsed;
 977
 978          /* Find the first unused slot. */
 979          variant->drawpix_sampler = ffs(~samplers_used) - 1;
 980          options.drawpix_sampler = variant->drawpix_sampler;
 981          samplers_used |= (1 << variant->drawpix_sampler);
 982
 983          options.pixel_maps = key->pixelMaps;
 984          if (key->pixelMaps) {
 985             variant->pixelmap_sampler = ffs(~samplers_used) - 1;
 986             options.pixelmap_sampler = variant->pixelmap_sampler;
 987          }
 988
 989          options.scale_and_bias = key->scaleAndBias;
 990          if (key->scaleAndBias) {
 991             _mesa_add_state_reference(params, scale_state);
 992             memcpy(options.scale_state_tokens, scale_state,
 993                    sizeof(options.scale_state_tokens));
 994             _mesa_add_state_reference(params, bias_state);
 995             memcpy(options.bias_state_tokens, bias_state,
 996                    sizeof(options.bias_state_tokens));
 997          }
 998
 999          _mesa_add_state_reference(params, texcoord_state);
1000          memcpy(options.texcoord_state_tokens, texcoord_state,
1001                 sizeof(options.texcoord_state_tokens));
1002
1003          NIR_PASS_V(tgsi.ir.nir, nir_lower_drawpixels, &options);
1004       }
1005
1006       if (unlikely(key->external.lower_nv12 || key->external.lower_iyuv)) {
1007          nir_lower_tex_options options = {0};
1008          options.lower_y_uv_external = key->external.lower_nv12;
1009          options.lower_y_u_v_external = key->external.lower_iyuv;
1010          NIR_PASS_V(tgsi.ir.nir, nir_lower_tex, &options);
1011       }
1012
1013       st_finalize_nir(st, &stfp->Base, tgsi.ir.nir);
1014
1015       if (unlikely(key->external.lower_nv12 || key->external.lower_iyuv)) {
1016          /* This pass needs to happen *after* nir_lower_sampler */
1017          NIR_PASS_V(tgsi.ir.nir, st_nir_lower_tex_src_plane,
1018                     ~stfp->Base.SamplersUsed,
1019                     key->external.lower_nv12,
1020                     key->external.lower_iyuv);
1021       }
1022
1023       variant->driver_shader = pipe->create_fs_state(pipe, &tgsi);
1024       variant->key = *key;
1025
1026       return variant;
1027    }
1028
1029    tgsi.tokens = stfp->tgsi.tokens;
1030
1031    assert(!(key->bitmap && key->drawpixels));
1032
1033    /* Fix texture targets and add fog for ATI_fs */
1034    if (stfp->ati_fs) {
1035       const struct tgsi_token *tokens = st_fixup_atifs(tgsi.tokens, key);
1036
1037       if (tokens)
1038          tgsi.tokens = tokens;
1039       else
1040          fprintf(stderr, "mesa: cannot post-process ATI_fs\n");
1041    }
1042
1043    /* Emulate features. */
1044    if (key->clamp_color || key->persample_shading) {
1045       const struct tgsi_token *tokens;
1046       unsigned flags =
1047          (key->clamp_color ? TGSI_EMU_CLAMP_COLOR_OUTPUTS : 0) |
1048          (key->persample_shading ? TGSI_EMU_FORCE_PERSAMPLE_INTERP : 0);
1049
1050       tokens = tgsi_emulate(tgsi.tokens, flags);
1051
1052       if (tokens) {
1053          if (tgsi.tokens != stfp->tgsi.tokens)
1054             tgsi_free_tokens(tgsi.tokens);
1055          tgsi.tokens = tokens;
1056       } else
1057          fprintf(stderr, "mesa: cannot emulate deprecated features\n");
1058    }
1059
1060    /* glBitmap */
1061    if (key->bitmap) {
1062       const struct tgsi_token *tokens;
1063
1064       variant->bitmap_sampler = ffs(~stfp->Base.SamplersUsed) - 1;
1065
1066       tokens = st_get_bitmap_shader(tgsi.tokens,
1067                                     st->internal_target,
1068                                     variant->bitmap_sampler,
1069                                     st->needs_texcoord_semantic,
1070                                     st->bitmap.tex_format ==
1071                                     PIPE_FORMAT_L8_UNORM);
1072
1073       if (tokens) {
1074          if (tgsi.tokens != stfp->tgsi.tokens)
1075             tgsi_free_tokens(tgsi.tokens);
1076          tgsi.tokens = tokens;
1077       } else
1078          fprintf(stderr, "mesa: cannot create a shader for glBitmap\n");
1079    }
1080
1081    /* glDrawPixels (color only) */
1082    if (key->drawpixels) {
1083       const struct tgsi_token *tokens;
1084       unsigned scale_const = 0, bias_const = 0, texcoord_const = 0;
1085
1086       /* Find the first unused slot. */
1087       variant->drawpix_sampler = ffs(~stfp->Base.SamplersUsed) - 1;
1088
1089       if (key->pixelMaps) {
1090          unsigned samplers_used = stfp->Base.SamplersUsed |
1091                                   (1 << variant->drawpix_sampler);
1092
1093          variant->pixelmap_sampler = ffs(~samplers_used) - 1;
1094       }
1095
1096       if (key->scaleAndBias) {
1097          scale_const = _mesa_add_state_reference(params, scale_state);
1098          bias_const = _mesa_add_state_reference(params, bias_state);
1099       }
1100
1101       texcoord_const = _mesa_add_state_reference(params, texcoord_state);
1102
1103       tokens = st_get_drawpix_shader(tgsi.tokens,
1104                                      st->needs_texcoord_semantic,
1105                                      key->scaleAndBias, scale_const,
1106                                      bias_const, key->pixelMaps,
1107                                      variant->drawpix_sampler,
1108                                      variant->pixelmap_sampler,
1109                                      texcoord_const, st->internal_target);
1110
1111       if (tokens) {
1112          if (tgsi.tokens != stfp->tgsi.tokens)
1113             tgsi_free_tokens(tgsi.tokens);
1114          tgsi.tokens = tokens;
1115       } else
1116          fprintf(stderr, "mesa: cannot create a shader for glDrawPixels\n");
1117    }
1118
1119    if (unlikely(key->external.lower_nv12 || key->external.lower_iyuv)) {
1120       const struct tgsi_token *tokens;
1121
1122       /* samplers inserted would conflict, but this should be unpossible: */
1123       assert(!(key->bitmap || key->drawpixels));
1124
1125       tokens = st_tgsi_lower_yuv(tgsi.tokens,
1126                                  ~stfp->Base.SamplersUsed,
1127                                  key->external.lower_nv12,
1128                                  key->external.lower_iyuv);
1129       if (tokens) {
1130          if (tgsi.tokens != stfp->tgsi.tokens)
1131             tgsi_free_tokens(tgsi.tokens);
1132          tgsi.tokens = tokens;
1133       } else {
1134          fprintf(stderr, "mesa: cannot create a shader for samplerExternalOES\n");
1135       }
1136    }
1137
1138    if (ST_DEBUG & DEBUG_TGSI) {
1139       tgsi_dump(tgsi.tokens, 0);
1140       debug_printf("\n");
1141    }
1142
1143    /* fill in variant */
1144    variant->driver_shader = pipe->create_fs_state(pipe, &tgsi);
1145    variant->key = *key;
1146
1147    if (tgsi.tokens != stfp->tgsi.tokens)
1148       tgsi_free_tokens(tgsi.tokens);
1149    return variant;
1150 }
1151
1152 /**
1153  * Translate fragment program if needed.
1154  */
1155 struct st_fp_variant *
1156 st_get_fp_variant(struct st_context *st,
1157                   struct st_fragment_program *stfp,
1158                   const struct st_fp_variant_key *key)
1159 {
1160    struct st_fp_variant *fpv;
1161
1162    /* Search for existing variant */
1163    for (fpv = stfp->variants; fpv; fpv = fpv->next) {
1164       if (memcmp(&fpv->key, key, sizeof(*key)) == 0) {
1165          break;
1166       }
1167    }
1168
1169    if (!fpv) {
1170       /* create new */
1171       fpv = st_create_fp_variant(st, stfp, key);
1172       if (fpv) {
1173          /* insert into list */
1174          fpv->next = stfp->variants;
1175          stfp->variants = fpv;
1176       }
1177    }
1178
1179    return fpv;
1180 }
1181
1182
1183 /**
1184  * Translate a program. This is common code for geometry and tessellation
1185  * shaders.
1186  */
1187 static void
1188 st_translate_program_common(struct st_context *st,
1189                             struct gl_program *prog,
1190                             struct glsl_to_tgsi_visitor *glsl_to_tgsi,
1191                             struct ureg_program *ureg,
1192                             unsigned tgsi_processor,
1193                             struct pipe_shader_state *out_state)
1194 {
1195    GLuint inputSlotToAttr[VARYING_SLOT_TESS_MAX];
1196    GLuint inputMapping[VARYING_SLOT_TESS_MAX];
1197    GLuint outputSlotToAttr[VARYING_SLOT_TESS_MAX];
1198    GLuint outputMapping[VARYING_SLOT_TESS_MAX];
1199    GLuint attr;
1200
1201    ubyte input_semantic_name[PIPE_MAX_SHADER_INPUTS];
1202    ubyte input_semantic_index[PIPE_MAX_SHADER_INPUTS];
1203    uint num_inputs = 0;
1204
1205    ubyte output_semantic_name[PIPE_MAX_SHADER_OUTPUTS];
1206    ubyte output_semantic_index[PIPE_MAX_SHADER_OUTPUTS];
1207    uint num_outputs = 0;
1208
1209    GLint i;
1210
1211    memset(inputSlotToAttr, 0, sizeof(inputSlotToAttr));
1212    memset(inputMapping, 0, sizeof(inputMapping));
1213    memset(outputSlotToAttr, 0, sizeof(outputSlotToAttr));
1214    memset(outputMapping, 0, sizeof(outputMapping));
1215    memset(out_state, 0, sizeof(*out_state));
1216
1217    if (prog->ClipDistanceArraySize)
1218       ureg_property(ureg, TGSI_PROPERTY_NUM_CLIPDIST_ENABLED,
1219                     prog->ClipDistanceArraySize);
1220    if (prog->CullDistanceArraySize)
1221       ureg_property(ureg, TGSI_PROPERTY_NUM_CULLDIST_ENABLED,
1222                     prog->CullDistanceArraySize);
1223
1224    /*
1225     * Convert Mesa program inputs to TGSI input register semantics.
1226     */
1227    for (attr = 0; attr < VARYING_SLOT_MAX; attr++) {
1228       if ((prog->info.inputs_read & BITFIELD64_BIT(attr)) != 0) {
1229          const GLuint slot = num_inputs++;
1230
1231          inputMapping[attr] = slot;
1232          inputSlotToAttr[slot] = attr;
1233
1234          switch (attr) {
1235          case VARYING_SLOT_PRIMITIVE_ID:
1236             assert(tgsi_processor == PIPE_SHADER_GEOMETRY);
1237             input_semantic_name[slot] = TGSI_SEMANTIC_PRIMID;
1238             input_semantic_index[slot] = 0;
1239             break;
1240          case VARYING_SLOT_POS:
1241             input_semantic_name[slot] = TGSI_SEMANTIC_POSITION;
1242             input_semantic_index[slot] = 0;
1243             break;
1244          case VARYING_SLOT_COL0:
1245             input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
1246             input_semantic_index[slot] = 0;
1247             break;
1248          case VARYING_SLOT_COL1:
1249             input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
1250             input_semantic_index[slot] = 1;
1251             break;
1252          case VARYING_SLOT_FOGC:
1253             input_semantic_name[slot] = TGSI_SEMANTIC_FOG;
1254             input_semantic_index[slot] = 0;
1255             break;
1256          case VARYING_SLOT_CLIP_VERTEX:
1257             input_semantic_name[slot] = TGSI_SEMANTIC_CLIPVERTEX;
1258             input_semantic_index[slot] = 0;
1259             break;
1260          case VARYING_SLOT_CLIP_DIST0:
1261             input_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
1262             input_semantic_index[slot] = 0;
1263             break;
1264          case VARYING_SLOT_CLIP_DIST1:
1265             input_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
1266             input_semantic_index[slot] = 1;
1267             break;
1268          case VARYING_SLOT_CULL_DIST0:
1269          case VARYING_SLOT_CULL_DIST1:
1270             /* these should have been lowered by GLSL */
1271             assert(0);
1272             break;
1273          case VARYING_SLOT_PSIZ:
1274             input_semantic_name[slot] = TGSI_SEMANTIC_PSIZE;
1275             input_semantic_index[slot] = 0;
1276             break;
1277          case VARYING_SLOT_TEX0:
1278          case VARYING_SLOT_TEX1:
1279          case VARYING_SLOT_TEX2:
1280          case VARYING_SLOT_TEX3:
1281          case VARYING_SLOT_TEX4:
1282          case VARYING_SLOT_TEX5:
1283          case VARYING_SLOT_TEX6:
1284          case VARYING_SLOT_TEX7:
1285             if (st->needs_texcoord_semantic) {
1286                input_semantic_name[slot] = TGSI_SEMANTIC_TEXCOORD;
1287                input_semantic_index[slot] = attr - VARYING_SLOT_TEX0;
1288                break;
1289             }
1290             /* fall through */
1291          case VARYING_SLOT_VAR0:
1292          default:
1293             assert(attr >= VARYING_SLOT_VAR0 ||
1294                    (attr >= VARYING_SLOT_TEX0 && attr <= VARYING_SLOT_TEX7));
1295             input_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
1296             input_semantic_index[slot] =
1297                st_get_generic_varying_index(st, attr);
1298             break;
1299          }
1300       }
1301    }
1302
1303    /* Also add patch inputs. */
1304    for (attr = 0; attr < 32; attr++) {
1305       if (prog->PatchInputsRead & (1u << attr)) {
1306          GLuint slot = num_inputs++;
1307          GLuint patch_attr = VARYING_SLOT_PATCH0 + attr;
1308
1309          inputMapping[patch_attr] = slot;
1310          inputSlotToAttr[slot] = patch_attr;
1311          input_semantic_name[slot] = TGSI_SEMANTIC_PATCH;
1312          input_semantic_index[slot] = attr;
1313       }
1314    }
1315
1316    /* initialize output semantics to defaults */
1317    for (i = 0; i < PIPE_MAX_SHADER_OUTPUTS; i++) {
1318       output_semantic_name[i] = TGSI_SEMANTIC_GENERIC;
1319       output_semantic_index[i] = 0;
1320    }
1321
1322    /*
1323     * Determine number of outputs, the (default) output register
1324     * mapping and the semantic information for each output.
1325     */
1326    for (attr = 0; attr < VARYING_SLOT_MAX; attr++) {
1327       if (prog->OutputsWritten & BITFIELD64_BIT(attr)) {
1328          GLuint slot = num_outputs++;
1329
1330          outputMapping[attr] = slot;
1331          outputSlotToAttr[slot] = attr;
1332
1333          switch (attr) {
1334          case VARYING_SLOT_POS:
1335             assert(slot == 0);
1336             output_semantic_name[slot] = TGSI_SEMANTIC_POSITION;
1337             output_semantic_index[slot] = 0;
1338             break;
1339          case VARYING_SLOT_COL0:
1340             output_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
1341             output_semantic_index[slot] = 0;
1342             break;
1343          case VARYING_SLOT_COL1:
1344             output_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
1345             output_semantic_index[slot] = 1;
1346             break;
1347          case VARYING_SLOT_BFC0:
1348             output_semantic_name[slot] = TGSI_SEMANTIC_BCOLOR;
1349             output_semantic_index[slot] = 0;
1350             break;
1351          case VARYING_SLOT_BFC1:
1352             output_semantic_name[slot] = TGSI_SEMANTIC_BCOLOR;
1353             output_semantic_index[slot] = 1;
1354             break;
1355          case VARYING_SLOT_FOGC:
1356             output_semantic_name[slot] = TGSI_SEMANTIC_FOG;
1357             output_semantic_index[slot] = 0;
1358             break;
1359          case VARYING_SLOT_PSIZ:
1360             output_semantic_name[slot] = TGSI_SEMANTIC_PSIZE;
1361             output_semantic_index[slot] = 0;
1362             break;
1363          case VARYING_SLOT_CLIP_VERTEX:
1364             output_semantic_name[slot] = TGSI_SEMANTIC_CLIPVERTEX;
1365             output_semantic_index[slot] = 0;
1366             break;
1367          case VARYING_SLOT_CLIP_DIST0:
1368             output_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
1369             output_semantic_index[slot] = 0;
1370             break;
1371          case VARYING_SLOT_CLIP_DIST1:
1372             output_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
1373             output_semantic_index[slot] = 1;
1374             break;
1375          case VARYING_SLOT_CULL_DIST0:
1376          case VARYING_SLOT_CULL_DIST1:
1377             /* these should have been lowered by GLSL */
1378             assert(0);
1379             break;
1380          case VARYING_SLOT_LAYER:
1381             output_semantic_name[slot] = TGSI_SEMANTIC_LAYER;
1382             output_semantic_index[slot] = 0;
1383             break;
1384          case VARYING_SLOT_PRIMITIVE_ID:
1385             output_semantic_name[slot] = TGSI_SEMANTIC_PRIMID;
1386             output_semantic_index[slot] = 0;
1387             break;
1388          case VARYING_SLOT_VIEWPORT:
1389             output_semantic_name[slot] = TGSI_SEMANTIC_VIEWPORT_INDEX;
1390             output_semantic_index[slot] = 0;
1391             break;
1392          case VARYING_SLOT_TESS_LEVEL_OUTER:
1393             output_semantic_name[slot] = TGSI_SEMANTIC_TESSOUTER;
1394             output_semantic_index[slot] = 0;
1395             break;
1396          case VARYING_SLOT_TESS_LEVEL_INNER:
1397             output_semantic_name[slot] = TGSI_SEMANTIC_TESSINNER;
1398             output_semantic_index[slot] = 0;
1399             break;
1400          case VARYING_SLOT_TEX0:
1401          case VARYING_SLOT_TEX1:
1402          case VARYING_SLOT_TEX2:
1403          case VARYING_SLOT_TEX3:
1404          case VARYING_SLOT_TEX4:
1405          case VARYING_SLOT_TEX5:
1406          case VARYING_SLOT_TEX6:
1407          case VARYING_SLOT_TEX7:
1408             if (st->needs_texcoord_semantic) {
1409                output_semantic_name[slot] = TGSI_SEMANTIC_TEXCOORD;
1410                output_semantic_index[slot] = attr - VARYING_SLOT_TEX0;
1411                break;
1412             }
1413             /* fall through */
1414          case VARYING_SLOT_VAR0:
1415          default:
1416             assert(slot < ARRAY_SIZE(output_semantic_name));
1417             assert(attr >= VARYING_SLOT_VAR0 ||
1418                    (attr >= VARYING_SLOT_TEX0 && attr <= VARYING_SLOT_TEX7));
1419             output_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
1420             output_semantic_index[slot] =
1421                st_get_generic_varying_index(st, attr);
1422             break;
1423          }
1424       }
1425    }
1426
1427    /* Also add patch outputs. */
1428    for (attr = 0; attr < 32; attr++) {
1429       if (prog->PatchOutputsWritten & (1u << attr)) {
1430          GLuint slot = num_outputs++;
1431          GLuint patch_attr = VARYING_SLOT_PATCH0 + attr;
1432
1433          outputMapping[patch_attr] = slot;
1434          outputSlotToAttr[slot] = patch_attr;
1435          output_semantic_name[slot] = TGSI_SEMANTIC_PATCH;
1436          output_semantic_index[slot] = attr;
1437       }
1438    }
1439
1440    st_translate_program(st->ctx,
1441                         tgsi_processor,
1442                         ureg,
1443                         glsl_to_tgsi,
1444                         prog,
1445                         /* inputs */
1446                         num_inputs,
1447                         inputMapping,
1448                         inputSlotToAttr,
1449                         input_semantic_name,
1450                         input_semantic_index,
1451                         NULL,
1452                         /* outputs */
1453                         num_outputs,
1454                         outputMapping,
1455                         outputSlotToAttr,
1456                         output_semantic_name,
1457                         output_semantic_index);
1458
1459    out_state->tokens = ureg_get_tokens(ureg, NULL);
1460    ureg_destroy(ureg);
1461
1462    st_translate_stream_output_info(glsl_to_tgsi,
1463                                    outputMapping,
1464                                    &out_state->stream_output);
1465
1466    if ((ST_DEBUG & DEBUG_TGSI) && (ST_DEBUG & DEBUG_MESA)) {
1467       _mesa_print_program(prog);
1468       debug_printf("\n");
1469    }
1470
1471    if (ST_DEBUG & DEBUG_TGSI) {
1472       tgsi_dump(out_state->tokens, 0);
1473       debug_printf("\n");
1474    }
1475 }
1476
1477
1478 /**
1479  * Translate a geometry program to create a new variant.
1480  */
1481 bool
1482 st_translate_geometry_program(struct st_context *st,
1483                               struct st_geometry_program *stgp)
1484 {
1485    struct ureg_program *ureg;
1486
1487    ureg = ureg_create_with_screen(PIPE_SHADER_GEOMETRY, st->pipe->screen);
1488    if (ureg == NULL)
1489       return false;
1490
1491    ureg_property(ureg, TGSI_PROPERTY_GS_INPUT_PRIM,
1492                  stgp->Base.info.gs.input_primitive);
1493    ureg_property(ureg, TGSI_PROPERTY_GS_OUTPUT_PRIM,
1494                  stgp->Base.info.gs.output_primitive);
1495    ureg_property(ureg, TGSI_PROPERTY_GS_MAX_OUTPUT_VERTICES,
1496                  stgp->Base.info.gs.vertices_out);
1497    ureg_property(ureg, TGSI_PROPERTY_GS_INVOCATIONS,
1498                  stgp->Base.info.gs.invocations);
1499
1500    st_translate_program_common(st, &stgp->Base, stgp->glsl_to_tgsi, ureg,
1501                                PIPE_SHADER_GEOMETRY, &stgp->tgsi);
1502
1503    free_glsl_to_tgsi_visitor(stgp->glsl_to_tgsi);
1504    stgp->glsl_to_tgsi = NULL;
1505    return true;
1506 }
1507
1508
1509 /**
1510  * Get/create a basic program variant.
1511  */
1512 struct st_basic_variant *
1513 st_get_basic_variant(struct st_context *st,
1514                      unsigned pipe_shader,
1515                      struct pipe_shader_state *tgsi,
1516                      struct st_basic_variant **variants)
1517 {
1518    struct pipe_context *pipe = st->pipe;
1519    struct st_basic_variant *v;
1520    struct st_basic_variant_key key;
1521
1522    memset(&key, 0, sizeof(key));
1523    key.st = st->has_shareable_shaders ? NULL : st;
1524
1525    /* Search for existing variant */
1526    for (v = *variants; v; v = v->next) {
1527       if (memcmp(&v->key, &key, sizeof(key)) == 0) {
1528          break;
1529       }
1530    }
1531
1532    if (!v) {
1533       /* create new */
1534       v = CALLOC_STRUCT(st_basic_variant);
1535       if (v) {
1536          /* fill in new variant */
1537          switch (pipe_shader) {
1538          case PIPE_SHADER_TESS_CTRL:
1539             v->driver_shader = pipe->create_tcs_state(pipe, tgsi);
1540             break;
1541          case PIPE_SHADER_TESS_EVAL:
1542             v->driver_shader = pipe->create_tes_state(pipe, tgsi);
1543             break;
1544          case PIPE_SHADER_GEOMETRY:
1545             v->driver_shader = pipe->create_gs_state(pipe, tgsi);
1546             break;
1547          default:
1548             assert(!"unhandled shader type");
1549             free(v);
1550             return NULL;
1551          }
1552
1553          v->key = key;
1554
1555          /* insert into list */
1556          v->next = *variants;
1557          *variants = v;
1558       }
1559    }
1560
1561    return v;
1562 }
1563
1564
1565 /**
1566  * Translate a tessellation control program to create a new variant.
1567  */
1568 bool
1569 st_translate_tessctrl_program(struct st_context *st,
1570                               struct st_tessctrl_program *sttcp)
1571 {
1572    struct ureg_program *ureg;
1573
1574    ureg = ureg_create_with_screen(PIPE_SHADER_TESS_CTRL, st->pipe->screen);
1575    if (ureg == NULL)
1576       return false;
1577
1578    ureg_property(ureg, TGSI_PROPERTY_TCS_VERTICES_OUT,
1579                  sttcp->Base.info.tcs.vertices_out);
1580
1581    st_translate_program_common(st, &sttcp->Base, sttcp->glsl_to_tgsi, ureg,
1582                                PIPE_SHADER_TESS_CTRL, &sttcp->tgsi);
1583
1584    free_glsl_to_tgsi_visitor(sttcp->glsl_to_tgsi);
1585    sttcp->glsl_to_tgsi = NULL;
1586    return true;
1587 }
1588
1589
1590 /**
1591  * Translate a tessellation evaluation program to create a new variant.
1592  */
1593 bool
1594 st_translate_tesseval_program(struct st_context *st,
1595                               struct st_tesseval_program *sttep)
1596 {
1597    struct ureg_program *ureg;
1598
1599    ureg = ureg_create_with_screen(PIPE_SHADER_TESS_EVAL, st->pipe->screen);
1600    if (ureg == NULL)
1601       return false;
1602
1603    if (sttep->Base.info.tes.primitive_mode == GL_ISOLINES)
1604       ureg_property(ureg, TGSI_PROPERTY_TES_PRIM_MODE, GL_LINES);
1605    else
1606       ureg_property(ureg, TGSI_PROPERTY_TES_PRIM_MODE,
1607                     sttep->Base.info.tes.primitive_mode);
1608
1609    switch (sttep->Base.info.tes.spacing) {
1610    case GL_EQUAL:
1611       ureg_property(ureg, TGSI_PROPERTY_TES_SPACING, PIPE_TESS_SPACING_EQUAL);
1612       break;
1613    case GL_FRACTIONAL_EVEN:
1614       ureg_property(ureg, TGSI_PROPERTY_TES_SPACING,
1615                     PIPE_TESS_SPACING_FRACTIONAL_EVEN);
1616       break;
1617    case GL_FRACTIONAL_ODD:
1618       ureg_property(ureg, TGSI_PROPERTY_TES_SPACING,
1619                     PIPE_TESS_SPACING_FRACTIONAL_ODD);
1620       break;
1621    default:
1622       assert(0);
1623    }
1624
1625    ureg_property(ureg, TGSI_PROPERTY_TES_VERTEX_ORDER_CW,
1626                  sttep->Base.info.tes.vertex_order == GL_CW);
1627    ureg_property(ureg, TGSI_PROPERTY_TES_POINT_MODE,
1628                  sttep->Base.info.tes.point_mode);
1629
1630    st_translate_program_common(st, &sttep->Base, sttep->glsl_to_tgsi,
1631                                ureg, PIPE_SHADER_TESS_EVAL, &sttep->tgsi);
1632
1633    free_glsl_to_tgsi_visitor(sttep->glsl_to_tgsi);
1634    sttep->glsl_to_tgsi = NULL;
1635    return true;
1636 }
1637
1638
1639 /**
1640  * Translate a compute program to create a new variant.
1641  */
1642 bool
1643 st_translate_compute_program(struct st_context *st,
1644                              struct st_compute_program *stcp)
1645 {
1646    struct ureg_program *ureg;
1647    struct pipe_shader_state prog;
1648
1649    ureg = ureg_create_with_screen(PIPE_SHADER_COMPUTE, st->pipe->screen);
1650    if (ureg == NULL)
1651       return false;
1652
1653    st_translate_program_common(st, &stcp->Base, stcp->glsl_to_tgsi, ureg,
1654                                PIPE_SHADER_COMPUTE, &prog);
1655
1656    stcp->tgsi.ir_type = PIPE_SHADER_IR_TGSI;
1657    stcp->tgsi.prog = prog.tokens;
1658    stcp->tgsi.req_local_mem = stcp->Base.info.cs.shared_size;
1659    stcp->tgsi.req_private_mem = 0;
1660    stcp->tgsi.req_input_mem = 0;
1661
1662    free_glsl_to_tgsi_visitor(stcp->glsl_to_tgsi);
1663    stcp->glsl_to_tgsi = NULL;
1664    return true;
1665 }
1666
1667
1668 /**
1669  * Get/create compute program variant.
1670  */
1671 struct st_basic_variant *
1672 st_get_cp_variant(struct st_context *st,
1673                   struct pipe_compute_state *tgsi,
1674                   struct st_basic_variant **variants)
1675 {
1676    struct pipe_context *pipe = st->pipe;
1677    struct st_basic_variant *v;
1678    struct st_basic_variant_key key;
1679
1680    memset(&key, 0, sizeof(key));
1681    key.st = st->has_shareable_shaders ? NULL : st;
1682
1683    /* Search for existing variant */
1684    for (v = *variants; v; v = v->next) {
1685       if (memcmp(&v->key, &key, sizeof(key)) == 0) {
1686          break;
1687       }
1688    }
1689
1690    if (!v) {
1691       /* create new */
1692       v = CALLOC_STRUCT(st_basic_variant);
1693       if (v) {
1694          /* fill in new variant */
1695          v->driver_shader = pipe->create_compute_state(pipe, tgsi);
1696          v->key = key;
1697
1698          /* insert into list */
1699          v->next = *variants;
1700          *variants = v;
1701       }
1702    }
1703
1704    return v;
1705 }
1706
1707
1708 /**
1709  * Vert/Geom/Frag programs have per-context variants.  Free all the
1710  * variants attached to the given program which match the given context.
1711  */
1712 static void
1713 destroy_program_variants(struct st_context *st, struct gl_program *target)
1714 {
1715    if (!target || target == &_mesa_DummyProgram)
1716       return;
1717
1718    switch (target->Target) {
1719    case GL_VERTEX_PROGRAM_ARB:
1720       {
1721          struct st_vertex_program *stvp = (struct st_vertex_program *) target;
1722          struct st_vp_variant *vpv, **prevPtr = &stvp->variants;
1723
1724          for (vpv = stvp->variants; vpv; ) {
1725             struct st_vp_variant *next = vpv->next;
1726             if (vpv->key.st == st) {
1727                /* unlink from list */
1728                *prevPtr = next;
1729                /* destroy this variant */
1730                delete_vp_variant(st, vpv);
1731             }
1732             else {
1733                prevPtr = &vpv->next;
1734             }
1735             vpv = next;
1736          }
1737       }
1738       break;
1739    case GL_FRAGMENT_PROGRAM_ARB:
1740       {
1741          struct st_fragment_program *stfp =
1742             (struct st_fragment_program *) target;
1743          struct st_fp_variant *fpv, **prevPtr = &stfp->variants;
1744
1745          for (fpv = stfp->variants; fpv; ) {
1746             struct st_fp_variant *next = fpv->next;
1747             if (fpv->key.st == st) {
1748                /* unlink from list */
1749                *prevPtr = next;
1750                /* destroy this variant */
1751                delete_fp_variant(st, fpv);
1752             }
1753             else {
1754                prevPtr = &fpv->next;
1755             }
1756             fpv = next;
1757          }
1758       }
1759       break;
1760    case GL_GEOMETRY_PROGRAM_NV:
1761    case GL_TESS_CONTROL_PROGRAM_NV:
1762    case GL_TESS_EVALUATION_PROGRAM_NV:
1763    case GL_COMPUTE_PROGRAM_NV:
1764       {
1765          struct st_geometry_program *gp = (struct st_geometry_program*)target;
1766          struct st_tessctrl_program *tcp = (struct st_tessctrl_program*)target;
1767          struct st_tesseval_program *tep = (struct st_tesseval_program*)target;
1768          struct st_compute_program *cp = (struct st_compute_program*)target;
1769          struct st_basic_variant **variants =
1770             target->Target == GL_GEOMETRY_PROGRAM_NV ? &gp->variants :
1771             target->Target == GL_TESS_CONTROL_PROGRAM_NV ? &tcp->variants :
1772             target->Target == GL_TESS_EVALUATION_PROGRAM_NV ? &tep->variants :
1773             target->Target == GL_COMPUTE_PROGRAM_NV ? &cp->variants :
1774             NULL;
1775          struct st_basic_variant *v, **prevPtr = variants;
1776
1777          for (v = *variants; v; ) {
1778             struct st_basic_variant *next = v->next;
1779             if (v->key.st == st) {
1780                /* unlink from list */
1781                *prevPtr = next;
1782                /* destroy this variant */
1783                delete_basic_variant(st, v, target->Target);
1784             }
1785             else {
1786                prevPtr = &v->next;
1787             }
1788             v = next;
1789          }
1790       }
1791       break;
1792    default:
1793       _mesa_problem(NULL, "Unexpected program target 0x%x in "
1794                     "destroy_program_variants_cb()", target->Target);
1795    }
1796 }
1797
1798
1799 /**
1800  * Callback for _mesa_HashWalk.  Free all the shader's program variants
1801  * which match the given context.
1802  */
1803 static void
1804 destroy_shader_program_variants_cb(GLuint key, void *data, void *userData)
1805 {
1806    struct st_context *st = (struct st_context *) userData;
1807    struct gl_shader *shader = (struct gl_shader *) data;
1808
1809    switch (shader->Type) {
1810    case GL_SHADER_PROGRAM_MESA:
1811       {
1812          struct gl_shader_program *shProg = (struct gl_shader_program *) data;
1813          GLuint i;
1814
1815          for (i = 0; i < ARRAY_SIZE(shProg->_LinkedShaders); i++) {
1816             if (shProg->_LinkedShaders[i])
1817                destroy_program_variants(st, shProg->_LinkedShaders[i]->Program);
1818          }
1819       }
1820       break;
1821    case GL_VERTEX_SHADER:
1822    case GL_FRAGMENT_SHADER:
1823    case GL_GEOMETRY_SHADER:
1824    case GL_TESS_CONTROL_SHADER:
1825    case GL_TESS_EVALUATION_SHADER:
1826    case GL_COMPUTE_SHADER:
1827       break;
1828    default:
1829       assert(0);
1830    }
1831 }
1832
1833
1834 /**
1835  * Callback for _mesa_HashWalk.  Free all the program variants which match
1836  * the given context.
1837  */
1838 static void
1839 destroy_program_variants_cb(GLuint key, void *data, void *userData)
1840 {
1841    struct st_context *st = (struct st_context *) userData;
1842    struct gl_program *program = (struct gl_program *) data;
1843    destroy_program_variants(st, program);
1844 }
1845
1846
1847 /**
1848  * Walk over all shaders and programs to delete any variants which
1849  * belong to the given context.
1850  * This is called during context tear-down.
1851  */
1852 void
1853 st_destroy_program_variants(struct st_context *st)
1854 {
1855    /* If shaders can be shared with other contexts, the last context will
1856     * call DeleteProgram on all shaders, releasing everything.
1857     */
1858    if (st->has_shareable_shaders)
1859       return;
1860
1861    /* ARB vert/frag program */
1862    _mesa_HashWalk(st->ctx->Shared->Programs,
1863                   destroy_program_variants_cb, st);
1864
1865    /* GLSL vert/frag/geom shaders */
1866    _mesa_HashWalk(st->ctx->Shared->ShaderObjects,
1867                   destroy_shader_program_variants_cb, st);
1868 }
1869
1870
1871 /**
1872  * For debugging, print/dump the current vertex program.
1873  */
1874 void
1875 st_print_current_vertex_program(void)
1876 {
1877    GET_CURRENT_CONTEXT(ctx);
1878
1879    if (ctx->VertexProgram._Current) {
1880       struct st_vertex_program *stvp =
1881          (struct st_vertex_program *) ctx->VertexProgram._Current;
1882       struct st_vp_variant *stv;
1883
1884       debug_printf("Vertex program %u\n", stvp->Base.Id);
1885
1886       for (stv = stvp->variants; stv; stv = stv->next) {
1887          debug_printf("variant %p\n", stv);
1888          tgsi_dump(stv->tgsi.tokens, 0);
1889       }
1890    }
1891 }
1892
1893
1894 /**
1895  * Compile one shader variant.
1896  */
1897 void
1898 st_precompile_shader_variant(struct st_context *st,
1899                              struct gl_program *prog)
1900 {
1901    switch (prog->Target) {
1902    case GL_VERTEX_PROGRAM_ARB: {
1903       struct st_vertex_program *p = (struct st_vertex_program *)prog;
1904       struct st_vp_variant_key key;
1905
1906       memset(&key, 0, sizeof(key));
1907       key.st = st->has_shareable_shaders ? NULL : st;
1908       st_get_vp_variant(st, p, &key);
1909       break;
1910    }
1911
1912    case GL_TESS_CONTROL_PROGRAM_NV: {
1913       struct st_tessctrl_program *p = (struct st_tessctrl_program *)prog;
1914       st_get_basic_variant(st, PIPE_SHADER_TESS_CTRL, &p->tgsi, &p->variants);
1915       break;
1916    }
1917
1918    case GL_TESS_EVALUATION_PROGRAM_NV: {
1919       struct st_tesseval_program *p = (struct st_tesseval_program *)prog;
1920       st_get_basic_variant(st, PIPE_SHADER_TESS_EVAL, &p->tgsi, &p->variants);
1921       break;
1922    }
1923
1924    case GL_GEOMETRY_PROGRAM_NV: {
1925       struct st_geometry_program *p = (struct st_geometry_program *)prog;
1926       st_get_basic_variant(st, PIPE_SHADER_GEOMETRY, &p->tgsi, &p->variants);
1927       break;
1928    }
1929
1930    case GL_FRAGMENT_PROGRAM_ARB: {
1931       struct st_fragment_program *p = (struct st_fragment_program *)prog;
1932       struct st_fp_variant_key key;
1933
1934       memset(&key, 0, sizeof(key));
1935       key.st = st->has_shareable_shaders ? NULL : st;
1936       st_get_fp_variant(st, p, &key);
1937       break;
1938    }
1939
1940    case GL_COMPUTE_PROGRAM_NV: {
1941       struct st_compute_program *p = (struct st_compute_program *)prog;
1942       st_get_cp_variant(st, &p->tgsi, &p->variants);
1943       break;
1944    }
1945
1946    default:
1947       assert(0);
1948    }
1949 }