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
 587    /*
 588     * Convert Mesa program inputs to TGSI input register semantics.
 589     */
 590    inputsRead = stfp->Base.Base.InputsRead;
 591    for (attr = 0; attr < VARYING_SLOT_MAX; attr++) {
 592       if ((inputsRead & BITFIELD64_BIT(attr)) != 0) {
 593          const GLuint slot = fs_num_inputs++;
 594
 595          inputMapping[attr] = slot;
 596          inputSlotToAttr[slot] = attr;
 597          if (stfp->Base.IsCentroid & BITFIELD64_BIT(attr))
 598             interpLocation[slot] = TGSI_INTERPOLATE_LOC_CENTROID;
 599          else if (stfp->Base.IsSample & BITFIELD64_BIT(attr))
 600             interpLocation[slot] = TGSI_INTERPOLATE_LOC_SAMPLE;
 601          else
 602             interpLocation[slot] = TGSI_INTERPOLATE_LOC_CENTER;
 603
 604          if (stfp->Base.Base.SystemValuesRead & (SYSTEM_BIT_SAMPLE_ID |
 605                                                  SYSTEM_BIT_SAMPLE_POS))
 606             interpLocation[slot] = TGSI_INTERPOLATE_LOC_SAMPLE;
 607
 608          switch (attr) {
 609          case VARYING_SLOT_POS:
 610             input_semantic_name[slot] = TGSI_SEMANTIC_POSITION;
 611             input_semantic_index[slot] = 0;
 612             interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
 613             break;
 614          case VARYING_SLOT_COL0:
 615             input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
 616             input_semantic_index[slot] = 0;
 617             interpMode[slot] = st_translate_interp(stfp->Base.InterpQualifier[attr],
 618                                                    TRUE);
 619             break;
 620          case VARYING_SLOT_COL1:
 621             input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
 622             input_semantic_index[slot] = 1;
 623             interpMode[slot] = st_translate_interp(stfp->Base.InterpQualifier[attr],
 624                                                    TRUE);
 625             break;
 626          case VARYING_SLOT_FOGC:
 627             input_semantic_name[slot] = TGSI_SEMANTIC_FOG;
 628             input_semantic_index[slot] = 0;
 629             interpMode[slot] = TGSI_INTERPOLATE_PERSPECTIVE;
 630             break;
 631          case VARYING_SLOT_FACE:
 632             input_semantic_name[slot] = TGSI_SEMANTIC_FACE;
 633             input_semantic_index[slot] = 0;
 634             interpMode[slot] = TGSI_INTERPOLATE_CONSTANT;
 635             break;
 636          case VARYING_SLOT_PRIMITIVE_ID:
 637             input_semantic_name[slot] = TGSI_SEMANTIC_PRIMID;
 638             input_semantic_index[slot] = 0;
 639             interpMode[slot] = TGSI_INTERPOLATE_CONSTANT;
 640             break;
 641          case VARYING_SLOT_LAYER:
 642             input_semantic_name[slot] = TGSI_SEMANTIC_LAYER;
 643             input_semantic_index[slot] = 0;
 644             interpMode[slot] = TGSI_INTERPOLATE_CONSTANT;
 645             break;
 646          case VARYING_SLOT_VIEWPORT:
 647             input_semantic_name[slot] = TGSI_SEMANTIC_VIEWPORT_INDEX;
 648             input_semantic_index[slot] = 0;
 649             interpMode[slot] = TGSI_INTERPOLATE_CONSTANT;
 650             break;
 651          case VARYING_SLOT_CLIP_DIST0:
 652             input_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
 653             input_semantic_index[slot] = 0;
 654             interpMode[slot] = TGSI_INTERPOLATE_PERSPECTIVE;
 655             break;
 656          case VARYING_SLOT_CLIP_DIST1:
 657             input_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
 658             input_semantic_index[slot] = 1;
 659             interpMode[slot] = TGSI_INTERPOLATE_PERSPECTIVE;
 660             break;
 661             /* In most cases, there is nothing special about these
 662              * inputs, so adopt a convention to use the generic
 663              * semantic name and the mesa VARYING_SLOT_ number as the
 664              * index.
 665              *
 666              * All that is required is that the vertex shader labels
 667              * its own outputs similarly, and that the vertex shader
 668              * generates at least every output required by the
 669              * fragment shader plus fixed-function hardware (such as
 670              * BFC).
 671              *
 672              * However, some drivers may need us to identify the PNTC and TEXi
 673              * varyings if, for example, their capability to replace them with
 674              * sprite coordinates is limited.
 675              */
 676          case VARYING_SLOT_PNTC:
 677             if (st->needs_texcoord_semantic) {
 678                input_semantic_name[slot] = TGSI_SEMANTIC_PCOORD;
 679                input_semantic_index[slot] = 0;
 680                interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
 681                break;
 682             }
 683             /* fall through */
 684          case VARYING_SLOT_TEX0:
 685          case VARYING_SLOT_TEX1:
 686          case VARYING_SLOT_TEX2:
 687          case VARYING_SLOT_TEX3:
 688          case VARYING_SLOT_TEX4:
 689          case VARYING_SLOT_TEX5:
 690          case VARYING_SLOT_TEX6:
 691          case VARYING_SLOT_TEX7:
 692             if (st->needs_texcoord_semantic) {
 693                input_semantic_name[slot] = TGSI_SEMANTIC_TEXCOORD;
 694                input_semantic_index[slot] = attr - VARYING_SLOT_TEX0;
 695                interpMode[slot] =
 696                   st_translate_interp(stfp->Base.InterpQualifier[attr], FALSE);
 697                break;
 698             }
 699             /* fall through */
 700          case VARYING_SLOT_VAR0:
 701          default:
 702             /* Semantic indices should be zero-based because drivers may choose
 703              * to assign a fixed slot determined by that index.
 704              * This is useful because ARB_separate_shader_objects uses location
 705              * qualifiers for linkage, and if the semantic index corresponds to
 706              * these locations, linkage passes in the driver become unecessary.
 707              *
 708              * If needs_texcoord_semantic is true, no semantic indices will be
 709              * consumed for the TEXi varyings, and we can base the locations of
 710              * the user varyings on VAR0.  Otherwise, we use TEX0 as base index.
 711              */
 712             assert(attr >= VARYING_SLOT_VAR0 || attr == VARYING_SLOT_PNTC ||
 713                    (attr >= VARYING_SLOT_TEX0 && attr <= VARYING_SLOT_TEX7));
 714             input_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
 715             input_semantic_index[slot] = st_get_generic_varying_index(st, attr);
 716             if (attr == VARYING_SLOT_PNTC)
 717                interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
 718             else
 719                interpMode[slot] = st_translate_interp(stfp->Base.InterpQualifier[attr],
 720                                                       FALSE);
 721             break;
 722          }
 723       }
 724       else {
 725          inputMapping[attr] = -1;
 726       }
 727    }
 728
 729    /*
 730     * Semantics and mapping for outputs
 731     */
 732    {
 733       uint numColors = 0;
 734       GLbitfield64 outputsWritten = stfp->Base.Base.OutputsWritten;
 735
 736       /* if z is written, emit that first */
 737       if (outputsWritten & BITFIELD64_BIT(FRAG_RESULT_DEPTH)) {
 738          fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_POSITION;
 739          fs_output_semantic_index[fs_num_outputs] = 0;
 740          outputMapping[FRAG_RESULT_DEPTH] = fs_num_outputs;
 741          fs_num_outputs++;
 742          outputsWritten &= ~(1 << FRAG_RESULT_DEPTH);
 743       }
 744
 745       if (outputsWritten & BITFIELD64_BIT(FRAG_RESULT_STENCIL)) {
 746          fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_STENCIL;
 747          fs_output_semantic_index[fs_num_outputs] = 0;
 748          outputMapping[FRAG_RESULT_STENCIL] = fs_num_outputs;
 749          fs_num_outputs++;
 750          outputsWritten &= ~(1 << FRAG_RESULT_STENCIL);
 751       }
 752
 753       if (outputsWritten & BITFIELD64_BIT(FRAG_RESULT_SAMPLE_MASK)) {
 754          fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_SAMPLEMASK;
 755          fs_output_semantic_index[fs_num_outputs] = 0;
 756          outputMapping[FRAG_RESULT_SAMPLE_MASK] = fs_num_outputs;
 757          fs_num_outputs++;
 758          outputsWritten &= ~(1 << FRAG_RESULT_SAMPLE_MASK);
 759       }
 760
 761       /* handle remaining outputs (color) */
 762       for (attr = 0; attr < FRAG_RESULT_MAX; attr++) {
 763          if (outputsWritten & BITFIELD64_BIT(attr)) {
 764             switch (attr) {
 765             case FRAG_RESULT_DEPTH:
 766             case FRAG_RESULT_STENCIL:
 767             case FRAG_RESULT_SAMPLE_MASK:
 768                /* handled above */
 769                assert(0);
 770                break;
 771             case FRAG_RESULT_COLOR:
 772                write_all = GL_TRUE; /* fallthrough */
 773             default:
 774                assert(attr == FRAG_RESULT_COLOR ||
 775                       (FRAG_RESULT_DATA0 <= attr && attr < FRAG_RESULT_MAX));
 776                fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_COLOR;
 777                fs_output_semantic_index[fs_num_outputs] = numColors;
 778                outputMapping[attr] = fs_num_outputs;
 779                numColors++;
 780                break;
 781             }
 782
 783             fs_num_outputs++;
 784          }
 785       }
 786    }
 787
 788    ureg = ureg_create_with_screen(TGSI_PROCESSOR_FRAGMENT, st->pipe->screen);
 789    if (ureg == NULL)
 790       return false;
 791
 792    if (ST_DEBUG & DEBUG_MESA) {
 793       _mesa_print_program(&stfp->Base.Base);
 794       _mesa_print_program_parameters(st->ctx, &stfp->Base.Base);
 795       debug_printf("\n");
 796    }
 797    if (write_all == GL_TRUE)
 798       ureg_property(ureg, TGSI_PROPERTY_FS_COLOR0_WRITES_ALL_CBUFS, 1);
 799
 800    if (stfp->Base.FragDepthLayout != FRAG_DEPTH_LAYOUT_NONE) {
 801       switch (stfp->Base.FragDepthLayout) {
 802       case FRAG_DEPTH_LAYOUT_ANY:
 803          ureg_property(ureg, TGSI_PROPERTY_FS_DEPTH_LAYOUT,
 804                        TGSI_FS_DEPTH_LAYOUT_ANY);
 805          break;
 806       case FRAG_DEPTH_LAYOUT_GREATER:
 807          ureg_property(ureg, TGSI_PROPERTY_FS_DEPTH_LAYOUT,
 808                        TGSI_FS_DEPTH_LAYOUT_GREATER);
 809          break;
 810       case FRAG_DEPTH_LAYOUT_LESS:
 811          ureg_property(ureg, TGSI_PROPERTY_FS_DEPTH_LAYOUT,
 812                        TGSI_FS_DEPTH_LAYOUT_LESS);
 813          break;
 814       case FRAG_DEPTH_LAYOUT_UNCHANGED:
 815          ureg_property(ureg, TGSI_PROPERTY_FS_DEPTH_LAYOUT,
 816                        TGSI_FS_DEPTH_LAYOUT_UNCHANGED);
 817          break;
 818       default:
 819          assert(0);
 820       }
 821    }
 822
 823    if (stfp->glsl_to_tgsi) {
 824       st_translate_program(st->ctx,
 825                            TGSI_PROCESSOR_FRAGMENT,
 826                            ureg,
 827                            stfp->glsl_to_tgsi,
 828                            &stfp->Base.Base,
 829                            /* inputs */
 830                            fs_num_inputs,
 831                            inputMapping,
 832                            inputSlotToAttr,
 833                            input_semantic_name,
 834                            input_semantic_index,
 835                            interpMode,
 836                            interpLocation,
 837                            /* outputs */
 838                            fs_num_outputs,
 839                            outputMapping,
 840                            NULL,
 841                            fs_output_semantic_name,
 842                            fs_output_semantic_index);
 843
 844       free_glsl_to_tgsi_visitor(stfp->glsl_to_tgsi);
 845       stfp->glsl_to_tgsi = NULL;
 846    } else
 847       st_translate_mesa_program(st->ctx,
 848                                 TGSI_PROCESSOR_FRAGMENT,
 849                                 ureg,
 850                                 &stfp->Base.Base,
 851                                 /* inputs */
 852                                 fs_num_inputs,
 853                                 inputMapping,
 854                                 input_semantic_name,
 855                                 input_semantic_index,
 856                                 interpMode,
 857                                 /* outputs */
 858                                 fs_num_outputs,
 859                                 outputMapping,
 860                                 fs_output_semantic_name,
 861                                 fs_output_semantic_index);
 862
 863    stfp->tgsi.tokens = ureg_get_tokens(ureg, NULL);
 864    ureg_destroy(ureg);
 865    return stfp->tgsi.tokens != NULL;
 866 }
 867
 868 static struct st_fp_variant *
 869 st_create_fp_variant(struct st_context *st,
 870                      struct st_fragment_program *stfp,
 871                      const struct st_fp_variant_key *key)
 872 {
 873    struct pipe_context *pipe = st->pipe;
 874    struct st_fp_variant *variant = CALLOC_STRUCT(st_fp_variant);
 875    struct pipe_shader_state tgsi = {0};
 876
 877    if (!variant)
 878       return NULL;
 879
 880    tgsi.tokens = stfp->tgsi.tokens;
 881
 882    assert(!(key->bitmap && key->drawpixels));
 883
 884    /* Emulate features. */
 885    if (key->clamp_color || key->persample_shading) {
 886       const struct tgsi_token *tokens;
 887       unsigned flags =
 888          (key->clamp_color ? TGSI_EMU_CLAMP_COLOR_OUTPUTS : 0) |
 889          (key->persample_shading ? TGSI_EMU_FORCE_PERSAMPLE_INTERP : 0);
 890
 891       tokens = tgsi_emulate(tgsi.tokens, flags);
 892
 893       if (tokens)
 894          tgsi.tokens = tokens;
 895       else
 896          fprintf(stderr, "mesa: cannot emulate deprecated features\n");
 897    }
 898
 899    /* glBitmap */
 900    if (key->bitmap) {
 901       const struct tgsi_token *tokens;
 902
 903       variant->bitmap_sampler = ffs(~stfp->Base.Base.SamplersUsed) - 1;
 904
 905       tokens = st_get_bitmap_shader(tgsi.tokens,
 906                                     variant->bitmap_sampler,
 907                                     st->needs_texcoord_semantic,
 908                                     st->bitmap.tex_format ==
 909                                     PIPE_FORMAT_L8_UNORM);
 910
 911       if (tokens) {
 912          if (tgsi.tokens != stfp->tgsi.tokens)
 913             tgsi_free_tokens(tgsi.tokens);
 914          tgsi.tokens = tokens;
 915       } else
 916          fprintf(stderr, "mesa: cannot create a shader for glBitmap\n");
 917    }
 918
 919    /* glDrawPixels (color only) */
 920    if (key->drawpixels) {
 921       const struct tgsi_token *tokens;
 922       unsigned scale_const = 0, bias_const = 0, texcoord_const = 0;
 923       struct gl_program_parameter_list *params = stfp->Base.Base.Parameters;
 924
 925       /* Find the first unused slot. */
 926       variant->drawpix_sampler = ffs(~stfp->Base.Base.SamplersUsed) - 1;
 927
 928       if (key->pixelMaps) {
 929          unsigned samplers_used = stfp->Base.Base.SamplersUsed |
 930                                   (1 << variant->drawpix_sampler);
 931
 932          variant->pixelmap_sampler = ffs(~samplers_used) - 1;
 933       }
 934
 935       if (key->scaleAndBias) {
 936          static const gl_state_index scale_state[STATE_LENGTH] =
 937             { STATE_INTERNAL, STATE_PT_SCALE };
 938          static const gl_state_index bias_state[STATE_LENGTH] =
 939             { STATE_INTERNAL, STATE_PT_BIAS };
 940
 941          scale_const = _mesa_add_state_reference(params, scale_state);
 942          bias_const = _mesa_add_state_reference(params, bias_state);
 943       }
 944
 945       {
 946          static const gl_state_index state[STATE_LENGTH] =
 947             { STATE_INTERNAL, STATE_CURRENT_ATTRIB, VERT_ATTRIB_TEX0 };
 948
 949          texcoord_const = _mesa_add_state_reference(params, state);
 950       }
 951
 952       tokens = st_get_drawpix_shader(tgsi.tokens,
 953                                      st->needs_texcoord_semantic,
 954                                      key->scaleAndBias, scale_const,
 955                                      bias_const, key->pixelMaps,
 956                                      variant->drawpix_sampler,
 957                                      variant->pixelmap_sampler,
 958                                      texcoord_const);
 959
 960       if (tokens) {
 961          if (tgsi.tokens != stfp->tgsi.tokens)
 962             tgsi_free_tokens(tgsi.tokens);
 963          tgsi.tokens = tokens;
 964       } else
 965          fprintf(stderr, "mesa: cannot create a shader for glDrawPixels\n");
 966    }
 967
 968    if (ST_DEBUG & DEBUG_TGSI) {
 969       tgsi_dump(tgsi.tokens, 0);
 970       debug_printf("\n");
 971    }
 972
 973    /* fill in variant */
 974    variant->driver_shader = pipe->create_fs_state(pipe, &tgsi);
 975    variant->key = *key;
 976
 977    if (tgsi.tokens != stfp->tgsi.tokens)
 978       tgsi_free_tokens(tgsi.tokens);
 979    return variant;
 980 }
 981
 982 /**
 983  * Translate fragment program if needed.
 984  */
 985 struct st_fp_variant *
 986 st_get_fp_variant(struct st_context *st,
 987                   struct st_fragment_program *stfp,
 988                   const struct st_fp_variant_key *key)
 989 {
 990    struct st_fp_variant *fpv;
 991
 992    /* Search for existing variant */
 993    for (fpv = stfp->variants; fpv; fpv = fpv->next) {
 994       if (memcmp(&fpv->key, key, sizeof(*key)) == 0) {
 995          break;
 996       }
 997    }
 998
 999    if (!fpv) {
1000       /* create new */
1001       fpv = st_create_fp_variant(st, stfp, key);
1002       if (fpv) {
1003          /* insert into list */
1004          fpv->next = stfp->variants;
1005          stfp->variants = fpv;
1006       }
1007    }
1008
1009    return fpv;
1010 }
1011
1012
1013 /**
1014  * Translate a program. This is common code for geometry and tessellation
1015  * shaders.
1016  */
1017 static void
1018 st_translate_program_common(struct st_context *st,
1019                             struct gl_program *prog,
1020                             struct glsl_to_tgsi_visitor *glsl_to_tgsi,
1021                             struct ureg_program *ureg,
1022                             unsigned tgsi_processor,
1023                             struct pipe_shader_state *out_state)
1024 {
1025    GLuint inputSlotToAttr[VARYING_SLOT_TESS_MAX];
1026    GLuint inputMapping[VARYING_SLOT_TESS_MAX];
1027    GLuint outputSlotToAttr[VARYING_SLOT_TESS_MAX];
1028    GLuint outputMapping[VARYING_SLOT_TESS_MAX];
1029    GLuint attr;
1030
1031    ubyte input_semantic_name[PIPE_MAX_SHADER_INPUTS];
1032    ubyte input_semantic_index[PIPE_MAX_SHADER_INPUTS];
1033    uint num_inputs = 0;
1034
1035    ubyte output_semantic_name[PIPE_MAX_SHADER_OUTPUTS];
1036    ubyte output_semantic_index[PIPE_MAX_SHADER_OUTPUTS];
1037    uint num_outputs = 0;
1038
1039    GLint i;
1040
1041    memset(inputSlotToAttr, 0, sizeof(inputSlotToAttr));
1042    memset(inputMapping, 0, sizeof(inputMapping));
1043    memset(outputSlotToAttr, 0, sizeof(outputSlotToAttr));
1044    memset(outputMapping, 0, sizeof(outputMapping));
1045    memset(out_state, 0, sizeof(*out_state));
1046
1047    if (prog->ClipDistanceArraySize)
1048       ureg_property(ureg, TGSI_PROPERTY_NUM_CLIPDIST_ENABLED,
1049                     prog->ClipDistanceArraySize);
1050
1051    /*
1052     * Convert Mesa program inputs to TGSI input register semantics.
1053     */
1054    for (attr = 0; attr < VARYING_SLOT_MAX; attr++) {
1055       if ((prog->InputsRead & BITFIELD64_BIT(attr)) != 0) {
1056          const GLuint slot = num_inputs++;
1057
1058          inputMapping[attr] = slot;
1059          inputSlotToAttr[slot] = attr;
1060
1061          switch (attr) {
1062          case VARYING_SLOT_PRIMITIVE_ID:
1063             assert(tgsi_processor == TGSI_PROCESSOR_GEOMETRY);
1064             input_semantic_name[slot] = TGSI_SEMANTIC_PRIMID;
1065             input_semantic_index[slot] = 0;
1066             break;
1067          case VARYING_SLOT_POS:
1068             input_semantic_name[slot] = TGSI_SEMANTIC_POSITION;
1069             input_semantic_index[slot] = 0;
1070             break;
1071          case VARYING_SLOT_COL0:
1072             input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
1073             input_semantic_index[slot] = 0;
1074             break;
1075          case VARYING_SLOT_COL1:
1076             input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
1077             input_semantic_index[slot] = 1;
1078             break;
1079          case VARYING_SLOT_FOGC:
1080             input_semantic_name[slot] = TGSI_SEMANTIC_FOG;
1081             input_semantic_index[slot] = 0;
1082             break;
1083          case VARYING_SLOT_CLIP_VERTEX:
1084             input_semantic_name[slot] = TGSI_SEMANTIC_CLIPVERTEX;
1085             input_semantic_index[slot] = 0;
1086             break;
1087          case VARYING_SLOT_CLIP_DIST0:
1088             input_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
1089             input_semantic_index[slot] = 0;
1090             break;
1091          case VARYING_SLOT_CLIP_DIST1:
1092             input_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
1093             input_semantic_index[slot] = 1;
1094             break;
1095          case VARYING_SLOT_PSIZ:
1096             input_semantic_name[slot] = TGSI_SEMANTIC_PSIZE;
1097             input_semantic_index[slot] = 0;
1098             break;
1099          case VARYING_SLOT_TEX0:
1100          case VARYING_SLOT_TEX1:
1101          case VARYING_SLOT_TEX2:
1102          case VARYING_SLOT_TEX3:
1103          case VARYING_SLOT_TEX4:
1104          case VARYING_SLOT_TEX5:
1105          case VARYING_SLOT_TEX6:
1106          case VARYING_SLOT_TEX7:
1107             if (st->needs_texcoord_semantic) {
1108                input_semantic_name[slot] = TGSI_SEMANTIC_TEXCOORD;
1109                input_semantic_index[slot] = attr - VARYING_SLOT_TEX0;
1110                break;
1111             }
1112             /* fall through */
1113          case VARYING_SLOT_VAR0:
1114          default:
1115             assert(attr >= VARYING_SLOT_VAR0 ||
1116                    (attr >= VARYING_SLOT_TEX0 && attr <= VARYING_SLOT_TEX7));
1117             input_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
1118             input_semantic_index[slot] =
1119                st_get_generic_varying_index(st, attr);
1120             break;
1121          }
1122       }
1123    }
1124
1125    /* Also add patch inputs. */
1126    for (attr = 0; attr < 32; attr++) {
1127       if (prog->PatchInputsRead & (1 << attr)) {
1128          GLuint slot = num_inputs++;
1129          GLuint patch_attr = VARYING_SLOT_PATCH0 + attr;
1130
1131          inputMapping[patch_attr] = slot;
1132          inputSlotToAttr[slot] = patch_attr;
1133          input_semantic_name[slot] = TGSI_SEMANTIC_PATCH;
1134          input_semantic_index[slot] = attr;
1135       }
1136    }
1137
1138    /* initialize output semantics to defaults */
1139    for (i = 0; i < PIPE_MAX_SHADER_OUTPUTS; i++) {
1140       output_semantic_name[i] = TGSI_SEMANTIC_GENERIC;
1141       output_semantic_index[i] = 0;
1142    }
1143
1144    /*
1145     * Determine number of outputs, the (default) output register
1146     * mapping and the semantic information for each output.
1147     */
1148    for (attr = 0; attr < VARYING_SLOT_MAX; attr++) {
1149       if (prog->OutputsWritten & BITFIELD64_BIT(attr)) {
1150          GLuint slot = num_outputs++;
1151
1152          outputMapping[attr] = slot;
1153          outputSlotToAttr[slot] = attr;
1154
1155          switch (attr) {
1156          case VARYING_SLOT_POS:
1157             assert(slot == 0);
1158             output_semantic_name[slot] = TGSI_SEMANTIC_POSITION;
1159             output_semantic_index[slot] = 0;
1160             break;
1161          case VARYING_SLOT_COL0:
1162             output_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
1163             output_semantic_index[slot] = 0;
1164             break;
1165          case VARYING_SLOT_COL1:
1166             output_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
1167             output_semantic_index[slot] = 1;
1168             break;
1169          case VARYING_SLOT_BFC0:
1170             output_semantic_name[slot] = TGSI_SEMANTIC_BCOLOR;
1171             output_semantic_index[slot] = 0;
1172             break;
1173          case VARYING_SLOT_BFC1:
1174             output_semantic_name[slot] = TGSI_SEMANTIC_BCOLOR;
1175             output_semantic_index[slot] = 1;
1176             break;
1177          case VARYING_SLOT_FOGC:
1178             output_semantic_name[slot] = TGSI_SEMANTIC_FOG;
1179             output_semantic_index[slot] = 0;
1180             break;
1181          case VARYING_SLOT_PSIZ:
1182             output_semantic_name[slot] = TGSI_SEMANTIC_PSIZE;
1183             output_semantic_index[slot] = 0;
1184             break;
1185          case VARYING_SLOT_CLIP_VERTEX:
1186             output_semantic_name[slot] = TGSI_SEMANTIC_CLIPVERTEX;
1187             output_semantic_index[slot] = 0;
1188             break;
1189          case VARYING_SLOT_CLIP_DIST0:
1190             output_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
1191             output_semantic_index[slot] = 0;
1192             break;
1193          case VARYING_SLOT_CLIP_DIST1:
1194             output_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
1195             output_semantic_index[slot] = 1;
1196             break;
1197          case VARYING_SLOT_LAYER:
1198             output_semantic_name[slot] = TGSI_SEMANTIC_LAYER;
1199             output_semantic_index[slot] = 0;
1200             break;
1201          case VARYING_SLOT_PRIMITIVE_ID:
1202             output_semantic_name[slot] = TGSI_SEMANTIC_PRIMID;
1203             output_semantic_index[slot] = 0;
1204             break;
1205          case VARYING_SLOT_VIEWPORT:
1206             output_semantic_name[slot] = TGSI_SEMANTIC_VIEWPORT_INDEX;
1207             output_semantic_index[slot] = 0;
1208             break;
1209          case VARYING_SLOT_TESS_LEVEL_OUTER:
1210             output_semantic_name[slot] = TGSI_SEMANTIC_TESSOUTER;
1211             output_semantic_index[slot] = 0;
1212             break;
1213          case VARYING_SLOT_TESS_LEVEL_INNER:
1214             output_semantic_name[slot] = TGSI_SEMANTIC_TESSINNER;
1215             output_semantic_index[slot] = 0;
1216             break;
1217          case VARYING_SLOT_TEX0:
1218          case VARYING_SLOT_TEX1:
1219          case VARYING_SLOT_TEX2:
1220          case VARYING_SLOT_TEX3:
1221          case VARYING_SLOT_TEX4:
1222          case VARYING_SLOT_TEX5:
1223          case VARYING_SLOT_TEX6:
1224          case VARYING_SLOT_TEX7:
1225             if (st->needs_texcoord_semantic) {
1226                output_semantic_name[slot] = TGSI_SEMANTIC_TEXCOORD;
1227                output_semantic_index[slot] = attr - VARYING_SLOT_TEX0;
1228                break;
1229             }
1230             /* fall through */
1231          case VARYING_SLOT_VAR0:
1232          default:
1233             assert(slot < ARRAY_SIZE(output_semantic_name));
1234             assert(attr >= VARYING_SLOT_VAR0 ||
1235                    (attr >= VARYING_SLOT_TEX0 && attr <= VARYING_SLOT_TEX7));
1236             output_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
1237             output_semantic_index[slot] =
1238                st_get_generic_varying_index(st, attr);
1239             break;
1240          }
1241       }
1242    }
1243
1244    /* Also add patch outputs. */
1245    for (attr = 0; attr < 32; attr++) {
1246       if (prog->PatchOutputsWritten & (1 << attr)) {
1247          GLuint slot = num_outputs++;
1248          GLuint patch_attr = VARYING_SLOT_PATCH0 + attr;
1249
1250          outputMapping[patch_attr] = slot;
1251          outputSlotToAttr[slot] = patch_attr;
1252          output_semantic_name[slot] = TGSI_SEMANTIC_PATCH;
1253          output_semantic_index[slot] = attr;
1254       }
1255    }
1256
1257    st_translate_program(st->ctx,
1258                         tgsi_processor,
1259                         ureg,
1260                         glsl_to_tgsi,
1261                         prog,
1262                         /* inputs */
1263                         num_inputs,
1264                         inputMapping,
1265                         inputSlotToAttr,
1266                         input_semantic_name,
1267                         input_semantic_index,
1268                         NULL,
1269                         NULL,
1270                         /* outputs */
1271                         num_outputs,
1272                         outputMapping,
1273                         outputSlotToAttr,
1274                         output_semantic_name,
1275                         output_semantic_index);
1276
1277    out_state->tokens = ureg_get_tokens(ureg, NULL);
1278    ureg_destroy(ureg);
1279
1280    st_translate_stream_output_info(glsl_to_tgsi,
1281                                    outputMapping,
1282                                    &out_state->stream_output);
1283
1284    if ((ST_DEBUG & DEBUG_TGSI) && (ST_DEBUG & DEBUG_MESA)) {
1285       _mesa_print_program(prog);
1286       debug_printf("\n");
1287    }
1288
1289    if (ST_DEBUG & DEBUG_TGSI) {
1290       tgsi_dump(out_state->tokens, 0);
1291       debug_printf("\n");
1292    }
1293 }
1294
1295
1296 /**
1297  * Translate a geometry program to create a new variant.
1298  */
1299 bool
1300 st_translate_geometry_program(struct st_context *st,
1301                               struct st_geometry_program *stgp)
1302 {
1303    struct ureg_program *ureg;
1304
1305    ureg = ureg_create_with_screen(TGSI_PROCESSOR_GEOMETRY, st->pipe->screen);
1306    if (ureg == NULL)
1307       return false;
1308
1309    ureg_property(ureg, TGSI_PROPERTY_GS_INPUT_PRIM, stgp->Base.InputType);
1310    ureg_property(ureg, TGSI_PROPERTY_GS_OUTPUT_PRIM, stgp->Base.OutputType);
1311    ureg_property(ureg, TGSI_PROPERTY_GS_MAX_OUTPUT_VERTICES,
1312                  stgp->Base.VerticesOut);
1313    ureg_property(ureg, TGSI_PROPERTY_GS_INVOCATIONS, stgp->Base.Invocations);
1314
1315    st_translate_program_common(st, &stgp->Base.Base, stgp->glsl_to_tgsi, ureg,
1316                                TGSI_PROCESSOR_GEOMETRY, &stgp->tgsi);
1317
1318    free_glsl_to_tgsi_visitor(stgp->glsl_to_tgsi);
1319    stgp->glsl_to_tgsi = NULL;
1320    return true;
1321 }
1322
1323
1324 static struct st_gp_variant *
1325 st_create_gp_variant(struct st_context *st,
1326                      struct st_geometry_program *stgp,
1327                      const struct st_gp_variant_key *key)
1328 {
1329    struct pipe_context *pipe = st->pipe;
1330    struct st_gp_variant *gpv;
1331
1332    gpv = CALLOC_STRUCT(st_gp_variant);
1333    if (!gpv)
1334       return NULL;
1335
1336    /* fill in new variant */
1337    gpv->driver_shader = pipe->create_gs_state(pipe, &stgp->tgsi);
1338    gpv->key = *key;
1339    return gpv;
1340 }
1341
1342
1343 /**
1344  * Get/create geometry program variant.
1345  */
1346 struct st_gp_variant *
1347 st_get_gp_variant(struct st_context *st,
1348                   struct st_geometry_program *stgp,
1349                   const struct st_gp_variant_key *key)
1350 {
1351    struct st_gp_variant *gpv;
1352
1353    /* Search for existing variant */
1354    for (gpv = stgp->variants; gpv; gpv = gpv->next) {
1355       if (memcmp(&gpv->key, key, sizeof(*key)) == 0) {
1356          break;
1357       }
1358    }
1359
1360    if (!gpv) {
1361       /* create new */
1362       gpv = st_create_gp_variant(st, stgp, key);
1363       if (gpv) {
1364          /* insert into list */
1365          gpv->next = stgp->variants;
1366          stgp->variants = gpv;
1367       }
1368    }
1369
1370    return gpv;
1371 }
1372
1373
1374 /**
1375  * Translate a tessellation control program to create a new variant.
1376  */
1377 bool
1378 st_translate_tessctrl_program(struct st_context *st,
1379                               struct st_tessctrl_program *sttcp)
1380 {
1381    struct ureg_program *ureg;
1382
1383    ureg = ureg_create_with_screen(TGSI_PROCESSOR_TESS_CTRL, st->pipe->screen);
1384    if (ureg == NULL)
1385       return false;
1386
1387    ureg_property(ureg, TGSI_PROPERTY_TCS_VERTICES_OUT,
1388                  sttcp->Base.VerticesOut);
1389
1390    st_translate_program_common(st, &sttcp->Base.Base, sttcp->glsl_to_tgsi,
1391                                ureg, TGSI_PROCESSOR_TESS_CTRL, &sttcp->tgsi);
1392
1393    free_glsl_to_tgsi_visitor(sttcp->glsl_to_tgsi);
1394    sttcp->glsl_to_tgsi = NULL;
1395    return true;
1396 }
1397
1398
1399 static struct st_tcp_variant *
1400 st_create_tcp_variant(struct st_context *st,
1401                       struct st_tessctrl_program *sttcp,
1402                       const struct st_tcp_variant_key *key)
1403 {
1404    struct pipe_context *pipe = st->pipe;
1405    struct st_tcp_variant *tcpv;
1406
1407    tcpv = CALLOC_STRUCT(st_tcp_variant);
1408    if (!tcpv)
1409       return NULL;
1410
1411    /* fill in new variant */
1412    tcpv->driver_shader = pipe->create_tcs_state(pipe, &sttcp->tgsi);
1413    tcpv->key = *key;
1414    return tcpv;
1415 }
1416
1417
1418 /**
1419  * Get/create tessellation control program variant.
1420  */
1421 struct st_tcp_variant *
1422 st_get_tcp_variant(struct st_context *st,
1423                   struct st_tessctrl_program *sttcp,
1424                   const struct st_tcp_variant_key *key)
1425 {
1426    struct st_tcp_variant *tcpv;
1427
1428    /* Search for existing variant */
1429    for (tcpv = sttcp->variants; tcpv; tcpv = tcpv->next) {
1430       if (memcmp(&tcpv->key, key, sizeof(*key)) == 0) {
1431          break;
1432       }
1433    }
1434
1435    if (!tcpv) {
1436       /* create new */
1437       tcpv = st_create_tcp_variant(st, sttcp, key);
1438       if (tcpv) {
1439          /* insert into list */
1440          tcpv->next = sttcp->variants;
1441          sttcp->variants = tcpv;
1442       }
1443    }
1444
1445    return tcpv;
1446 }
1447
1448
1449 /**
1450  * Translate a tessellation evaluation program to create a new variant.
1451  */
1452 bool
1453 st_translate_tesseval_program(struct st_context *st,
1454                               struct st_tesseval_program *sttep)
1455 {
1456    struct ureg_program *ureg;
1457
1458    ureg = ureg_create_with_screen(TGSI_PROCESSOR_TESS_EVAL, st->pipe->screen);
1459    if (ureg == NULL)
1460       return false;
1461
1462    if (sttep->Base.PrimitiveMode == GL_ISOLINES)
1463       ureg_property(ureg, TGSI_PROPERTY_TES_PRIM_MODE, GL_LINES);
1464    else
1465       ureg_property(ureg, TGSI_PROPERTY_TES_PRIM_MODE, sttep->Base.PrimitiveMode);
1466
1467    switch (sttep->Base.Spacing) {
1468    case GL_EQUAL:
1469       ureg_property(ureg, TGSI_PROPERTY_TES_SPACING, PIPE_TESS_SPACING_EQUAL);
1470       break;
1471    case GL_FRACTIONAL_EVEN:
1472       ureg_property(ureg, TGSI_PROPERTY_TES_SPACING,
1473                     PIPE_TESS_SPACING_FRACTIONAL_EVEN);
1474       break;
1475    case GL_FRACTIONAL_ODD:
1476       ureg_property(ureg, TGSI_PROPERTY_TES_SPACING,
1477                     PIPE_TESS_SPACING_FRACTIONAL_ODD);
1478       break;
1479    default:
1480       assert(0);
1481    }
1482
1483    ureg_property(ureg, TGSI_PROPERTY_TES_VERTEX_ORDER_CW,
1484                  sttep->Base.VertexOrder == GL_CW);
1485    ureg_property(ureg, TGSI_PROPERTY_TES_POINT_MODE, sttep->Base.PointMode);
1486
1487    st_translate_program_common(st, &sttep->Base.Base, sttep->glsl_to_tgsi,
1488                                ureg, TGSI_PROCESSOR_TESS_EVAL, &sttep->tgsi);
1489
1490    free_glsl_to_tgsi_visitor(sttep->glsl_to_tgsi);
1491    sttep->glsl_to_tgsi = NULL;
1492    return true;
1493 }
1494
1495
1496 static struct st_tep_variant *
1497 st_create_tep_variant(struct st_context *st,
1498                       struct st_tesseval_program *sttep,
1499                       const struct st_tep_variant_key *key)
1500 {
1501    struct pipe_context *pipe = st->pipe;
1502    struct st_tep_variant *tepv;
1503
1504    tepv = CALLOC_STRUCT(st_tep_variant);
1505    if (!tepv)
1506       return NULL;
1507
1508    /* fill in new variant */
1509    tepv->driver_shader = pipe->create_tes_state(pipe, &sttep->tgsi);
1510    tepv->key = *key;
1511    return tepv;
1512 }
1513
1514
1515 /**
1516  * Get/create tessellation evaluation program variant.
1517  */
1518 struct st_tep_variant *
1519 st_get_tep_variant(struct st_context *st,
1520                   struct st_tesseval_program *sttep,
1521                   const struct st_tep_variant_key *key)
1522 {
1523    struct st_tep_variant *tepv;
1524
1525    /* Search for existing variant */
1526    for (tepv = sttep->variants; tepv; tepv = tepv->next) {
1527       if (memcmp(&tepv->key, key, sizeof(*key)) == 0) {
1528          break;
1529       }
1530    }
1531
1532    if (!tepv) {
1533       /* create new */
1534       tepv = st_create_tep_variant(st, sttep, key);
1535       if (tepv) {
1536          /* insert into list */
1537          tepv->next = sttep->variants;
1538          sttep->variants = tepv;
1539       }
1540    }
1541
1542    return tepv;
1543 }
1544
1545
1546 /**
1547  * Vert/Geom/Frag programs have per-context variants.  Free all the
1548  * variants attached to the given program which match the given context.
1549  */
1550 static void
1551 destroy_program_variants(struct st_context *st, struct gl_program *program)
1552 {
1553    if (!program || program == &_mesa_DummyProgram)
1554       return;
1555
1556    switch (program->Target) {
1557    case GL_VERTEX_PROGRAM_ARB:
1558       {
1559          struct st_vertex_program *stvp = (struct st_vertex_program *) program;
1560          struct st_vp_variant *vpv, **prevPtr = &stvp->variants;
1561
1562          for (vpv = stvp->variants; vpv; ) {
1563             struct st_vp_variant *next = vpv->next;
1564             if (vpv->key.st == st) {
1565                /* unlink from list */
1566                *prevPtr = next;
1567                /* destroy this variant */
1568                delete_vp_variant(st, vpv);
1569             }
1570             else {
1571                prevPtr = &vpv->next;
1572             }
1573             vpv = next;
1574          }
1575       }
1576       break;
1577    case GL_FRAGMENT_PROGRAM_ARB:
1578       {
1579          struct st_fragment_program *stfp =
1580             (struct st_fragment_program *) program;
1581          struct st_fp_variant *fpv, **prevPtr = &stfp->variants;
1582
1583          for (fpv = stfp->variants; fpv; ) {
1584             struct st_fp_variant *next = fpv->next;
1585             if (fpv->key.st == st) {
1586                /* unlink from list */
1587                *prevPtr = next;
1588                /* destroy this variant */
1589                delete_fp_variant(st, fpv);
1590             }
1591             else {
1592                prevPtr = &fpv->next;
1593             }
1594             fpv = next;
1595          }
1596       }
1597       break;
1598    case GL_GEOMETRY_PROGRAM_NV:
1599       {
1600          struct st_geometry_program *stgp =
1601             (struct st_geometry_program *) program;
1602          struct st_gp_variant *gpv, **prevPtr = &stgp->variants;
1603
1604          for (gpv = stgp->variants; gpv; ) {
1605             struct st_gp_variant *next = gpv->next;
1606             if (gpv->key.st == st) {
1607                /* unlink from list */
1608                *prevPtr = next;
1609                /* destroy this variant */
1610                delete_gp_variant(st, gpv);
1611             }
1612             else {
1613                prevPtr = &gpv->next;
1614             }
1615             gpv = next;
1616          }
1617       }
1618       break;
1619    case GL_TESS_CONTROL_PROGRAM_NV:
1620       {
1621          struct st_tessctrl_program *sttcp =
1622             (struct st_tessctrl_program *) program;
1623          struct st_tcp_variant *tcpv, **prevPtr = &sttcp->variants;
1624
1625          for (tcpv = sttcp->variants; tcpv; ) {
1626             struct st_tcp_variant *next = tcpv->next;
1627             if (tcpv->key.st == st) {
1628                /* unlink from list */
1629                *prevPtr = next;
1630                /* destroy this variant */
1631                delete_tcp_variant(st, tcpv);
1632             }
1633             else {
1634                prevPtr = &tcpv->next;
1635             }
1636             tcpv = next;
1637          }
1638       }
1639       break;
1640    case GL_TESS_EVALUATION_PROGRAM_NV:
1641       {
1642          struct st_tesseval_program *sttep =
1643             (struct st_tesseval_program *) program;
1644          struct st_tep_variant *tepv, **prevPtr = &sttep->variants;
1645
1646          for (tepv = sttep->variants; tepv; ) {
1647             struct st_tep_variant *next = tepv->next;
1648             if (tepv->key.st == st) {
1649                /* unlink from list */
1650                *prevPtr = next;
1651                /* destroy this variant */
1652                delete_tep_variant(st, tepv);
1653             }
1654             else {
1655                prevPtr = &tepv->next;
1656             }
1657             tepv = next;
1658          }
1659       }
1660       break;
1661    default:
1662       _mesa_problem(NULL, "Unexpected program target 0x%x in "
1663                     "destroy_program_variants_cb()", program->Target);
1664    }
1665 }
1666
1667
1668 /**
1669  * Callback for _mesa_HashWalk.  Free all the shader's program variants
1670  * which match the given context.
1671  */
1672 static void
1673 destroy_shader_program_variants_cb(GLuint key, void *data, void *userData)
1674 {
1675    struct st_context *st = (struct st_context *) userData;
1676    struct gl_shader *shader = (struct gl_shader *) data;
1677
1678    switch (shader->Type) {
1679    case GL_SHADER_PROGRAM_MESA:
1680       {
1681          struct gl_shader_program *shProg = (struct gl_shader_program *) data;
1682          GLuint i;
1683
1684          for (i = 0; i < shProg->NumShaders; i++) {
1685             destroy_program_variants(st, shProg->Shaders[i]->Program);
1686          }
1687
1688          for (i = 0; i < ARRAY_SIZE(shProg->_LinkedShaders); i++) {
1689             if (shProg->_LinkedShaders[i])
1690                destroy_program_variants(st, shProg->_LinkedShaders[i]->Program);
1691          }
1692       }
1693       break;
1694    case GL_VERTEX_SHADER:
1695    case GL_FRAGMENT_SHADER:
1696    case GL_GEOMETRY_SHADER:
1697    case GL_TESS_CONTROL_SHADER:
1698    case GL_TESS_EVALUATION_SHADER:
1699       {
1700          destroy_program_variants(st, shader->Program);
1701       }
1702       break;
1703    default:
1704       assert(0);
1705    }
1706 }
1707
1708
1709 /**
1710  * Callback for _mesa_HashWalk.  Free all the program variants which match
1711  * the given context.
1712  */
1713 static void
1714 destroy_program_variants_cb(GLuint key, void *data, void *userData)
1715 {
1716    struct st_context *st = (struct st_context *) userData;
1717    struct gl_program *program = (struct gl_program *) data;
1718    destroy_program_variants(st, program);
1719 }
1720
1721
1722 /**
1723  * Walk over all shaders and programs to delete any variants which
1724  * belong to the given context.
1725  * This is called during context tear-down.
1726  */
1727 void
1728 st_destroy_program_variants(struct st_context *st)
1729 {
1730    /* If shaders can be shared with other contexts, the last context will
1731     * call DeleteProgram on all shaders, releasing everything.
1732     */
1733    if (st->has_shareable_shaders)
1734       return;
1735
1736    /* ARB vert/frag program */
1737    _mesa_HashWalk(st->ctx->Shared->Programs,
1738                   destroy_program_variants_cb, st);
1739
1740    /* GLSL vert/frag/geom shaders */
1741    _mesa_HashWalk(st->ctx->Shared->ShaderObjects,
1742                   destroy_shader_program_variants_cb, st);
1743 }
1744
1745
1746 /**
1747  * For debugging, print/dump the current vertex program.
1748  */
1749 void
1750 st_print_current_vertex_program(void)
1751 {
1752    GET_CURRENT_CONTEXT(ctx);
1753
1754    if (ctx->VertexProgram._Current) {
1755       struct st_vertex_program *stvp =
1756          (struct st_vertex_program *) ctx->VertexProgram._Current;
1757       struct st_vp_variant *stv;
1758
1759       debug_printf("Vertex program %u\n", stvp->Base.Base.Id);
1760
1761       for (stv = stvp->variants; stv; stv = stv->next) {
1762          debug_printf("variant %p\n", stv);
1763          tgsi_dump(stv->tgsi.tokens, 0);
1764       }
1765    }
1766 }
1767
1768
1769 /**
1770  * Compile one shader variant.
1771  */
1772 void
1773 st_precompile_shader_variant(struct st_context *st,
1774                              struct gl_program *prog)
1775 {
1776    switch (prog->Target) {
1777    case GL_VERTEX_PROGRAM_ARB: {
1778       struct st_vertex_program *p = (struct st_vertex_program *)prog;
1779       struct st_vp_variant_key key;
1780
1781       memset(&key, 0, sizeof(key));
1782       key.st = st->has_shareable_shaders ? NULL : st;
1783       st_get_vp_variant(st, p, &key);
1784       break;
1785    }
1786
1787    case GL_TESS_CONTROL_PROGRAM_NV: {
1788       struct st_tessctrl_program *p = (struct st_tessctrl_program *)prog;
1789       struct st_tcp_variant_key key;
1790
1791       memset(&key, 0, sizeof(key));
1792       key.st = st->has_shareable_shaders ? NULL : st;
1793       st_get_tcp_variant(st, p, &key);
1794       break;
1795    }
1796
1797    case GL_TESS_EVALUATION_PROGRAM_NV: {
1798       struct st_tesseval_program *p = (struct st_tesseval_program *)prog;
1799       struct st_tep_variant_key key;
1800
1801       memset(&key, 0, sizeof(key));
1802       key.st = st->has_shareable_shaders ? NULL : st;
1803       st_get_tep_variant(st, p, &key);
1804       break;
1805    }
1806
1807    case GL_GEOMETRY_PROGRAM_NV: {
1808       struct st_geometry_program *p = (struct st_geometry_program *)prog;
1809       struct st_gp_variant_key key;
1810
1811       memset(&key, 0, sizeof(key));
1812       key.st = st->has_shareable_shaders ? NULL : st;
1813       st_get_gp_variant(st, p, &key);
1814       break;
1815    }
1816
1817    case GL_FRAGMENT_PROGRAM_ARB: {
1818       struct st_fragment_program *p = (struct st_fragment_program *)prog;
1819       struct st_fp_variant_key key;
1820
1821       memset(&key, 0, sizeof(key));
1822       key.st = st->has_shareable_shaders ? NULL : st;
1823       st_get_fp_variant(st, p, &key);
1824       break;
1825    }
1826
1827    default:
1828       assert(0);
1829    }
1830 }