nir: split out instruction comparison functions

Right now nir_instrs_equal() is tied pretty tightly to CSE, but we're
going to introduce the idea of an instruction set and tie it to that
instead.  In anticipation of that, move this into its own file where
we'll add the rest of the instruction set implementation later.

v2: Rebase on texture support.

Reviewed-by: Jason Ekstrand <[email protected]>
Signed-off-by: Connor Abbott <[email protected]>

1 files changed, 1 insertions, 154 deletions

diff --git a/src/glsl/nir/nir_opt_cse.c b/src/glsl/nir/nir_opt_cse.c
index 64c94afd480..72438dda43f 100644
--- a/src/glsl/nir/nir_opt_cse.c
+++ b/src/glsl/nir/nir_opt_cse.c
@@ -25,7 +25,7 @@
  *
  */
 
-#include "nir.h"
+#include "nir_instr_set.h"
 
 /*
  * Implements common subexpression elimination
@@ -36,159 +36,6 @@ struct cse_state {
    bool progress;
 };
 
-static bool
-nir_alu_srcs_equal(nir_alu_instr *alu1, nir_alu_instr *alu2, unsigned src1,
-                   unsigned src2)
-{
-   if (alu1->src[src1].abs != alu2->src[src2].abs ||
-       alu1->src[src1].negate != alu2->src[src2].negate)
-      return false;
-
-   for (unsigned i = 0; i < nir_ssa_alu_instr_src_components(alu1, src1); i++) {
-      if (alu1->src[src1].swizzle[i] != alu2->src[src2].swizzle[i])
-         return false;
-   }
-
-   return nir_srcs_equal(alu1->src[src1].src, alu2->src[src2].src);
-}
-
-static bool
-nir_instrs_equal(nir_instr *instr1, nir_instr *instr2)
-{
-   if (instr1->type != instr2->type)
-      return false;
-
-   switch (instr1->type) {
-   case nir_instr_type_alu: {
-      nir_alu_instr *alu1 = nir_instr_as_alu(instr1);
-      nir_alu_instr *alu2 = nir_instr_as_alu(instr2);
-
-      if (alu1->op != alu2->op)
-         return false;
-
-      /* TODO: We can probably acutally do something more inteligent such
-       * as allowing different numbers and taking a maximum or something
-       * here */
-      if (alu1->dest.dest.ssa.num_components != alu2->dest.dest.ssa.num_components)
-         return false;
-
-      if (nir_op_infos[alu1->op].algebraic_properties & NIR_OP_IS_COMMUTATIVE) {
-         assert(nir_op_infos[alu1->op].num_inputs == 2);
-         return (nir_alu_srcs_equal(alu1, alu2, 0, 0) &&
-                 nir_alu_srcs_equal(alu1, alu2, 1, 1)) ||
-                (nir_alu_srcs_equal(alu1, alu2, 0, 1) &&
-                 nir_alu_srcs_equal(alu1, alu2, 1, 0));
-      } else {
-         for (unsigned i = 0; i < nir_op_infos[alu1->op].num_inputs; i++) {
-            if (!nir_alu_srcs_equal(alu1, alu2, i, i))
-               return false;
-         }
-      }
-      return true;
-   }
-   case nir_instr_type_tex: {
-      nir_tex_instr *tex1 = nir_instr_as_tex(instr1);
-      nir_tex_instr *tex2 = nir_instr_as_tex(instr2);
-
-      if (tex1->op != tex2->op)
-         return false;
-
-      if (tex1->num_srcs != tex2->num_srcs)
-         return false;
-      for (unsigned i = 0; i < tex1->num_srcs; i++) {
-         if (tex1->src[i].src_type != tex2->src[i].src_type ||
-             !nir_srcs_equal(tex1->src[i].src, tex2->src[i].src)) {
-            return false;
-         }
-      }
-
-      if (tex1->coord_components != tex2->coord_components ||
-          tex1->sampler_dim != tex2->sampler_dim ||
-          tex1->is_array != tex2->is_array ||
-          tex1->is_shadow != tex2->is_shadow ||
-          tex1->is_new_style_shadow != tex2->is_new_style_shadow ||
-          memcmp(tex1->const_offset, tex2->const_offset,
-                 sizeof(tex1->const_offset)) != 0 ||
-          tex1->component != tex2->component ||
-         tex1->sampler_index != tex2->sampler_index ||
-         tex1->sampler_array_size != tex2->sampler_array_size) {
-         return false;
-      }
-
-      /* Don't support un-lowered sampler derefs currently. */
-      if (tex1->sampler || tex2->sampler)
-         return false;
-
-      return true;
-   }
-   case nir_instr_type_load_const: {
-      nir_load_const_instr *load1 = nir_instr_as_load_const(instr1);
-      nir_load_const_instr *load2 = nir_instr_as_load_const(instr2);
-
-      if (load1->def.num_components != load2->def.num_components)
-         return false;
-
-      return memcmp(load1->value.f, load2->value.f,
-                    load1->def.num_components * sizeof(*load2->value.f)) == 0;
-   }
-   case nir_instr_type_phi: {
-      nir_phi_instr *phi1 = nir_instr_as_phi(instr1);
-      nir_phi_instr *phi2 = nir_instr_as_phi(instr2);
-
-      if (phi1->instr.block != phi2->instr.block)
-         return false;
-
-      nir_foreach_phi_src(phi1, src1) {
-         nir_foreach_phi_src(phi2, src2) {
-            if (src1->pred == src2->pred) {
-               if (!nir_srcs_equal(src1->src, src2->src))
-                  return false;
-
-               break;
-            }
-         }
-      }
-
-      return true;
-   }
-   case nir_instr_type_intrinsic: {
-      nir_intrinsic_instr *intrinsic1 = nir_instr_as_intrinsic(instr1);
-      nir_intrinsic_instr *intrinsic2 = nir_instr_as_intrinsic(instr2);
-      const nir_intrinsic_info *info =
-         &nir_intrinsic_infos[intrinsic1->intrinsic];
-
-      if (intrinsic1->intrinsic != intrinsic2->intrinsic ||
-          intrinsic1->num_components != intrinsic2->num_components)
-         return false;
-
-      if (info->has_dest && intrinsic1->dest.ssa.num_components !=
-                            intrinsic2->dest.ssa.num_components)
-         return false;
-
-      for (unsigned i = 0; i < info->num_srcs; i++) {
-         if (!nir_srcs_equal(intrinsic1->src[i], intrinsic2->src[i]))
-            return false;
-      }
-
-      assert(info->num_variables == 0);
-
-      for (unsigned i = 0; i < info->num_indices; i++) {
-         if (intrinsic1->const_index[i] != intrinsic2->const_index[i])
-            return false;
-      }
-
-      return true;
-   }
-   case nir_instr_type_call:
-   case nir_instr_type_jump:
-   case nir_instr_type_ssa_undef:
-   case nir_instr_type_parallel_copy:
-   default:
-      unreachable("Invalid instruction type");
-   }
-
-   return false;
-}
 
 static bool
 src_is_ssa(nir_src *src, void *data)