src/mesa/state_tracker/st_program.c

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