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