8277850: C2: optimize mask checks in counted loops

src/hotspot/share/opto/mulnode.cpp

@@ -505,6 +505,15 @@ const Type *AndINode::mul_ring( const Type *t0, const Type *t1 ) const {
   return TypeInt::INT;          // No constants to be had
 }
 
+const Type* AndINode::Value(PhaseGVN* phase) const {
+  // patterns similar to (v << 2) & 3
+  if (AndIL_shift_and_mask(phase, in(2), in(1), T_INT)) {
+    return TypeInt::ZERO;
+  }
+
+  return MulNode::Value(phase);
+}
+
 //------------------------------Identity---------------------------------------
 // Masking off the high bits of an unsigned load is not required
 Node* AndINode::Identity(PhaseGVN* phase) {
@@ -598,6 +607,12 @@ Node *AndINode::Ideal(PhaseGVN *phase, bool can_reshape) {
       phase->type(load->in(1)) == TypeInt::ZERO )
     return new AndINode( load->in(2), in(2) );
 
+  // pattern similar to (v1 + (v2 << 2)) & 3 transformed to v1 & 3
+  Node* progress = AndIL_add_shift_and_mask(phase, T_INT);
+  if (progress != NULL) {
+    return progress;
+  }
+
   return MulNode::Ideal(phase, can_reshape);
 }
 
@@ -629,6 +644,15 @@ const Type *AndLNode::mul_ring( const Type *t0, const Type *t1 ) const {
   return TypeLong::LONG;        // No constants to be had
 }
 
+const Type* AndLNode::Value(PhaseGVN* phase) const {
+  // patterns similar to (v << 2) & 3
+  if (AndIL_shift_and_mask(phase, in(2), in(1), T_LONG)) {
+    return TypeLong::ZERO;
+  }
+
+  return MulNode::Value(phase);
+}
+
 //------------------------------Identity---------------------------------------
 // Masking off the high bits of an unsigned load is not required
 Node* AndLNode::Identity(PhaseGVN* phase) {
@@ -675,7 +699,7 @@ Node *AndLNode::Ideal(PhaseGVN *phase, bool can_reshape) {
   const jlong mask = t2->get_con();
 
   Node* in1 = in(1);
-  uint op = in1->Opcode();
+  int op = in1->Opcode();
 
   // Are we masking a long that was converted from an int with a mask
   // that fits in 32-bits?  Commute them and use an AndINode.  Don't
@@ -705,6 +729,12 @@ Node *AndLNode::Ideal(PhaseGVN *phase, bool can_reshape) {
     }
   }
 
+  // pattern similar to (v1 + (v2 << 2)) & 3 transformed to v1 & 3
+  Node* progress = AndIL_add_shift_and_mask(phase, T_LONG);
+  if (progress != NULL) {
+    return progress;
+  }
+
   return MulNode::Ideal(phase, can_reshape);
 }
 
@@ -1683,3 +1713,64 @@ const Type* RotateRightNode::Value(PhaseGVN* phase) const {
     return TypeLong::LONG;
   }
 }
+
+// Helper method to transform:
+// patterns similar to (v << 2) & 3 to 0
+// and
+// patterns similar to (v1 + (v2 << 2)) & 3 transformed to v1 & 3
+bool MulNode::AndIL_shift_and_mask(PhaseGVN* phase, Node* mask, Node* shift, BasicType bt) {
+  if (mask == NULL || shift == NULL) {
+    return false;
+  }
+  const TypeInteger* mask_t = phase->type(mask)->isa_integer(bt);
+  const TypeInteger* shift_t = phase->type(shift)->isa_integer(bt);
+  if (mask_t == NULL || shift_t == NULL) {
+    return false;
+  }
+  if (bt == T_LONG && shift != NULL && shift->Opcode() == Op_ConvI2L) {
+    bt = T_INT;
+    shift = shift->in(1);
+    if (shift == NULL) {
+      return false;
+    }
+  }
+  if (shift->Opcode() != Op_LShift(bt)) {
+    return false;
+  }
+  Node* shift2 = shift->in(2);
+  if (shift2 == NULL) {
+    return false;
+  }
+  const Type* shift2_t = phase->type(shift2);
+  if (!shift2_t->isa_int() || !shift2_t->is_int()->is_con()) {
+    return false;
+  }
+
+  jint shift_con = shift2_t->is_int()->get_con() & ((bt == T_INT ? BitsPerJavaInteger : BitsPerJavaLong) - 1);
+  if ((((jlong)1) << shift_con) > mask_t->hi_as_long() && mask_t->lo_as_long() >= 0) {
+    return true;
+  }
+
+  return false;
+}
+
+// Helper method to transform:
+// patterns similar to (v1 + (v2 << 2)) & 3 to v1 & 3
+Node* MulNode::AndIL_add_shift_and_mask(PhaseGVN* phase, BasicType bt) {
+  Node* in1 = in(1);
+  Node* in2 = in(2);
+  if (in1 != NULL && in2 != NULL && in1->Opcode() == Op_Add(bt)) {
+    Node* add1 = in1->in(1);
+    Node* add2 = in1->in(2);
+    if (add1 != NULL && add2 != NULL) {
+      if (AndIL_shift_and_mask(phase, in2, add1, bt)) {
+        set_req_X(1, add2, phase);
+        return this;
+      } else if (AndIL_shift_and_mask(phase, in2, add2, bt)) {
+        set_req_X(1, add1, phase);
+        return this;
+      }
+    }
+  }
+  return NULL;
+}

src/hotspot/share/opto/mulnode.hpp

@@ -82,6 +82,9 @@ class MulNode : public Node {
   virtual int min_opcode() const = 0;
 
   static MulNode* make(Node* in1, Node* in2, BasicType bt);
+
+  static bool AndIL_shift_and_mask(PhaseGVN* phase, Node* mask, Node* shift, BasicType bt);
+  Node* AndIL_add_shift_and_mask(PhaseGVN* phase, BasicType bt);
 };
 
 //------------------------------MulINode---------------------------------------
@@ -189,6 +192,7 @@ class AndINode : public MulINode {
   virtual int Opcode() const;
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
   virtual Node* Identity(PhaseGVN* phase);
+  virtual const Type* Value(PhaseGVN* phase) const;
   virtual const Type *mul_ring( const Type *, const Type * ) const;
   const Type *mul_id() const { return TypeInt::MINUS_1; }
   const Type *add_id() const { return TypeInt::ZERO; }
@@ -208,6 +212,7 @@ class AndLNode : public MulLNode {
   virtual int Opcode() const;
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
   virtual Node* Identity(PhaseGVN* phase);
+  virtual const Type* Value(PhaseGVN* phase) const;
   virtual const Type *mul_ring( const Type *, const Type * ) const;
   const Type *mul_id() const { return TypeLong::MINUS_1; }
   const Type *add_id() const { return TypeLong::ZERO; }

test/hotspot/jtreg/compiler/c2/irTests/TestShiftAndMask.java

@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) 2021, Red Hat, Inc. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package compiler.c2.irTests;
+
+import compiler.lib.ir_framework.*;
+
+/*
+ * @test
+ * @bug 8277850
+ * @summary C2: optimize mask checks in counted loops
+ * @library /test/lib /
+ * @run driver compiler.c2.irTests.TestShiftAndMask
+ */
+
+public class TestShiftAndMask {
+    public static void main(String[] args) {
+        TestFramework.run();
+    }
+
+    @Test
+    @Arguments(Argument.RANDOM_EACH)
+    @IR(failOn = { IRNode.AND_I, IRNode.LSHIFT_I })
+    public static int shiftMaskInt(int i) {
+        return (i << 2) & 3; // transformed to: return 0;
+    }
+
+    @Test
+    @Arguments(Argument.RANDOM_EACH)
+    @IR(failOn = { IRNode.AND_L, IRNode.LSHIFT_L })
+    public static long shiftMaskLong(long i) {
+        return (i << 2) & 3; // transformed to: return 0;
+    }
+
+    @Test
+    @Arguments({Argument.RANDOM_EACH, Argument.RANDOM_EACH})
+    @IR(counts = { IRNode.AND_I, "1" })
+    @IR(failOn = { IRNode.ADD_I, IRNode.LSHIFT_I })
+    public static int addShiftMaskInt(int i, int j) {
+        return (j + (i << 2)) & 3; // transformed to: return j & 3;
+    }
+
+    @Test
+    @Arguments({Argument.RANDOM_EACH, Argument.RANDOM_EACH})
+    @IR(counts = { IRNode.AND_L, "1" })
+    @IR(failOn = { IRNode.ADD_L, IRNode.LSHIFT_L })
+    public static long addShiftMaskLong(long i, long j) {
+        return (j + (i << 2)) & 3; // transformed to: return j & 3;
+    }
+
+    @Test
+    @Arguments({Argument.RANDOM_EACH, Argument.RANDOM_EACH})
+    @IR(failOn = { IRNode.AND_I, IRNode.ADD_I, IRNode.LSHIFT_I })
+    public static int addShiftMaskInt2(int i, int j) {
+        return ((j << 2) + (i << 2)) & 3; // transformed to: return 0;
+    }
+
+    @Test
+    @Arguments({Argument.RANDOM_EACH, Argument.RANDOM_EACH})
+    @IR(failOn = { IRNode.AND_L, IRNode.ADD_L, IRNode.LSHIFT_L })
+    public static long addShiftMaskLong2(long i, long j) {
+        return ((j << 2) + (i << 2)) & 3; // transformed to: return 0;
+    }
+
+    @Test
+    @Arguments(Argument.RANDOM_EACH)
+    @IR(failOn = { IRNode.AND_L, IRNode.LSHIFT_I })
+    public static long shiftConvMask(int i) {
+        return ((long)(i << 2)) & 3; // transformed to: return 0;
+    }
+
+    @Test
+    @Arguments({Argument.RANDOM_EACH, Argument.RANDOM_EACH})
+    @IR(counts = { IRNode.AND_L, "1" })
+    @IR(failOn = { IRNode.ADD_L, IRNode.LSHIFT_I, IRNode.CONV_I2L })
+    public static long addShiftConvMask(int i, long j) {
+        return (j + (i << 2)) & 3; // transformed to: return j & 3;
+    }
+
+    @Test
+    @Arguments({Argument.RANDOM_EACH, Argument.RANDOM_EACH})
+    @IR(failOn = { IRNode.AND_L, IRNode.ADD_L, IRNode.LSHIFT_L })
+    public static long addShiftConvMask2(int i, int j) {
+        return (((long)(j << 2)) + ((long)(i << 2))) & 3; // transformed to: return 0;
+    }
+
+}
+

test/hotspot/jtreg/compiler/lib/ir_framework/IRNode.java

@@ -133,6 +133,14 @@ public class IRNode {
     public static final String SCOPE_OBJECT = "(.*# ScObj.*" + END;
     public static final String MEMBAR = START + "MemBar" + MID + END;
 
+    public static final String AND_I = START + "AndI" + MID + END;
+    public static final String AND_L = START + "AndL" + MID + END;
+    public static final String LSHIFT_I = START + "LShiftI" + MID + END;
+    public static final String LSHIFT_L = START + "LShiftL" + MID + END;
+    public static final String ADD_I = START + "AddI" + MID + END;
+    public static final String ADD_L = START + "AddL" + MID + END;
+    public static final String CONV_I2L = START + "ConvI2L" + MID + END;
+
     /**
      * Called by {@link IRMatcher} to merge special composite nodes together with additional user-defined input.
      */