8332268: C2: Add missing optimizations for UDivI/L and UModI/L and unify the shared logic with the signed nodes

Reviewed-by: chagedorn, thartmann, epeter, qamai

Author: theoweidmannoracle

src/hotspot/share/opto/divnode.cpp

@@ -447,6 +447,47 @@ static Node *transform_long_divide( PhaseGVN *phase, Node *dividend, jlong divis
   return q;
 }
 
+template <typename TypeClass, typename Unsigned>
+Node* unsigned_div_ideal(PhaseGVN* phase, bool can_reshape, Node* div) {
+  // Check for dead control input
+  if (div->in(0) != nullptr && div->remove_dead_region(phase, can_reshape)) {
+    return div;
+  }
+  // Don't bother trying to transform a dead node
+  if (div->in(0) != nullptr && div->in(0)->is_top()) {
+    return nullptr;
+  }
+
+  const Type* t = phase->type(div->in(2));
+  if (t == Type::TOP) {
+    return nullptr;
+  }
+  const TypeClass* type_divisor = t->cast<TypeClass>();
+
+  // Check for useless control input
+  // Check for excluding div-zero case
+  if (div->in(0) != nullptr && (type_divisor->_hi < 0 || type_divisor->_lo > 0)) {
+    div->set_req(0, nullptr); // Yank control input
+    return div;
+  }
+
+  if (!type_divisor->is_con()) {
+    return nullptr;
+  }
+  Unsigned divisor = static_cast<Unsigned>(type_divisor->get_con()); // Get divisor
+
+  if (divisor == 0 || divisor == 1) {
+    return nullptr; // Dividing by zero constant does not idealize
+  }
+
+  if (is_power_of_2(divisor)) {
+    return make_urshift<TypeClass>(div->in(1), phase->intcon(log2i_graceful(divisor)));
+  }
+
+  return nullptr;
+}
+
+
 //=============================================================================
 //------------------------------Identity---------------------------------------
 // If the divisor is 1, we are an identity on the dividend.
@@ -873,12 +914,9 @@ const Type* UDivINode::Value(PhaseGVN* phase) const {
 
 //------------------------------Idealize---------------------------------------
 Node *UDivINode::Ideal(PhaseGVN *phase, bool can_reshape) {
-  // Check for dead control input
-  if (in(0) && remove_dead_region(phase, can_reshape))  return this;
-  return nullptr;
+  return unsigned_div_ideal<TypeInt, juint>(phase, can_reshape, this);
 }
 
-
 //=============================================================================
 //------------------------------Identity---------------------------------------
 // If the divisor is 1, we are an identity on the dividend.
@@ -912,12 +950,9 @@ const Type* UDivLNode::Value(PhaseGVN* phase) const {
 
 //------------------------------Idealize---------------------------------------
 Node *UDivLNode::Ideal(PhaseGVN *phase, bool can_reshape) {
-  // Check for dead control input
-  if (in(0) && remove_dead_region(phase, can_reshape))  return this;
-  return nullptr;
+  return unsigned_div_ideal<TypeLong, julong>(phase, can_reshape, this);
 }
 
-
 //=============================================================================
 //------------------------------Idealize---------------------------------------
 Node *ModINode::Ideal(PhaseGVN *phase, bool can_reshape) {
@@ -1084,12 +1119,98 @@ const Type* ModINode::Value(PhaseGVN* phase) const {
 
 //=============================================================================
 //------------------------------Idealize---------------------------------------
-Node *UModINode::Ideal(PhaseGVN *phase, bool can_reshape) {
+
+template <typename TypeClass, typename Unsigned>
+static Node* unsigned_mod_ideal(PhaseGVN* phase, bool can_reshape, Node* mod) {
   // Check for dead control input
-  if( in(0) && remove_dead_region(phase, can_reshape) )  return this;
+  if (mod->in(0) != nullptr && mod->remove_dead_region(phase, can_reshape)) {
+    return mod;
+  }
+  // Don't bother trying to transform a dead node
+  if (mod->in(0) != nullptr && mod->in(0)->is_top()) {
+    return nullptr;
+  }
+
+  // Get the modulus
+  const Type* t = phase->type(mod->in(2));
+  if (t == Type::TOP) {
+    return nullptr;
+  }
+  const TypeClass* type_divisor = t->cast<TypeClass>();
+
+  // Check for useless control input
+  // Check for excluding mod-zero case
+  if (mod->in(0) != nullptr && (type_divisor->_hi < 0 || type_divisor->_lo > 0)) {
+    mod->set_req(0, nullptr); // Yank control input
+    return mod;
+  }
+
+  if (!type_divisor->is_con()) {
+    return nullptr;
+  }
+  Unsigned divisor = static_cast<Unsigned>(type_divisor->get_con());
+
+  if (divisor == 0) {
+    return nullptr;
+  }
+
+  if (is_power_of_2(divisor)) {
+    return make_and<TypeClass>(mod->in(1), phase->makecon(TypeClass::make(divisor - 1)));
+  }
+
   return nullptr;
 }
 
+template <typename TypeClass, typename Unsigned, typename Signed>
+static const Type* unsigned_mod_value(PhaseGVN* phase, const Node* mod) {
+  const Type* t1 = phase->type(mod->in(1));
+  const Type* t2 = phase->type(mod->in(2));
+  if (t1 == Type::TOP) {
+    return Type::TOP;
+  }
+  if (t2 == Type::TOP) {
+    return Type::TOP;
+  }
+
+  // 0 MOD X is 0
+  if (t1 == TypeClass::ZERO) {
+    return TypeClass::ZERO;
+  }
+  // X MOD X is 0
+  if (mod->in(1) == mod->in(2)) {
+    return TypeClass::ZERO;
+  }
+
+  // Either input is BOTTOM ==> the result is the local BOTTOM
+  const Type* bot = mod->bottom_type();
+  if ((t1 == bot) || (t2 == bot) ||
+      (t1 == Type::BOTTOM) || (t2 == Type::BOTTOM)) {
+    return bot;
+  }
+
+  const TypeClass* type_divisor = t2->cast<TypeClass>();
+  if (type_divisor->is_con() && type_divisor->get_con() == 1) {
+    return TypeClass::ZERO;
+  }
+
+  const TypeClass* type_dividend = t1->cast<TypeClass>();
+  if (type_dividend->is_con() && type_divisor->is_con()) {
+    Unsigned dividend = static_cast<Unsigned>(type_dividend->get_con());
+    Unsigned divisor = static_cast<Unsigned>(type_divisor->get_con());
+    return TypeClass::make(static_cast<Signed>(dividend % divisor));
+  }
+
+  return bot;
+}
+
+Node* UModINode::Ideal(PhaseGVN* phase, bool can_reshape) {
+  return unsigned_mod_ideal<TypeInt, juint>(phase, can_reshape, this);
+}
+
+const Type* UModINode::Value(PhaseGVN* phase) const {
+  return unsigned_mod_value<TypeInt, juint, jint>(phase, this);
+}
+
 //=============================================================================
 //------------------------------Idealize---------------------------------------
 Node *ModLNode::Ideal(PhaseGVN *phase, bool can_reshape) {
@@ -1303,11 +1424,12 @@ const Type* ModFNode::Value(PhaseGVN* phase) const {
 //=============================================================================
 //------------------------------Idealize---------------------------------------
 Node *UModLNode::Ideal(PhaseGVN *phase, bool can_reshape) {
-  // Check for dead control input
-  if( in(0) && remove_dead_region(phase, can_reshape) )  return this;
-  return nullptr;
+  return unsigned_mod_ideal<TypeLong, julong>(phase, can_reshape, this);
 }
 
+const Type* UModLNode::Value(PhaseGVN* phase) const {
+  return unsigned_mod_value<TypeLong, julong, jlong>(phase, this);
+}
 
 //=============================================================================
 //------------------------------Value------------------------------------------

src/hotspot/share/opto/divnode.hpp

@@ -171,6 +171,7 @@ class UModINode : public Node {
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
   virtual const Type *bottom_type() const { return TypeInt::INT; }
   virtual uint ideal_reg() const { return Op_RegI; }
+  virtual const Type* Value(PhaseGVN* phase) const;
 };
 
 //------------------------------UModLNode---------------------------------------
@@ -182,6 +183,7 @@ class UModLNode : public Node {
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
   virtual const Type *bottom_type() const { return TypeLong::LONG; }
   virtual uint ideal_reg() const { return Op_RegL; }
+  virtual const Type* Value(PhaseGVN* phase) const;
 };
 
 //------------------------------DivModNode---------------------------------------

src/hotspot/share/opto/loopopts.cpp

@@ -278,10 +278,14 @@ bool PhaseIdealLoop::cannot_split_division(const Node* n, const Node* region) co
   switch (n->Opcode()) {
     case Op_DivI:
     case Op_ModI:
+    case Op_UDivI:
+    case Op_UModI:
       zero = TypeInt::ZERO;
       break;
     case Op_DivL:
     case Op_ModL:
+    case Op_UDivL:
+    case Op_UModL:
       zero = TypeLong::ZERO;
       break;
     default:

src/hotspot/share/opto/mulnode.hpp

@@ -226,6 +226,19 @@ class AndLNode : public MulLNode {
   virtual uint ideal_reg() const { return Op_RegL; }
 };
 
+template <typename TypeClass>
+Node* make_and(Node* a, Node* b);
+
+template <>
+inline Node* make_and<TypeLong>(Node* a, Node* b) {
+  return new AndLNode(a, b);
+}
+
+template <>
+inline Node* make_and<TypeInt>(Node* a, Node* b) {
+  return new AndINode(a, b);
+}
+
 class LShiftNode : public Node {
 public:
   LShiftNode(Node *in1, Node *in2) : Node(nullptr,in1,in2) {
@@ -358,6 +371,19 @@ class URShiftLNode : public Node {
   virtual uint ideal_reg() const { return Op_RegL; }
 };
 
+template <typename TypeClass>
+Node* make_urshift(Node* a, Node* b);
+
+template <>
+inline Node* make_urshift<TypeLong>(Node* a, Node* b) {
+  return new URShiftLNode(a, b);
+}
+
+template <>
+inline Node* make_urshift<TypeInt>(Node* a, Node* b) {
+  return new URShiftINode(a, b);
+}
+
 //------------------------------FmaNode--------------------------------------
 // fused-multiply-add
 class FmaNode : public Node {

src/hotspot/share/opto/node.hpp

@@ -1126,7 +1126,6 @@ class Node {
   // Check if 'this' node dominates or equal to 'sub'.
   DomResult dominates(Node* sub, Node_List &nlist);
 
-protected:
   bool remove_dead_region(PhaseGVN *phase, bool can_reshape);
 public:
 

src/hotspot/share/opto/phaseX.cpp

@@ -1731,7 +1731,9 @@ void PhaseIterGVN::remove_speculative_types()  {
 bool PhaseIterGVN::no_dependent_zero_check(Node* n) const {
   switch (n->Opcode()) {
     case Op_DivI:
-    case Op_ModI: {
+    case Op_ModI:
+    case Op_UDivI:
+    case Op_UModI: {
       // Type of divisor includes 0?
       if (type(n->in(2)) == Type::TOP) {
         // 'n' is dead. Treat as if zero check is still there to avoid any further optimizations.
@@ -1741,7 +1743,9 @@ bool PhaseIterGVN::no_dependent_zero_check(Node* n) const {
       return (type_divisor->_hi < 0 || type_divisor->_lo > 0);
     }
     case Op_DivL:
-    case Op_ModL: {
+    case Op_ModL:
+    case Op_UDivL:
+    case Op_UModL: {
       // Type of divisor includes 0?
       if (type(n->in(2)) == Type::TOP) {
         // 'n' is dead. Treat as if zero check is still there to avoid any further optimizations.

src/hotspot/share/opto/type.hpp

@@ -314,6 +314,9 @@ class Type {
   const TypeAryPtr   *isa_aryptr() const;        // Returns null if not AryPtr
   const TypeAryPtr   *is_aryptr() const;         // Array oop
 
+  template <typename TypeClass>
+  const TypeClass* cast() const;
+
   const TypeMetadataPtr   *isa_metadataptr() const;   // Returns null if not oop ptr type
   const TypeMetadataPtr   *is_metadataptr() const;    // Java-style GC'd pointer
   const TypeKlassPtr      *isa_klassptr() const;      // Returns null if not KlassPtr
@@ -2166,6 +2169,15 @@ inline bool Type::is_floatingpoint() const {
   return false;
 }
 
+template <>
+inline const TypeInt* Type::cast<TypeInt>() const {
+  return is_int();
+}
+
+template <>
+inline const TypeLong* Type::cast<TypeLong>() const {
+  return is_long();
+}
 
 // ===============================================================
 // Things that need to be 64-bits in the 64-bit build but

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

@@ -127,7 +127,6 @@ public int identityThird(int x, int y) {
                   IRNode.DIV, "1",
                   IRNode.DIV_BY_ZERO_TRAP, "1"
                  })
-    // Hotspot should keep the division because it may cause a division by zero trap
     public int retainDenominator(int x, int y) {
         return (x * y) / y;
     }

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

@@ -125,7 +125,6 @@ public long identityThird(long x, long y) {
                   IRNode.DIV_L, "1",
                   IRNode.DIV_BY_ZERO_TRAP, "1"
                  })
-    // Hotspot should keep the division because it may cause a division by zero trap
     public long retainDenominator(long x, long y) {
         return (x * y) / y;
     }