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