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