Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

  1. /**************************************************************************
  2.  *
  3.  * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
  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 TUNGSTEN GRAPHICS 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 <keith@tungstengraphics.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_ureg.h"
  47.  
  48. #include "st_debug.h"
  49. #include "st_cb_bitmap.h"
  50. #include "st_cb_drawpixels.h"
  51. #include "st_context.h"
  52. #include "st_program.h"
  53. #include "st_mesa_to_tgsi.h"
  54. #include "cso_cache/cso_context.h"
  55.  
  56.  
  57.  
  58. /**
  59.  * Delete a vertex program variant.  Note the caller must unlink
  60.  * the variant from the linked list.
  61.  */
  62. static void
  63. delete_vp_variant(struct st_context *st, struct st_vp_variant *vpv)
  64. {
  65.    if (vpv->driver_shader)
  66.       cso_delete_vertex_shader(st->cso_context, vpv->driver_shader);
  67.      
  68.    if (vpv->draw_shader)
  69.       draw_delete_vertex_shader( st->draw, vpv->draw_shader );
  70.      
  71.    if (vpv->tgsi.tokens)
  72.       st_free_tokens(vpv->tgsi.tokens);
  73.      
  74.    free( vpv );
  75. }
  76.  
  77.  
  78.  
  79. /**
  80.  * Clean out any old compilations:
  81.  */
  82. void
  83. st_release_vp_variants( struct st_context *st,
  84.                         struct st_vertex_program *stvp )
  85. {
  86.    struct st_vp_variant *vpv;
  87.  
  88.    for (vpv = stvp->variants; vpv; ) {
  89.       struct st_vp_variant *next = vpv->next;
  90.       delete_vp_variant(st, vpv);
  91.       vpv = next;
  92.    }
  93.  
  94.    stvp->variants = NULL;
  95. }
  96.  
  97.  
  98.  
  99. /**
  100.  * Delete a fragment program variant.  Note the caller must unlink
  101.  * the variant from the linked list.
  102.  */
  103. static void
  104. delete_fp_variant(struct st_context *st, struct st_fp_variant *fpv)
  105. {
  106.    if (fpv->driver_shader)
  107.       cso_delete_fragment_shader(st->cso_context, fpv->driver_shader);
  108.    if (fpv->parameters)
  109.       _mesa_free_parameter_list(fpv->parameters);
  110.    if (fpv->tgsi.tokens)
  111.       st_free_tokens(fpv->tgsi.tokens);
  112.    free(fpv);
  113. }
  114.  
  115.  
  116. /**
  117.  * Free all variants of a fragment program.
  118.  */
  119. void
  120. st_release_fp_variants(struct st_context *st, struct st_fragment_program *stfp)
  121. {
  122.    struct st_fp_variant *fpv;
  123.  
  124.    for (fpv = stfp->variants; fpv; ) {
  125.       struct st_fp_variant *next = fpv->next;
  126.       delete_fp_variant(st, fpv);
  127.       fpv = next;
  128.    }
  129.  
  130.    stfp->variants = NULL;
  131. }
  132.  
  133.  
  134. /**
  135.  * Delete a geometry program variant.  Note the caller must unlink
  136.  * the variant from the linked list.
  137.  */
  138. static void
  139. delete_gp_variant(struct st_context *st, struct st_gp_variant *gpv)
  140. {
  141.    if (gpv->driver_shader)
  142.       cso_delete_geometry_shader(st->cso_context, gpv->driver_shader);
  143.      
  144.    free(gpv);
  145. }
  146.  
  147.  
  148. /**
  149.  * Free all variants of a geometry program.
  150.  */
  151. void
  152. st_release_gp_variants(struct st_context *st, struct st_geometry_program *stgp)
  153. {
  154.    struct st_gp_variant *gpv;
  155.  
  156.    for (gpv = stgp->variants; gpv; ) {
  157.       struct st_gp_variant *next = gpv->next;
  158.       delete_gp_variant(st, gpv);
  159.       gpv = next;
  160.    }
  161.  
  162.    stgp->variants = NULL;
  163. }
  164.  
  165.  
  166.  
  167.  
  168. /**
  169.  * Translate a Mesa vertex shader into a TGSI shader.
  170.  * \param outputMapping  to map vertex program output registers (VARYING_SLOT_x)
  171.  *       to TGSI output slots
  172.  * \param tokensOut  destination for TGSI tokens
  173.  * \return  pointer to cached pipe_shader object.
  174.  */
  175. void
  176. st_prepare_vertex_program(struct gl_context *ctx,
  177.                             struct st_vertex_program *stvp)
  178. {
  179.    struct st_context *st = st_context(ctx);
  180.    GLuint attr;
  181.  
  182.    stvp->num_inputs = 0;
  183.    stvp->num_outputs = 0;
  184.  
  185.    if (stvp->Base.IsPositionInvariant)
  186.       _mesa_insert_mvp_code(ctx, &stvp->Base);
  187.  
  188.    if (!stvp->glsl_to_tgsi)
  189.       assert(stvp->Base.Base.NumInstructions > 1);
  190.  
  191.    /*
  192.     * Determine number of inputs, the mappings between VERT_ATTRIB_x
  193.     * and TGSI generic input indexes, plus input attrib semantic info.
  194.     */
  195.    for (attr = 0; attr < VERT_ATTRIB_MAX; attr++) {
  196.       if ((stvp->Base.Base.InputsRead & BITFIELD64_BIT(attr)) != 0) {
  197.          stvp->input_to_index[attr] = stvp->num_inputs;
  198.          stvp->index_to_input[stvp->num_inputs] = attr;
  199.          stvp->num_inputs++;
  200.       }
  201.    }
  202.    /* bit of a hack, presetup potentially unused edgeflag input */
  203.    stvp->input_to_index[VERT_ATTRIB_EDGEFLAG] = stvp->num_inputs;
  204.    stvp->index_to_input[stvp->num_inputs] = VERT_ATTRIB_EDGEFLAG;
  205.  
  206.    /* Compute mapping of vertex program outputs to slots.
  207.     */
  208.    for (attr = 0; attr < VARYING_SLOT_MAX; attr++) {
  209.       if ((stvp->Base.Base.OutputsWritten & BITFIELD64_BIT(attr)) == 0) {
  210.          stvp->result_to_output[attr] = ~0;
  211.       }
  212.       else {
  213.          unsigned slot = stvp->num_outputs++;
  214.  
  215.          stvp->result_to_output[attr] = slot;
  216.  
  217.          switch (attr) {
  218.          case VARYING_SLOT_POS:
  219.             stvp->output_semantic_name[slot] = TGSI_SEMANTIC_POSITION;
  220.             stvp->output_semantic_index[slot] = 0;
  221.             break;
  222.          case VARYING_SLOT_COL0:
  223.             stvp->output_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
  224.             stvp->output_semantic_index[slot] = 0;
  225.             break;
  226.          case VARYING_SLOT_COL1:
  227.             stvp->output_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
  228.             stvp->output_semantic_index[slot] = 1;
  229.             break;
  230.          case VARYING_SLOT_BFC0:
  231.             stvp->output_semantic_name[slot] = TGSI_SEMANTIC_BCOLOR;
  232.             stvp->output_semantic_index[slot] = 0;
  233.             break;
  234.          case VARYING_SLOT_BFC1:
  235.             stvp->output_semantic_name[slot] = TGSI_SEMANTIC_BCOLOR;
  236.             stvp->output_semantic_index[slot] = 1;
  237.             break;
  238.          case VARYING_SLOT_FOGC:
  239.             stvp->output_semantic_name[slot] = TGSI_SEMANTIC_FOG;
  240.             stvp->output_semantic_index[slot] = 0;
  241.             break;
  242.          case VARYING_SLOT_PSIZ:
  243.             stvp->output_semantic_name[slot] = TGSI_SEMANTIC_PSIZE;
  244.             stvp->output_semantic_index[slot] = 0;
  245.             break;
  246.          case VARYING_SLOT_CLIP_DIST0:
  247.             stvp->output_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
  248.             stvp->output_semantic_index[slot] = 0;
  249.             break;
  250.          case VARYING_SLOT_CLIP_DIST1:
  251.             stvp->output_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
  252.             stvp->output_semantic_index[slot] = 1;
  253.             break;
  254.          case VARYING_SLOT_EDGE:
  255.             assert(0);
  256.             break;
  257.          case VARYING_SLOT_CLIP_VERTEX:
  258.             stvp->output_semantic_name[slot] = TGSI_SEMANTIC_CLIPVERTEX;
  259.             stvp->output_semantic_index[slot] = 0;
  260.             break;
  261.  
  262.          case VARYING_SLOT_TEX0:
  263.          case VARYING_SLOT_TEX1:
  264.          case VARYING_SLOT_TEX2:
  265.          case VARYING_SLOT_TEX3:
  266.          case VARYING_SLOT_TEX4:
  267.          case VARYING_SLOT_TEX5:
  268.          case VARYING_SLOT_TEX6:
  269.          case VARYING_SLOT_TEX7:
  270.             stvp->output_semantic_name[slot] = st->needs_texcoord_semantic ?
  271.                TGSI_SEMANTIC_TEXCOORD : TGSI_SEMANTIC_GENERIC;
  272.             stvp->output_semantic_index[slot] = attr - VARYING_SLOT_TEX0;
  273.             break;
  274.  
  275.          case VARYING_SLOT_VAR0:
  276.          default:
  277.             assert(attr < VARYING_SLOT_MAX);
  278.             stvp->output_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
  279.             stvp->output_semantic_index[slot] = st->needs_texcoord_semantic ?
  280.                (attr - VARYING_SLOT_VAR0) : (attr - VARYING_SLOT_TEX0);
  281.             break;
  282.          }
  283.       }
  284.    }
  285.    /* similar hack to above, presetup potentially unused edgeflag output */
  286.    stvp->result_to_output[VARYING_SLOT_EDGE] = stvp->num_outputs;
  287.    stvp->output_semantic_name[stvp->num_outputs] = TGSI_SEMANTIC_EDGEFLAG;
  288.    stvp->output_semantic_index[stvp->num_outputs] = 0;
  289. }
  290.  
  291.  
  292. /**
  293.  * Translate a vertex program to create a new variant.
  294.  */
  295. static struct st_vp_variant *
  296. st_translate_vertex_program(struct st_context *st,
  297.                             struct st_vertex_program *stvp,
  298.                             const struct st_vp_variant_key *key)
  299. {
  300.    struct st_vp_variant *vpv = CALLOC_STRUCT(st_vp_variant);
  301.    struct pipe_context *pipe = st->pipe;
  302.    struct ureg_program *ureg;
  303.    enum pipe_error error;
  304.    unsigned num_outputs;
  305.  
  306.    st_prepare_vertex_program(st->ctx, stvp);
  307.  
  308.    if (!stvp->glsl_to_tgsi)
  309.    {
  310.       _mesa_remove_output_reads(&stvp->Base.Base, PROGRAM_OUTPUT);
  311.    }
  312.  
  313.    ureg = ureg_create( TGSI_PROCESSOR_VERTEX );
  314.    if (ureg == NULL) {
  315.       free(vpv);
  316.       return NULL;
  317.    }
  318.  
  319.    vpv->key = *key;
  320.  
  321.    vpv->num_inputs = stvp->num_inputs;
  322.    num_outputs = stvp->num_outputs;
  323.    if (key->passthrough_edgeflags) {
  324.       vpv->num_inputs++;
  325.       num_outputs++;
  326.    }
  327.  
  328.    if (ST_DEBUG & DEBUG_MESA) {
  329.       _mesa_print_program(&stvp->Base.Base);
  330.       _mesa_print_program_parameters(st->ctx, &stvp->Base.Base);
  331.       debug_printf("\n");
  332.    }
  333.  
  334.    if (stvp->glsl_to_tgsi)
  335.       error = st_translate_program(st->ctx,
  336.                                    TGSI_PROCESSOR_VERTEX,
  337.                                    ureg,
  338.                                    stvp->glsl_to_tgsi,
  339.                                    &stvp->Base.Base,
  340.                                    /* inputs */
  341.                                    stvp->num_inputs,
  342.                                    stvp->input_to_index,
  343.                                    NULL, /* input semantic name */
  344.                                    NULL, /* input semantic index */
  345.                                    NULL, /* interp mode */
  346.                                    NULL, /* is centroid */
  347.                                    /* outputs */
  348.                                    stvp->num_outputs,
  349.                                    stvp->result_to_output,
  350.                                    stvp->output_semantic_name,
  351.                                    stvp->output_semantic_index,
  352.                                    key->passthrough_edgeflags,
  353.                                    key->clamp_color);
  354.    else
  355.       error = st_translate_mesa_program(st->ctx,
  356.                                         TGSI_PROCESSOR_VERTEX,
  357.                                         ureg,
  358.                                         &stvp->Base.Base,
  359.                                         /* inputs */
  360.                                         vpv->num_inputs,
  361.                                         stvp->input_to_index,
  362.                                         NULL, /* input semantic name */
  363.                                         NULL, /* input semantic index */
  364.                                         NULL,
  365.                                         /* outputs */
  366.                                         num_outputs,
  367.                                         stvp->result_to_output,
  368.                                         stvp->output_semantic_name,
  369.                                         stvp->output_semantic_index,
  370.                                         key->passthrough_edgeflags,
  371.                                         key->clamp_color);
  372.  
  373.    if (error)
  374.       goto fail;
  375.  
  376.    vpv->tgsi.tokens = ureg_get_tokens( ureg, NULL );
  377.    if (!vpv->tgsi.tokens)
  378.       goto fail;
  379.  
  380.    ureg_destroy( ureg );
  381.  
  382.    if (stvp->glsl_to_tgsi) {
  383.       st_translate_stream_output_info(stvp->glsl_to_tgsi,
  384.                                       stvp->result_to_output,
  385.                                       &vpv->tgsi.stream_output);
  386.    }
  387.  
  388.    vpv->driver_shader = pipe->create_vs_state(pipe, &vpv->tgsi);
  389.  
  390.    if (ST_DEBUG & DEBUG_TGSI) {
  391.       tgsi_dump( vpv->tgsi.tokens, 0 );
  392.       debug_printf("\n");
  393.    }
  394.  
  395.    return vpv;
  396.  
  397. fail:
  398.    debug_printf("%s: failed to translate Mesa program:\n", __FUNCTION__);
  399.    _mesa_print_program(&stvp->Base.Base);
  400.    debug_assert(0);
  401.  
  402.    ureg_destroy( ureg );
  403.    return NULL;
  404. }
  405.  
  406.  
  407. /**
  408.  * Find/create a vertex program variant.
  409.  */
  410. struct st_vp_variant *
  411. st_get_vp_variant(struct st_context *st,
  412.                   struct st_vertex_program *stvp,
  413.                   const struct st_vp_variant_key *key)
  414. {
  415.    struct st_vp_variant *vpv;
  416.  
  417.    /* Search for existing variant */
  418.    for (vpv = stvp->variants; vpv; vpv = vpv->next) {
  419.       if (memcmp(&vpv->key, key, sizeof(*key)) == 0) {
  420.          break;
  421.       }
  422.    }
  423.  
  424.    if (!vpv) {
  425.       /* create now */
  426.       vpv = st_translate_vertex_program(st, stvp, key);
  427.       if (vpv) {
  428.          /* insert into list */
  429.          vpv->next = stvp->variants;
  430.          stvp->variants = vpv;
  431.       }
  432.    }
  433.  
  434.    return vpv;
  435. }
  436.  
  437.  
  438. static unsigned
  439. st_translate_interp(enum glsl_interp_qualifier glsl_qual, bool is_color)
  440. {
  441.    switch (glsl_qual) {
  442.    case INTERP_QUALIFIER_NONE:
  443.       if (is_color)
  444.          return TGSI_INTERPOLATE_COLOR;
  445.       return TGSI_INTERPOLATE_PERSPECTIVE;
  446.    case INTERP_QUALIFIER_SMOOTH:
  447.       return TGSI_INTERPOLATE_PERSPECTIVE;
  448.    case INTERP_QUALIFIER_FLAT:
  449.       return TGSI_INTERPOLATE_CONSTANT;
  450.    case INTERP_QUALIFIER_NOPERSPECTIVE:
  451.       return TGSI_INTERPOLATE_LINEAR;
  452.    default:
  453.       assert(0 && "unexpected interp mode in st_translate_interp()");
  454.       return TGSI_INTERPOLATE_PERSPECTIVE;
  455.    }
  456. }
  457.  
  458.  
  459. /**
  460.  * Translate a Mesa fragment shader into a TGSI shader using extra info in
  461.  * the key.
  462.  * \return  new fragment program variant
  463.  */
  464. static struct st_fp_variant *
  465. st_translate_fragment_program(struct st_context *st,
  466.                               struct st_fragment_program *stfp,
  467.                               const struct st_fp_variant_key *key)
  468. {
  469.    struct pipe_context *pipe = st->pipe;
  470.    struct st_fp_variant *variant = CALLOC_STRUCT(st_fp_variant);
  471.    GLboolean deleteFP = GL_FALSE;
  472.  
  473.    GLuint outputMapping[FRAG_RESULT_MAX];
  474.    GLuint inputMapping[VARYING_SLOT_MAX];
  475.    GLuint interpMode[PIPE_MAX_SHADER_INPUTS];  /* XXX size? */
  476.    GLuint attr;
  477.    GLbitfield64 inputsRead;
  478.    struct ureg_program *ureg;
  479.  
  480.    GLboolean write_all = GL_FALSE;
  481.  
  482.    ubyte input_semantic_name[PIPE_MAX_SHADER_INPUTS];
  483.    ubyte input_semantic_index[PIPE_MAX_SHADER_INPUTS];
  484.    GLboolean is_centroid[PIPE_MAX_SHADER_INPUTS];
  485.    uint fs_num_inputs = 0;
  486.  
  487.    ubyte fs_output_semantic_name[PIPE_MAX_SHADER_OUTPUTS];
  488.    ubyte fs_output_semantic_index[PIPE_MAX_SHADER_OUTPUTS];
  489.    uint fs_num_outputs = 0;
  490.  
  491.    if (!variant)
  492.       return NULL;
  493.  
  494.    assert(!(key->bitmap && key->drawpixels));
  495.  
  496.    if (key->bitmap) {
  497.       /* glBitmap drawing */
  498.       struct gl_fragment_program *fp; /* we free this temp program below */
  499.  
  500.       st_make_bitmap_fragment_program(st, &stfp->Base,
  501.                                       &fp, &variant->bitmap_sampler);
  502.  
  503.       variant->parameters = _mesa_clone_parameter_list(fp->Base.Parameters);
  504.       stfp = st_fragment_program(fp);
  505.       deleteFP = GL_TRUE;
  506.    }
  507.    else if (key->drawpixels) {
  508.       /* glDrawPixels drawing */
  509.       struct gl_fragment_program *fp; /* we free this temp program below */
  510.  
  511.       if (key->drawpixels_z || key->drawpixels_stencil) {
  512.          fp = st_make_drawpix_z_stencil_program(st, key->drawpixels_z,
  513.                                                 key->drawpixels_stencil);
  514.       }
  515.       else {
  516.          /* RGBA */
  517.          st_make_drawpix_fragment_program(st, &stfp->Base, &fp);
  518.          variant->parameters = _mesa_clone_parameter_list(fp->Base.Parameters);
  519.          deleteFP = GL_TRUE;
  520.       }
  521.       stfp = st_fragment_program(fp);
  522.    }
  523.  
  524.    if (!stfp->glsl_to_tgsi)
  525.       _mesa_remove_output_reads(&stfp->Base.Base, PROGRAM_OUTPUT);
  526.  
  527.    /*
  528.     * Convert Mesa program inputs to TGSI input register semantics.
  529.     */
  530.    inputsRead = stfp->Base.Base.InputsRead;
  531.    for (attr = 0; attr < VARYING_SLOT_MAX; attr++) {
  532.       if ((inputsRead & BITFIELD64_BIT(attr)) != 0) {
  533.          const GLuint slot = fs_num_inputs++;
  534.  
  535.          inputMapping[attr] = slot;
  536.          is_centroid[slot] = (stfp->Base.IsCentroid & BITFIELD64_BIT(attr)) != 0;
  537.  
  538.          switch (attr) {
  539.          case VARYING_SLOT_POS:
  540.             input_semantic_name[slot] = TGSI_SEMANTIC_POSITION;
  541.             input_semantic_index[slot] = 0;
  542.             interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
  543.             break;
  544.          case VARYING_SLOT_COL0:
  545.             input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
  546.             input_semantic_index[slot] = 0;
  547.             interpMode[slot] = st_translate_interp(stfp->Base.InterpQualifier[attr],
  548.                                                    TRUE);
  549.             break;
  550.          case VARYING_SLOT_COL1:
  551.             input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
  552.             input_semantic_index[slot] = 1;
  553.             interpMode[slot] = st_translate_interp(stfp->Base.InterpQualifier[attr],
  554.                                                    TRUE);
  555.             break;
  556.          case VARYING_SLOT_FOGC:
  557.             input_semantic_name[slot] = TGSI_SEMANTIC_FOG;
  558.             input_semantic_index[slot] = 0;
  559.             interpMode[slot] = TGSI_INTERPOLATE_PERSPECTIVE;
  560.             break;
  561.          case VARYING_SLOT_FACE:
  562.             input_semantic_name[slot] = TGSI_SEMANTIC_FACE;
  563.             input_semantic_index[slot] = 0;
  564.             interpMode[slot] = TGSI_INTERPOLATE_CONSTANT;
  565.             break;
  566.          case VARYING_SLOT_CLIP_DIST0:
  567.             input_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
  568.             input_semantic_index[slot] = 0;
  569.             interpMode[slot] = TGSI_INTERPOLATE_PERSPECTIVE;
  570.             break;
  571.          case VARYING_SLOT_CLIP_DIST1:
  572.             input_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
  573.             input_semantic_index[slot] = 1;
  574.             interpMode[slot] = TGSI_INTERPOLATE_PERSPECTIVE;
  575.             break;
  576.             /* In most cases, there is nothing special about these
  577.              * inputs, so adopt a convention to use the generic
  578.              * semantic name and the mesa VARYING_SLOT_ number as the
  579.              * index.
  580.              *
  581.              * All that is required is that the vertex shader labels
  582.              * its own outputs similarly, and that the vertex shader
  583.              * generates at least every output required by the
  584.              * fragment shader plus fixed-function hardware (such as
  585.              * BFC).
  586.              *
  587.              * However, some drivers may need us to identify the PNTC and TEXi
  588.              * varyings if, for example, their capability to replace them with
  589.              * sprite coordinates is limited.
  590.              */
  591.          case VARYING_SLOT_PNTC:
  592.             if (st->needs_texcoord_semantic) {
  593.                input_semantic_name[slot] = TGSI_SEMANTIC_PCOORD;
  594.                input_semantic_index[slot] = 0;
  595.                interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
  596.                break;
  597.             }
  598.             /* fall through */
  599.          case VARYING_SLOT_TEX0:
  600.          case VARYING_SLOT_TEX1:
  601.          case VARYING_SLOT_TEX2:
  602.          case VARYING_SLOT_TEX3:
  603.          case VARYING_SLOT_TEX4:
  604.          case VARYING_SLOT_TEX5:
  605.          case VARYING_SLOT_TEX6:
  606.          case VARYING_SLOT_TEX7:
  607.             if (st->needs_texcoord_semantic) {
  608.                input_semantic_name[slot] = TGSI_SEMANTIC_TEXCOORD;
  609.                input_semantic_index[slot] = attr - VARYING_SLOT_TEX0;
  610.                interpMode[slot] =
  611.                   st_translate_interp(stfp->Base.InterpQualifier[attr], FALSE);
  612.                break;
  613.             }
  614.             /* fall through */
  615.          case VARYING_SLOT_VAR0:
  616.          default:
  617.             /* Semantic indices should be zero-based because drivers may choose
  618.              * to assign a fixed slot determined by that index.
  619.              * This is useful because ARB_separate_shader_objects uses location
  620.              * qualifiers for linkage, and if the semantic index corresponds to
  621.              * these locations, linkage passes in the driver become unecessary.
  622.              *
  623.              * If needs_texcoord_semantic is true, no semantic indices will be
  624.              * consumed for the TEXi varyings, and we can base the locations of
  625.              * the user varyings on VAR0.  Otherwise, we use TEX0 as base index.
  626.              */
  627.             assert(attr >= VARYING_SLOT_TEX0);
  628.             input_semantic_index[slot] = st->needs_texcoord_semantic ?
  629.                (attr - VARYING_SLOT_VAR0) : (attr - VARYING_SLOT_TEX0);
  630.             input_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
  631.             if (attr == VARYING_SLOT_PNTC)
  632.                interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
  633.             else
  634.                interpMode[slot] = st_translate_interp(stfp->Base.InterpQualifier[attr],
  635.                                                       FALSE);
  636.             break;
  637.          }
  638.       }
  639.       else {
  640.          inputMapping[attr] = -1;
  641.       }
  642.    }
  643.  
  644.    /*
  645.     * Semantics and mapping for outputs
  646.     */
  647.    {
  648.       uint numColors = 0;
  649.       GLbitfield64 outputsWritten = stfp->Base.Base.OutputsWritten;
  650.  
  651.       /* if z is written, emit that first */
  652.       if (outputsWritten & BITFIELD64_BIT(FRAG_RESULT_DEPTH)) {
  653.          fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_POSITION;
  654.          fs_output_semantic_index[fs_num_outputs] = 0;
  655.          outputMapping[FRAG_RESULT_DEPTH] = fs_num_outputs;
  656.          fs_num_outputs++;
  657.          outputsWritten &= ~(1 << FRAG_RESULT_DEPTH);
  658.       }
  659.  
  660.       if (outputsWritten & BITFIELD64_BIT(FRAG_RESULT_STENCIL)) {
  661.          fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_STENCIL;
  662.          fs_output_semantic_index[fs_num_outputs] = 0;
  663.          outputMapping[FRAG_RESULT_STENCIL] = fs_num_outputs;
  664.          fs_num_outputs++;
  665.          outputsWritten &= ~(1 << FRAG_RESULT_STENCIL);
  666.       }
  667.  
  668.       /* handle remaining outputs (color) */
  669.       for (attr = 0; attr < FRAG_RESULT_MAX; attr++) {
  670.          if (outputsWritten & BITFIELD64_BIT(attr)) {
  671.             switch (attr) {
  672.             case FRAG_RESULT_DEPTH:
  673.             case FRAG_RESULT_STENCIL:
  674.                /* handled above */
  675.                assert(0);
  676.                break;
  677.             case FRAG_RESULT_COLOR:
  678.                write_all = GL_TRUE; /* fallthrough */
  679.             default:
  680.                assert(attr == FRAG_RESULT_COLOR ||
  681.                       (FRAG_RESULT_DATA0 <= attr && attr < FRAG_RESULT_MAX));
  682.                fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_COLOR;
  683.                fs_output_semantic_index[fs_num_outputs] = numColors;
  684.                outputMapping[attr] = fs_num_outputs;
  685.                numColors++;
  686.                break;
  687.             }
  688.  
  689.             fs_num_outputs++;
  690.          }
  691.       }
  692.    }
  693.  
  694.    ureg = ureg_create( TGSI_PROCESSOR_FRAGMENT );
  695.    if (ureg == NULL) {
  696.       free(variant);
  697.       return NULL;
  698.    }
  699.  
  700.    if (ST_DEBUG & DEBUG_MESA) {
  701.       _mesa_print_program(&stfp->Base.Base);
  702.       _mesa_print_program_parameters(st->ctx, &stfp->Base.Base);
  703.       debug_printf("\n");
  704.    }
  705.    if (write_all == GL_TRUE)
  706.       ureg_property_fs_color0_writes_all_cbufs(ureg, 1);
  707.  
  708.    if (stfp->Base.FragDepthLayout != FRAG_DEPTH_LAYOUT_NONE) {
  709.       switch (stfp->Base.FragDepthLayout) {
  710.       case FRAG_DEPTH_LAYOUT_ANY:
  711.          ureg_property_fs_depth_layout(ureg, TGSI_FS_DEPTH_LAYOUT_ANY);
  712.          break;
  713.       case FRAG_DEPTH_LAYOUT_GREATER:
  714.          ureg_property_fs_depth_layout(ureg, TGSI_FS_DEPTH_LAYOUT_GREATER);
  715.          break;
  716.       case FRAG_DEPTH_LAYOUT_LESS:
  717.          ureg_property_fs_depth_layout(ureg, TGSI_FS_DEPTH_LAYOUT_LESS);
  718.          break;
  719.       case FRAG_DEPTH_LAYOUT_UNCHANGED:
  720.          ureg_property_fs_depth_layout(ureg, TGSI_FS_DEPTH_LAYOUT_UNCHANGED);
  721.          break;
  722.       default:
  723.          assert(0);
  724.       }
  725.    }
  726.  
  727.    if (stfp->glsl_to_tgsi)
  728.       st_translate_program(st->ctx,
  729.                            TGSI_PROCESSOR_FRAGMENT,
  730.                            ureg,
  731.                            stfp->glsl_to_tgsi,
  732.                            &stfp->Base.Base,
  733.                            /* inputs */
  734.                            fs_num_inputs,
  735.                            inputMapping,
  736.                            input_semantic_name,
  737.                            input_semantic_index,
  738.                            interpMode,
  739.                            is_centroid,
  740.                            /* outputs */
  741.                            fs_num_outputs,
  742.                            outputMapping,
  743.                            fs_output_semantic_name,
  744.                            fs_output_semantic_index, FALSE,
  745.                            key->clamp_color );
  746.    else
  747.       st_translate_mesa_program(st->ctx,
  748.                                 TGSI_PROCESSOR_FRAGMENT,
  749.                                 ureg,
  750.                                 &stfp->Base.Base,
  751.                                 /* inputs */
  752.                                 fs_num_inputs,
  753.                                 inputMapping,
  754.                                 input_semantic_name,
  755.                                 input_semantic_index,
  756.                                 interpMode,
  757.                                 /* outputs */
  758.                                 fs_num_outputs,
  759.                                 outputMapping,
  760.                                 fs_output_semantic_name,
  761.                                 fs_output_semantic_index, FALSE,
  762.                                 key->clamp_color);
  763.  
  764.    variant->tgsi.tokens = ureg_get_tokens( ureg, NULL );
  765.    ureg_destroy( ureg );
  766.  
  767.    /* fill in variant */
  768.    variant->driver_shader = pipe->create_fs_state(pipe, &variant->tgsi);
  769.    variant->key = *key;
  770.  
  771.    if (ST_DEBUG & DEBUG_TGSI) {
  772.       tgsi_dump( variant->tgsi.tokens, 0/*TGSI_DUMP_VERBOSE*/ );
  773.       debug_printf("\n");
  774.    }
  775.  
  776.    if (deleteFP) {
  777.       /* Free the temporary program made above */
  778.       struct gl_fragment_program *fp = &stfp->Base;
  779.       _mesa_reference_fragprog(st->ctx, &fp, NULL);
  780.    }
  781.  
  782.    return variant;
  783. }
  784.  
  785.  
  786. /**
  787.  * Translate fragment program if needed.
  788.  */
  789. struct st_fp_variant *
  790. st_get_fp_variant(struct st_context *st,
  791.                   struct st_fragment_program *stfp,
  792.                   const struct st_fp_variant_key *key)
  793. {
  794.    struct st_fp_variant *fpv;
  795.  
  796.    /* Search for existing variant */
  797.    for (fpv = stfp->variants; fpv; fpv = fpv->next) {
  798.       if (memcmp(&fpv->key, key, sizeof(*key)) == 0) {
  799.          break;
  800.       }
  801.    }
  802.  
  803.    if (!fpv) {
  804.       /* create new */
  805.       fpv = st_translate_fragment_program(st, stfp, key);
  806.       if (fpv) {
  807.          /* insert into list */
  808.          fpv->next = stfp->variants;
  809.          stfp->variants = fpv;
  810.       }
  811.    }
  812.  
  813.    return fpv;
  814. }
  815.  
  816.  
  817. /**
  818.  * Translate a geometry program to create a new variant.
  819.  */
  820. static struct st_gp_variant *
  821. st_translate_geometry_program(struct st_context *st,
  822.                               struct st_geometry_program *stgp,
  823.                               const struct st_gp_variant_key *key)
  824. {
  825.    GLuint inputMapping[VARYING_SLOT_MAX];
  826.    GLuint outputMapping[VARYING_SLOT_MAX];
  827.    struct pipe_context *pipe = st->pipe;
  828.    GLuint attr;
  829.    GLbitfield64 inputsRead;
  830.    GLuint vslot = 0;
  831.    GLuint num_generic = 0;
  832.  
  833.    uint gs_num_inputs = 0;
  834.    uint gs_builtin_inputs = 0;
  835.    uint gs_array_offset = 0;
  836.  
  837.    ubyte gs_output_semantic_name[PIPE_MAX_SHADER_OUTPUTS];
  838.    ubyte gs_output_semantic_index[PIPE_MAX_SHADER_OUTPUTS];
  839.    uint gs_num_outputs = 0;
  840.  
  841.    GLint i;
  842.    GLuint maxSlot = 0;
  843.    struct ureg_program *ureg;
  844.  
  845.    struct st_gp_variant *gpv;
  846.  
  847.    gpv = CALLOC_STRUCT(st_gp_variant);
  848.    if (!gpv)
  849.       return NULL;
  850.  
  851.    _mesa_remove_output_reads(&stgp->Base.Base, PROGRAM_OUTPUT);
  852.  
  853.    ureg = ureg_create( TGSI_PROCESSOR_GEOMETRY );
  854.    if (ureg == NULL) {
  855.       free(gpv);
  856.       return NULL;
  857.    }
  858.  
  859.    /* which vertex output goes to the first geometry input */
  860.    vslot = 0;
  861.  
  862.    memset(inputMapping, 0, sizeof(inputMapping));
  863.    memset(outputMapping, 0, sizeof(outputMapping));
  864.  
  865.    /*
  866.     * Convert Mesa program inputs to TGSI input register semantics.
  867.     */
  868.    inputsRead = stgp->Base.Base.InputsRead;
  869.    for (attr = 0; attr < VARYING_SLOT_MAX; attr++) {
  870.       if ((inputsRead & BITFIELD64_BIT(attr)) != 0) {
  871.          const GLuint slot = gs_num_inputs;
  872.  
  873.          gs_num_inputs++;
  874.  
  875.          inputMapping[attr] = slot;
  876.  
  877.          stgp->input_map[slot + gs_array_offset] = vslot - gs_builtin_inputs;
  878.          stgp->input_to_index[attr] = vslot;
  879.          stgp->index_to_input[vslot] = attr;
  880.          ++vslot;
  881.  
  882.          if (attr != VARYING_SLOT_PRIMITIVE_ID) {
  883.             gs_array_offset += 2;
  884.          } else
  885.             ++gs_builtin_inputs;
  886.  
  887. #if 0
  888.          debug_printf("input map at %d = %d\n",
  889.                       slot + gs_array_offset, stgp->input_map[slot + gs_array_offset]);
  890. #endif
  891.  
  892.          switch (attr) {
  893.          case VARYING_SLOT_PRIMITIVE_ID:
  894.             stgp->input_semantic_name[slot] = TGSI_SEMANTIC_PRIMID;
  895.             stgp->input_semantic_index[slot] = 0;
  896.             break;
  897.          case VARYING_SLOT_POS:
  898.             stgp->input_semantic_name[slot] = TGSI_SEMANTIC_POSITION;
  899.             stgp->input_semantic_index[slot] = 0;
  900.             break;
  901.          case VARYING_SLOT_COL0:
  902.             stgp->input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
  903.             stgp->input_semantic_index[slot] = 0;
  904.             break;
  905.          case VARYING_SLOT_COL1:
  906.             stgp->input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
  907.             stgp->input_semantic_index[slot] = 1;
  908.             break;
  909.          case VARYING_SLOT_FOGC:
  910.             stgp->input_semantic_name[slot] = TGSI_SEMANTIC_FOG;
  911.             stgp->input_semantic_index[slot] = 0;
  912.             break;
  913.          case VARYING_SLOT_TEX0:
  914.             stgp->input_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
  915.             stgp->input_semantic_index[slot] = num_generic++;
  916.             break;
  917.          case VARYING_SLOT_VAR0:
  918.             /* fall-through */
  919.          default:
  920.             stgp->input_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
  921.             stgp->input_semantic_index[slot] = num_generic++;
  922.          }
  923.       }
  924.    }
  925.  
  926.    /* initialize output semantics to defaults */
  927.    for (i = 0; i < PIPE_MAX_SHADER_OUTPUTS; i++) {
  928.       gs_output_semantic_name[i] = TGSI_SEMANTIC_GENERIC;
  929.       gs_output_semantic_index[i] = 0;
  930.    }
  931.  
  932.    num_generic = 0;
  933.    /*
  934.     * Determine number of outputs, the (default) output register
  935.     * mapping and the semantic information for each output.
  936.     */
  937.    for (attr = 0; attr < VARYING_SLOT_MAX; attr++) {
  938.       if (stgp->Base.Base.OutputsWritten & BITFIELD64_BIT(attr)) {
  939.          GLuint slot;
  940.  
  941.          slot = gs_num_outputs;
  942.          gs_num_outputs++;
  943.          outputMapping[attr] = slot;
  944.  
  945.          switch (attr) {
  946.          case VARYING_SLOT_POS:
  947.             assert(slot == 0);
  948.             gs_output_semantic_name[slot] = TGSI_SEMANTIC_POSITION;
  949.             gs_output_semantic_index[slot] = 0;
  950.             break;
  951.          case VARYING_SLOT_COL0:
  952.             gs_output_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
  953.             gs_output_semantic_index[slot] = 0;
  954.             break;
  955.          case VARYING_SLOT_COL1:
  956.             gs_output_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
  957.             gs_output_semantic_index[slot] = 1;
  958.             break;
  959.          case VARYING_SLOT_BFC0:
  960.             gs_output_semantic_name[slot] = TGSI_SEMANTIC_BCOLOR;
  961.             gs_output_semantic_index[slot] = 0;
  962.             break;
  963.          case VARYING_SLOT_BFC1:
  964.             gs_output_semantic_name[slot] = TGSI_SEMANTIC_BCOLOR;
  965.             gs_output_semantic_index[slot] = 1;
  966.             break;
  967.          case VARYING_SLOT_FOGC:
  968.             gs_output_semantic_name[slot] = TGSI_SEMANTIC_FOG;
  969.             gs_output_semantic_index[slot] = 0;
  970.             break;
  971.          case VARYING_SLOT_PSIZ:
  972.             gs_output_semantic_name[slot] = TGSI_SEMANTIC_PSIZE;
  973.             gs_output_semantic_index[slot] = 0;
  974.             break;
  975.          case VARYING_SLOT_TEX0:
  976.          case VARYING_SLOT_TEX1:
  977.          case VARYING_SLOT_TEX2:
  978.          case VARYING_SLOT_TEX3:
  979.          case VARYING_SLOT_TEX4:
  980.          case VARYING_SLOT_TEX5:
  981.          case VARYING_SLOT_TEX6:
  982.          case VARYING_SLOT_TEX7:
  983.             /* fall-through */
  984.          case VARYING_SLOT_VAR0:
  985.             /* fall-through */
  986.          default:
  987.             assert(slot < Elements(gs_output_semantic_name));
  988.             /* use default semantic info */
  989.             gs_output_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
  990.             gs_output_semantic_index[slot] = num_generic++;
  991.          }
  992.       }
  993.    }
  994.  
  995.    assert(gs_output_semantic_name[0] == TGSI_SEMANTIC_POSITION);
  996.  
  997.    /* find max output slot referenced to compute gs_num_outputs */
  998.    for (attr = 0; attr < VARYING_SLOT_MAX; attr++) {
  999.       if (outputMapping[attr] != ~0 && outputMapping[attr] > maxSlot)
  1000.          maxSlot = outputMapping[attr];
  1001.    }
  1002.    gs_num_outputs = maxSlot + 1;
  1003.  
  1004. #if 0 /* debug */
  1005.    {
  1006.       GLuint i;
  1007.       printf("outputMapping? %d\n", outputMapping ? 1 : 0);
  1008.       if (outputMapping) {
  1009.          printf("attr -> slot\n");
  1010.          for (i = 0; i < 16;  i++) {
  1011.             printf(" %2d       %3d\n", i, outputMapping[i]);
  1012.          }
  1013.       }
  1014.       printf("slot    sem_name  sem_index\n");
  1015.       for (i = 0; i < gs_num_outputs; i++) {
  1016.          printf(" %2d         %d         %d\n",
  1017.                 i,
  1018.                 gs_output_semantic_name[i],
  1019.                 gs_output_semantic_index[i]);
  1020.       }
  1021.    }
  1022. #endif
  1023.  
  1024.    /* free old shader state, if any */
  1025.    if (stgp->tgsi.tokens) {
  1026.       st_free_tokens(stgp->tgsi.tokens);
  1027.       stgp->tgsi.tokens = NULL;
  1028.    }
  1029.  
  1030.    ureg_property_gs_input_prim(ureg, stgp->Base.InputType);
  1031.    ureg_property_gs_output_prim(ureg, stgp->Base.OutputType);
  1032.    ureg_property_gs_max_vertices(ureg, stgp->Base.VerticesOut);
  1033.  
  1034.    st_translate_mesa_program(st->ctx,
  1035.                              TGSI_PROCESSOR_GEOMETRY,
  1036.                              ureg,
  1037.                              &stgp->Base.Base,
  1038.                              /* inputs */
  1039.                              gs_num_inputs,
  1040.                              inputMapping,
  1041.                              stgp->input_semantic_name,
  1042.                              stgp->input_semantic_index,
  1043.                              NULL,
  1044.                              /* outputs */
  1045.                              gs_num_outputs,
  1046.                              outputMapping,
  1047.                              gs_output_semantic_name,
  1048.                              gs_output_semantic_index,
  1049.                              FALSE,
  1050.                              FALSE);
  1051.  
  1052.    stgp->num_inputs = gs_num_inputs;
  1053.    stgp->tgsi.tokens = ureg_get_tokens( ureg, NULL );
  1054.    ureg_destroy( ureg );
  1055.  
  1056.    if (stgp->glsl_to_tgsi) {
  1057.       st_translate_stream_output_info(stgp->glsl_to_tgsi,
  1058.                                       outputMapping,
  1059.                                       &stgp->tgsi.stream_output);
  1060.    }
  1061.  
  1062.    /* fill in new variant */
  1063.    gpv->driver_shader = pipe->create_gs_state(pipe, &stgp->tgsi);
  1064.    gpv->key = *key;
  1065.  
  1066.    if ((ST_DEBUG & DEBUG_TGSI) && (ST_DEBUG & DEBUG_MESA)) {
  1067.       _mesa_print_program(&stgp->Base.Base);
  1068.       debug_printf("\n");
  1069.    }
  1070.  
  1071.    if (ST_DEBUG & DEBUG_TGSI) {
  1072.       tgsi_dump(stgp->tgsi.tokens, 0);
  1073.       debug_printf("\n");
  1074.    }
  1075.  
  1076.    return gpv;
  1077. }
  1078.  
  1079.  
  1080. /**
  1081.  * Get/create geometry program variant.
  1082.  */
  1083. struct st_gp_variant *
  1084. st_get_gp_variant(struct st_context *st,
  1085.                   struct st_geometry_program *stgp,
  1086.                   const struct st_gp_variant_key *key)
  1087. {
  1088.    struct st_gp_variant *gpv;
  1089.  
  1090.    /* Search for existing variant */
  1091.    for (gpv = stgp->variants; gpv; gpv = gpv->next) {
  1092.       if (memcmp(&gpv->key, key, sizeof(*key)) == 0) {
  1093.          break;
  1094.       }
  1095.    }
  1096.  
  1097.    if (!gpv) {
  1098.       /* create new */
  1099.       gpv = st_translate_geometry_program(st, stgp, key);
  1100.       if (gpv) {
  1101.          /* insert into list */
  1102.          gpv->next = stgp->variants;
  1103.          stgp->variants = gpv;
  1104.       }
  1105.    }
  1106.  
  1107.    return gpv;
  1108. }
  1109.  
  1110.  
  1111.  
  1112.  
  1113. /**
  1114.  * Debug- print current shader text
  1115.  */
  1116. void
  1117. st_print_shaders(struct gl_context *ctx)
  1118. {
  1119.    struct gl_shader_program *shProg[3] = {
  1120.       ctx->Shader.CurrentVertexProgram,
  1121.       ctx->Shader.CurrentGeometryProgram,
  1122.       ctx->Shader.CurrentFragmentProgram,
  1123.    };
  1124.    unsigned j;
  1125.  
  1126.    for (j = 0; j < 3; j++) {
  1127.       unsigned i;
  1128.  
  1129.       if (shProg[j] == NULL)
  1130.          continue;
  1131.  
  1132.       for (i = 0; i < shProg[j]->NumShaders; i++) {
  1133.          struct gl_shader *sh;
  1134.  
  1135.          switch (shProg[j]->Shaders[i]->Type) {
  1136.          case GL_VERTEX_SHADER:
  1137.             sh = (i != 0) ? NULL : shProg[j]->Shaders[i];
  1138.             break;
  1139.          case GL_GEOMETRY_SHADER_ARB:
  1140.             sh = (i != 1) ? NULL : shProg[j]->Shaders[i];
  1141.             break;
  1142.          case GL_FRAGMENT_SHADER:
  1143.             sh = (i != 2) ? NULL : shProg[j]->Shaders[i];
  1144.             break;
  1145.          default:
  1146.             assert(0);
  1147.             sh = NULL;
  1148.             break;
  1149.          }
  1150.  
  1151.          if (sh != NULL) {
  1152.             printf("GLSL shader %u of %u:\n", i, shProg[j]->NumShaders);
  1153.             printf("%s\n", sh->Source);
  1154.          }
  1155.       }
  1156.    }
  1157. }
  1158.  
  1159.  
  1160. /**
  1161.  * Vert/Geom/Frag programs have per-context variants.  Free all the
  1162.  * variants attached to the given program which match the given context.
  1163.  */
  1164. static void
  1165. destroy_program_variants(struct st_context *st, struct gl_program *program)
  1166. {
  1167.    if (!program || program == &_mesa_DummyProgram)
  1168.       return;
  1169.  
  1170.    switch (program->Target) {
  1171.    case GL_VERTEX_PROGRAM_ARB:
  1172.       {
  1173.          struct st_vertex_program *stvp = (struct st_vertex_program *) program;
  1174.          struct st_vp_variant *vpv, **prevPtr = &stvp->variants;
  1175.  
  1176.          for (vpv = stvp->variants; vpv; ) {
  1177.             struct st_vp_variant *next = vpv->next;
  1178.             if (vpv->key.st == st) {
  1179.                /* unlink from list */
  1180.                *prevPtr = next;
  1181.                /* destroy this variant */
  1182.                delete_vp_variant(st, vpv);
  1183.             }
  1184.             else {
  1185.                prevPtr = &vpv->next;
  1186.             }
  1187.             vpv = next;
  1188.          }
  1189.       }
  1190.       break;
  1191.    case GL_FRAGMENT_PROGRAM_ARB:
  1192.       {
  1193.          struct st_fragment_program *stfp =
  1194.             (struct st_fragment_program *) program;
  1195.          struct st_fp_variant *fpv, **prevPtr = &stfp->variants;
  1196.  
  1197.          for (fpv = stfp->variants; fpv; ) {
  1198.             struct st_fp_variant *next = fpv->next;
  1199.             if (fpv->key.st == st) {
  1200.                /* unlink from list */
  1201.                *prevPtr = next;
  1202.                /* destroy this variant */
  1203.                delete_fp_variant(st, fpv);
  1204.             }
  1205.             else {
  1206.                prevPtr = &fpv->next;
  1207.             }
  1208.             fpv = next;
  1209.          }
  1210.       }
  1211.       break;
  1212.    case MESA_GEOMETRY_PROGRAM:
  1213.       {
  1214.          struct st_geometry_program *stgp =
  1215.             (struct st_geometry_program *) program;
  1216.          struct st_gp_variant *gpv, **prevPtr = &stgp->variants;
  1217.  
  1218.          for (gpv = stgp->variants; gpv; ) {
  1219.             struct st_gp_variant *next = gpv->next;
  1220.             if (gpv->key.st == st) {
  1221.                /* unlink from list */
  1222.                *prevPtr = next;
  1223.                /* destroy this variant */
  1224.                delete_gp_variant(st, gpv);
  1225.             }
  1226.             else {
  1227.                prevPtr = &gpv->next;
  1228.             }
  1229.             gpv = next;
  1230.          }
  1231.       }
  1232.       break;
  1233.    default:
  1234.       _mesa_problem(NULL, "Unexpected program target 0x%x in "
  1235.                     "destroy_program_variants_cb()", program->Target);
  1236.    }
  1237. }
  1238.  
  1239.  
  1240. /**
  1241.  * Callback for _mesa_HashWalk.  Free all the shader's program variants
  1242.  * which match the given context.
  1243.  */
  1244. static void
  1245. destroy_shader_program_variants_cb(GLuint key, void *data, void *userData)
  1246. {
  1247.    struct st_context *st = (struct st_context *) userData;
  1248.    struct gl_shader *shader = (struct gl_shader *) data;
  1249.  
  1250.    switch (shader->Type) {
  1251.    case GL_SHADER_PROGRAM_MESA:
  1252.       {
  1253.          struct gl_shader_program *shProg = (struct gl_shader_program *) data;
  1254.          GLuint i;
  1255.  
  1256.          for (i = 0; i < shProg->NumShaders; i++) {
  1257.             destroy_program_variants(st, shProg->Shaders[i]->Program);
  1258.          }
  1259.  
  1260.          for (i = 0; i < Elements(shProg->_LinkedShaders); i++) {
  1261.             if (shProg->_LinkedShaders[i])
  1262.                destroy_program_variants(st, shProg->_LinkedShaders[i]->Program);
  1263.          }
  1264.       }
  1265.       break;
  1266.    case GL_VERTEX_SHADER:
  1267.    case GL_FRAGMENT_SHADER:
  1268.    case GL_GEOMETRY_SHADER:
  1269.       {
  1270.          destroy_program_variants(st, shader->Program);
  1271.       }
  1272.       break;
  1273.    default:
  1274.       assert(0);
  1275.    }
  1276. }
  1277.  
  1278.  
  1279. /**
  1280.  * Callback for _mesa_HashWalk.  Free all the program variants which match
  1281.  * the given context.
  1282.  */
  1283. static void
  1284. destroy_program_variants_cb(GLuint key, void *data, void *userData)
  1285. {
  1286.    struct st_context *st = (struct st_context *) userData;
  1287.    struct gl_program *program = (struct gl_program *) data;
  1288.    destroy_program_variants(st, program);
  1289. }
  1290.  
  1291.  
  1292. /**
  1293.  * Walk over all shaders and programs to delete any variants which
  1294.  * belong to the given context.
  1295.  * This is called during context tear-down.
  1296.  */
  1297. void
  1298. st_destroy_program_variants(struct st_context *st)
  1299. {
  1300.    /* ARB vert/frag program */
  1301.    _mesa_HashWalk(st->ctx->Shared->Programs,
  1302.                   destroy_program_variants_cb, st);
  1303.  
  1304.    /* GLSL vert/frag/geom shaders */
  1305.    _mesa_HashWalk(st->ctx->Shared->ShaderObjects,
  1306.                   destroy_shader_program_variants_cb, st);
  1307. }
  1308.  
  1309.  
  1310. /**
  1311.  * For debugging, print/dump the current vertex program.
  1312.  */
  1313. void
  1314. st_print_current_vertex_program(void)
  1315. {
  1316.    GET_CURRENT_CONTEXT(ctx);
  1317.  
  1318.    if (ctx->VertexProgram._Current) {
  1319.       struct st_vertex_program *stvp =
  1320.          (struct st_vertex_program *) ctx->VertexProgram._Current;
  1321.       struct st_vp_variant *stv;
  1322.  
  1323.       debug_printf("Vertex program %u\n", stvp->Base.Base.Id);
  1324.  
  1325.       for (stv = stvp->variants; stv; stv = stv->next) {
  1326.          debug_printf("variant %p\n", stv);
  1327.          tgsi_dump(stv->tgsi.tokens, 0);
  1328.       }
  1329.    }
  1330. }
  1331.