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