src/mesa/state_tracker/st_program.c

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