[Mesa-dev] [PATCH 2/3] i965/fs: Allow CSE to handle MULs with negated arguments.

[Matt Turner]

mul x, -y is equivalent to mul -x, y; and mul x, y is the negation of
mul x, -y.

total instructions in shared programs: 5937689 -> 5929512 (-0.14%)
instructions in affected programs:     871152 -> 862975 (-0.94%)
helped:                                4228
HURT:                                  17
GAINED:                                12
---
 src/mesa/drivers/dri/i965/brw_fs_cse.cpp | 43 +++++++++++++++++++++++++++-----
 1 file changed, 37 insertions(+), 6 deletions(-)

diff --git a/src/mesa/drivers/dri/i965/brw_fs_cse.cpp b/src/mesa/drivers/dri/i965/brw_fs_cse.cpp
index ae069bb..803c3be 100644
--- a/src/mesa/drivers/dri/i965/brw_fs_cse.cpp
+++ b/src/mesa/drivers/dri/i965/brw_fs_cse.cpp
@@ -116,7 +116,6 @@ is_expression_commutative(const fs_inst *inst)
    case BRW_OPCODE_OR:
    case BRW_OPCODE_XOR:
    case BRW_OPCODE_ADD:
-   case BRW_OPCODE_MUL:
       return true;
    case BRW_OPCODE_SEL:
       /* MIN and MAX are commutative. */
@@ -131,7 +130,7 @@ is_expression_commutative(const fs_inst *inst)
 }
 
 static bool
-operands_match(const fs_inst *a, const fs_inst *b)
+operands_match(const fs_inst *a, const fs_inst *b, bool *negate)
 {
    fs_reg *xs = a->src;
    fs_reg *ys = b->src;
@@ -140,6 +139,35 @@ operands_match(const fs_inst *a, const fs_inst *b)
       return xs[0].equals(ys[0]) &&
              ((xs[1].equals(ys[1]) && xs[2].equals(ys[2])) ||
               (xs[2].equals(ys[1]) && xs[1].equals(ys[2])));
+   } else if (a->opcode == BRW_OPCODE_MUL && a->dst.type == BRW_REGISTER_TYPE_F) {
+      bool xs0_negate = xs[0].negate;
+      bool xs1_negate = xs[1].file == IMM ? xs[1].fixed_hw_reg.dw1.f < 0.0f
+                                          : xs[1].negate;
+      bool ys0_negate = ys[0].negate;
+      bool ys1_negate = ys[1].file == IMM ? ys[1].fixed_hw_reg.dw1.f < 0.0f
+                                          : ys[1].negate;
+      float xs1_imm = xs[1].fixed_hw_reg.dw1.f;
+      float ys1_imm = ys[1].fixed_hw_reg.dw1.f;
+
+      xs[0].negate = false;
+      xs[1].negate = false;
+      ys[0].negate = false;
+      ys[1].negate = false;
+      xs[1].fixed_hw_reg.dw1.f = fabsf(xs[1].fixed_hw_reg.dw1.f);
+      ys[1].fixed_hw_reg.dw1.f = fabsf(ys[1].fixed_hw_reg.dw1.f);
+
+      bool ret = (xs[0].equals(ys[0]) && xs[1].equals(ys[1])) ||
+                 (xs[1].equals(ys[0]) && xs[0].equals(ys[1]));
+
+      xs[0].negate = xs0_negate;
+      xs[1].negate = xs[1].file == IMM ? false : xs1_negate;
+      ys[0].negate = ys0_negate;
+      ys[1].negate = ys[1].file == IMM ? false : ys1_negate;
+      xs[1].fixed_hw_reg.dw1.f = xs1_imm;
+      ys[1].fixed_hw_reg.dw1.f = ys1_imm;
+
+      *negate = (xs0_negate + xs1_negate) != (ys0_negate + ys1_negate);
+      return ret;
    } else if (!is_expression_commutative(a)) {
       bool match = true;
       for (int i = 0; i < a->sources; i++) {
@@ -156,7 +184,7 @@ operands_match(const fs_inst *a, const fs_inst *b)
 }
 
 static bool
-instructions_match(fs_inst *a, fs_inst *b)
+instructions_match(fs_inst *a, fs_inst *b, bool *negate)
 {
    return a->opcode == b->opcode &&
           a->saturate == b->saturate &&
@@ -173,7 +201,7 @@ instructions_match(fs_inst *a, fs_inst *b)
                           a->header_present == b->header_present &&
                           a->shadow_compare == b->shadow_compare)
                        : true) &&
-          operands_match(a, b);
+          operands_match(a, b, negate);
 }
 
 bool
@@ -191,11 +219,12 @@ fs_visitor::opt_cse_local(bblock_t *block)
           (inst->dst.file != HW_REG || inst->dst.is_null()))
       {
          bool found = false;
+         bool negate = false;
 
          foreach_in_list_use_after(aeb_entry, entry, &aeb) {
             /* Match current instruction's expression against those in AEB. */
             if (!(entry->generator->dst.is_null() && !inst->dst.is_null()) &&
-                instructions_match(inst, entry->generator)) {
+                instructions_match(inst, entry->generator, &negate)) {
                found = true;
                progress = true;
                break;
@@ -261,6 +290,7 @@ fs_visitor::opt_cse_local(bblock_t *block)
                } else {
                   copy = MOV(dst, tmp);
                   copy->force_writemask_all = inst->force_writemask_all;
+                  copy->src[0].negate = negate;
                }
                inst->insert_before(block, copy);
             }
@@ -281,9 +311,10 @@ fs_visitor::opt_cse_local(bblock_t *block)
           * the flag register if we just wrote it.
           */
          if (inst->writes_flag()) {
+            bool negate; /* dummy */
             if (entry->generator->reads_flag() ||
                 (entry->generator->writes_flag() &&
-                 !instructions_match(inst, entry->generator))) {
+                 !instructions_match(inst, entry->generator, &negate))) {
                entry->remove();
                ralloc_free(entry);
                continue;
-- 
2.0.5