8327111: Replace remaining uses of create_bool_from_template_assertio…

…n_predicate() which involve additional transformations with new code from JDK-8327110

src/hotspot/share/opto/loopTransform.cpp

@@ -1488,96 +1488,23 @@ void PhaseIdealLoop::count_opaque_loop_nodes(Node* n, uint& init, uint& stride)
   }
 }
 
-// Create a new Bool node from the provided Template Assertion Predicate.
-// Unswitched loop: new_init and new_stride are both null. Clone OpaqueLoopInit and OpaqueLoopStride.
-// Otherwise: Replace found OpaqueLoop* nodes with new_init and new_stride, respectively.
-Node* PhaseIdealLoop::create_bool_from_template_assertion_predicate(Node* template_assertion_predicate, Node* new_init,
-                                                                    Node* new_stride, Node* control) {
-  Node_Stack to_clone(2);
-  Node* opaque4 = template_assertion_predicate->in(1);
-  assert(opaque4->Opcode() == Op_Opaque4, "must be Opaque4");
-  to_clone.push(opaque4, 1);
-  uint current = C->unique();
-  Node* result = nullptr;
-  bool is_unswitched_loop = new_init == nullptr && new_stride == nullptr;
-  assert(new_init != nullptr || is_unswitched_loop, "new_init must be set when new_stride is non-null");
-  // Look for the opaque node to replace with the new value
-  // and clone everything in between. We keep the Opaque4 node
-  // so the duplicated predicates are eliminated once loop
-  // opts are over: they are here only to keep the IR graph
-  // consistent.
-  do {
-    Node* n = to_clone.node();
-    uint i = to_clone.index();
-    Node* m = n->in(i);
-    if (is_part_of_template_assertion_predicate_bool(m)) {
-      to_clone.push(m, 1);
-      continue;
-    }
-    if (m->is_Opaque1()) {
-      if (n->_idx < current) {
-        n = n->clone();
-        register_new_node(n, control);
-      }
-      int op = m->Opcode();
-      if (op == Op_OpaqueLoopInit) {
-        if (is_unswitched_loop && m->_idx < current && new_init == nullptr) {
-          new_init = m->clone();
-          register_new_node(new_init, control);
-        }
-        n->set_req(i, new_init);
-      } else {
-        assert(op == Op_OpaqueLoopStride, "unexpected opaque node");
-        if (is_unswitched_loop && m->_idx < current && new_stride == nullptr) {
-          new_stride = m->clone();
-          register_new_node(new_stride, control);
-        }
-        if (new_stride != nullptr) {
-          n->set_req(i, new_stride);
-        }
-      }
-      to_clone.set_node(n);
-    }
-    while (true) {
-      Node* cur = to_clone.node();
-      uint j = to_clone.index();
-      if (j+1 < cur->req()) {
-        to_clone.set_index(j+1);
-        break;
-      }
-      to_clone.pop();
-      if (to_clone.size() == 0) {
-        result = cur;
-        break;
-      }
-      Node* next = to_clone.node();
-      j = to_clone.index();
-      if (next->in(j) != cur) {
-        assert(cur->_idx >= current || next->in(j)->Opcode() == Op_Opaque1, "new node or Opaque1 being replaced");
-        if (next->_idx < current) {
-          next = next->clone();
-          register_new_node(next, control);
-          to_clone.set_node(next);
-        }
-        next->set_req(j, cur);
-      }
-    }
-  } while (result == nullptr);
-  assert(result->_idx >= current, "new node expected");
-  assert(!is_unswitched_loop || new_init != nullptr, "new_init must always be found and cloned");
-  return result;
-}
-
 // Clone an Assertion Predicate for the main loop. new_init and new_stride are set as new inputs. Since the predicates
 // cannot fail at runtime, Halt nodes are inserted instead of uncommon traps.
 Node* PhaseIdealLoop::clone_assertion_predicate_and_initialize(Node* iff, Node* new_init, Node* new_stride, Node* predicate,
                                                                Node* uncommon_proj, Node* control, IdealLoopTree* outer_loop,
                                                                Node* input_proj) {
-  Node* result = create_bool_from_template_assertion_predicate(iff, new_init, new_stride, control);
+  TemplateAssertionPredicateExpression template_assertion_predicate_expression(iff->in(1)->as_Opaque4());
+  Opaque4Node* new_opaque4_node;
+  if (new_stride == nullptr) {
+    new_opaque4_node = template_assertion_predicate_expression.clone_and_replace_init(new_init, control, this);
+  } else {
+    new_opaque4_node = template_assertion_predicate_expression.clone_and_replace_init_and_stride(new_init, new_stride,
+                                                                                                 control, this);
+  }
   Node* proj = predicate->clone();
   Node* other_proj = uncommon_proj->clone();
   Node* new_iff = iff->clone();
-  new_iff->set_req(1, result);
+  new_iff->set_req(1, new_opaque4_node);
   proj->set_req(0, new_iff);
   other_proj->set_req(0, new_iff);
   Node* frame = new ParmNode(C->start(), TypeFunc::FramePtr);

src/hotspot/share/opto/loopnode.hpp

@@ -950,8 +950,6 @@ class PhaseIdealLoop : public PhaseTransform {
                                                  Node* input_proj);
   static void count_opaque_loop_nodes(Node* n, uint& init, uint& stride);
   static bool subgraph_has_opaque(Node* n);
-  Node* create_bool_from_template_assertion_predicate(Node* template_assertion_predicate, Node* new_init, Node* new_stride,
-                                                      Node* control);
   static bool assertion_predicate_has_loop_opaque_node(IfNode* iff);
   static void get_assertion_predicates(Node* predicate, Unique_Node_List& list, bool get_opaque = false);
   void update_main_loop_assertion_predicates(Node* ctrl, CountedLoopNode* loop_head, Node* init, int stride_con);

src/hotspot/share/opto/predicates.cpp

@@ -170,6 +170,49 @@ class CloneStrategy : public TransformStrategyForOpaqueLoopNodes {
   }
 };
 
+// This strategy replaces the OpaqueLoopInitNode with the provided init node and clones the OpaqueLoopStrideNode.
+class ReplaceInitAndCloneStrideStrategy : public TransformStrategyForOpaqueLoopNodes {
+  Node* const _new_init;
+  Node* const _new_ctrl;
+  PhaseIdealLoop* const _phase;
+
+ public:
+  ReplaceInitAndCloneStrideStrategy(Node* new_init, Node* new_ctrl, PhaseIdealLoop* phase)
+      : _new_init(new_init),
+        _new_ctrl(new_ctrl),
+        _phase(phase) {}
+  NONCOPYABLE(ReplaceInitAndCloneStrideStrategy);
+
+  Node* transform_opaque_init(OpaqueLoopInitNode* opaque_init) override {
+    return _new_init;
+  }
+
+  Node* transform_opaque_stride(OpaqueLoopStrideNode* opaque_stride) override {
+    return _phase->clone_and_register(opaque_stride, _new_ctrl)->as_OpaqueLoopStride();
+  }
+};
+
+// This strategy replaces the OpaqueLoopInit and OpaqueLoopStride nodes with the provided init and stride nodes,
+// respectively.
+class ReplaceInitAndStrideStrategy : public TransformStrategyForOpaqueLoopNodes {
+  Node* const _new_init;
+  Node* const _new_stride;
+
+ public:
+  ReplaceInitAndStrideStrategy(Node* new_init, Node* new_stride)
+      : _new_init(new_init),
+        _new_stride(new_stride) {}
+  NONCOPYABLE(ReplaceInitAndStrideStrategy);
+
+  Node* transform_opaque_init(OpaqueLoopInitNode* opaque_init) override {
+    return _new_init;
+  }
+
+  Node* transform_opaque_stride(OpaqueLoopStrideNode* opaque_stride) override {
+    return _new_stride;
+  }
+};
+
 // Creates an identical clone of this Template Assertion Predicate Expression (i.e.cloning all nodes from the Opaque4Node
 // to and including the OpaqueLoop* nodes). The cloned nodes are rewired to reflect the same graph structure as found for
 // this Template Assertion Predicate Expression. The cloned nodes get 'new_ctrl' as ctrl. There is no other update done
@@ -179,6 +222,22 @@ Opaque4Node* TemplateAssertionPredicateExpression::clone(Node* new_ctrl, PhaseId
   return clone(clone_init_and_stride_strategy, new_ctrl, phase);
 }
 
+// Same as clone() but instead of cloning the OpaqueLoopInitNode, we replace it with the provided 'new_init' node.
+Opaque4Node* TemplateAssertionPredicateExpression::clone_and_replace_init(Node* new_init, Node* new_ctrl,
+                                                                          PhaseIdealLoop* phase) {
+  ReplaceInitAndCloneStrideStrategy replace_init_and_clone_stride_strategy(new_init, new_ctrl, phase);
+  return clone(replace_init_and_clone_stride_strategy, new_ctrl, phase);
+}
+
+// Same as clone() but instead of cloning the OpaqueLoopInit and OpaqueLoopStride node, we replace them with the provided
+// 'new_init' and 'new_stride' nodes, respectively.
+Opaque4Node* TemplateAssertionPredicateExpression::clone_and_replace_init_and_stride(Node* new_init, Node* new_stride,
+                                                                                     Node* new_ctrl,
+                                                                                     PhaseIdealLoop* phase) {
+  ReplaceInitAndStrideStrategy replace_init_and_stride_strategy(new_init, new_stride);
+  return clone(replace_init_and_stride_strategy, new_ctrl, phase);
+}
+
 // Class to collect data nodes from a source to target nodes by following the inputs of the source node recursively.
 // The class takes a node filter to decide which input nodes to follow and a target node predicate to start backtracking
 // from. All nodes found on all paths from source->target(s) are returned in a Unique_Node_List (without duplicates).

src/hotspot/share/opto/predicates.hpp

@@ -307,6 +307,8 @@ class TemplateAssertionPredicateExpression : public StackObj {
   }
 
   Opaque4Node* clone(Node* new_ctrl, PhaseIdealLoop* phase);
+  Opaque4Node* clone_and_replace_init(Node* new_init, Node* new_ctrl,PhaseIdealLoop* phase);
+  Opaque4Node* clone_and_replace_init_and_stride(Node* new_init, Node* new_stride, Node* new_ctrl, PhaseIdealLoop* phase);
 };
 
 // This class represents a Predicate Block (i.e. either a Loop Predicate Block, a Profiled Loop Predicate Block,