src/mesa/state_tracker/st_program.c

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