i965: Use blorp for all clears

We used to use a meta path on gen8 but we haven't since c7cf17ae758.  We
might as well delete the meta path since blorp works on all gens.

Reviewed-by: Topi Pohjolainen <[email protected]>

5 files changed, 0 insertions, 634 deletions

diff --git a/src/mesa/drivers/dri/i965/Makefile.sources b/src/mesa/drivers/dri/i965/Makefile.sources
index 5938bbbf383..98c3e05412d 100644
--- a/src/mesa/drivers/dri/i965/Makefile.sources
+++ b/src/mesa/drivers/dri/i965/Makefile.sources
@@ -136,7 +136,6 @@ i965_FILES = \
 	brw_link.cpp \
 	brw_lower_texture_gradients.cpp \
 	brw_lower_unnormalized_offset.cpp \
-	brw_meta_fast_clear.c \
 	brw_meta_util.c \
 	brw_meta_util.h \
 	brw_misc_state.c \
diff --git a/src/mesa/drivers/dri/i965/brw_clear.c b/src/mesa/drivers/dri/i965/brw_clear.c
index d57b67737a3..1dfff090c08 100644
--- a/src/mesa/drivers/dri/i965/brw_clear.c
+++ b/src/mesa/drivers/dri/i965/brw_clear.c
@@ -248,14 +248,6 @@ brw_clear(struct gl_context *ctx, GLbitfield mask)
       }
    }
 
-   /* Clear color buffers with fast clear or at least rep16 writes. */
-   if (brw->gen >= 6 && (mask & BUFFER_BITS_COLOR)) {
-      if (brw_meta_fast_clear(brw, fb, mask, partial_clear)) {
-         debug_mask("blorp color", mask & BUFFER_BITS_COLOR);
-         mask &= ~BUFFER_BITS_COLOR;
-      }
-   }
-
    GLbitfield tri_mask = mask & (BUFFER_BITS_COLOR |
 				 BUFFER_BIT_STENCIL |
 				 BUFFER_BIT_DEPTH);
diff --git a/src/mesa/drivers/dri/i965/brw_context.c b/src/mesa/drivers/dri/i965/brw_context.c
index 26514a0c7b6..1ab02ae3d0f 100644
--- a/src/mesa/drivers/dri/i965/brw_context.c
+++ b/src/mesa/drivers/dri/i965/brw_context.c
@@ -1055,7 +1055,6 @@ intelDestroyContext(__DRIcontext * driContextPriv)
    }
 
    _mesa_meta_free(&brw->ctx);
-   brw_meta_fast_clear_free(brw);
 
    if (INTEL_DEBUG & DEBUG_SHADER_TIME) {
       /* Force a report. */
diff --git a/src/mesa/drivers/dri/i965/brw_context.h b/src/mesa/drivers/dri/i965/brw_context.h
index 3209e5e45b8..e8c7f0245be 100644
--- a/src/mesa/drivers/dri/i965/brw_context.h
+++ b/src/mesa/drivers/dri/i965/brw_context.h
@@ -1372,17 +1372,9 @@ GLboolean brwCreateContext(gl_api api,
 /*======================================================================
  * brw_misc_state.c
  */
-bool brw_meta_fast_clear(struct brw_context *brw,
-                         struct gl_framebuffer *fb,
-                         GLbitfield mask,
-                         bool partial_clear);
-
 void
 brw_meta_resolve_color(struct brw_context *brw,
                        struct intel_mipmap_tree *mt);
-void
-brw_meta_fast_clear_free(struct brw_context *brw);
-
 
 /*======================================================================
  * brw_misc_state.c
diff --git a/src/mesa/drivers/dri/i965/brw_meta_fast_clear.c b/src/mesa/drivers/dri/i965/brw_meta_fast_clear.c
deleted file mode 100644
index 245125d48ea..00000000000
--- a/src/mesa/drivers/dri/i965/brw_meta_fast_clear.c
+++ /dev/null
@@ -1,616 +0,0 @@
-/*
- * Copyright © 2014 Intel Corporation
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
- */
-
-#include "main/mtypes.h"
-#include "main/macros.h"
-#include "main/context.h"
-#include "main/objectlabel.h"
-#include "main/shaderapi.h"
-#include "main/shaderobj.h"
-#include "main/arrayobj.h"
-#include "main/bufferobj.h"
-#include "main/buffers.h"
-#include "main/blend.h"
-#include "main/enable.h"
-#include "main/depth.h"
-#include "main/stencil.h"
-#include "main/varray.h"
-#include "main/uniforms.h"
-#include "main/fbobject.h"
-#include "main/framebuffer.h"
-#include "main/renderbuffer.h"
-#include "main/texobj.h"
-
-#include "main/api_validate.h"
-#include "main/state.h"
-
-#include "vbo/vbo_context.h"
-
-#include "drivers/common/meta.h"
-
-#include "brw_defines.h"
-#include "brw_context.h"
-#include "brw_draw.h"
-#include "brw_state.h"
-#include "intel_fbo.h"
-#include "intel_batchbuffer.h"
-
-#include "brw_blorp.h"
-#include "brw_meta_util.h"
-
-struct brw_fast_clear_state {
-   struct gl_buffer_object *buf_obj;
-   struct gl_vertex_array_object *array_obj;
-   struct gl_shader_program *shader_prog;
-   GLuint vao;
-   GLint color_location;
-};
-
-static bool
-brw_fast_clear_init(struct brw_context *brw)
-{
-   struct brw_fast_clear_state *clear;
-   struct gl_context *ctx = &brw->ctx;
-
-   if (brw->fast_clear_state) {
-      clear = brw->fast_clear_state;
-      _mesa_BindVertexArray(clear->vao);
-      return true;
-   }
-
-   brw->fast_clear_state = clear = malloc(sizeof *clear);
-   if (clear == NULL)
-      return false;
-
-   memset(clear, 0, sizeof *clear);
-   _mesa_GenVertexArrays(1, &clear->vao);
-   _mesa_BindVertexArray(clear->vao);
-
-   clear->buf_obj = ctx->Driver.NewBufferObject(ctx, 0xDEADBEEF);
-   if (clear->buf_obj == NULL)
-      return false;
-
-   clear->array_obj = _mesa_lookup_vao(ctx, clear->vao);
-   assert(clear->array_obj != NULL);
-
-   _mesa_update_array_format(ctx, clear->array_obj, VERT_ATTRIB_GENERIC(0),
-                             2, GL_FLOAT, GL_RGBA, GL_FALSE, GL_FALSE, GL_FALSE,
-                             0, true);
-   _mesa_bind_vertex_buffer(ctx, clear->array_obj, VERT_ATTRIB_GENERIC(0),
-                            clear->buf_obj, 0, sizeof(float) * 2);
-   _mesa_enable_vertex_array_attrib(ctx, clear->array_obj,
-                                    VERT_ATTRIB_GENERIC(0));
-
-   return true;
-}
-
-static void
-brw_bind_rep_write_shader(struct brw_context *brw, float *color)
-{
-   const char *vs_source =
-      "#extension GL_AMD_vertex_shader_layer : enable\n"
-      "#extension GL_ARB_draw_instanced : enable\n"
-      "#extension GL_ARB_explicit_attrib_location : enable\n"
-      "layout(location = 0) in vec4 position;\n"
-      "uniform int layer;\n"
-      "void main()\n"
-      "{\n"
-      "#ifdef GL_AMD_vertex_shader_layer\n"
-      "   gl_Layer = gl_InstanceID;\n"
-      "#endif\n"
-      "   gl_Position = position;\n"
-      "}\n";
-   const char *fs_source =
-      "uniform vec4 color;\n"
-      "void main()\n"
-      "{\n"
-      "   gl_FragColor = color;\n"
-      "}\n";
-
-   struct brw_fast_clear_state *clear = brw->fast_clear_state;
-   struct gl_context *ctx = &brw->ctx;
-
-   if (clear->shader_prog) {
-      _mesa_meta_use_program(ctx, clear->shader_prog);
-      _mesa_Uniform4fv(clear->color_location, 1, color);
-      return;
-   }
-
-   _mesa_meta_compile_and_link_program(ctx, vs_source, fs_source,
-                                       "meta repclear",
-                                       &clear->shader_prog);
-
-   clear->color_location =
-      _mesa_program_resource_location(clear->shader_prog, GL_UNIFORM, "color");
-
-   _mesa_meta_use_program(ctx, clear->shader_prog);
-   _mesa_Uniform4fv(clear->color_location, 1, color);
-}
-
-void
-brw_meta_fast_clear_free(struct brw_context *brw)
-{
-   struct brw_fast_clear_state *clear = brw->fast_clear_state;
-   GET_CURRENT_CONTEXT(old_context);
-
-   if (clear == NULL)
-      return;
-
-   _mesa_make_current(&brw->ctx, NULL, NULL);
-
-   _mesa_DeleteVertexArrays(1, &clear->vao);
-   _mesa_reference_buffer_object(&brw->ctx, &clear->buf_obj, NULL);
-   _mesa_reference_shader_program(&brw->ctx, &clear->shader_prog, NULL);
-   free(clear);
-
-   if (old_context)
-      _mesa_make_current(old_context, old_context->WinSysDrawBuffer, old_context->WinSysReadBuffer);
-   else
-      _mesa_make_current(NULL, NULL, NULL);
-}
-
-struct rect {
-   unsigned x0, y0, x1, y1;
-};
-
-static void
-brw_draw_rectlist(struct brw_context *brw, struct rect *rect, int num_instances)
-{
-   struct gl_context *ctx = &brw->ctx;
-   struct brw_fast_clear_state *clear = brw->fast_clear_state;
-   int start = 0, count = 3;
-   struct _mesa_prim prim;
-   float verts[6];
-
-   verts[0] = rect->x1;
-   verts[1] = rect->y1;
-   verts[2] = rect->x0;
-   verts[3] = rect->y1;
-   verts[4] = rect->x0;
-   verts[5] = rect->y0;
-
-   /* upload new vertex data */
-   _mesa_buffer_data(ctx, clear->buf_obj, GL_NONE, sizeof(verts), verts,
-                     GL_DYNAMIC_DRAW, __func__);
-
-   if (ctx->NewState)
-      _mesa_update_state(ctx);
-
-   vbo_bind_arrays(ctx);
-
-   memset(&prim, 0, sizeof prim);
-   prim.begin = 1;
-   prim.end = 1;
-   prim.mode = BRW_PRIM_OFFSET + _3DPRIM_RECTLIST;
-   prim.num_instances = num_instances;
-   prim.start = start;
-   prim.count = count;
-
-   /* Make sure our internal prim value doesn't clash with a valid GL value. */
-   assert(!_mesa_is_valid_prim_mode(ctx, prim.mode));
-
-   brw_draw_prims(ctx, &prim, 1, NULL,
-                  GL_TRUE, start, start + count - 1,
-                  NULL, 0, NULL);
-}
-
-static const uint32_t fast_clear_color[4] = { ~0, ~0, ~0, ~0 };
-
-static void
-set_fast_clear_op(struct brw_context *brw, uint32_t op)
-{
-   /* Set op and dirty BRW_NEW_FRAGMENT_PROGRAM to make sure we re-emit
-    * 3DSTATE_PS.
-    */
-   brw->wm.fast_clear_op = op;
-   brw->ctx.NewDriverState |= BRW_NEW_FRAGMENT_PROGRAM;
-}
-
-static void
-use_rectlist(struct brw_context *brw, bool enable)
-{
-   /* Set custom state to let us use _3DPRIM_RECTLIST and the replicated
-    * rendertarget write.  When we enable reclist mode, we disable the
-    * viewport transform, disable clipping, enable the rep16 write
-    * optimization and disable simd8 dispatch in the PS.
-    */
-   brw->sf.viewport_transform_enable = !enable;
-   brw->use_rep_send = enable;
-   brw->no_simd8 = enable;
-
-   /* Dirty state to make sure we reemit the state packages affected by the
-    * custom state.  We dirty BRW_NEW_FRAGMENT_PROGRAM to emit 3DSTATE_PS for
-    * disabling simd8 dispatch, _NEW_LIGHT to emit 3DSTATE_SF for disabling
-    * the viewport transform and 3DSTATE_CLIP to disable clipping for the
-    * reclist primitive.  This is a little messy - it would be nicer to
-    * BRW_NEW_FAST_CLEAR flag or so, but we're out of brw state bits.  Dirty
-    * _NEW_BUFFERS to make sure we emit new SURFACE_STATE with the new fast
-    * clear color value.
-    */
-   brw->NewGLState |= _NEW_LIGHT | _NEW_BUFFERS;
-   brw->ctx.NewDriverState |= BRW_NEW_FRAGMENT_PROGRAM;
-}
-
-/**
- * Individually fast clear each color buffer attachment. On previous gens this
- * isn't required. The motivation for this comes from one line (which seems to
- * be specific to SKL+). The list item is in section titled _MCS Buffer for
- * Render Target(s)_
- *
- *   "Since only one RT is bound with a clear pass, only one RT can be cleared
- *   at a time. To clear multiple RTs, multiple clear passes are required."
- *
- * The code follows the same idea as the resolve code which creates a fake FBO
- * to avoid interfering with too much of the GL state.
- */
-static void
-fast_clear_attachments(struct brw_context *brw,
-                       struct gl_framebuffer *fb,
-                       uint32_t fast_clear_buffers,
-                       struct rect fast_clear_rect)
-{
-   struct gl_context *ctx = &brw->ctx;
-   const bool srgb_enabled = ctx->Color.sRGBEnabled;
-
-   assert(brw->gen >= 9);
-
-   /* Make sure the GL_FRAMEBUFFER_SRGB is disabled during fast clear so that
-    * the surface state will always be uploaded with a linear buffer. SRGB
-    * buffers are not supported on Gen9 because they are not marked as
-    * losslessly compressible. This shouldn't matter for the fast clear
-    * because the color is not written to the framebuffer yet so the hardware
-    * doesn't need to do any SRGB conversion.
-    */
-   if (srgb_enabled)
-      _mesa_set_framebuffer_srgb(ctx, GL_FALSE);
-
-   brw_bind_rep_write_shader(brw, (float *) fast_clear_color);
-
-   /* SKL+ also has a resolve mode for compressed render targets and thus more
-    * bits to let us select the type of resolve.  For fast clear resolves, it
-    * turns out we can use the same value as pre-SKL though.
-    */
-   set_fast_clear_op(brw, GEN7_PS_RENDER_TARGET_FAST_CLEAR_ENABLE);
-
-   while (fast_clear_buffers) {
-      int index = ffs(fast_clear_buffers) - 1;
-
-      fast_clear_buffers &= ~(1 << index);
-
-      _mesa_meta_drawbuffers_from_bitfield(1 << index);
-
-      brw_draw_rectlist(brw, &fast_clear_rect, MAX2(1, fb->MaxNumLayers));
-
-      /* Now set the mcs we cleared to INTEL_FAST_CLEAR_STATE_CLEAR so we'll
-       * resolve them eventually.
-       */
-      struct gl_renderbuffer *rb = fb->_ColorDrawBuffers[0];
-      struct intel_renderbuffer *irb = intel_renderbuffer(rb);
-      irb->mt->fast_clear_state = INTEL_FAST_CLEAR_STATE_CLEAR;
-   }
-
-   set_fast_clear_op(brw, 0);
-
-   if (srgb_enabled)
-      _mesa_set_framebuffer_srgb(ctx, GL_TRUE);
-}
-
-bool
-brw_meta_fast_clear(struct brw_context *brw, struct gl_framebuffer *fb,
-                    GLbitfield buffers, bool partial_clear)
-{
-   struct gl_context *ctx = &brw->ctx;
-   enum { FAST_CLEAR, REP_CLEAR, PLAIN_CLEAR } clear_type;
-   GLbitfield plain_clear_buffers, meta_save, rep_clear_buffers, fast_clear_buffers;
-   struct rect fast_clear_rect, clear_rect;
-   int layers;
-
-   fast_clear_buffers = rep_clear_buffers = plain_clear_buffers = 0;
-
-   /* First we loop through the color draw buffers and determine which ones
-    * can be fast cleared, which ones can use the replicated write and which
-    * ones have to fall back to regular color clear.
-    */
-   for (unsigned buf = 0; buf < fb->_NumColorDrawBuffers; buf++) {
-      struct gl_renderbuffer *rb = fb->_ColorDrawBuffers[buf];
-      struct intel_renderbuffer *irb = intel_renderbuffer(rb);
-      int index = fb->_ColorDrawBufferIndexes[buf];
-
-      /* Only clear the buffers present in the provided mask */
-      if (((1 << index) & buffers) == 0)
-         continue;
-
-      /* If this is an ES2 context or GL_ARB_ES2_compatibility is supported,
-       * the framebuffer can be complete with some attachments missing.  In
-       * this case the _ColorDrawBuffers pointer will be NULL.
-       */
-      if (rb == NULL)
-         continue;
-
-      clear_type = FAST_CLEAR;
-
-      /* We don't have fast clear until gen7. */
-      if (brw->gen < 7)
-         clear_type = REP_CLEAR;
-
-      if (irb->mt->fast_clear_state == INTEL_FAST_CLEAR_STATE_NO_MCS)
-         clear_type = REP_CLEAR;
-
-      /* We can't do scissored fast clears because of the restrictions on the
-       * fast clear rectangle size.
-       */
-      if (partial_clear)
-         clear_type = REP_CLEAR;
-
-      /* Fast clear is only supported for colors where all components are
-       * either 0 or 1.
-       */
-      if (!brw_is_color_fast_clear_compatible(brw, irb->mt,
-                                              &ctx->Color.ClearColor))
-         clear_type = REP_CLEAR;
-
-      /* From the SNB PRM (Vol4_Part1):
-       *
-       *     "Replicated data (Message Type = 111) is only supported when
-       *      accessing tiled memory.  Using this Message Type to access
-       *      linear (untiled) memory is UNDEFINED."
-       */
-      if (irb->mt->tiling == I915_TILING_NONE) {
-         perf_debug("Falling back to plain clear because %dx%d buffer is untiled\n",
-                    irb->mt->logical_width0, irb->mt->logical_height0);
-         clear_type = PLAIN_CLEAR;
-      }
-
-      /* Constant color writes ignore everything in blend and color calculator
-       * state.  This is not documented.
-       */
-      GLubyte *color_mask = ctx->Color.ColorMask[buf];
-      for (int i = 0; i < 4; i++) {
-         if (_mesa_format_has_color_component(irb->mt->format, i) &&
-             !(i == 3 && irb->Base.Base._BaseFormat == GL_RGB) &&
-             !color_mask[i]) {
-            perf_debug("Falling back to plain clear on %dx%d buffer because of color mask\n",
-                       irb->mt->logical_width0, irb->mt->logical_height0);
-            clear_type = PLAIN_CLEAR;
-         }
-      }
-
-      /* Allocate the MCS for non MSRT surfaces now if we're doing a fast
-       * clear and we don't have the MCS yet.  On failure, fall back to
-       * replicated clear.
-       */
-      if (clear_type == FAST_CLEAR && irb->mt->mcs_mt == NULL)
-         if (!intel_miptree_alloc_non_msrt_mcs(brw, irb->mt))
-            clear_type = REP_CLEAR;
-
-      switch (clear_type) {
-      case FAST_CLEAR:
-         brw_meta_set_fast_clear_color(brw, irb->mt, &ctx->Color.ClearColor);
-         irb->need_downsample = true;
-
-         /* If the buffer is already in INTEL_FAST_CLEAR_STATE_CLEAR, the
-          * clear is redundant and can be skipped.  Only skip after we've
-          * updated the fast clear color above though.
-          */
-         if (irb->mt->fast_clear_state == INTEL_FAST_CLEAR_STATE_CLEAR)
-            continue;
-
-         /* Set fast_clear_state to RESOLVED so we don't try resolve them when
-          * we draw, in case the mt is also bound as a texture.
-          */
-         irb->mt->fast_clear_state = INTEL_FAST_CLEAR_STATE_RESOLVED;
-         irb->need_downsample = true;
-         fast_clear_buffers |= 1 << index;
-         brw_get_fast_clear_rect(brw, fb, irb->mt,
-                                 &fast_clear_rect.x0, &fast_clear_rect.y0,
-                                 &fast_clear_rect.x1, &fast_clear_rect.y1);
-         break;
-
-      case REP_CLEAR:
-         rep_clear_buffers |= 1 << index;
-         brw_meta_get_buffer_rect(fb,
-                                  &clear_rect.x0, &clear_rect.y0,
-                                  &clear_rect.x1, &clear_rect.y1);
-         break;
-
-      case PLAIN_CLEAR:
-         plain_clear_buffers |= 1 << index;
-         brw_meta_get_buffer_rect(fb,
-                                  &clear_rect.x0, &clear_rect.y0,
-                                  &clear_rect.x1, &clear_rect.y1);
-         continue;
-      }
-   }
-
-   assert((fast_clear_buffers & rep_clear_buffers) == 0);
-
-   if (!(fast_clear_buffers | rep_clear_buffers)) {
-      if (plain_clear_buffers)
-         /* If we only have plain clears, skip the meta save/restore. */
-         goto out;
-      else
-         /* Nothing left to do.  This happens when we hit the redundant fast
-          * clear case above and nothing else.
-          */
-         return true;
-   }
-
-   meta_save =
-      MESA_META_ALPHA_TEST |
-      MESA_META_BLEND |
-      MESA_META_DEPTH_TEST |
-      MESA_META_RASTERIZATION |
-      MESA_META_SHADER |
-      MESA_META_STENCIL_TEST |
-      MESA_META_VERTEX |
-      MESA_META_VIEWPORT |
-      MESA_META_CLIP |
-      MESA_META_CLAMP_FRAGMENT_COLOR |
-      MESA_META_MULTISAMPLE |
-      MESA_META_OCCLUSION_QUERY |
-      MESA_META_DRAW_BUFFERS;
-
-   _mesa_meta_begin(ctx, meta_save);
-
-   if (!brw_fast_clear_init(brw)) {
-      /* This is going to be hard to recover from, most likely out of memory.
-       * Bail and let meta try and (probably) fail for us.
-       */
-      plain_clear_buffers = buffers;
-      goto bail_to_meta;
-   }
-
-   /* Clears never have the color clamped. */
-   if (ctx->Extensions.ARB_color_buffer_float)
-      _mesa_ClampColor(GL_CLAMP_FRAGMENT_COLOR, GL_FALSE);
-
-   _mesa_set_enable(ctx, GL_DEPTH_TEST, GL_FALSE);
-   _mesa_DepthMask(GL_FALSE);
-   _mesa_set_enable(ctx, GL_STENCIL_TEST, GL_FALSE);
-
-   use_rectlist(brw, true);
-
-   layers = MAX2(1, fb->MaxNumLayers);
-
-   if (brw->gen >= 9 && fast_clear_buffers) {
-      fast_clear_attachments(brw, fb, fast_clear_buffers, fast_clear_rect);
-   } else if (fast_clear_buffers) {
-      _mesa_meta_drawbuffers_from_bitfield(fast_clear_buffers);
-      brw_bind_rep_write_shader(brw, (float *) fast_clear_color);
-      set_fast_clear_op(brw, GEN7_PS_RENDER_TARGET_FAST_CLEAR_ENABLE);
-      brw_draw_rectlist(brw, &fast_clear_rect, layers);
-      set_fast_clear_op(brw, 0);
-
-      /* Now set the mcs we cleared to INTEL_FAST_CLEAR_STATE_CLEAR so we'll
-       * resolve them eventually.
-       */
-      for (unsigned buf = 0; buf < fb->_NumColorDrawBuffers; buf++) {
-         struct gl_renderbuffer *rb = fb->_ColorDrawBuffers[buf];
-         struct intel_renderbuffer *irb = intel_renderbuffer(rb);
-         int index = fb->_ColorDrawBufferIndexes[buf];
-
-         if ((1 << index) & fast_clear_buffers)
-            irb->mt->fast_clear_state = INTEL_FAST_CLEAR_STATE_CLEAR;
-      }
-   }
-
-   if (rep_clear_buffers) {
-      _mesa_meta_drawbuffers_from_bitfield(rep_clear_buffers);
-      brw_bind_rep_write_shader(brw, ctx->Color.ClearColor.f);
-      brw_draw_rectlist(brw, &clear_rect, layers);
-   }
-
- bail_to_meta:
-   /* Dirty _NEW_BUFFERS so we reemit SURFACE_STATE which sets the fast clear
-    * color before resolve and sets irb->mt->fast_clear_state to UNRESOLVED if
-    * we render to it.
-    */
-   brw->NewGLState |= _NEW_BUFFERS;
-
-
-   /* Set the custom state back to normal and dirty the same bits as above */
-   use_rectlist(brw, false);
-
-   _mesa_meta_end(ctx);
-
-   /* From BSpec: Render Target Fast Clear:
-    *
-    *     After Render target fast clear, pipe-control with color cache
-    *     write-flush must be issued before sending any DRAW commands on that
-    *     render target.
-    */
-   brw_emit_mi_flush(brw);
-
-   /* If we had to fall back to plain clear for any buffers, clear those now
-    * by calling into meta.
-    */
- out:
-   if (plain_clear_buffers)
-      _mesa_meta_glsl_Clear(&brw->ctx, plain_clear_buffers);
-
-   return true;
-}
-
-void
-brw_meta_resolve_color(struct brw_context *brw,
-                       struct intel_mipmap_tree *mt)
-{
-   struct gl_context *ctx = &brw->ctx;
-   struct gl_framebuffer *drawFb;
-   struct gl_renderbuffer *rb;
-   struct rect rect;
-
-   brw_emit_mi_flush(brw);
-
-   drawFb = ctx->Driver.NewFramebuffer(ctx, 0xDEADBEEF);
-   if (drawFb == NULL) {
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "in %s", __func__);
-      return;
-   }
-
-   _mesa_meta_begin(ctx, MESA_META_ALL);
-
-   rb = brw_get_rb_for_slice(brw, mt, 0, 0, false);
-
-   _mesa_bind_framebuffers(ctx, drawFb, ctx->ReadBuffer);
-   _mesa_framebuffer_renderbuffer(ctx, ctx->DrawBuffer, GL_COLOR_ATTACHMENT0,
-                                  rb);
-   _mesa_DrawBuffer(GL_COLOR_ATTACHMENT0);
-
-   brw_fast_clear_init(brw);
-
-   use_rectlist(brw, true);
-
-   brw_bind_rep_write_shader(brw, (float *) fast_clear_color);
-
-   /* SKL+ also has a resolve mode for compressed render targets and thus more
-    * bits to let us select the type of resolve.  For fast clear resolves, it
-    * turns out we can use the same value as pre-SKL though.
-    */
-   if (intel_miptree_is_lossless_compressed(brw, mt))
-      set_fast_clear_op(brw, GEN9_PS_RENDER_TARGET_RESOLVE_FULL);
-   else
-      set_fast_clear_op(brw, GEN7_PS_RENDER_TARGET_RESOLVE_ENABLE);
-
-   mt->fast_clear_state = INTEL_FAST_CLEAR_STATE_RESOLVED;
-   brw_get_resolve_rect(brw, mt, &rect.x0, &rect.y0, &rect.x1, &rect.y1);
-
-   brw_draw_rectlist(brw, &rect, 1);
-
-   set_fast_clear_op(brw, 0);
-   use_rectlist(brw, false);
-
-   _mesa_reference_renderbuffer(&rb, NULL);
-   _mesa_reference_framebuffer(&drawFb, NULL);
-
-   _mesa_meta_end(ctx);
-
-   /* We're typically called from intel_update_state() and we're supposed to
-    * return with the state all updated to what it was before
-    * brw_meta_resolve_color() was called.  The meta rendering will have
-    * messed up the state and we need to call _mesa_update_state() again to
-    * get back to where we were supposed to be when resolve was called.
-    */
-   if (ctx->NewState)
-      _mesa_update_state(ctx);
-}