Backport a73c06de2ac47033503189140c0f8ee61fcbceae

src/hotspot/share/opto/addnode.cpp

@@ -363,6 +363,13 @@ Node *AddINode::Ideal(PhaseGVN *phase, bool can_reshape) {
     }
   }
 
+  // Convert (~x+1) into -x. Note there isn't a bitwise not bytecode,
+  // "~x" would typically represented as "x^(-1)", so (~x+1) will
+  // be (x^(-1))+1.
+  if (op1 == Op_XorI && phase->type(in2) == TypeInt::ONE &&
+      phase->type(in1->in(2)) == TypeInt::MINUS_1) {
+    return new SubINode(phase->makecon(TypeInt::ZERO), in1->in(1));
+  }
   return AddNode::Ideal(phase, can_reshape);
 }
 
@@ -486,7 +493,13 @@ Node *AddLNode::Ideal(PhaseGVN *phase, bool can_reshape) {
     }
   }
 
-
+  // Convert (~x+1) into -x. Note there isn't a bitwise not bytecode,
+  // "~x" would typically represented as "x^(-1)", so (~x+1) will
+  // be (x^(-1))+1
+  if (op1 == Op_XorL && phase->type(in2) == TypeLong::ONE &&
+      phase->type(in1->in(2)) == TypeLong::MINUS_1) {
+    return new SubLNode(phase->makecon(TypeLong::ZERO), in1->in(1));
+  }
   return AddNode::Ideal(phase, can_reshape);
 }
 
@@ -899,6 +912,21 @@ const Type *OrLNode::add_ring( const Type *t0, const Type *t1 ) const {
 }
 
 //=============================================================================
+//------------------------------Idealize---------------------------------------
+Node* XorINode::Ideal(PhaseGVN* phase, bool can_reshape) {
+  Node* in1 = in(1);
+  Node* in2 = in(2);
+  int op1 = in1->Opcode();
+  // Convert ~(x-1) into -x. Note there isn't a bitwise not bytecode,
+  // "~x" would typically represented as "x^(-1)", and "x-c0" would
+  // convert into "x+ -c0" in SubXNode::Ideal. So ~(x-1) will eventually
+  // be (x+(-1))^-1.
+  if (op1 == Op_AddI && phase->type(in2) == TypeInt::MINUS_1 &&
+      phase->type(in1->in(2)) == TypeInt::MINUS_1) {
+    return new SubINode(phase->makecon(TypeInt::ZERO), in1->in(1));
+  }
+  return AddNode::Ideal(phase, can_reshape);
+}
 
 const Type* XorINode::Value(PhaseGVN* phase) const {
   Node* in1 = in(1);
@@ -964,6 +992,21 @@ const Type *XorLNode::add_ring( const Type *t0, const Type *t1 ) const {
   return TypeLong::make( r0->get_con() ^ r1->get_con() );
 }
 
+Node* XorLNode::Ideal(PhaseGVN* phase, bool can_reshape) {
+  Node* in1 = in(1);
+  Node* in2 = in(2);
+  int op1 = in1->Opcode();
+  // Convert ~(x-1) into -x. Note there isn't a bitwise not bytecode,
+  // "~x" would typically represented as "x^(-1)", and "x-c0" would
+  // convert into "x+ -c0" in SubXNode::Ideal. So ~(x-1) will eventually
+  // be (x+(-1))^-1.
+  if (op1 == Op_AddL && phase->type(in2) == TypeLong::MINUS_1 &&
+      phase->type(in1->in(2)) == TypeLong::MINUS_1) {
+    return new SubLNode(phase->makecon(TypeLong::ZERO), in1->in(1));
+  }
+  return AddNode::Ideal(phase, can_reshape);
+}
+
 const Type* XorLNode::Value(PhaseGVN* phase) const {
   Node* in1 = in(1);
   Node* in2 = in(2);

src/hotspot/share/opto/addnode.hpp

@@ -227,6 +227,7 @@ class XorINode : public AddNode {
 public:
   XorINode( Node *in1, Node *in2 ) : AddNode(in1,in2) {}
   virtual int Opcode() const;
+  virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
   virtual const Type *add_ring( const Type *, const Type * ) const;
   virtual const Type *add_id() const { return TypeInt::ZERO; }
   virtual const Type *bottom_type() const { return TypeInt::INT; }
@@ -242,6 +243,7 @@ class XorLNode : public AddNode {
 public:
   XorLNode( Node *in1, Node *in2 ) : AddNode(in1,in2) {}
   virtual int Opcode() const;
+  virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
   virtual const Type *add_ring( const Type *, const Type * ) const;
   virtual const Type *add_id() const { return TypeLong::ZERO; }
   virtual const Type *bottom_type() const { return TypeLong::LONG; }

test/hotspot/jtreg/compiler/c2/TestAddXorIdeal.java

@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) 2021, Alibaba Group Holding Limited. 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.
+ *
+ */
+
+/*
+ * @test
+ * @key randomness
+ * @bug 8273021
+ * @summary C2: Improve Add and Xor ideal optimizations
+ * @library /test/lib
+ * @run main/othervm -XX:-TieredCompilation
+ *                   -XX:CompileCommand=dontinline,compiler.c2.TestAddXorIdeal::test*
+ *                   compiler.c2.TestAddXorIdeal
+ */
+package compiler.c2;
+
+import java.util.Random;
+
+import jdk.test.lib.Asserts;
+import jdk.test.lib.Utils;
+
+public class TestAddXorIdeal {
+
+    public static int test1(int x) {
+        return ~x + 1;
+    }
+
+    public static int test2(int x) {
+        return ~(x - 1);
+    }
+
+    public static long test3(long x) {
+        return ~x + 1L;
+    }
+
+    public static long test4(long x) {
+        return ~(x - 1L);
+    }
+
+    public static int test5(int x) {
+        return 1 + ~x;
+    }
+
+    public static int test6(int x) {
+        return ~(-1 + x);
+    }
+
+    public static long test7(long x) {
+        return 1L + ~x;
+    }
+
+    public static long test8(long x) {
+        return ~(-1L + x);
+    }
+
+    public static void main(String... args) {
+        Random random = Utils.getRandomInstance();
+        for (int i = 0; i < 50_000; i++) {
+            int a = random.nextInt();
+            long b = random.nextLong();
+            Asserts.assertTrue(test1(a) == -a);
+            Asserts.assertTrue(test2(a) == -a);
+            Asserts.assertTrue(test3(b) == -b);
+            Asserts.assertTrue(test4(b) == -b);
+            Asserts.assertTrue(test5(a) == -a);
+            Asserts.assertTrue(test6(a) ==  -a);
+            Asserts.assertTrue(test7(b) == -b);
+            Asserts.assertTrue(test8(b) == -b);
+        }
+    }
+}