panfrost: Remove unused nir_lower_framebuffer pass

Superseded.

Signed-off-by: Alyssa Rosenzweig <[email protected]>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/5284>

2 files changed, 0 insertions, 425 deletions

diff --git a/src/gallium/drivers/panfrost/nir/nir_lower_blend.h b/src/gallium/drivers/panfrost/nir/nir_lower_blend.h
index f846ba10827..4bce2cc79b8 100644
--- a/src/gallium/drivers/panfrost/nir/nir_lower_blend.h
+++ b/src/gallium/drivers/panfrost/nir/nir_lower_blend.h
@@ -59,8 +59,4 @@ typedef struct {
 
 void nir_lower_blend(nir_shader *shader, nir_lower_blend_options options);
 
-void
-nir_lower_framebuffer(nir_shader *shader, enum pipe_format format,
-                      unsigned gpu_id);
-
 #endif
diff --git a/src/gallium/drivers/panfrost/nir/nir_lower_framebuffer.c b/src/gallium/drivers/panfrost/nir/nir_lower_framebuffer.c
deleted file mode 100644
index f575a63b731..00000000000
--- a/src/gallium/drivers/panfrost/nir/nir_lower_framebuffer.c
+++ /dev/null
@@ -1,421 +0,0 @@
-/*
- * Copyright (C) 2019 Collabora, Ltd.
- *
- * 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.
- *
- * Authors (Collabora):
- *      Alyssa Rosenzweig <[email protected]>
- */
-
-/**
- * @file
- *
- * Implements framebuffer format conversions in software, specifically for
- * blend shaders on Midgard/Bifrost. load_output/store_output (derefs more
- * correctly -- pre I/O lowering) normally for the fragment stage within the
- * blend shader will operate with purely vec4 float ("nir") encodings. This
- * lowering stage, to be run before I/O is lowered, converts the native
- * framebuffer format to a NIR encoding after loads and vice versa before
- * stores. This pass is designed for a single render target; Midgard duplicates
- * blend shaders for MRT to simplify everything.
- */
-
-#include "compiler/nir/nir.h"
-#include "compiler/nir/nir_builder.h"
-#include "compiler/nir/nir_format_convert.h"
-#include "nir_lower_blend.h"
-#include "util/format/u_format.h"
-
-/* Determines the best NIR intrinsic to load a tile buffer of a given type,
- * using native format conversion where possible. RGBA8 UNORM has a fast path
- * (on some chips). Otherwise, we default to raw reads. */
-
-static nir_intrinsic_op
-nir_best_load_for_format(
-      const struct util_format_description *desc,
-      unsigned *special_bitsize,
-      unsigned *special_components,
-      unsigned gpu_id)
-{
-   if (util_format_is_unorm8(desc) && gpu_id != 0x750) {
-      *special_bitsize = 16;
-      return nir_intrinsic_load_output_u8_as_fp16_pan;
-   } else if (desc->format == PIPE_FORMAT_R11G11B10_FLOAT) {
-      *special_bitsize = 32;
-      *special_components = 1;
-      return nir_intrinsic_load_raw_output_pan;
-   } else
-      return nir_intrinsic_load_raw_output_pan;
-}
-
-
-/* Converters for UNORM8 formats, e.g. R8G8B8A8_UNORM */
-
-static nir_ssa_def *
-nir_float_to_unorm8(nir_builder *b, nir_ssa_def *c_float)
-{
-   /* First, we degrade quality to fp16; we don't need the extra bits */
-   nir_ssa_def *degraded = /*nir_f2f16(b, c_float)*/c_float;
-
-   /* Scale from [0, 1] to [0, 255.0] */
-   nir_ssa_def *scaled = nir_fmul_imm(b, nir_fsat(b, degraded), 255.0);
-
-   /* Next, we type convert */
-   nir_ssa_def *converted = nir_u2u8(b, nir_f2u16(b,
-                                     nir_fround_even(b, nir_f2f16(b, scaled))));
-
-   return converted;
-}
-
-static nir_ssa_def *
-nir_unorm8_to_float(nir_builder *b, nir_ssa_def *c_native)
-{
-   /* First, we convert up from u8 to f16 */
-   nir_ssa_def *converted = nir_f2f32(b, nir_u2f16(b, nir_u2u16(b, c_native)));
-
-   /* Next, we scale down from [0, 255.0] to [0, 1] */
-   nir_ssa_def *scaled = nir_fsat(b, nir_fmul_imm(b, converted, 1.0/255.0));
-
-   return scaled;
-}
-
-/* Converters for UNORM4 formats, packing the final result into 16-bit */
-
-static nir_ssa_def *
-nir_float_to_unorm4(nir_builder *b, nir_ssa_def *c_float)
-{
-   /* First, we degrade quality to fp16; we don't need the extra bits */
-   nir_ssa_def *degraded = nir_f2f16(b, c_float);
-
-   /* Scale from [0, 1] to [0, 15.0] */
-   nir_ssa_def *scaled = nir_fmul_imm(b, nir_fsat(b, degraded), 15.0);
-
-   /* Next, we type convert to u16 */
-   nir_ssa_def *converted = nir_f2u16(b,
-                                      nir_fround_even(b, scaled));
-
-   /* In u16 land, we now need to pack */
-   nir_ssa_def *cr = nir_channel(b, converted, 0);
-   nir_ssa_def *cg = nir_channel(b, converted, 1);
-   nir_ssa_def *cb = nir_channel(b, converted, 2);
-   nir_ssa_def *ca = nir_channel(b, converted, 3);
-
-   nir_ssa_def *pack =
-      nir_ior(b,
-              nir_ior(b, cr, nir_ishl(b, cg, nir_imm_int(b, 4))),
-              nir_ior(b, nir_ishl(b, cb, nir_imm_int(b, 8)), nir_ishl(b, ca, nir_imm_int(b, 12))));
-
-   return pack;
-}
-
-static nir_ssa_def *
-nir_float_to_rgb10a2(nir_builder *b, nir_ssa_def *c_float, bool normalize)
-{
-   nir_ssa_def *converted = c_float;
-
-   if (normalize) {
-      nir_ssa_def *scaled = nir_fmul(b, nir_fsat(b, c_float),
-                                     nir_imm_vec4(b, 1023.0, 1023.0, 1023.0, 3.0));
-
-      converted = nir_f2u32(b,
-                            nir_fround_even(b, scaled));
-   }
-
-   nir_ssa_def *cr = nir_channel(b, converted, 0);
-   nir_ssa_def *cg = nir_channel(b, converted, 1);
-   nir_ssa_def *cb = nir_channel(b, converted, 2);
-   nir_ssa_def *ca = nir_channel(b, converted, 3);
-
-   nir_ssa_def *pack =
-      nir_ior(b,
-              nir_ior(b, cr, nir_ishl(b, cg, nir_imm_int(b, 10))),
-              nir_ior(b, nir_ishl(b, cb, nir_imm_int(b, 20)), nir_ishl(b, ca, nir_imm_int(b, 30))));
-
-   return pack;
-}
-
-static nir_ssa_def *
-nir_float_to_rgb5a1(nir_builder *b, nir_ssa_def *c_float)
-{
-   nir_ssa_def *degraded = nir_f2f16(b, c_float);
-
-   nir_ssa_def *scaled = nir_fmul(b, nir_fsat(b, degraded),
-                                  nir_imm_vec4_16(b, 31.0, 31.0, 31.0, 1.0));
-
-   nir_ssa_def *converted = nir_f2u16(b,
-                                      nir_fround_even(b, scaled));
-
-   nir_ssa_def *cr = nir_channel(b, converted, 0);
-   nir_ssa_def *cg = nir_channel(b, converted, 1);
-   nir_ssa_def *cb = nir_channel(b, converted, 2);
-   nir_ssa_def *ca = nir_channel(b, converted, 3);
-
-   nir_ssa_def *pack =
-      nir_ior(b,
-              nir_ior(b, cr, nir_ishl(b, cg, nir_imm_int(b, 5))),
-              nir_ior(b, nir_ishl(b, cb, nir_imm_int(b, 10)), nir_ishl(b, ca, nir_imm_int(b, 15))));
-
-   return pack;
-}
-
-static nir_ssa_def *
-nir_shader_to_native(nir_builder *b,
-                     nir_ssa_def *c_shader,
-                     const struct util_format_description *desc,
-                     unsigned bits,
-                     bool homogenous_bits)
-{
-   bool float_or_pure_int =
-      util_format_is_float(desc->format) ||
-      util_format_is_pure_integer(desc->format);
-
-   if (util_format_is_unorm8(desc))
-      return nir_float_to_unorm8(b, c_shader);
-   else if (homogenous_bits && float_or_pure_int)
-      return c_shader; /* type is already correct */
-
-   //unsigned bgra[4] = { 2, 1, 0, 3 }; /* BGRA */
-   //c_shader = nir_swizzle(b, c_shader, swiz, 4);
-
-   /* Special formats */
-   switch (desc->format) {
-   case PIPE_FORMAT_B4G4R4A4_UNORM:
-   case PIPE_FORMAT_B4G4R4X4_UNORM:
-   case PIPE_FORMAT_A4R4_UNORM:
-   case PIPE_FORMAT_R4A4_UNORM:
-   case PIPE_FORMAT_A4B4G4R4_UNORM:
-      return nir_float_to_unorm4(b, c_shader);
-
-   case PIPE_FORMAT_R10G10B10A2_UNORM:
-   case PIPE_FORMAT_B10G10R10A2_UNORM:
-   case PIPE_FORMAT_R10G10B10X2_UNORM:
-   case PIPE_FORMAT_B10G10R10X2_UNORM:
-      return nir_float_to_rgb10a2(b, c_shader, true);
-
-   case PIPE_FORMAT_R10G10B10A2_UINT:
-      return nir_float_to_rgb10a2(b, c_shader, false);
-
-   case PIPE_FORMAT_B5G5R5A1_UNORM:
-      return nir_float_to_rgb5a1(b, c_shader);
-
-   case PIPE_FORMAT_R11G11B10_FLOAT:
-      return nir_format_pack_11f11f10f(b, c_shader);
-
-   default:
-      fprintf(stderr, "%s\n", desc->name);
-      unreachable("Unknown format name");
-   }
-}
-
-static nir_ssa_def *
-nir_native_to_shader(nir_builder *b,
-                     nir_ssa_def *c_native,
-                     nir_intrinsic_op op,
-                     const struct util_format_description *desc,
-                     unsigned bits,
-                     bool homogenous_bits)
-{
-   bool float_or_pure_int =
-      util_format_is_float(desc->format) ||
-      util_format_is_pure_integer(desc->format);
-
-   /* Handle preconverted formats */
-   if (op == nir_intrinsic_load_output_u8_as_fp16_pan) {
-      assert(util_format_is_unorm8(desc));
-      return nir_f2f32(b, c_native);
-   }
-
-   /* Otherwise, we're raw */
-   assert(op == nir_intrinsic_load_raw_output_pan);
-
-   if (util_format_is_unorm8(desc))
-      return nir_unorm8_to_float(b, c_native);
-   else if (homogenous_bits && float_or_pure_int)
-      return c_native; /* type is already correct */
-
-   /* Special formats */
-   switch (desc->format) {
-   case PIPE_FORMAT_R11G11B10_FLOAT: {
-      nir_ssa_def *unpacked = nir_format_unpack_11f11f10f(b, c_native);
-
-      /* Extend to vec4 with alpha */
-      nir_ssa_def *components[4] = {
-         nir_channel(b, unpacked, 0),
-         nir_channel(b, unpacked, 1),
-         nir_channel(b, unpacked, 2),
-         nir_imm_float(b, 1.0)
-      };
-
-      return nir_vec(b, components, 4);
-   }
-
-   default:
-      fprintf(stderr, "%s\n", desc->name);
-      unreachable("Unknown format name");
-   }
-}
-
-void
-nir_lower_framebuffer(nir_shader *shader, enum pipe_format format,
-                      unsigned gpu_id)
-{
-   /* Blend shaders are represented as special fragment shaders */
-   assert(shader->info.stage == MESA_SHADER_FRAGMENT);
-
-   const struct util_format_description *format_desc =
-      util_format_description(format);
-
-   unsigned nr_channels = format_desc->nr_channels;
-   unsigned bits = format_desc->channel[0].size;
-
-   /* Do all channels have the same bit count? */
-   bool homogenous_bits = true;
-
-   for (unsigned c = 1; c < nr_channels; ++c)
-      homogenous_bits &= (format_desc->channel[c].size == bits);
-
-   if (format == PIPE_FORMAT_R11G11B10_FLOAT)
-      homogenous_bits = false;
-
-   /* Figure out the formats for the raw */
-   unsigned raw_bitsize_in = bits;
-   unsigned raw_bitsize_out = bits;
-   unsigned raw_out_components = 4;
-
-   /* We pack a 4-bit vec4 as 16-bit vec1 */
-   if ((homogenous_bits && bits == 4 && util_format_is_unorm(format)) || format == PIPE_FORMAT_B5G5R5A1_UNORM) {
-      raw_bitsize_out = 16;
-      raw_out_components = 1;
-   } else if (format == PIPE_FORMAT_R10G10B10A2_UNORM || format == PIPE_FORMAT_B10G10R10A2_UNORM || format == PIPE_FORMAT_R10G10B10A2_UINT || format == PIPE_FORMAT_R11G11B10_FLOAT) {
-      raw_bitsize_out = 32;
-      raw_out_components = 1;
-   }
-
-   nir_foreach_function(func, shader) {
-      nir_foreach_block(block, func->impl) {
-         nir_foreach_instr_safe(instr, block) {
-            if (instr->type != nir_instr_type_intrinsic)
-               continue;
-
-            nir_intrinsic_instr *intr = nir_instr_as_intrinsic(instr);
-
-            bool is_load = intr->intrinsic == nir_intrinsic_load_deref;
-            bool is_store = intr->intrinsic == nir_intrinsic_store_deref;
-
-            if (!(is_load || is_store))
-               continue;
-
-            /* Don't worry about MRT */
-            nir_variable *var = nir_intrinsic_get_var(intr, 0);
-
-            if (var->data.location != FRAG_RESULT_COLOR)
-               continue;
-
-            nir_builder b;
-            nir_builder_init(&b, func->impl);
-
-            if (is_store) {
-               /* For stores, add conversion before */
-               b.cursor = nir_before_instr(instr);
-
-               /* Grab the input color */
-               nir_ssa_def *c_nir = nir_ssa_for_src(&b, intr->src[1], 4);
-
-               /* Apply sRGB transform */
-
-               if (format_desc->colorspace == UTIL_FORMAT_COLORSPACE_SRGB) {
-                  nir_ssa_def *rgb = nir_channels(&b, c_nir, 0x7);
-                  nir_ssa_def *trans = nir_format_linear_to_srgb(&b, rgb);
-
-                  nir_ssa_def *comp[4] = {
-                     nir_channel(&b, trans, 0),
-                     nir_channel(&b, trans, 1),
-                     nir_channel(&b, trans, 2),
-                     nir_channel(&b, c_nir, 3),
-                  };
-
-                  c_nir = nir_vec(&b, comp, 4);
-               }
-
-               /* Format convert */
-               nir_ssa_def *converted = nir_shader_to_native(&b, c_nir, format_desc, bits, homogenous_bits);
-
-               if (util_format_is_float(format)) {
-                  if (raw_bitsize_out == 16)
-                     converted = nir_f2f16(&b, converted);
-                  else if (raw_bitsize_out == 32)
-                     converted = nir_f2f32(&b, converted);
-               } else {
-                  converted = nir_i2i(&b, converted, raw_bitsize_out);
-               }
-
-               /* Rewrite to use a native store by creating a new intrinsic */
-               nir_intrinsic_instr *new =
-                  nir_intrinsic_instr_create(shader, nir_intrinsic_store_raw_output_pan);
-               new->src[0] = nir_src_for_ssa(converted);
-
-               new->num_components = raw_out_components;
-
-               nir_builder_instr_insert(&b, &new->instr);
-
-               /* (And finally removing the old) */
-               nir_instr_remove(instr);
-            } else {
-               /* For loads, add conversion after */
-               b.cursor = nir_after_instr(instr);
-
-               /* Determine the best op for the format/hardware */
-               unsigned bitsize = raw_bitsize_in;
-               unsigned components = 4;
-               nir_intrinsic_op op = nir_best_load_for_format(format_desc,
-                                                              &bitsize,
-                                                              &components,
-                                                              gpu_id);
-
-               /* Rewrite to use a native load by creating a new intrinsic */
-               nir_intrinsic_instr *new = nir_intrinsic_instr_create(shader, op);
-               new->num_components = components;
-
-               nir_ssa_dest_init(&new->instr, &new->dest, components, bitsize, NULL);
-               nir_builder_instr_insert(&b, &new->instr);
-
-               /* Convert the raw value */
-               nir_ssa_def *raw = &new->dest.ssa;
-               nir_ssa_def *converted = nir_native_to_shader(&b, raw, op, format_desc, bits, homogenous_bits);
-
-               if (util_format_is_float(format))
-                  converted = nir_f2f32(&b, converted);
-               else
-                  converted = nir_i2i32(&b, converted);
-
-               /* Rewrite to use the converted value */
-               nir_src rewritten = nir_src_for_ssa(converted);
-               nir_ssa_def_rewrite_uses_after(&intr->dest.ssa, rewritten, instr);
-
-               /* Finally, remove the old load */
-               nir_instr_remove(instr);
-            }
-         }
-      }
-
-      nir_metadata_preserve(func->impl, nir_metadata_block_index |
-                            nir_metadata_dominance);
-   }
-}