src/mesa/drivers/dri/i965/brw_wm.c

   1 /*
   2  Copyright (C) Intel Corp.  2006.  All Rights Reserved.
   3  Intel funded Tungsten Graphics (http://www.tungstengraphics.com) to
   4  develop this 3D driver.
   5
   6  Permission is hereby granted, free of charge, to any person obtaining
   7  a 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, sublicense, 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
  16  portions of the Software.
  17
  18  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  19  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  21  IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
  22  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  23  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  24  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25
  26  **********************************************************************/
  27  /*
  28   * Authors:
  29   *   Keith Whitwell <keith@tungstengraphics.com>
  30   */
  31
  32 #include "brw_context.h"
  33 #include "brw_wm.h"
  34 #include "brw_state.h"
  35 #include "main/formats.h"
  36 #include "main/fbobject.h"
  37 #include "main/samplerobj.h"
  38 #include "program/prog_parameter.h"
  39
  40 #include "glsl/ralloc.h"
  41
  42 /**
  43  * Return a bitfield where bit n is set if barycentric interpolation mode n
  44  * (see enum brw_wm_barycentric_interp_mode) is needed by the fragment shader.
  45  */
  46 static unsigned
  47 brw_compute_barycentric_interp_modes(struct brw_context *brw,
  48                                      bool shade_model_flat,
  49                                      const struct gl_fragment_program *fprog)
  50 {
  51    unsigned barycentric_interp_modes = 0;
  52    int attr;
  53
  54    /* Loop through all fragment shader inputs to figure out what interpolation
  55     * modes are in use, and set the appropriate bits in
  56     * barycentric_interp_modes.
  57     */
  58    for (attr = 0; attr < FRAG_ATTRIB_MAX; ++attr) {
  59       enum glsl_interp_qualifier interp_qualifier =
  60          fprog->InterpQualifier[attr];
  61       bool is_centroid = fprog->IsCentroid & BITFIELD64_BIT(attr);
  62       bool is_gl_Color = attr == FRAG_ATTRIB_COL0 || attr == FRAG_ATTRIB_COL1;
  63
  64       /* Ignore unused inputs. */
  65       if (!(fprog->Base.InputsRead & BITFIELD64_BIT(attr)))
  66          continue;
  67
  68       /* Ignore WPOS and FACE, because they don't require interpolation. */
  69       if (attr == FRAG_ATTRIB_WPOS || attr == FRAG_ATTRIB_FACE)
  70          continue;
  71
  72       /* Determine the set (or sets) of barycentric coordinates needed to
  73        * interpolate this variable.  Note that when
  74        * brw->needs_unlit_centroid_workaround is set, centroid interpolation
  75        * uses PIXEL interpolation for unlit pixels and CENTROID interpolation
  76        * for lit pixels, so we need both sets of barycentric coordinates.
  77        */
  78       if (interp_qualifier == INTERP_QUALIFIER_NOPERSPECTIVE) {
  79          if (is_centroid) {
  80             barycentric_interp_modes |=
  81                1 << BRW_WM_NONPERSPECTIVE_CENTROID_BARYCENTRIC;
  82          }
  83          if (!is_centroid || brw->needs_unlit_centroid_workaround) {
  84             barycentric_interp_modes |=
  85                1 << BRW_WM_NONPERSPECTIVE_PIXEL_BARYCENTRIC;
  86          }
  87       } else if (interp_qualifier == INTERP_QUALIFIER_SMOOTH ||
  88                  (!(shade_model_flat && is_gl_Color) &&
  89                   interp_qualifier == INTERP_QUALIFIER_NONE)) {
  90          if (is_centroid) {
  91             barycentric_interp_modes |=
  92                1 << BRW_WM_PERSPECTIVE_CENTROID_BARYCENTRIC;
  93          }
  94          if (!is_centroid || brw->needs_unlit_centroid_workaround) {
  95             barycentric_interp_modes |=
  96                1 << BRW_WM_PERSPECTIVE_PIXEL_BARYCENTRIC;
  97          }
  98       }
  99    }
 100
 101    return barycentric_interp_modes;
 102 }
 103
 104
 105 void
 106 brw_wm_payload_setup(struct brw_context *brw,
 107                      struct brw_wm_compile *c)
 108 {
 109    struct intel_context *intel = &brw->intel;
 110    bool uses_depth = (c->fp->program.Base.InputsRead &
 111                       (1 << FRAG_ATTRIB_WPOS)) != 0;
 112    unsigned barycentric_interp_modes = c->prog_data.barycentric_interp_modes;
 113    int i;
 114
 115    if (intel->gen >= 6) {
 116       /* R0-1: masks, pixel X/Y coordinates. */
 117       c->nr_payload_regs = 2;
 118       /* R2: only for 32-pixel dispatch.*/
 119
 120       /* R3-26: barycentric interpolation coordinates.  These appear in the
 121        * same order that they appear in the brw_wm_barycentric_interp_mode
 122        * enum.  Each set of coordinates occupies 2 registers if dispatch width
 123        * == 8 and 4 registers if dispatch width == 16.  Coordinates only
 124        * appear if they were enabled using the "Barycentric Interpolation
 125        * Mode" bits in WM_STATE.
 126        */
 127       for (i = 0; i < BRW_WM_BARYCENTRIC_INTERP_MODE_COUNT; ++i) {
 128          if (barycentric_interp_modes & (1 << i)) {
 129             c->barycentric_coord_reg[i] = c->nr_payload_regs;
 130             c->nr_payload_regs += 2;
 131             if (c->dispatch_width == 16) {
 132                c->nr_payload_regs += 2;
 133             }
 134          }
 135       }
 136
 137       /* R27: interpolated depth if uses source depth */
 138       if (uses_depth) {
 139          c->source_depth_reg = c->nr_payload_regs;
 140          c->nr_payload_regs++;
 141          if (c->dispatch_width == 16) {
 142             /* R28: interpolated depth if not 8-wide. */
 143             c->nr_payload_regs++;
 144          }
 145       }
 146       /* R29: interpolated W set if GEN6_WM_USES_SOURCE_W.
 147        */
 148       if (uses_depth) {
 149          c->source_w_reg = c->nr_payload_regs;
 150          c->nr_payload_regs++;
 151          if (c->dispatch_width == 16) {
 152             /* R30: interpolated W if not 8-wide. */
 153             c->nr_payload_regs++;
 154          }
 155       }
 156       /* R31: MSAA position offsets. */
 157       /* R32-: bary for 32-pixel. */
 158       /* R58-59: interp W for 32-pixel. */
 159
 160       if (c->fp->program.Base.OutputsWritten &
 161           BITFIELD64_BIT(FRAG_RESULT_DEPTH)) {
 162          c->source_depth_to_render_target = true;
 163       }
 164    } else {
 165       brw_wm_lookup_iz(intel, c);
 166    }
 167 }
 168
 169 bool
 170 brw_wm_prog_data_compare(const void *in_a, const void *in_b,
 171                          int aux_size, const void *in_key)
 172 {
 173    const struct brw_wm_prog_data *a = in_a;
 174    const struct brw_wm_prog_data *b = in_b;
 175
 176    /* Compare all the struct up to the pointers. */
 177    if (memcmp(a, b, offsetof(struct brw_wm_prog_data, param)))
 178       return false;
 179
 180    if (memcmp(a->param, b->param, a->nr_params * sizeof(void *)))
 181       return false;
 182
 183    if (memcmp(a->pull_param, b->pull_param, a->nr_pull_params * sizeof(void *)))
 184       return false;
 185
 186    return true;
 187 }
 188
 189 void
 190 brw_wm_prog_data_free(const void *in_prog_data)
 191 {
 192    const struct brw_wm_prog_data *prog_data = in_prog_data;
 193
 194    ralloc_free((void *)prog_data->param);
 195    ralloc_free((void *)prog_data->pull_param);
 196 }
 197
 198 /**
 199  * All Mesa program -> GPU code generation goes through this function.
 200  * Depending on the instructions used (i.e. flow control instructions)
 201  * we'll use one of two code generators.
 202  */
 203 bool do_wm_prog(struct brw_context *brw,
 204                 struct gl_shader_program *prog,
 205                 struct brw_fragment_program *fp,
 206                 struct brw_wm_prog_key *key)
 207 {
 208    struct intel_context *intel = &brw->intel;
 209    struct brw_wm_compile *c;
 210    const GLuint *program;
 211    struct gl_shader *fs = NULL;
 212    GLuint program_size;
 213
 214    if (prog)
 215       fs = prog->_LinkedShaders[MESA_SHADER_FRAGMENT];
 216
 217    c = rzalloc(NULL, struct brw_wm_compile);
 218
 219    /* Allocate the references to the uniforms that will end up in the
 220     * prog_data associated with the compiled program, and which will be freed
 221     * by the state cache.
 222     */
 223    int param_count;
 224    if (fs) {
 225       param_count = fs->num_uniform_components;
 226    } else {
 227       param_count = fp->program.Base.Parameters->NumParameters * 4;
 228    }
 229    /* The backend also sometimes adds params for texture size. */
 230    param_count += 2 * BRW_MAX_TEX_UNIT;
 231    c->prog_data.param = rzalloc_array(NULL, const float *, param_count);
 232    c->prog_data.pull_param = rzalloc_array(NULL, const float *, param_count);
 233
 234    memcpy(&c->key, key, sizeof(*key));
 235
 236    c->fp = fp;
 237
 238    brw_init_compile(brw, &c->func, c);
 239
 240    c->prog_data.barycentric_interp_modes =
 241       brw_compute_barycentric_interp_modes(brw, c->key.flat_shade,
 242                                            &fp->program);
 243
 244    brw_wm_fs_emit(brw, c, prog);
 245
 246    /* Scratch space is used for register spilling */
 247    if (c->last_scratch) {
 248       perf_debug("Fragment shader triggered register spilling.  "
 249                  "Try reducing the number of live scalar values to "
 250                  "improve performance.\n");
 251
 252       c->prog_data.total_scratch = brw_get_scratch_size(c->last_scratch);
 253
 254       brw_get_scratch_bo(intel, &brw->wm.scratch_bo,
 255                          c->prog_data.total_scratch * brw->max_wm_threads);
 256    }
 257
 258    if (unlikely(INTEL_DEBUG & DEBUG_WM))
 259       fprintf(stderr, "\n");
 260
 261    /* get the program
 262     */
 263    program = brw_get_program(&c->func, &program_size);
 264
 265    brw_upload_cache(&brw->cache, BRW_WM_PROG,
 266                     &c->key, sizeof(c->key),
 267                     program, program_size,
 268                     &c->prog_data, sizeof(c->prog_data),
 269                     &brw->wm.prog_offset, &brw->wm.prog_data);
 270
 271    ralloc_free(c);
 272
 273    return true;
 274 }
 275
 276 static bool
 277 key_debug(const char *name, int a, int b)
 278 {
 279    if (a != b) {
 280       perf_debug("  %s %d->%d\n", name, a, b);
 281       return true;
 282    } else {
 283       return false;
 284    }
 285 }
 286
 287 bool
 288 brw_debug_recompile_sampler_key(const struct brw_sampler_prog_key_data *old_key,
 289                                 const struct brw_sampler_prog_key_data *key)
 290 {
 291    bool found = false;
 292
 293    for (unsigned int i = 0; i < MAX_SAMPLERS; i++) {
 294       found |= key_debug("EXT_texture_swizzle or DEPTH_TEXTURE_MODE",
 295                          old_key->swizzles[i], key->swizzles[i]);
 296    }
 297    found |= key_debug("GL_CLAMP enabled on any texture unit's 1st coordinate",
 298                       old_key->gl_clamp_mask[0], key->gl_clamp_mask[0]);
 299    found |= key_debug("GL_CLAMP enabled on any texture unit's 2nd coordinate",
 300                       old_key->gl_clamp_mask[1], key->gl_clamp_mask[1]);
 301    found |= key_debug("GL_CLAMP enabled on any texture unit's 3rd coordinate",
 302                       old_key->gl_clamp_mask[2], key->gl_clamp_mask[2]);
 303    found |= key_debug("GL_MESA_ycbcr texturing\n",
 304                       old_key->yuvtex_mask, key->yuvtex_mask);
 305    found |= key_debug("GL_MESA_ycbcr UV swapping\n",
 306                       old_key->yuvtex_swap_mask, key->yuvtex_swap_mask);
 307
 308    return found;
 309 }
 310
 311 void
 312 brw_wm_debug_recompile(struct brw_context *brw,
 313                        struct gl_shader_program *prog,
 314                        const struct brw_wm_prog_key *key)
 315 {
 316    struct brw_cache_item *c = NULL;
 317    const struct brw_wm_prog_key *old_key = NULL;
 318    bool found = false;
 319
 320    perf_debug("Recompiling fragment shader for program %d\n", prog->Name);
 321
 322    for (unsigned int i = 0; i < brw->cache.size; i++) {
 323       for (c = brw->cache.items[i]; c; c = c->next) {
 324          if (c->cache_id == BRW_WM_PROG) {
 325             old_key = c->key;
 326
 327             if (old_key->program_string_id == key->program_string_id)
 328                break;
 329          }
 330       }
 331       if (c)
 332          break;
 333    }
 334
 335    if (!c) {
 336       perf_debug("  Didn't find previous compile in the shader cache for "
 337                  "debug\n");
 338       return;
 339    }
 340
 341    found |= key_debug("alphatest, computed depth, depth test, or depth write",
 342                       old_key->iz_lookup, key->iz_lookup);
 343    found |= key_debug("depth statistics", old_key->stats_wm, key->stats_wm);
 344    found |= key_debug("flat shading", old_key->flat_shade, key->flat_shade);
 345    found |= key_debug("number of color buffers", old_key->nr_color_regions, key->nr_color_regions);
 346    found |= key_debug("sample alpha to coverage", old_key->sample_alpha_to_coverage, key->sample_alpha_to_coverage);
 347    found |= key_debug("rendering to FBO", old_key->render_to_fbo, key->render_to_fbo);
 348    found |= key_debug("fragment color clamping", old_key->clamp_fragment_color, key->clamp_fragment_color);
 349    found |= key_debug("line smoothing", old_key->line_aa, key->line_aa);
 350    found |= key_debug("proj_attrib_mask", old_key->proj_attrib_mask, key->proj_attrib_mask);
 351    found |= key_debug("renderbuffer height", old_key->drawable_height, key->drawable_height);
 352    found |= key_debug("vertex shader outputs", old_key->vp_outputs_written, key->vp_outputs_written);
 353
 354    found |= brw_debug_recompile_sampler_key(&old_key->tex, &key->tex);
 355
 356    if (!found) {
 357       perf_debug("  Something else\n");
 358    }
 359 }
 360
 361 void
 362 brw_populate_sampler_prog_key_data(struct gl_context *ctx,
 363                                    const struct gl_program *prog,
 364                                    struct brw_sampler_prog_key_data *key)
 365 {
 366    struct intel_context *intel = intel_context(ctx);
 367
 368    for (int s = 0; s < MAX_SAMPLERS; s++) {
 369       key->swizzles[s] = SWIZZLE_NOOP;
 370
 371       if (!(prog->SamplersUsed & (1 << s)))
 372          continue;
 373
 374       int unit_id = prog->SamplerUnits[s];
 375       const struct gl_texture_unit *unit = &ctx->Texture.Unit[unit_id];
 376
 377       if (unit->_ReallyEnabled && unit->_Current->Target != GL_TEXTURE_BUFFER) {
 378          const struct gl_texture_object *t = unit->_Current;
 379          const struct gl_texture_image *img = t->Image[0][t->BaseLevel];
 380          struct gl_sampler_object *sampler = _mesa_get_samplerobj(ctx, unit_id);
 381
 382          const bool alpha_depth = t->DepthMode == GL_ALPHA &&
 383             (img->_BaseFormat == GL_DEPTH_COMPONENT ||
 384              img->_BaseFormat == GL_DEPTH_STENCIL);
 385
 386          /* Haswell handles texture swizzling as surface format overrides
 387           * (except for GL_ALPHA); all other platforms need MOVs in the shader.
 388           */
 389          if (!intel->is_haswell || alpha_depth)
 390             key->swizzles[s] = brw_get_texture_swizzle(t);
 391
 392          if (img->InternalFormat == GL_YCBCR_MESA) {
 393             key->yuvtex_mask |= 1 << s;
 394             if (img->TexFormat == MESA_FORMAT_YCBCR)
 395                 key->yuvtex_swap_mask |= 1 << s;
 396          }
 397
 398          if (sampler->MinFilter != GL_NEAREST &&
 399              sampler->MagFilter != GL_NEAREST) {
 400             if (sampler->WrapS == GL_CLAMP)
 401                key->gl_clamp_mask[0] |= 1 << s;
 402             if (sampler->WrapT == GL_CLAMP)
 403                key->gl_clamp_mask[1] |= 1 << s;
 404             if (sampler->WrapR == GL_CLAMP)
 405                key->gl_clamp_mask[2] |= 1 << s;
 406          }
 407       }
 408    }
 409 }
 410
 411 static void brw_wm_populate_key( struct brw_context *brw,
 412                                  struct brw_wm_prog_key *key )
 413 {
 414    struct gl_context *ctx = &brw->intel.ctx;
 415    struct intel_context *intel = &brw->intel;
 416    /* BRW_NEW_FRAGMENT_PROGRAM */
 417    const struct brw_fragment_program *fp =
 418       (struct brw_fragment_program *)brw->fragment_program;
 419    const struct gl_program *prog = (struct gl_program *) brw->fragment_program;
 420    GLuint lookup = 0;
 421    GLuint line_aa;
 422    bool program_uses_dfdy = fp->program.UsesDFdy;
 423
 424    memset(key, 0, sizeof(*key));
 425
 426    /* Build the index for table lookup
 427     */
 428    if (intel->gen < 6) {
 429       /* _NEW_COLOR */
 430       if (fp->program.UsesKill || ctx->Color.AlphaEnabled)
 431          lookup |= IZ_PS_KILL_ALPHATEST_BIT;
 432
 433       if (fp->program.Base.OutputsWritten & BITFIELD64_BIT(FRAG_RESULT_DEPTH))
 434          lookup |= IZ_PS_COMPUTES_DEPTH_BIT;
 435
 436       /* _NEW_DEPTH */
 437       if (ctx->Depth.Test)
 438          lookup |= IZ_DEPTH_TEST_ENABLE_BIT;
 439
 440       if (ctx->Depth.Test && ctx->Depth.Mask) /* ?? */
 441          lookup |= IZ_DEPTH_WRITE_ENABLE_BIT;
 442
 443       /* _NEW_STENCIL */
 444       if (ctx->Stencil._Enabled) {
 445          lookup |= IZ_STENCIL_TEST_ENABLE_BIT;
 446
 447          if (ctx->Stencil.WriteMask[0] ||
 448              ctx->Stencil.WriteMask[ctx->Stencil._BackFace])
 449             lookup |= IZ_STENCIL_WRITE_ENABLE_BIT;
 450       }
 451       key->iz_lookup = lookup;
 452    }
 453
 454    line_aa = AA_NEVER;
 455
 456    /* _NEW_LINE, _NEW_POLYGON, BRW_NEW_REDUCED_PRIMITIVE */
 457    if (ctx->Line.SmoothFlag) {
 458       if (brw->intel.reduced_primitive == GL_LINES) {
 459          line_aa = AA_ALWAYS;
 460       }
 461       else if (brw->intel.reduced_primitive == GL_TRIANGLES) {
 462          if (ctx->Polygon.FrontMode == GL_LINE) {
 463             line_aa = AA_SOMETIMES;
 464
 465             if (ctx->Polygon.BackMode == GL_LINE ||
 466                 (ctx->Polygon.CullFlag &&
 467                  ctx->Polygon.CullFaceMode == GL_BACK))
 468                line_aa = AA_ALWAYS;
 469          }
 470          else if (ctx->Polygon.BackMode == GL_LINE) {
 471             line_aa = AA_SOMETIMES;
 472
 473             if ((ctx->Polygon.CullFlag &&
 474                  ctx->Polygon.CullFaceMode == GL_FRONT))
 475                line_aa = AA_ALWAYS;
 476          }
 477       }
 478    }
 479
 480    key->line_aa = line_aa;
 481
 482    if (intel->gen < 6)
 483       key->stats_wm = brw->intel.stats_wm;
 484
 485    /* BRW_NEW_WM_INPUT_DIMENSIONS */
 486    /* Only set this for fixed function.  The optimization it enables isn't
 487     * useful for programs using shaders.
 488     */
 489    if (ctx->Shader.CurrentFragmentProgram)
 490       key->proj_attrib_mask = 0xffffffff;
 491    else
 492       key->proj_attrib_mask = brw->wm.input_size_masks[4-1];
 493
 494    /* _NEW_LIGHT */
 495    key->flat_shade = (ctx->Light.ShadeModel == GL_FLAT);
 496
 497    /* _NEW_FRAG_CLAMP | _NEW_BUFFERS */
 498    key->clamp_fragment_color = ctx->Color._ClampFragmentColor;
 499
 500    /* _NEW_TEXTURE */
 501    brw_populate_sampler_prog_key_data(ctx, prog, &key->tex);
 502
 503    /* _NEW_BUFFERS */
 504    /*
 505     * Include the draw buffer origin and height so that we can calculate
 506     * fragment position values relative to the bottom left of the drawable,
 507     * from the incoming screen origin relative position we get as part of our
 508     * payload.
 509     *
 510     * This is only needed for the WM_WPOSXY opcode when the fragment program
 511     * uses the gl_FragCoord input.
 512     *
 513     * We could avoid recompiling by including this as a constant referenced by
 514     * our program, but if we were to do that it would also be nice to handle
 515     * getting that constant updated at batchbuffer submit time (when we
 516     * hold the lock and know where the buffer really is) rather than at emit
 517     * time when we don't hold the lock and are just guessing.  We could also
 518     * just avoid using this as key data if the program doesn't use
 519     * fragment.position.
 520     *
 521     * For DRI2 the origin_x/y will always be (0,0) but we still need the
 522     * drawable height in order to invert the Y axis.
 523     */
 524    if (fp->program.Base.InputsRead & FRAG_BIT_WPOS) {
 525       key->drawable_height = ctx->DrawBuffer->Height;
 526    }
 527
 528    if ((fp->program.Base.InputsRead & FRAG_BIT_WPOS) || program_uses_dfdy) {
 529       key->render_to_fbo = _mesa_is_user_fbo(ctx->DrawBuffer);
 530    }
 531
 532    /* _NEW_BUFFERS */
 533    key->nr_color_regions = ctx->DrawBuffer->_NumColorDrawBuffers;
 534   /* _NEW_MULTISAMPLE */
 535    key->sample_alpha_to_coverage = ctx->Multisample.SampleAlphaToCoverage;
 536
 537    /* CACHE_NEW_VS_PROG */
 538    if (intel->gen < 6)
 539       key->vp_outputs_written = brw->vs.prog_data->outputs_written;
 540
 541    /* The unique fragment program ID */
 542    key->program_string_id = fp->id;
 543 }
 544
 545
 546 static void
 547 brw_upload_wm_prog(struct brw_context *brw)
 548 {
 549    struct intel_context *intel = &brw->intel;
 550    struct gl_context *ctx = &intel->ctx;
 551    struct brw_wm_prog_key key;
 552    struct brw_fragment_program *fp = (struct brw_fragment_program *)
 553       brw->fragment_program;
 554
 555    brw_wm_populate_key(brw, &key);
 556
 557    if (!brw_search_cache(&brw->cache, BRW_WM_PROG,
 558                          &key, sizeof(key),
 559                          &brw->wm.prog_offset, &brw->wm.prog_data)) {
 560       bool success = do_wm_prog(brw, ctx->Shader._CurrentFragmentProgram, fp,
 561                                 &key);
 562       (void) success;
 563       assert(success);
 564    }
 565 }
 566
 567
 568 const struct brw_tracked_state brw_wm_prog = {
 569    .dirty = {
 570       .mesa  = (_NEW_COLOR |
 571                 _NEW_DEPTH |
 572                 _NEW_STENCIL |
 573                 _NEW_POLYGON |
 574                 _NEW_LINE |
 575                 _NEW_LIGHT |
 576                 _NEW_FRAG_CLAMP |
 577                 _NEW_BUFFERS |
 578                 _NEW_TEXTURE |
 579                 _NEW_MULTISAMPLE),
 580       .brw   = (BRW_NEW_FRAGMENT_PROGRAM |
 581                 BRW_NEW_WM_INPUT_DIMENSIONS |
 582                 BRW_NEW_REDUCED_PRIMITIVE),
 583       .cache = CACHE_NEW_VS_PROG,
 584    },
 585    .emit = brw_upload_wm_prog
 586 };
 587