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
 874    if (!variant)
 875       return NULL;
 876
 877    tgsi.tokens = stfp->tgsi.tokens;
 878
 879    assert(!(key->bitmap && key->drawpixels));
 880
 881    /* Fix texture targets and add fog for ATI_fs */
 882    if (stfp->ati_fs) {
 883       const struct tgsi_token *tokens = st_fixup_atifs(tgsi.tokens, key);
 884
 885       if (tokens)
 886          tgsi.tokens = tokens;
 887       else
 888          fprintf(stderr, "mesa: cannot post-process ATI_fs\n");
 889    }
 890
 891    /* Emulate features. */
 892    if (key->clamp_color || key->persample_shading) {
 893       const struct tgsi_token *tokens;
 894       unsigned flags =
 895          (key->clamp_color ? TGSI_EMU_CLAMP_COLOR_OUTPUTS : 0) |
 896          (key->persample_shading ? TGSI_EMU_FORCE_PERSAMPLE_INTERP : 0);
 897
 898       tokens = tgsi_emulate(tgsi.tokens, flags);
 899
 900       if (tokens) {
 901          if (tgsi.tokens != stfp->tgsi.tokens)
 902             tgsi_free_tokens(tgsi.tokens);
 903          tgsi.tokens = tokens;
 904       } else
 905          fprintf(stderr, "mesa: cannot emulate deprecated features\n");
 906    }
 907
 908    /* glBitmap */
 909    if (key->bitmap) {
 910       const struct tgsi_token *tokens;
 911
 912       variant->bitmap_sampler = ffs(~stfp->Base.Base.SamplersUsed) - 1;
 913
 914       tokens = st_get_bitmap_shader(tgsi.tokens,
 915                                     st->internal_target,
 916                                     variant->bitmap_sampler,
 917                                     st->needs_texcoord_semantic,
 918                                     st->bitmap.tex_format ==
 919                                     PIPE_FORMAT_L8_UNORM);
 920
 921       if (tokens) {
 922          if (tgsi.tokens != stfp->tgsi.tokens)
 923             tgsi_free_tokens(tgsi.tokens);
 924          tgsi.tokens = tokens;
 925       } else
 926          fprintf(stderr, "mesa: cannot create a shader for glBitmap\n");
 927    }
 928
 929    /* glDrawPixels (color only) */
 930    if (key->drawpixels) {
 931       const struct tgsi_token *tokens;
 932       unsigned scale_const = 0, bias_const = 0, texcoord_const = 0;
 933       struct gl_program_parameter_list *params = stfp->Base.Base.Parameters;
 934
 935       /* Find the first unused slot. */
 936       variant->drawpix_sampler = ffs(~stfp->Base.Base.SamplersUsed) - 1;
 937
 938       if (key->pixelMaps) {
 939          unsigned samplers_used = stfp->Base.Base.SamplersUsed |
 940                                   (1 << variant->drawpix_sampler);
 941
 942          variant->pixelmap_sampler = ffs(~samplers_used) - 1;
 943       }
 944
 945       if (key->scaleAndBias) {
 946          static const gl_state_index scale_state[STATE_LENGTH] =
 947             { STATE_INTERNAL, STATE_PT_SCALE };
 948          static const gl_state_index bias_state[STATE_LENGTH] =
 949             { STATE_INTERNAL, STATE_PT_BIAS };
 950
 951          scale_const = _mesa_add_state_reference(params, scale_state);
 952          bias_const = _mesa_add_state_reference(params, bias_state);
 953       }
 954
 955       {
 956          static const gl_state_index state[STATE_LENGTH] =
 957             { STATE_INTERNAL, STATE_CURRENT_ATTRIB, VERT_ATTRIB_TEX0 };
 958
 959          texcoord_const = _mesa_add_state_reference(params, state);
 960       }
 961
 962       tokens = st_get_drawpix_shader(tgsi.tokens,
 963                                      st->needs_texcoord_semantic,
 964                                      key->scaleAndBias, scale_const,
 965                                      bias_const, key->pixelMaps,
 966                                      variant->drawpix_sampler,
 967                                      variant->pixelmap_sampler,
 968                                      texcoord_const, st->internal_target);
 969
 970       if (tokens) {
 971          if (tgsi.tokens != stfp->tgsi.tokens)
 972             tgsi_free_tokens(tgsi.tokens);
 973          tgsi.tokens = tokens;
 974       } else
 975          fprintf(stderr, "mesa: cannot create a shader for glDrawPixels\n");
 976    }
 977
 978    if (ST_DEBUG & DEBUG_TGSI) {
 979       tgsi_dump(tgsi.tokens, 0);
 980       debug_printf("\n");
 981    }
 982
 983    /* fill in variant */
 984    variant->driver_shader = pipe->create_fs_state(pipe, &tgsi);
 985    variant->key = *key;
 986
 987    if (tgsi.tokens != stfp->tgsi.tokens)
 988       tgsi_free_tokens(tgsi.tokens);
 989    return variant;
 990 }
 991
 992 /**
 993  * Translate fragment program if needed.
 994  */
 995 struct st_fp_variant *
 996 st_get_fp_variant(struct st_context *st,
 997                   struct st_fragment_program *stfp,
 998                   const struct st_fp_variant_key *key)
 999 {
1000    struct st_fp_variant *fpv;
1001
1002    /* Search for existing variant */
1003    for (fpv = stfp->variants; fpv; fpv = fpv->next) {
1004       if (memcmp(&fpv->key, key, sizeof(*key)) == 0) {
1005          break;
1006       }
1007    }
1008
1009    if (!fpv) {
1010       /* create new */
1011       fpv = st_create_fp_variant(st, stfp, key);
1012       if (fpv) {
1013          /* insert into list */
1014          fpv->next = stfp->variants;
1015          stfp->variants = fpv;
1016       }
1017    }
1018
1019    return fpv;
1020 }
1021
1022
1023 /**
1024  * Translate a program. This is common code for geometry and tessellation
1025  * shaders.
1026  */
1027 static void
1028 st_translate_program_common(struct st_context *st,
1029                             struct gl_program *prog,
1030                             struct glsl_to_tgsi_visitor *glsl_to_tgsi,
1031                             struct ureg_program *ureg,
1032                             unsigned tgsi_processor,
1033                             struct pipe_shader_state *out_state)
1034 {
1035    GLuint inputSlotToAttr[VARYING_SLOT_TESS_MAX];
1036    GLuint inputMapping[VARYING_SLOT_TESS_MAX];
1037    GLuint outputSlotToAttr[VARYING_SLOT_TESS_MAX];
1038    GLuint outputMapping[VARYING_SLOT_TESS_MAX];
1039    GLuint attr;
1040
1041    ubyte input_semantic_name[PIPE_MAX_SHADER_INPUTS];
1042    ubyte input_semantic_index[PIPE_MAX_SHADER_INPUTS];
1043    uint num_inputs = 0;
1044
1045    ubyte output_semantic_name[PIPE_MAX_SHADER_OUTPUTS];
1046    ubyte output_semantic_index[PIPE_MAX_SHADER_OUTPUTS];
1047    uint num_outputs = 0;
1048
1049    GLint i;
1050
1051    memset(inputSlotToAttr, 0, sizeof(inputSlotToAttr));
1052    memset(inputMapping, 0, sizeof(inputMapping));
1053    memset(outputSlotToAttr, 0, sizeof(outputSlotToAttr));
1054    memset(outputMapping, 0, sizeof(outputMapping));
1055    memset(out_state, 0, sizeof(*out_state));
1056
1057    if (prog->ClipDistanceArraySize)
1058       ureg_property(ureg, TGSI_PROPERTY_NUM_CLIPDIST_ENABLED,
1059                     prog->ClipDistanceArraySize);
1060    if (prog->CullDistanceArraySize)
1061       ureg_property(ureg, TGSI_PROPERTY_NUM_CULLDIST_ENABLED,
1062                     prog->CullDistanceArraySize);
1063
1064    /*
1065     * Convert Mesa program inputs to TGSI input register semantics.
1066     */
1067    for (attr = 0; attr < VARYING_SLOT_MAX; attr++) {
1068       if ((prog->InputsRead & BITFIELD64_BIT(attr)) != 0) {
1069          const GLuint slot = num_inputs++;
1070
1071          inputMapping[attr] = slot;
1072          inputSlotToAttr[slot] = attr;
1073
1074          switch (attr) {
1075          case VARYING_SLOT_PRIMITIVE_ID:
1076             assert(tgsi_processor == PIPE_SHADER_GEOMETRY);
1077             input_semantic_name[slot] = TGSI_SEMANTIC_PRIMID;
1078             input_semantic_index[slot] = 0;
1079             break;
1080          case VARYING_SLOT_POS:
1081             input_semantic_name[slot] = TGSI_SEMANTIC_POSITION;
1082             input_semantic_index[slot] = 0;
1083             break;
1084          case VARYING_SLOT_COL0:
1085             input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
1086             input_semantic_index[slot] = 0;
1087             break;
1088          case VARYING_SLOT_COL1:
1089             input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
1090             input_semantic_index[slot] = 1;
1091             break;
1092          case VARYING_SLOT_FOGC:
1093             input_semantic_name[slot] = TGSI_SEMANTIC_FOG;
1094             input_semantic_index[slot] = 0;
1095             break;
1096          case VARYING_SLOT_CLIP_VERTEX:
1097             input_semantic_name[slot] = TGSI_SEMANTIC_CLIPVERTEX;
1098             input_semantic_index[slot] = 0;
1099             break;
1100          case VARYING_SLOT_CLIP_DIST0:
1101             input_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
1102             input_semantic_index[slot] = 0;
1103             break;
1104          case VARYING_SLOT_CLIP_DIST1:
1105             input_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
1106             input_semantic_index[slot] = 1;
1107             break;
1108          case VARYING_SLOT_CULL_DIST0:
1109          case VARYING_SLOT_CULL_DIST1:
1110             /* these should have been lowered by GLSL */
1111             assert(0);
1112             break;
1113          case VARYING_SLOT_PSIZ:
1114             input_semantic_name[slot] = TGSI_SEMANTIC_PSIZE;
1115             input_semantic_index[slot] = 0;
1116             break;
1117          case VARYING_SLOT_TEX0:
1118          case VARYING_SLOT_TEX1:
1119          case VARYING_SLOT_TEX2:
1120          case VARYING_SLOT_TEX3:
1121          case VARYING_SLOT_TEX4:
1122          case VARYING_SLOT_TEX5:
1123          case VARYING_SLOT_TEX6:
1124          case VARYING_SLOT_TEX7:
1125             if (st->needs_texcoord_semantic) {
1126                input_semantic_name[slot] = TGSI_SEMANTIC_TEXCOORD;
1127                input_semantic_index[slot] = attr - VARYING_SLOT_TEX0;
1128                break;
1129             }
1130             /* fall through */
1131          case VARYING_SLOT_VAR0:
1132          default:
1133             assert(attr >= VARYING_SLOT_VAR0 ||
1134                    (attr >= VARYING_SLOT_TEX0 && attr <= VARYING_SLOT_TEX7));
1135             input_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
1136             input_semantic_index[slot] =
1137                st_get_generic_varying_index(st, attr);
1138             break;
1139          }
1140       }
1141    }
1142
1143    /* Also add patch inputs. */
1144    for (attr = 0; attr < 32; attr++) {
1145       if (prog->PatchInputsRead & (1u << attr)) {
1146          GLuint slot = num_inputs++;
1147          GLuint patch_attr = VARYING_SLOT_PATCH0 + attr;
1148
1149          inputMapping[patch_attr] = slot;
1150          inputSlotToAttr[slot] = patch_attr;
1151          input_semantic_name[slot] = TGSI_SEMANTIC_PATCH;
1152          input_semantic_index[slot] = attr;
1153       }
1154    }
1155
1156    /* initialize output semantics to defaults */
1157    for (i = 0; i < PIPE_MAX_SHADER_OUTPUTS; i++) {
1158       output_semantic_name[i] = TGSI_SEMANTIC_GENERIC;
1159       output_semantic_index[i] = 0;
1160    }
1161
1162    /*
1163     * Determine number of outputs, the (default) output register
1164     * mapping and the semantic information for each output.
1165     */
1166    for (attr = 0; attr < VARYING_SLOT_MAX; attr++) {
1167       if (prog->OutputsWritten & BITFIELD64_BIT(attr)) {
1168          GLuint slot = num_outputs++;
1169
1170          outputMapping[attr] = slot;
1171          outputSlotToAttr[slot] = attr;
1172
1173          switch (attr) {
1174          case VARYING_SLOT_POS:
1175             assert(slot == 0);
1176             output_semantic_name[slot] = TGSI_SEMANTIC_POSITION;
1177             output_semantic_index[slot] = 0;
1178             break;
1179          case VARYING_SLOT_COL0:
1180             output_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
1181             output_semantic_index[slot] = 0;
1182             break;
1183          case VARYING_SLOT_COL1:
1184             output_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
1185             output_semantic_index[slot] = 1;
1186             break;
1187          case VARYING_SLOT_BFC0:
1188             output_semantic_name[slot] = TGSI_SEMANTIC_BCOLOR;
1189             output_semantic_index[slot] = 0;
1190             break;
1191          case VARYING_SLOT_BFC1:
1192             output_semantic_name[slot] = TGSI_SEMANTIC_BCOLOR;
1193             output_semantic_index[slot] = 1;
1194             break;
1195          case VARYING_SLOT_FOGC:
1196             output_semantic_name[slot] = TGSI_SEMANTIC_FOG;
1197             output_semantic_index[slot] = 0;
1198             break;
1199          case VARYING_SLOT_PSIZ:
1200             output_semantic_name[slot] = TGSI_SEMANTIC_PSIZE;
1201             output_semantic_index[slot] = 0;
1202             break;
1203          case VARYING_SLOT_CLIP_VERTEX:
1204             output_semantic_name[slot] = TGSI_SEMANTIC_CLIPVERTEX;
1205             output_semantic_index[slot] = 0;
1206             break;
1207          case VARYING_SLOT_CLIP_DIST0:
1208             output_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
1209             output_semantic_index[slot] = 0;
1210             break;
1211          case VARYING_SLOT_CLIP_DIST1:
1212             output_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
1213             output_semantic_index[slot] = 1;
1214             break;
1215          case VARYING_SLOT_CULL_DIST0:
1216          case VARYING_SLOT_CULL_DIST1:
1217             /* these should have been lowered by GLSL */
1218             assert(0);
1219             break;
1220          case VARYING_SLOT_LAYER:
1221             output_semantic_name[slot] = TGSI_SEMANTIC_LAYER;
1222             output_semantic_index[slot] = 0;
1223             break;
1224          case VARYING_SLOT_PRIMITIVE_ID:
1225             output_semantic_name[slot] = TGSI_SEMANTIC_PRIMID;
1226             output_semantic_index[slot] = 0;
1227             break;
1228          case VARYING_SLOT_VIEWPORT:
1229             output_semantic_name[slot] = TGSI_SEMANTIC_VIEWPORT_INDEX;
1230             output_semantic_index[slot] = 0;
1231             break;
1232          case VARYING_SLOT_TESS_LEVEL_OUTER:
1233             output_semantic_name[slot] = TGSI_SEMANTIC_TESSOUTER;
1234             output_semantic_index[slot] = 0;
1235             break;
1236          case VARYING_SLOT_TESS_LEVEL_INNER:
1237             output_semantic_name[slot] = TGSI_SEMANTIC_TESSINNER;
1238             output_semantic_index[slot] = 0;
1239             break;
1240          case VARYING_SLOT_TEX0:
1241          case VARYING_SLOT_TEX1:
1242          case VARYING_SLOT_TEX2:
1243          case VARYING_SLOT_TEX3:
1244          case VARYING_SLOT_TEX4:
1245          case VARYING_SLOT_TEX5:
1246          case VARYING_SLOT_TEX6:
1247          case VARYING_SLOT_TEX7:
1248             if (st->needs_texcoord_semantic) {
1249                output_semantic_name[slot] = TGSI_SEMANTIC_TEXCOORD;
1250                output_semantic_index[slot] = attr - VARYING_SLOT_TEX0;
1251                break;
1252             }
1253             /* fall through */
1254          case VARYING_SLOT_VAR0:
1255          default:
1256             assert(slot < ARRAY_SIZE(output_semantic_name));
1257             assert(attr >= VARYING_SLOT_VAR0 ||
1258                    (attr >= VARYING_SLOT_TEX0 && attr <= VARYING_SLOT_TEX7));
1259             output_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
1260             output_semantic_index[slot] =
1261                st_get_generic_varying_index(st, attr);
1262             break;
1263          }
1264       }
1265    }
1266
1267    /* Also add patch outputs. */
1268    for (attr = 0; attr < 32; attr++) {
1269       if (prog->PatchOutputsWritten & (1u << attr)) {
1270          GLuint slot = num_outputs++;
1271          GLuint patch_attr = VARYING_SLOT_PATCH0 + attr;
1272
1273          outputMapping[patch_attr] = slot;
1274          outputSlotToAttr[slot] = patch_attr;
1275          output_semantic_name[slot] = TGSI_SEMANTIC_PATCH;
1276          output_semantic_index[slot] = attr;
1277       }
1278    }
1279
1280    st_translate_program(st->ctx,
1281                         tgsi_processor,
1282                         ureg,
1283                         glsl_to_tgsi,
1284                         prog,
1285                         /* inputs */
1286                         num_inputs,
1287                         inputMapping,
1288                         inputSlotToAttr,
1289                         input_semantic_name,
1290                         input_semantic_index,
1291                         NULL,
1292                         NULL,
1293                         /* outputs */
1294                         num_outputs,
1295                         outputMapping,
1296                         outputSlotToAttr,
1297                         output_semantic_name,
1298                         output_semantic_index);
1299
1300    out_state->tokens = ureg_get_tokens(ureg, NULL);
1301    ureg_destroy(ureg);
1302
1303    st_translate_stream_output_info(glsl_to_tgsi,
1304                                    outputMapping,
1305                                    &out_state->stream_output);
1306
1307    if ((ST_DEBUG & DEBUG_TGSI) && (ST_DEBUG & DEBUG_MESA)) {
1308       _mesa_print_program(prog);
1309       debug_printf("\n");
1310    }
1311
1312    if (ST_DEBUG & DEBUG_TGSI) {
1313       tgsi_dump(out_state->tokens, 0);
1314       debug_printf("\n");
1315    }
1316 }
1317
1318
1319 /**
1320  * Translate a geometry program to create a new variant.
1321  */
1322 bool
1323 st_translate_geometry_program(struct st_context *st,
1324                               struct st_geometry_program *stgp)
1325 {
1326    struct ureg_program *ureg;
1327
1328    ureg = ureg_create_with_screen(PIPE_SHADER_GEOMETRY, st->pipe->screen);
1329    if (ureg == NULL)
1330       return false;
1331
1332    ureg_property(ureg, TGSI_PROPERTY_GS_INPUT_PRIM, stgp->Base.InputType);
1333    ureg_property(ureg, TGSI_PROPERTY_GS_OUTPUT_PRIM, stgp->Base.OutputType);
1334    ureg_property(ureg, TGSI_PROPERTY_GS_MAX_OUTPUT_VERTICES,
1335                  stgp->Base.VerticesOut);
1336    ureg_property(ureg, TGSI_PROPERTY_GS_INVOCATIONS, stgp->Base.Invocations);
1337
1338    st_translate_program_common(st, &stgp->Base.Base, stgp->glsl_to_tgsi, ureg,
1339                                PIPE_SHADER_GEOMETRY, &stgp->tgsi);
1340
1341    free_glsl_to_tgsi_visitor(stgp->glsl_to_tgsi);
1342    stgp->glsl_to_tgsi = NULL;
1343    return true;
1344 }
1345
1346
1347 /**
1348  * Get/create a basic program variant.
1349  */
1350 struct st_basic_variant *
1351 st_get_basic_variant(struct st_context *st,
1352                      unsigned pipe_shader,
1353                      struct pipe_shader_state *tgsi,
1354                      struct st_basic_variant **variants)
1355 {
1356    struct pipe_context *pipe = st->pipe;
1357    struct st_basic_variant *v;
1358    struct st_basic_variant_key key;
1359
1360    memset(&key, 0, sizeof(key));
1361    key.st = st->has_shareable_shaders ? NULL : st;
1362
1363    /* Search for existing variant */
1364    for (v = *variants; v; v = v->next) {
1365       if (memcmp(&v->key, &key, sizeof(key)) == 0) {
1366          break;
1367       }
1368    }
1369
1370    if (!v) {
1371       /* create new */
1372       v = CALLOC_STRUCT(st_basic_variant);
1373       if (v) {
1374          /* fill in new variant */
1375          switch (pipe_shader) {
1376          case PIPE_SHADER_TESS_CTRL:
1377             v->driver_shader = pipe->create_tcs_state(pipe, tgsi);
1378             break;
1379          case PIPE_SHADER_TESS_EVAL:
1380             v->driver_shader = pipe->create_tes_state(pipe, tgsi);
1381             break;
1382          case PIPE_SHADER_GEOMETRY:
1383             v->driver_shader = pipe->create_gs_state(pipe, tgsi);
1384             break;
1385          default:
1386             assert(!"unhandled shader type");
1387             free(v);
1388             return NULL;
1389          }
1390
1391          v->key = key;
1392
1393          /* insert into list */
1394          v->next = *variants;
1395          *variants = v;
1396       }
1397    }
1398
1399    return v;
1400 }
1401
1402
1403 /**
1404  * Translate a tessellation control program to create a new variant.
1405  */
1406 bool
1407 st_translate_tessctrl_program(struct st_context *st,
1408                               struct st_tessctrl_program *sttcp)
1409 {
1410    struct ureg_program *ureg;
1411
1412    ureg = ureg_create_with_screen(PIPE_SHADER_TESS_CTRL, st->pipe->screen);
1413    if (ureg == NULL)
1414       return false;
1415
1416    ureg_property(ureg, TGSI_PROPERTY_TCS_VERTICES_OUT,
1417                  sttcp->Base.VerticesOut);
1418
1419    st_translate_program_common(st, &sttcp->Base.Base, sttcp->glsl_to_tgsi,
1420                                ureg, PIPE_SHADER_TESS_CTRL, &sttcp->tgsi);
1421
1422    free_glsl_to_tgsi_visitor(sttcp->glsl_to_tgsi);
1423    sttcp->glsl_to_tgsi = NULL;
1424    return true;
1425 }
1426
1427
1428 /**
1429  * Translate a tessellation evaluation program to create a new variant.
1430  */
1431 bool
1432 st_translate_tesseval_program(struct st_context *st,
1433                               struct st_tesseval_program *sttep)
1434 {
1435    struct ureg_program *ureg;
1436
1437    ureg = ureg_create_with_screen(PIPE_SHADER_TESS_EVAL, st->pipe->screen);
1438    if (ureg == NULL)
1439       return false;
1440
1441    if (sttep->Base.PrimitiveMode == GL_ISOLINES)
1442       ureg_property(ureg, TGSI_PROPERTY_TES_PRIM_MODE, GL_LINES);
1443    else
1444       ureg_property(ureg, TGSI_PROPERTY_TES_PRIM_MODE, sttep->Base.PrimitiveMode);
1445
1446    switch (sttep->Base.Spacing) {
1447    case GL_EQUAL:
1448       ureg_property(ureg, TGSI_PROPERTY_TES_SPACING, PIPE_TESS_SPACING_EQUAL);
1449       break;
1450    case GL_FRACTIONAL_EVEN:
1451       ureg_property(ureg, TGSI_PROPERTY_TES_SPACING,
1452                     PIPE_TESS_SPACING_FRACTIONAL_EVEN);
1453       break;
1454    case GL_FRACTIONAL_ODD:
1455       ureg_property(ureg, TGSI_PROPERTY_TES_SPACING,
1456                     PIPE_TESS_SPACING_FRACTIONAL_ODD);
1457       break;
1458    default:
1459       assert(0);
1460    }
1461
1462    ureg_property(ureg, TGSI_PROPERTY_TES_VERTEX_ORDER_CW,
1463                  sttep->Base.VertexOrder == GL_CW);
1464    ureg_property(ureg, TGSI_PROPERTY_TES_POINT_MODE, sttep->Base.PointMode);
1465
1466    st_translate_program_common(st, &sttep->Base.Base, sttep->glsl_to_tgsi,
1467                                ureg, PIPE_SHADER_TESS_EVAL, &sttep->tgsi);
1468
1469    free_glsl_to_tgsi_visitor(sttep->glsl_to_tgsi);
1470    sttep->glsl_to_tgsi = NULL;
1471    return true;
1472 }
1473
1474
1475 /**
1476  * Translate a compute program to create a new variant.
1477  */
1478 bool
1479 st_translate_compute_program(struct st_context *st,
1480                              struct st_compute_program *stcp)
1481 {
1482    struct ureg_program *ureg;
1483    struct pipe_shader_state prog;
1484
1485    ureg = ureg_create_with_screen(PIPE_SHADER_COMPUTE, st->pipe->screen);
1486    if (ureg == NULL)
1487       return false;
1488
1489    st_translate_program_common(st, &stcp->Base.Base, stcp->glsl_to_tgsi, ureg,
1490                                PIPE_SHADER_COMPUTE, &prog);
1491
1492    stcp->tgsi.ir_type = PIPE_SHADER_IR_TGSI;
1493    stcp->tgsi.prog = prog.tokens;
1494    stcp->tgsi.req_local_mem = stcp->Base.SharedSize;
1495    stcp->tgsi.req_private_mem = 0;
1496    stcp->tgsi.req_input_mem = 0;
1497
1498    free_glsl_to_tgsi_visitor(stcp->glsl_to_tgsi);
1499    stcp->glsl_to_tgsi = NULL;
1500    return true;
1501 }
1502
1503
1504 /**
1505  * Get/create compute program variant.
1506  */
1507 struct st_basic_variant *
1508 st_get_cp_variant(struct st_context *st,
1509                   struct pipe_compute_state *tgsi,
1510                   struct st_basic_variant **variants)
1511 {
1512    struct pipe_context *pipe = st->pipe;
1513    struct st_basic_variant *v;
1514    struct st_basic_variant_key key;
1515
1516    memset(&key, 0, sizeof(key));
1517    key.st = st->has_shareable_shaders ? NULL : st;
1518
1519    /* Search for existing variant */
1520    for (v = *variants; v; v = v->next) {
1521       if (memcmp(&v->key, &key, sizeof(key)) == 0) {
1522          break;
1523       }
1524    }
1525
1526    if (!v) {
1527       /* create new */
1528       v = CALLOC_STRUCT(st_basic_variant);
1529       if (v) {
1530          /* fill in new variant */
1531          v->driver_shader = pipe->create_compute_state(pipe, tgsi);
1532          v->key = key;
1533
1534          /* insert into list */
1535          v->next = *variants;
1536          *variants = v;
1537       }
1538    }
1539
1540    return v;
1541 }
1542
1543
1544 /**
1545  * Vert/Geom/Frag programs have per-context variants.  Free all the
1546  * variants attached to the given program which match the given context.
1547  */
1548 static void
1549 destroy_program_variants(struct st_context *st, struct gl_program *target)
1550 {
1551    if (!target || target == &_mesa_DummyProgram)
1552       return;
1553
1554    switch (target->Target) {
1555    case GL_VERTEX_PROGRAM_ARB:
1556       {
1557          struct st_vertex_program *stvp = (struct st_vertex_program *) target;
1558          struct st_vp_variant *vpv, **prevPtr = &stvp->variants;
1559
1560          for (vpv = stvp->variants; vpv; ) {
1561             struct st_vp_variant *next = vpv->next;
1562             if (vpv->key.st == st) {
1563                /* unlink from list */
1564                *prevPtr = next;
1565                /* destroy this variant */
1566                delete_vp_variant(st, vpv);
1567             }
1568             else {
1569                prevPtr = &vpv->next;
1570             }
1571             vpv = next;
1572          }
1573       }
1574       break;
1575    case GL_FRAGMENT_PROGRAM_ARB:
1576       {
1577          struct st_fragment_program *stfp =
1578             (struct st_fragment_program *) target;
1579          struct st_fp_variant *fpv, **prevPtr = &stfp->variants;
1580
1581          for (fpv = stfp->variants; fpv; ) {
1582             struct st_fp_variant *next = fpv->next;
1583             if (fpv->key.st == st) {
1584                /* unlink from list */
1585                *prevPtr = next;
1586                /* destroy this variant */
1587                delete_fp_variant(st, fpv);
1588             }
1589             else {
1590                prevPtr = &fpv->next;
1591             }
1592             fpv = next;
1593          }
1594       }
1595       break;
1596    case GL_GEOMETRY_PROGRAM_NV:
1597    case GL_TESS_CONTROL_PROGRAM_NV:
1598    case GL_TESS_EVALUATION_PROGRAM_NV:
1599    case GL_COMPUTE_PROGRAM_NV:
1600       {
1601          struct st_geometry_program *gp = (struct st_geometry_program*)target;
1602          struct st_tessctrl_program *tcp = (struct st_tessctrl_program*)target;
1603          struct st_tesseval_program *tep = (struct st_tesseval_program*)target;
1604          struct st_compute_program *cp = (struct st_compute_program*)target;
1605          struct st_basic_variant **variants =
1606             target->Target == GL_GEOMETRY_PROGRAM_NV ? &gp->variants :
1607             target->Target == GL_TESS_CONTROL_PROGRAM_NV ? &tcp->variants :
1608             target->Target == GL_TESS_EVALUATION_PROGRAM_NV ? &tep->variants :
1609             target->Target == GL_COMPUTE_PROGRAM_NV ? &cp->variants :
1610             NULL;
1611          struct st_basic_variant *v, **prevPtr = variants;
1612
1613          for (v = *variants; v; ) {
1614             struct st_basic_variant *next = v->next;
1615             if (v->key.st == st) {
1616                /* unlink from list */
1617                *prevPtr = next;
1618                /* destroy this variant */
1619                delete_basic_variant(st, v, target->Target);
1620             }
1621             else {
1622                prevPtr = &v->next;
1623             }
1624             v = next;
1625          }
1626       }
1627       break;
1628    default:
1629       _mesa_problem(NULL, "Unexpected program target 0x%x in "
1630                     "destroy_program_variants_cb()", target->Target);
1631    }
1632 }
1633
1634
1635 /**
1636  * Callback for _mesa_HashWalk.  Free all the shader's program variants
1637  * which match the given context.
1638  */
1639 static void
1640 destroy_shader_program_variants_cb(GLuint key, void *data, void *userData)
1641 {
1642    struct st_context *st = (struct st_context *) userData;
1643    struct gl_shader *shader = (struct gl_shader *) data;
1644
1645    switch (shader->Type) {
1646    case GL_SHADER_PROGRAM_MESA:
1647       {
1648          struct gl_shader_program *shProg = (struct gl_shader_program *) data;
1649          GLuint i;
1650
1651          for (i = 0; i < shProg->NumShaders; i++) {
1652             destroy_program_variants(st, shProg->Shaders[i]->Program);
1653          }
1654
1655          for (i = 0; i < ARRAY_SIZE(shProg->_LinkedShaders); i++) {
1656             if (shProg->_LinkedShaders[i])
1657                destroy_program_variants(st, shProg->_LinkedShaders[i]->Program);
1658          }
1659       }
1660       break;
1661    case GL_VERTEX_SHADER:
1662    case GL_FRAGMENT_SHADER:
1663    case GL_GEOMETRY_SHADER:
1664    case GL_TESS_CONTROL_SHADER:
1665    case GL_TESS_EVALUATION_SHADER:
1666    case GL_COMPUTE_SHADER:
1667       {
1668          destroy_program_variants(st, shader->Program);
1669       }
1670       break;
1671    default:
1672       assert(0);
1673    }
1674 }
1675
1676
1677 /**
1678  * Callback for _mesa_HashWalk.  Free all the program variants which match
1679  * the given context.
1680  */
1681 static void
1682 destroy_program_variants_cb(GLuint key, void *data, void *userData)
1683 {
1684    struct st_context *st = (struct st_context *) userData;
1685    struct gl_program *program = (struct gl_program *) data;
1686    destroy_program_variants(st, program);
1687 }
1688
1689
1690 /**
1691  * Walk over all shaders and programs to delete any variants which
1692  * belong to the given context.
1693  * This is called during context tear-down.
1694  */
1695 void
1696 st_destroy_program_variants(struct st_context *st)
1697 {
1698    /* If shaders can be shared with other contexts, the last context will
1699     * call DeleteProgram on all shaders, releasing everything.
1700     */
1701    if (st->has_shareable_shaders)
1702       return;
1703
1704    /* ARB vert/frag program */
1705    _mesa_HashWalk(st->ctx->Shared->Programs,
1706                   destroy_program_variants_cb, st);
1707
1708    /* GLSL vert/frag/geom shaders */
1709    _mesa_HashWalk(st->ctx->Shared->ShaderObjects,
1710                   destroy_shader_program_variants_cb, st);
1711 }
1712
1713
1714 /**
1715  * For debugging, print/dump the current vertex program.
1716  */
1717 void
1718 st_print_current_vertex_program(void)
1719 {
1720    GET_CURRENT_CONTEXT(ctx);
1721
1722    if (ctx->VertexProgram._Current) {
1723       struct st_vertex_program *stvp =
1724          (struct st_vertex_program *) ctx->VertexProgram._Current;
1725       struct st_vp_variant *stv;
1726
1727       debug_printf("Vertex program %u\n", stvp->Base.Base.Id);
1728
1729       for (stv = stvp->variants; stv; stv = stv->next) {
1730          debug_printf("variant %p\n", stv);
1731          tgsi_dump(stv->tgsi.tokens, 0);
1732       }
1733    }
1734 }
1735
1736
1737 /**
1738  * Compile one shader variant.
1739  */
1740 void
1741 st_precompile_shader_variant(struct st_context *st,
1742                              struct gl_program *prog)
1743 {
1744    switch (prog->Target) {
1745    case GL_VERTEX_PROGRAM_ARB: {
1746       struct st_vertex_program *p = (struct st_vertex_program *)prog;
1747       struct st_vp_variant_key key;
1748
1749       memset(&key, 0, sizeof(key));
1750       key.st = st->has_shareable_shaders ? NULL : st;
1751       st_get_vp_variant(st, p, &key);
1752       break;
1753    }
1754
1755    case GL_TESS_CONTROL_PROGRAM_NV: {
1756       struct st_tessctrl_program *p = (struct st_tessctrl_program *)prog;
1757       st_get_basic_variant(st, PIPE_SHADER_TESS_CTRL, &p->tgsi, &p->variants);
1758       break;
1759    }
1760
1761    case GL_TESS_EVALUATION_PROGRAM_NV: {
1762       struct st_tesseval_program *p = (struct st_tesseval_program *)prog;
1763       st_get_basic_variant(st, PIPE_SHADER_TESS_EVAL, &p->tgsi, &p->variants);
1764       break;
1765    }
1766
1767    case GL_GEOMETRY_PROGRAM_NV: {
1768       struct st_geometry_program *p = (struct st_geometry_program *)prog;
1769       st_get_basic_variant(st, PIPE_SHADER_GEOMETRY, &p->tgsi, &p->variants);
1770       break;
1771    }
1772
1773    case GL_FRAGMENT_PROGRAM_ARB: {
1774       struct st_fragment_program *p = (struct st_fragment_program *)prog;
1775       struct st_fp_variant_key key;
1776
1777       memset(&key, 0, sizeof(key));
1778       key.st = st->has_shareable_shaders ? NULL : st;
1779       st_get_fp_variant(st, p, &key);
1780       break;
1781    }
1782
1783    case GL_COMPUTE_PROGRAM_NV: {
1784       struct st_compute_program *p = (struct st_compute_program *)prog;
1785       st_get_cp_variant(st, &p->tgsi, &p->variants);
1786       break;
1787    }
1788
1789    default:
1790       assert(0);
1791    }
1792 }