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