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