8364409: [BACKOUT] Consolidate Identity of self-inverse operations

Reviewed-by: chagedorn, bmaillard
Backport-of: ddb64836e5bafededb705329137e353f8c74dd5d

Author: mhaessig

src/hotspot/share/opto/subnode.cpp

@@ -2074,9 +2074,15 @@ const Type* ReverseLNode::Value(PhaseGVN* phase) const {
   return bottom_type();
 }
 
-Node* InvolutionNode::Identity(PhaseGVN* phase) {
-  // Op ( Op x ) => x
-  if (in(1)->Opcode() == Opcode()) {
+Node* ReverseINode::Identity(PhaseGVN* phase) {
+  if (in(1)->Opcode() == Op_ReverseI) {
+    return in(1)->in(1);
+  }
+  return this;
+}
+
+Node* ReverseLNode::Identity(PhaseGVN* phase) {
+  if (in(1)->Opcode() == Op_ReverseL) {
     return in(1)->in(1);
   }
   return this;

src/hotspot/share/opto/subnode.hpp

@@ -439,18 +439,11 @@ class CmpLTMaskNode : public Node {
   virtual uint ideal_reg() const { return Op_RegI; }
 };
 
-//------------------------------InvolutionNode----------------------------------
-// Represents a self-inverse operation, i.e., op(op(x)) = x for any x
-class InvolutionNode : public Node {
-public:
-  InvolutionNode(Node* in) : Node(nullptr, in) {}
-  virtual Node* Identity(PhaseGVN* phase);
-};
 
 //------------------------------NegNode----------------------------------------
-class NegNode : public InvolutionNode {
+class NegNode : public Node {
 public:
-  NegNode(Node* in1) : InvolutionNode(in1) {
+  NegNode(Node* in1) : Node(nullptr, in1) {
     init_class_id(Class_Neg);
   }
 };
@@ -562,18 +555,16 @@ class SqrtHFNode : public Node {
 };
 
 
-class ReverseBytesNode : public InvolutionNode {
+class ReverseBytesNode : public Node {
 public:
-  ReverseBytesNode(Node* in) : InvolutionNode(in) {}
+  ReverseBytesNode(Node* in) : Node(nullptr, in) {}
   virtual const Type* Value(PhaseGVN* phase) const;
 };
 //-------------------------------ReverseBytesINode--------------------------------
 // reverse bytes of an integer
 class ReverseBytesINode : public ReverseBytesNode {
 public:
-  ReverseBytesINode(Node* in) : ReverseBytesNode(in) {
-  }
-
+  ReverseBytesINode(Node* in) : ReverseBytesNode(in) {}
   virtual int Opcode() const;
   const Type* bottom_type() const { return TypeInt::INT; }
   virtual uint ideal_reg() const { return Op_RegI; }
@@ -611,23 +602,25 @@ class ReverseBytesSNode : public ReverseBytesNode {
 
 //-------------------------------ReverseINode--------------------------------
 // reverse bits of an int
-class ReverseINode : public InvolutionNode {
+class ReverseINode : public Node {
 public:
-  ReverseINode(Node* in) : InvolutionNode(in) {}
+  ReverseINode(Node* in) : Node(nullptr,in) {}
   virtual int Opcode() const;
   const Type* bottom_type() const { return TypeInt::INT; }
   virtual uint ideal_reg() const { return Op_RegI; }
+  virtual Node* Identity(PhaseGVN* phase);
   virtual const Type* Value(PhaseGVN* phase) const;
 };
 
 //-------------------------------ReverseLNode--------------------------------
 // reverse bits of a long
-class ReverseLNode : public InvolutionNode {
+class ReverseLNode : public Node {
 public:
-  ReverseLNode(Node* in) : InvolutionNode(in) {}
+  ReverseLNode(Node* in) : Node(nullptr, in) {}
   virtual int Opcode() const;
   const Type* bottom_type() const { return TypeLong::LONG; }
   virtual uint ideal_reg() const { return Op_RegL; }
+  virtual Node* Identity(PhaseGVN* phase);
   virtual const Type* Value(PhaseGVN* phase) const;
 };
 

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

@@ -1469,16 +1469,6 @@ public class IRNode {
         superWordNodes(MAX_REDUCTION_V, "MaxReductionV");
     }
 
-    public static final String NEG_F = PREFIX + "NEG_F" + POSTFIX;
-    static {
-        beforeMatchingNameRegex(NEG_F, "NegF");
-    }
-
-    public static final String NEG_D = PREFIX + "NEG_D" + POSTFIX;
-    static {
-        beforeMatchingNameRegex(NEG_D, "NegD");
-    }
-
     public static final String NEG_VF = VECTOR_PREFIX + "NEG_VF" + POSTFIX;
     static {
         vectorNode(NEG_VF, "NegVF", TYPE_FLOAT);