src/mesa/state_tracker/st_program.c

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