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