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