8343148: C2: Refactor uses of "PhaseValue::*con*() + PhaseIdealLoop::set_ctrl()" into separate method

Reviewed-by: kvn, chagedorn, thartmann

Author: theoweidmannoracle

src/hotspot/share/gc/shenandoah/c2/shenandoahSupport.cpp

@@ -887,7 +887,7 @@ void ShenandoahBarrierC2Support::test_gc_state(Node*& ctrl, Node* raw_mem, Node*
   phase->register_new_node(gc_state_cmp,  old_ctrl);
   phase->register_new_node(gc_state_bool, old_ctrl);
 
-  phase->set_ctrl(gc_state_offset, phase->C->root());
+  phase->set_root_as_ctrl(gc_state_offset);
 
   assert(is_gc_state_test(gc_state_iff, flags), "Should match the shape");
 }
@@ -945,7 +945,7 @@ void ShenandoahBarrierC2Support::test_in_cset(Node*& ctrl, Node*& not_cset_ctrl,
   phase->register_control(ctrl,          loop, cset_iff);
   phase->register_control(not_cset_ctrl, loop, cset_iff);
 
-  phase->set_ctrl(cset_addr_ptr, phase->C->root());
+  phase->set_root_as_ctrl(cset_addr_ptr);
 
   phase->register_new_node(raw_val,        old_ctrl);
   phase->register_new_node(cset_idx,       old_ctrl);

src/hotspot/share/opto/loopPredicate.cpp

@@ -766,17 +766,15 @@ BoolNode* PhaseIdealLoop::rc_predicate(Node* ctrl, const int scale, Node* offset
     if ((stride > 0 && (java_subtract(limit_lo, stride) < limit_lo)) ||
         (stride < 0 && (java_subtract(limit_hi, stride) > limit_hi))) {
       // No overflow possible
-      ConINode* con_stride = _igvn.intcon(stride);
-      set_ctrl(con_stride, C->root());
+      ConINode* con_stride = intcon(stride);
       max_idx_expr = new SubINode(limit, con_stride);
       idx_type = TypeInt::make(limit_lo - stride, limit_hi - stride, limit_type->_widen);
     } else {
       // May overflow
       overflow = true;
       limit = new ConvI2LNode(limit);
       register_new_node(limit, ctrl);
-      ConLNode* con_stride = _igvn.longcon(stride);
-      set_ctrl(con_stride, C->root());
+      ConLNode* con_stride = longcon(stride);
       max_idx_expr = new SubLNode(limit, con_stride);
     }
     register_new_node(max_idx_expr, ctrl);
@@ -793,8 +791,7 @@ BoolNode* PhaseIdealLoop::rc_predicate(Node* ctrl, const int scale, Node* offset
   }
 
   if (scale != 1) {
-    ConNode* con_scale = _igvn.intcon(scale);
-    set_ctrl(con_scale, C->root());
+    ConNode* con_scale = intcon(scale);
     if (TraceLoopPredicate) {
       predString->print("* %d ", scale);
     }
@@ -811,8 +808,7 @@ BoolNode* PhaseIdealLoop::rc_predicate(Node* ctrl, const int scale, Node* offset
         register_new_node(max_idx_expr, ctrl);
       }
       overflow = true;
-      con_scale = _igvn.longcon(scale);
-      set_ctrl(con_scale, C->root());
+      con_scale = longcon(scale);
       max_idx_expr = new MulLNode(max_idx_expr, con_scale);
     } else {
       // No overflow possible
@@ -1342,8 +1338,7 @@ bool PhaseIdealLoop::loop_predication_impl(IdealLoopTree* loop) {
 #endif
     return false;
   }
-  ConNode* zero = _igvn.intcon(0);
-  set_ctrl(zero, C->root());
+  ConNode* zero = intcon(0);
 
   ResourceArea* area = Thread::current()->resource_area();
   Invariance invar(area, loop);

src/hotspot/share/opto/loopTransform.cpp

@@ -354,15 +354,11 @@ Node* IdealLoopTree::reassociate_add_sub_cmp(Node* n1, int inv1_idx, int inv2_id
   Node* inv1_c = phase->get_ctrl(inv1);
   Node* n_inv1;
   if (neg_inv1) {
-    Node* zero;
     if (is_int) {
-      zero = phase->_igvn.intcon(0);
-      n_inv1 = new SubINode(zero, inv1);
+      n_inv1 = new SubINode(phase->intcon(0), inv1);
     } else {
-      zero = phase->_igvn.longcon(0L);
-      n_inv1 = new SubLNode(zero, inv1);
+      n_inv1 = new SubLNode(phase->longcon(0L), inv1);
     }
-    phase->set_ctrl(zero, phase->C->root());
     phase->register_new_node(n_inv1, inv1_c);
   } else {
     n_inv1 = inv1;
@@ -1711,8 +1707,7 @@ void PhaseIdealLoop::update_main_loop_assertion_predicates(CountedLoopNode* main
   // Compute the value of the loop induction variable at the end of the
   // first iteration of the unrolled loop: init + new_stride_con - init_inc
   int unrolled_stride_con = main_loop_head->stride_con() * 2;
-  Node* unrolled_stride = _igvn.intcon(unrolled_stride_con);
-  set_ctrl(unrolled_stride, C->root());
+  Node* unrolled_stride = intcon(unrolled_stride_con);
 
   Node* loop_entry = main_loop_head->skip_strip_mined()->in(LoopNode::EntryControl);
   PredicateIterator predicate_iterator(loop_entry);
@@ -1879,23 +1874,20 @@ void PhaseIdealLoop::do_unroll(IdealLoopTree *loop, Node_List &old_new, bool adj
     if (limit->is_Con()) {
       // The check in policy_unroll and the assert above guarantee
       // no underflow if limit is constant.
-      new_limit = _igvn.intcon(limit->get_int() - stride_con);
-      set_ctrl(new_limit, C->root());
+      new_limit = intcon(limit->get_int() - stride_con);
     } else {
       // Limit is not constant. Int subtraction could lead to underflow.
       // (1) Convert to long.
       Node* limit_l = new ConvI2LNode(limit);
       register_new_node_with_ctrl_of(limit_l, limit);
-      Node* stride_l = _igvn.longcon(stride_con);
-      set_ctrl(stride_l, C->root());
+      Node* stride_l = longcon(stride_con);
 
       // (2) Subtract: compute in long, to prevent underflow.
       Node* new_limit_l = new SubLNode(limit_l, stride_l);
       register_new_node(new_limit_l, ctrl);
 
       // (3) Clamp to int range, in case we had subtraction underflow.
-      Node* underflow_clamp_l = _igvn.longcon((stride_con > 0) ? min_jint : max_jint);
-      set_ctrl(underflow_clamp_l, C->root());
+      Node* underflow_clamp_l = longcon((stride_con > 0) ? min_jint : max_jint);
       Node* new_limit_no_underflow_l = nullptr;
       if (stride_con > 0) {
         // limit = MaxL(limit - stride, min_jint)
@@ -1985,8 +1977,7 @@ void PhaseIdealLoop::do_unroll(IdealLoopTree *loop, Node_List &old_new, bool adj
   // Kill the clone's backedge
   Node *newcle = old_new[loop_end->_idx];
   _igvn.hash_delete(newcle);
-  Node *one = _igvn.intcon(1);
-  set_ctrl(one, C->root());
+  Node* one = intcon(1);
   newcle->set_req(1, one);
   // Force clone into same loop body
   uint max = loop->_body.size();
@@ -2122,8 +2113,7 @@ void PhaseIdealLoop::add_constraint(jlong stride_con, jlong scale_con, Node* off
   // Only do this for the pre-loop, one less iteration of the main loop doesn't hurt.
   bool round = ABS(scale_con) > 1;
 
-  Node* scale = _igvn.longcon(scale_con);
-  set_ctrl(scale, C->root());
+  Node* scale = longcon(scale_con);
 
   if ((stride_con^scale_con) >= 0) { // Use XOR to avoid overflow
     // Positive stride*scale: the affine function is increasing,
@@ -2162,8 +2152,7 @@ void PhaseIdealLoop::add_constraint(jlong stride_con, jlong scale_con, Node* off
     //     else /* scale > 0 and stride < 0 */
     //       I > (upper_limit-(offset+1))/scale
     //   )
-    Node* one = _igvn.longcon(1);
-    set_ctrl(one, C->root());
+    Node* one = longcon(1);
     Node* plus_one = new AddLNode(offset, one);
     register_new_node(plus_one, pre_ctrl);
     *pre_limit = adjust_limit(!is_positive_stride, scale, plus_one, upper_limit, *pre_limit, pre_ctrl, round);
@@ -2368,8 +2357,7 @@ bool PhaseIdealLoop::is_scaled_iv_plus_offset(Node* exp, Node* iv, BasicType bt,
       *p_scale = scale;
     }
     if (p_offset != nullptr) {
-      Node *zero = _igvn.zerocon(bt);
-      set_ctrl(zero, C->root());
+      Node* zero = zerocon(bt);
       *p_offset = zero;
     }
     return true;
@@ -2420,8 +2408,7 @@ bool PhaseIdealLoop::is_scaled_iv_plus_offset(Node* exp, Node* iv, BasicType bt,
       }
       if (p_offset != nullptr) {
         if (which == 1) {  // must negate the extracted offset
-          Node *zero = _igvn.integercon(0, exp_bt);
-          set_ctrl(zero, C->root());
+          Node* zero = integercon(0, exp_bt);
           Node *ctrl_off = get_ctrl(offset);
           offset = SubNode::make(zero, offset, exp_bt);
           register_new_node(offset, ctrl_off);
@@ -2540,13 +2527,10 @@ void PhaseIdealLoop::do_range_check(IdealLoopTree* loop) {
 
   int stride_con = cl->stride_con();
   bool abs_stride_is_one = stride_con == 1 || stride_con == -1;
-  Node* zero = _igvn.longcon(0);
-  Node* one  = _igvn.longcon(1);
+  Node* zero = longcon(0);
+  Node* one  = longcon(1);
   // Use symmetrical int range [-max_jint,max_jint]
-  Node* mini = _igvn.longcon(-max_jint);
-  set_ctrl(zero, C->root());
-  set_ctrl(one,  C->root());
-  set_ctrl(mini, C->root());
+  Node* mini = longcon(-max_jint);
 
   Node* loop_entry = cl->skip_strip_mined()->in(LoopNode::EntryControl);
   assert(loop_entry->is_Proj() && loop_entry->in(0)->is_If(), "if projection only");
@@ -2745,8 +2729,7 @@ void PhaseIdealLoop::do_range_check(IdealLoopTree* loop) {
 
       // Kill the eliminated test
       C->set_major_progress();
-      Node *kill_con = _igvn.intcon(1-flip);
-      set_ctrl(kill_con, C->root());
+      Node* kill_con = intcon(1-flip);
       _igvn.replace_input_of(iff, 1, kill_con);
       // Find surviving projection
       assert(iff->is_If(), "");

src/hotspot/share/opto/loopnode.cpp

@@ -313,8 +313,7 @@ IdealLoopTree* PhaseIdealLoop::insert_outer_loop(IdealLoopTree* loop, LoopNode*
 IdealLoopTree* PhaseIdealLoop::create_outer_strip_mined_loop(BoolNode *test, Node *cmp, Node *init_control,
                                                              IdealLoopTree* loop, float cl_prob, float le_fcnt,
                                                              Node*& entry_control, Node*& iffalse) {
-  Node* outer_test = _igvn.intcon(0);
-  set_ctrl(outer_test, C->root());
+  Node* outer_test = intcon(0);
   Node *orig = iffalse;
   iffalse = iffalse->clone();
   _igvn.register_new_node_with_optimizer(iffalse);
@@ -969,16 +968,14 @@ bool PhaseIdealLoop::create_loop_nest(IdealLoopTree* loop, Node_List &old_new) {
     inner_iters_actual_int = inner_iters_actual;
   }
 
-  Node* int_zero = _igvn.intcon(0);
-  set_ctrl(int_zero, C->root());
+  Node* int_zero = intcon(0);
   if (stride_con < 0) {
     inner_iters_actual_int = new SubINode(int_zero, inner_iters_actual_int);
     _igvn.register_new_node_with_optimizer(inner_iters_actual_int);
   }
 
   // Clone the iv data nodes as an integer iv
-  Node* int_stride = _igvn.intcon(stride_con);
-  set_ctrl(int_stride, C->root());
+  Node* int_stride = intcon(stride_con);
   Node* inner_phi = new PhiNode(x->in(0), TypeInt::INT);
   Node* inner_incr = new AddINode(inner_phi, int_stride);
   Node* inner_cmp = nullptr;
@@ -1273,14 +1270,10 @@ int PhaseIdealLoop::extract_long_range_checks(const IdealLoopTree* loop, jint st
 void PhaseIdealLoop::transform_long_range_checks(int stride_con, const Node_List &range_checks, Node* outer_phi,
                                                  Node* inner_iters_actual_int, Node* inner_phi,
                                                  Node* iv_add, LoopNode* inner_head) {
-  Node* long_zero = _igvn.longcon(0);
-  set_ctrl(long_zero, C->root());
-  Node* int_zero = _igvn.intcon(0);
-  set_ctrl(int_zero, this->C->root());
-  Node* long_one = _igvn.longcon(1);
-  set_ctrl(long_one, this->C->root());
-  Node* int_stride = _igvn.intcon(checked_cast<int>(stride_con));
-  set_ctrl(int_stride, this->C->root());
+  Node* long_zero = longcon(0);
+  Node* int_zero = intcon(0);
+  Node* long_one = longcon(1);
+  Node* int_stride = intcon(checked_cast<int>(stride_con));
 
   for (uint i = 0; i < range_checks.size(); i++) {
     ProjNode* proj = range_checks.at(i)->as_Proj();
@@ -1302,8 +1295,7 @@ void PhaseIdealLoop::transform_long_range_checks(int stride_con, const Node_List
     Node* entry_control = inner_head->in(LoopNode::EntryControl);
 
     Node* R = range;
-    Node* K = _igvn.longcon(scale);
-    set_ctrl(K, this->C->root());
+    Node* K = longcon(scale);
 
     Node* L = offset;
 
@@ -1334,8 +1326,7 @@ void PhaseIdealLoop::transform_long_range_checks(int stride_con, const Node_List
       // So this transformation could cause spurious deoptimizations and failed range check elimination
       // (but not incorrect execution) for unlikely corner cases with overflow.
       // If this causes problems in practice, we could maybe direct execution to a post-loop, instead of deoptimizing.
-      Node* max_jint_plus_one_long = _igvn.longcon((jlong)max_jint + 1);
-      set_ctrl(max_jint_plus_one_long, C->root());
+      Node* max_jint_plus_one_long = longcon((jlong)max_jint + 1);
       Node* max_range = new AddLNode(max_jint_plus_one_long, L);
       register_new_node(max_range, entry_control);
       R = MaxNode::unsigned_min(R, max_range, TypeLong::POS, _igvn);
@@ -1389,8 +1380,7 @@ void PhaseIdealLoop::transform_long_range_checks(int stride_con, const Node_List
 
     // H_clamp = Q_max+1 < Q_min ? max_jlong : Q_max+1
     // (Because Q_min and Q_max are close, the overflow check could also be encoded as Q_max+1 < 0 & Q_min >= 0.)
-    Node* max_jlong_long = _igvn.longcon(max_jlong);
-    set_ctrl(max_jlong_long, this->C->root());
+    Node* max_jlong_long = longcon(max_jlong);
     Node* Q_max_cmp = new CmpLNode(Q_max_plus_one, Q_min);
     register_new_node(Q_max_cmp, entry_control);
     Node* Q_max_bool = new BoolNode(Q_max_cmp, BoolTest::lt);
@@ -1424,8 +1414,7 @@ void PhaseIdealLoop::transform_long_range_checks(int stride_con, const Node_List
     // to:     j*K + L_2 <u32 R_2
     // that is:
     //   (j*K + Q_first) - L_clamp <u32 clamp(R, L_clamp, H_clamp) - L_clamp
-    K = _igvn.intcon(checked_cast<int>(scale));
-    set_ctrl(K, this->C->root());
+    K = intcon(checked_cast<int>(scale));
     Node* scaled_iv = new MulINode(inner_phi, K);
     register_new_node(scaled_iv, c);
     Node* scaled_iv_plus_offset = new AddINode(scaled_iv, L_2);
@@ -3155,7 +3144,7 @@ void OuterStripMinedLoopNode::transform_to_counted_loop(PhaseIterGVN* igvn, Phas
   // make counted loop exit test always fail
   ConINode* zero = igvn->intcon(0);
   if (iloop != nullptr) {
-    iloop->set_ctrl(zero, igvn->C->root());
+    iloop->set_root_as_ctrl(zero);
   }
   igvn->replace_input_of(cle, 1, zero);
   // replace outer loop end with CountedLoopEndNode with formers' CLE's exit test
@@ -4067,8 +4056,7 @@ void PhaseIdealLoop::replace_parallel_iv(IdealLoopTree *loop) {
     // variable differs from the trip counter by a loop-invariant
     // amount, the difference between their respective initial values.
     // It is scaled by the 'ratio_con'.
-    Node* ratio = _igvn.integercon(ratio_con, stride_con2_bt);
-    set_ctrl(ratio, C->root());
+    Node* ratio = integercon(ratio_con, stride_con2_bt);
 
     Node* init_converted = insert_convert_node_if_needed(stride_con2_bt, init);
     Node* phi_converted = insert_convert_node_if_needed(stride_con2_bt, phi);
@@ -4488,8 +4476,7 @@ void PhaseIdealLoop::eliminate_useless_template_assertion_predicates(Unique_Node
     OpaqueTemplateAssertionPredicateNode* opaque_node =
         C->template_assertion_predicate_opaq_node(i - 1)->as_OpaqueTemplateAssertionPredicate();
     if (!useful_predicates.member(opaque_node)) { // not in the useful list
-      ConINode* one = _igvn.intcon(1);
-      set_ctrl(one, C->root());
+      ConINode* one = intcon(1);
       _igvn.replace_node(opaque_node, one);
     }
   }
@@ -6870,6 +6857,36 @@ void PhaseIdealLoop::rpo(Node* start, Node_Stack &stk, VectorSet &visited, Node_
   }
 }
 
+ConINode* PhaseIdealLoop::intcon(jint i) {
+  ConINode* node = _igvn.intcon(i);
+  set_root_as_ctrl(node);
+  return node;
+}
+
+ConLNode* PhaseIdealLoop::longcon(jlong i) {
+  ConLNode* node = _igvn.longcon(i);
+  set_root_as_ctrl(node);
+  return node;
+}
+
+ConNode* PhaseIdealLoop::makecon(const Type* t) {
+  ConNode* node = _igvn.makecon(t);
+  set_root_as_ctrl(node);
+  return node;
+}
+
+ConNode* PhaseIdealLoop::integercon(jlong l, BasicType bt) {
+  ConNode* node = _igvn.integercon(l, bt);
+  set_root_as_ctrl(node);
+  return node;
+}
+
+ConNode* PhaseIdealLoop::zerocon(BasicType bt) {
+  ConNode* node = _igvn.zerocon(bt);
+  set_root_as_ctrl(node);
+  return node;
+}
+
 
 //=============================================================================
 //------------------------------LoopTreeIterator-------------------------------

src/hotspot/share/opto/loopnode.hpp

@@ -980,6 +980,10 @@ class PhaseIdealLoop : public PhaseTransform {
     assert( ctrl == find_non_split_ctrl(ctrl), "must set legal crtl" );
     _loop_or_ctrl.map(n->_idx, (Node*)((intptr_t)ctrl + 1));
   }
+  void set_root_as_ctrl(Node* n) {
+    assert(!has_node(n) || has_ctrl(n), "");
+    _loop_or_ctrl.map(n->_idx, (Node*)((intptr_t)C->root() + 1));
+  }
   // Set control and update loop membership
   void set_ctrl_and_loop(Node* n, Node* ctrl) {
     IdealLoopTree* old_loop = get_loop(get_ctrl(n));
@@ -1784,6 +1788,16 @@ class PhaseIdealLoop : public PhaseTransform {
   void pin_array_access_nodes_dependent_on(Node* ctrl);
 
   Node* ensure_node_and_inputs_are_above_pre_end(CountedLoopEndNode* pre_end, Node* node);
+
+  ConINode* intcon(jint i);
+
+  ConLNode* longcon(jlong i);
+
+  ConNode* makecon(const Type* t);
+
+  ConNode* integercon(jlong l, BasicType bt);
+
+  ConNode* zerocon(BasicType bt);
 };