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

   1 /*
   2  Copyright (C) Intel Corp.  2006.  All Rights Reserved.
   3  Intel funded Tungsten Graphics 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 <keithw@vmware.com>
  30   */
  31
  32 #include "brw_context.h"
  33 #include "brw_wm.h"
  34 #include "brw_state.h"
  35 #include "main/enums.h"
  36 #include "main/formats.h"
  37 #include "main/fbobject.h"
  38 #include "main/samplerobj.h"
  39 #include "main/framebuffer.h"
  40 #include "program/prog_parameter.h"
  41 #include "program/program.h"
  42 #include "intel_mipmap_tree.h"
  43
  44 #include "util/ralloc.h"
  45
  46 /**
  47  * Return a bitfield where bit n is set if barycentric interpolation mode n
  48  * (see enum brw_wm_barycentric_interp_mode) is needed by the fragment shader.
  49  */
  50 unsigned
  51 brw_compute_barycentric_interp_modes(struct brw_context *brw,
  52                                      bool shade_model_flat,
  53                                      bool persample_shading,
  54                                      const struct gl_fragment_program *fprog)
  55 {
  56    unsigned barycentric_interp_modes = 0;
  57    int attr;
  58
  59    /* Loop through all fragment shader inputs to figure out what interpolation
  60     * modes are in use, and set the appropriate bits in
  61     * barycentric_interp_modes.
  62     */
  63    for (attr = 0; attr < VARYING_SLOT_MAX; ++attr) {
  64       enum glsl_interp_qualifier interp_qualifier =
  65          fprog->InterpQualifier[attr];
  66       bool is_centroid = (fprog->IsCentroid & BITFIELD64_BIT(attr)) &&
  67          !persample_shading;
  68       bool is_sample = (fprog->IsSample & BITFIELD64_BIT(attr)) ||
  69          persample_shading;
  70       bool is_gl_Color = attr == VARYING_SLOT_COL0 || attr == VARYING_SLOT_COL1;
  71
  72       /* Ignore unused inputs. */
  73       if (!(fprog->Base.InputsRead & BITFIELD64_BIT(attr)))
  74          continue;
  75
  76       /* Ignore WPOS and FACE, because they don't require interpolation. */
  77       if (attr == VARYING_SLOT_POS || attr == VARYING_SLOT_FACE)
  78          continue;
  79
  80       /* Determine the set (or sets) of barycentric coordinates needed to
  81        * interpolate this variable.  Note that when
  82        * brw->needs_unlit_centroid_workaround is set, centroid interpolation
  83        * uses PIXEL interpolation for unlit pixels and CENTROID interpolation
  84        * for lit pixels, so we need both sets of barycentric coordinates.
  85        */
  86       if (interp_qualifier == INTERP_QUALIFIER_NOPERSPECTIVE) {
  87          if (is_centroid) {
  88             barycentric_interp_modes |=
  89                1 << BRW_WM_NONPERSPECTIVE_CENTROID_BARYCENTRIC;
  90          } else if (is_sample) {
  91             barycentric_interp_modes |=
  92                1 << BRW_WM_NONPERSPECTIVE_SAMPLE_BARYCENTRIC;
  93          }
  94          if ((!is_centroid && !is_sample) ||
  95              brw->needs_unlit_centroid_workaround) {
  96             barycentric_interp_modes |=
  97                1 << BRW_WM_NONPERSPECTIVE_PIXEL_BARYCENTRIC;
  98          }
  99       } else if (interp_qualifier == INTERP_QUALIFIER_SMOOTH ||
 100                  (!(shade_model_flat && is_gl_Color) &&
 101                   interp_qualifier == INTERP_QUALIFIER_NONE)) {
 102          if (is_centroid) {
 103             barycentric_interp_modes |=
 104                1 << BRW_WM_PERSPECTIVE_CENTROID_BARYCENTRIC;
 105          } else if (is_sample) {
 106             barycentric_interp_modes |=
 107                1 << BRW_WM_PERSPECTIVE_SAMPLE_BARYCENTRIC;
 108          }
 109          if ((!is_centroid && !is_sample) ||
 110              brw->needs_unlit_centroid_workaround) {
 111             barycentric_interp_modes |=
 112                1 << BRW_WM_PERSPECTIVE_PIXEL_BARYCENTRIC;
 113          }
 114       }
 115    }
 116
 117    return barycentric_interp_modes;
 118 }
 119
 120 static uint8_t
 121 computed_depth_mode(struct gl_fragment_program *fp)
 122 {
 123    if (fp->Base.OutputsWritten & BITFIELD64_BIT(FRAG_RESULT_DEPTH)) {
 124       switch (fp->FragDepthLayout) {
 125       case FRAG_DEPTH_LAYOUT_NONE:
 126       case FRAG_DEPTH_LAYOUT_ANY:
 127          return BRW_PSCDEPTH_ON;
 128       case FRAG_DEPTH_LAYOUT_GREATER:
 129          return BRW_PSCDEPTH_ON_GE;
 130       case FRAG_DEPTH_LAYOUT_LESS:
 131          return BRW_PSCDEPTH_ON_LE;
 132       case FRAG_DEPTH_LAYOUT_UNCHANGED:
 133          return BRW_PSCDEPTH_OFF;
 134       }
 135    }
 136    return BRW_PSCDEPTH_OFF;
 137 }
 138
 139 bool
 140 brw_wm_prog_data_compare(const void *in_a, const void *in_b)
 141 {
 142    const struct brw_wm_prog_data *a = in_a;
 143    const struct brw_wm_prog_data *b = in_b;
 144
 145    /* Compare the base structure. */
 146    if (!brw_stage_prog_data_compare(&a->base, &b->base))
 147       return false;
 148
 149    /* Compare the rest of the structure. */
 150    const unsigned offset = sizeof(struct brw_stage_prog_data);
 151    if (memcmp(((char *) a) + offset, ((char *) b) + offset,
 152               sizeof(struct brw_wm_prog_data) - offset))
 153       return false;
 154
 155    return true;
 156 }
 157
 158 /**
 159  * All Mesa program -> GPU code generation goes through this function.
 160  * Depending on the instructions used (i.e. flow control instructions)
 161  * we'll use one of two code generators.
 162  */
 163 bool
 164 brw_codegen_wm_prog(struct brw_context *brw,
 165                     struct gl_shader_program *prog,
 166                     struct brw_fragment_program *fp,
 167                     struct brw_wm_prog_key *key)
 168 {
 169    struct gl_context *ctx = &brw->ctx;
 170    void *mem_ctx = ralloc_context(NULL);
 171    struct brw_wm_prog_data prog_data;
 172    const GLuint *program;
 173    struct gl_shader *fs = NULL;
 174    GLuint program_size;
 175
 176    if (prog)
 177       fs = prog->_LinkedShaders[MESA_SHADER_FRAGMENT];
 178
 179    memset(&prog_data, 0, sizeof(prog_data));
 180    /* key->alpha_test_func means simulating alpha testing via discards,
 181     * so the shader definitely kills pixels.
 182     */
 183    prog_data.uses_kill = fp->program.UsesKill || key->alpha_test_func;
 184
 185    prog_data.computed_depth_mode = computed_depth_mode(&fp->program);
 186
 187    /* Use ALT floating point mode for ARB programs so that 0^0 == 1. */
 188    if (!prog)
 189       prog_data.base.use_alt_mode = true;
 190
 191    /* Allocate the references to the uniforms that will end up in the
 192     * prog_data associated with the compiled program, and which will be freed
 193     * by the state cache.
 194     */
 195    int param_count;
 196    if (fs) {
 197       param_count = fs->num_uniform_components;
 198    } else {
 199       param_count = fp->program.Base.Parameters->NumParameters * 4;
 200    }
 201    /* The backend also sometimes adds params for texture size. */
 202    param_count += 2 * ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits;
 203    prog_data.base.param =
 204       rzalloc_array(NULL, const gl_constant_value *, param_count);
 205    prog_data.base.pull_param =
 206       rzalloc_array(NULL, const gl_constant_value *, param_count);
 207    prog_data.base.nr_params = param_count;
 208
 209    prog_data.barycentric_interp_modes =
 210       brw_compute_barycentric_interp_modes(brw, key->flat_shade,
 211                                            key->persample_shading,
 212                                            &fp->program);
 213
 214    program = brw_wm_fs_emit(brw, mem_ctx, key, &prog_data,
 215                             &fp->program, prog, &program_size);
 216    if (program == NULL) {
 217       ralloc_free(mem_ctx);
 218       return false;
 219    }
 220
 221    if (prog_data.base.total_scratch) {
 222       brw_get_scratch_bo(brw, &brw->wm.base.scratch_bo,
 223                          prog_data.base.total_scratch * brw->max_wm_threads);
 224    }
 225
 226    if (unlikely(INTEL_DEBUG & DEBUG_WM))
 227       fprintf(stderr, "\n");
 228
 229    brw_upload_cache(&brw->cache, BRW_CACHE_FS_PROG,
 230                     key, sizeof(struct brw_wm_prog_key),
 231                     program, program_size,
 232                     &prog_data, sizeof(prog_data),
 233                     &brw->wm.base.prog_offset, &brw->wm.prog_data);
 234
 235    ralloc_free(mem_ctx);
 236
 237    return true;
 238 }
 239
 240 static bool
 241 key_debug(struct brw_context *brw, const char *name, int a, int b)
 242 {
 243    if (a != b) {
 244       perf_debug("  %s %d->%d\n", name, a, b);
 245       return true;
 246    } else {
 247       return false;
 248    }
 249 }
 250
 251 bool
 252 brw_debug_recompile_sampler_key(struct brw_context *brw,
 253                                 const struct brw_sampler_prog_key_data *old_key,
 254                                 const struct brw_sampler_prog_key_data *key)
 255 {
 256    bool found = false;
 257
 258    for (unsigned int i = 0; i < MAX_SAMPLERS; i++) {
 259       found |= key_debug(brw, "EXT_texture_swizzle or DEPTH_TEXTURE_MODE",
 260                          old_key->swizzles[i], key->swizzles[i]);
 261    }
 262    found |= key_debug(brw, "GL_CLAMP enabled on any texture unit's 1st coordinate",
 263                       old_key->gl_clamp_mask[0], key->gl_clamp_mask[0]);
 264    found |= key_debug(brw, "GL_CLAMP enabled on any texture unit's 2nd coordinate",
 265                       old_key->gl_clamp_mask[1], key->gl_clamp_mask[1]);
 266    found |= key_debug(brw, "GL_CLAMP enabled on any texture unit's 3rd coordinate",
 267                       old_key->gl_clamp_mask[2], key->gl_clamp_mask[2]);
 268    found |= key_debug(brw, "gather channel quirk on any texture unit",
 269                       old_key->gather_channel_quirk_mask, key->gather_channel_quirk_mask);
 270    found |= key_debug(brw, "compressed multisample layout",
 271                       old_key->compressed_multisample_layout_mask,
 272                       key->compressed_multisample_layout_mask);
 273
 274    for (unsigned int i = 0; i < MAX_SAMPLERS; i++) {
 275       found |= key_debug(brw, "textureGather workarounds",
 276                          old_key->gen6_gather_wa[i], key->gen6_gather_wa[i]);
 277    }
 278
 279    return found;
 280 }
 281
 282 void
 283 brw_wm_debug_recompile(struct brw_context *brw,
 284                        struct gl_shader_program *prog,
 285                        const struct brw_wm_prog_key *key)
 286 {
 287    struct brw_cache_item *c = NULL;
 288    const struct brw_wm_prog_key *old_key = NULL;
 289    bool found = false;
 290
 291    perf_debug("Recompiling fragment shader for program %d\n", prog->Name);
 292
 293    for (unsigned int i = 0; i < brw->cache.size; i++) {
 294       for (c = brw->cache.items[i]; c; c = c->next) {
 295          if (c->cache_id == BRW_CACHE_FS_PROG) {
 296             old_key = c->key;
 297
 298             if (old_key->program_string_id == key->program_string_id)
 299                break;
 300          }
 301       }
 302       if (c)
 303          break;
 304    }
 305
 306    if (!c) {
 307       perf_debug("  Didn't find previous compile in the shader cache for debug\n");
 308       return;
 309    }
 310
 311    found |= key_debug(brw, "alphatest, computed depth, depth test, or "
 312                       "depth write",
 313                       old_key->iz_lookup, key->iz_lookup);
 314    found |= key_debug(brw, "depth statistics",
 315                       old_key->stats_wm, key->stats_wm);
 316    found |= key_debug(brw, "flat shading",
 317                       old_key->flat_shade, key->flat_shade);
 318    found |= key_debug(brw, "per-sample shading",
 319                       old_key->persample_shading, key->persample_shading);
 320    found |= key_debug(brw, "per-sample shading and 2x MSAA",
 321                       old_key->persample_2x, key->persample_2x);
 322    found |= key_debug(brw, "number of color buffers",
 323                       old_key->nr_color_regions, key->nr_color_regions);
 324    found |= key_debug(brw, "MRT alpha test or alpha-to-coverage",
 325                       old_key->replicate_alpha, key->replicate_alpha);
 326    found |= key_debug(brw, "rendering to FBO",
 327                       old_key->render_to_fbo, key->render_to_fbo);
 328    found |= key_debug(brw, "fragment color clamping",
 329                       old_key->clamp_fragment_color, key->clamp_fragment_color);
 330    found |= key_debug(brw, "line smoothing",
 331                       old_key->line_aa, key->line_aa);
 332    found |= key_debug(brw, "renderbuffer height",
 333                       old_key->drawable_height, key->drawable_height);
 334    found |= key_debug(brw, "input slots valid",
 335                       old_key->input_slots_valid, key->input_slots_valid);
 336    found |= key_debug(brw, "mrt alpha test function",
 337                       old_key->alpha_test_func, key->alpha_test_func);
 338    found |= key_debug(brw, "mrt alpha test reference value",
 339                       old_key->alpha_test_ref, key->alpha_test_ref);
 340
 341    found |= brw_debug_recompile_sampler_key(brw, &old_key->tex, &key->tex);
 342
 343    if (!found) {
 344       perf_debug("  Something else\n");
 345    }
 346 }
 347
 348 static uint8_t
 349 gen6_gather_workaround(GLenum internalformat)
 350 {
 351    switch (internalformat) {
 352       case GL_R8I: return WA_SIGN | WA_8BIT;
 353       case GL_R8UI: return WA_8BIT;
 354       case GL_R16I: return WA_SIGN | WA_16BIT;
 355       case GL_R16UI: return WA_16BIT;
 356       /* note that even though GL_R32I and GL_R32UI have format overrides
 357        * in the surface state, there is no shader w/a required */
 358       default: return 0;
 359    }
 360 }
 361
 362 void
 363 brw_populate_sampler_prog_key_data(struct gl_context *ctx,
 364                                    const struct gl_program *prog,
 365                                    unsigned sampler_count,
 366                                    struct brw_sampler_prog_key_data *key)
 367 {
 368    struct brw_context *brw = brw_context(ctx);
 369
 370    for (int s = 0; s < sampler_count; s++) {
 371       key->swizzles[s] = SWIZZLE_NOOP;
 372
 373       if (!(prog->SamplersUsed & (1 << s)))
 374          continue;
 375
 376       int unit_id = prog->SamplerUnits[s];
 377       const struct gl_texture_unit *unit = &ctx->Texture.Unit[unit_id];
 378
 379       if (unit->_Current && unit->_Current->Target != GL_TEXTURE_BUFFER) {
 380          const struct gl_texture_object *t = unit->_Current;
 381          const struct gl_texture_image *img = t->Image[0][t->BaseLevel];
 382          struct gl_sampler_object *sampler = _mesa_get_samplerobj(ctx, unit_id);
 383
 384          const bool alpha_depth = t->DepthMode == GL_ALPHA &&
 385             (img->_BaseFormat == GL_DEPTH_COMPONENT ||
 386              img->_BaseFormat == GL_DEPTH_STENCIL);
 387
 388          /* Haswell handles texture swizzling as surface format overrides
 389           * (except for GL_ALPHA); all other platforms need MOVs in the shader.
 390           */
 391          if (alpha_depth || (brw->gen < 8 && !brw->is_haswell))
 392             key->swizzles[s] = brw_get_texture_swizzle(ctx, t);
 393
 394          if (brw->gen < 8 &&
 395              sampler->MinFilter != GL_NEAREST &&
 396              sampler->MagFilter != GL_NEAREST) {
 397             if (sampler->WrapS == GL_CLAMP)
 398                key->gl_clamp_mask[0] |= 1 << s;
 399             if (sampler->WrapT == GL_CLAMP)
 400                key->gl_clamp_mask[1] |= 1 << s;
 401             if (sampler->WrapR == GL_CLAMP)
 402                key->gl_clamp_mask[2] |= 1 << s;
 403          }
 404
 405          /* gather4's channel select for green from RG32F is broken;
 406           * requires a shader w/a on IVB; fixable with just SCS on HSW. */
 407          if (brw->gen == 7 && !brw->is_haswell && prog->UsesGather) {
 408             if (img->InternalFormat == GL_RG32F)
 409                key->gather_channel_quirk_mask |= 1 << s;
 410          }
 411
 412          /* Gen6's gather4 is broken for UINT/SINT; we treat them as
 413           * UNORM/FLOAT instead and fix it in the shader.
 414           */
 415          if (brw->gen == 6 && prog->UsesGather) {
 416             key->gen6_gather_wa[s] = gen6_gather_workaround(img->InternalFormat);
 417          }
 418
 419          /* If this is a multisample sampler, and uses the CMS MSAA layout,
 420           * then we need to emit slightly different code to first sample the
 421           * MCS surface.
 422           */
 423          struct intel_texture_object *intel_tex =
 424             intel_texture_object((struct gl_texture_object *)t);
 425
 426          if (brw->gen >= 7 &&
 427              intel_tex->mt->msaa_layout == INTEL_MSAA_LAYOUT_CMS) {
 428             key->compressed_multisample_layout_mask |= 1 << s;
 429          }
 430       }
 431    }
 432 }
 433
 434 static bool
 435 brw_wm_state_dirty (struct brw_context *brw)
 436 {
 437    return brw_state_dirty(brw,
 438                           _NEW_BUFFERS |
 439                           _NEW_COLOR |
 440                           _NEW_DEPTH |
 441                           _NEW_FRAG_CLAMP |
 442                           _NEW_HINT |
 443                           _NEW_LIGHT |
 444                           _NEW_LINE |
 445                           _NEW_MULTISAMPLE |
 446                           _NEW_POLYGON |
 447                           _NEW_STENCIL |
 448                           _NEW_TEXTURE,
 449                           BRW_NEW_FRAGMENT_PROGRAM |
 450                           BRW_NEW_REDUCED_PRIMITIVE |
 451                           BRW_NEW_STATS_WM |
 452                           BRW_NEW_VUE_MAP_GEOM_OUT);
 453 }
 454
 455 static void brw_wm_populate_key( struct brw_context *brw,
 456                                  struct brw_wm_prog_key *key )
 457 {
 458    struct gl_context *ctx = &brw->ctx;
 459    /* BRW_NEW_FRAGMENT_PROGRAM */
 460    const struct brw_fragment_program *fp =
 461       (struct brw_fragment_program *)brw->fragment_program;
 462    const struct gl_program *prog = (struct gl_program *) brw->fragment_program;
 463    GLuint lookup = 0;
 464    GLuint line_aa;
 465    bool program_uses_dfdy = fp->program.UsesDFdy;
 466    const bool multisample_fbo = _mesa_geometric_samples(ctx->DrawBuffer) > 1;
 467
 468    memset(key, 0, sizeof(*key));
 469
 470    /* Build the index for table lookup
 471     */
 472    if (brw->gen < 6) {
 473       /* _NEW_COLOR */
 474       if (fp->program.UsesKill || ctx->Color.AlphaEnabled)
 475          lookup |= IZ_PS_KILL_ALPHATEST_BIT;
 476
 477       if (fp->program.Base.OutputsWritten & BITFIELD64_BIT(FRAG_RESULT_DEPTH))
 478          lookup |= IZ_PS_COMPUTES_DEPTH_BIT;
 479
 480       /* _NEW_DEPTH */
 481       if (ctx->Depth.Test)
 482          lookup |= IZ_DEPTH_TEST_ENABLE_BIT;
 483
 484       if (ctx->Depth.Test && ctx->Depth.Mask) /* ?? */
 485          lookup |= IZ_DEPTH_WRITE_ENABLE_BIT;
 486
 487       /* _NEW_STENCIL | _NEW_BUFFERS */
 488       if (ctx->Stencil._Enabled) {
 489          lookup |= IZ_STENCIL_TEST_ENABLE_BIT;
 490
 491          if (ctx->Stencil.WriteMask[0] ||
 492              ctx->Stencil.WriteMask[ctx->Stencil._BackFace])
 493             lookup |= IZ_STENCIL_WRITE_ENABLE_BIT;
 494       }
 495       key->iz_lookup = lookup;
 496    }
 497
 498    line_aa = AA_NEVER;
 499
 500    /* _NEW_LINE, _NEW_POLYGON, BRW_NEW_REDUCED_PRIMITIVE */
 501    if (ctx->Line.SmoothFlag) {
 502       if (brw->reduced_primitive == GL_LINES) {
 503          line_aa = AA_ALWAYS;
 504       }
 505       else if (brw->reduced_primitive == GL_TRIANGLES) {
 506          if (ctx->Polygon.FrontMode == GL_LINE) {
 507             line_aa = AA_SOMETIMES;
 508
 509             if (ctx->Polygon.BackMode == GL_LINE ||
 510                 (ctx->Polygon.CullFlag &&
 511                  ctx->Polygon.CullFaceMode == GL_BACK))
 512                line_aa = AA_ALWAYS;
 513          }
 514          else if (ctx->Polygon.BackMode == GL_LINE) {
 515             line_aa = AA_SOMETIMES;
 516
 517             if ((ctx->Polygon.CullFlag &&
 518                  ctx->Polygon.CullFaceMode == GL_FRONT))
 519                line_aa = AA_ALWAYS;
 520          }
 521       }
 522    }
 523
 524    key->line_aa = line_aa;
 525
 526    /* _NEW_HINT */
 527    key->high_quality_derivatives =
 528       ctx->Hint.FragmentShaderDerivative == GL_NICEST;
 529
 530    if (brw->gen < 6)
 531       key->stats_wm = brw->stats_wm;
 532
 533    /* _NEW_LIGHT */
 534    key->flat_shade = (ctx->Light.ShadeModel == GL_FLAT);
 535
 536    /* _NEW_FRAG_CLAMP | _NEW_BUFFERS */
 537    key->clamp_fragment_color = ctx->Color._ClampFragmentColor;
 538
 539    /* _NEW_TEXTURE */
 540    brw_populate_sampler_prog_key_data(ctx, prog, brw->wm.base.sampler_count,
 541                                       &key->tex);
 542
 543    /* _NEW_BUFFERS */
 544    /*
 545     * Include the draw buffer origin and height so that we can calculate
 546     * fragment position values relative to the bottom left of the drawable,
 547     * from the incoming screen origin relative position we get as part of our
 548     * payload.
 549     *
 550     * This is only needed for the WM_WPOSXY opcode when the fragment program
 551     * uses the gl_FragCoord input.
 552     *
 553     * We could avoid recompiling by including this as a constant referenced by
 554     * our program, but if we were to do that it would also be nice to handle
 555     * getting that constant updated at batchbuffer submit time (when we
 556     * hold the lock and know where the buffer really is) rather than at emit
 557     * time when we don't hold the lock and are just guessing.  We could also
 558     * just avoid using this as key data if the program doesn't use
 559     * fragment.position.
 560     *
 561     * For DRI2 the origin_x/y will always be (0,0) but we still need the
 562     * drawable height in order to invert the Y axis.
 563     */
 564    if (fp->program.Base.InputsRead & VARYING_BIT_POS) {
 565       key->drawable_height = _mesa_geometric_height(ctx->DrawBuffer);
 566    }
 567
 568    if ((fp->program.Base.InputsRead & VARYING_BIT_POS) || program_uses_dfdy) {
 569       key->render_to_fbo = _mesa_is_user_fbo(ctx->DrawBuffer);
 570    }
 571
 572    /* _NEW_BUFFERS */
 573    key->nr_color_regions = ctx->DrawBuffer->_NumColorDrawBuffers;
 574
 575    /* _NEW_MULTISAMPLE, _NEW_COLOR, _NEW_BUFFERS */
 576    key->replicate_alpha = ctx->DrawBuffer->_NumColorDrawBuffers > 1 &&
 577       (ctx->Multisample.SampleAlphaToCoverage || ctx->Color.AlphaEnabled);
 578
 579    /* _NEW_BUFFERS _NEW_MULTISAMPLE */
 580    /* Ignore sample qualifier while computing this flag. */
 581    key->persample_shading =
 582       _mesa_get_min_invocations_per_fragment(ctx, &fp->program, true) > 1;
 583    if (key->persample_shading)
 584       key->persample_2x = _mesa_geometric_samples(ctx->DrawBuffer) == 2;
 585
 586    key->compute_pos_offset =
 587       _mesa_get_min_invocations_per_fragment(ctx, &fp->program, false) > 1 &&
 588       fp->program.Base.SystemValuesRead & SYSTEM_BIT_SAMPLE_POS;
 589
 590    key->compute_sample_id =
 591       multisample_fbo &&
 592       ctx->Multisample.Enabled &&
 593       (fp->program.Base.SystemValuesRead & SYSTEM_BIT_SAMPLE_ID);
 594
 595    /* BRW_NEW_VUE_MAP_GEOM_OUT */
 596    if (brw->gen < 6 || _mesa_bitcount_64(fp->program.Base.InputsRead &
 597                                          BRW_FS_VARYING_INPUT_MASK) > 16)
 598       key->input_slots_valid = brw->vue_map_geom_out.slots_valid;
 599
 600
 601    /* _NEW_COLOR | _NEW_BUFFERS */
 602    /* Pre-gen6, the hardware alpha test always used each render
 603     * target's alpha to do alpha test, as opposed to render target 0's alpha
 604     * like GL requires.  Fix that by building the alpha test into the
 605     * shader, and we'll skip enabling the fixed function alpha test.
 606     */
 607    if (brw->gen < 6 && ctx->DrawBuffer->_NumColorDrawBuffers > 1 && ctx->Color.AlphaEnabled) {
 608       key->alpha_test_func = ctx->Color.AlphaFunc;
 609       key->alpha_test_ref = ctx->Color.AlphaRef;
 610    }
 611
 612    /* The unique fragment program ID */
 613    key->program_string_id = fp->id;
 614 }
 615
 616 void
 617 brw_upload_wm_prog(struct brw_context *brw)
 618 {
 619    struct gl_context *ctx = &brw->ctx;
 620    struct gl_shader_program *current = ctx->_Shader->_CurrentFragmentProgram;
 621    struct brw_wm_prog_key key;
 622    struct brw_fragment_program *fp = (struct brw_fragment_program *)
 623       brw->fragment_program;
 624
 625    if (!brw_wm_state_dirty(brw))
 626       return;
 627
 628    brw_wm_populate_key(brw, &key);
 629
 630    if (!brw_search_cache(&brw->cache, BRW_CACHE_FS_PROG,
 631                          &key, sizeof(key),
 632                          &brw->wm.base.prog_offset, &brw->wm.prog_data)) {
 633       bool success = brw_codegen_wm_prog(brw, current, fp, &key);
 634       (void) success;
 635       assert(success);
 636    }
 637    brw->wm.base.prog_data = &brw->wm.prog_data->base;
 638 }