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