8343745: Only update Last Value Assertion Predicates in Loop Unrolling

Reviewed-by: thartmann, kvn

Author: chhagedorn

src/hotspot/share/opto/cfgnode.hpp

@@ -324,7 +324,7 @@ class IfNode : public MultiBranchNode {
   float _fcnt;                           // Frequency counter
 
  private:
-  NOT_PRODUCT(AssertionPredicateType _assertion_predicate_type;)
+  AssertionPredicateType _assertion_predicate_type;
 
   void init_node(Node* control, Node* bol) {
     init_class_id(Class_If);
@@ -426,7 +426,7 @@ class IfNode : public MultiBranchNode {
   // gen_subtype_check() and catch_inline_exceptions().
 
   IfNode(Node* control, Node* bol, float p, float fcnt);
-  NOT_PRODUCT(IfNode(Node* control, Node* bol, float p, float fcnt, AssertionPredicateType assertion_predicate_type);)
+  IfNode(Node* control, Node* bol, float p, float fcnt, AssertionPredicateType assertion_predicate_type);
 
   static IfNode* make_with_same_profile(IfNode* if_node_profile, Node* ctrl, BoolNode* bol);
 
@@ -448,11 +448,11 @@ class IfNode : public MultiBranchNode {
   // Returns null is it couldn't improve the type.
   static const TypeInt* filtered_int_type(PhaseGVN* phase, Node* val, Node* if_proj);
 
-#ifndef PRODUCT
   AssertionPredicateType assertion_predicate_type() const {
     return _assertion_predicate_type;
   }
 
+#ifndef PRODUCT
   virtual void dump_spec(outputStream *st) const;
 #endif
 
@@ -468,12 +468,10 @@ class RangeCheckNode : public IfNode {
     init_class_id(Class_RangeCheck);
   }
 
-#ifndef PRODUCT
   RangeCheckNode(Node* control, Node* bol, float p, float fcnt, AssertionPredicateType assertion_predicate_type)
       : IfNode(control, bol, p, fcnt, assertion_predicate_type) {
     init_class_id(Class_RangeCheck);
   }
-#endif // NOT PRODUCT
 
   virtual int Opcode() const;
   virtual Node* Ideal(PhaseGVN *phase, bool can_reshape);

src/hotspot/share/opto/ifnode.cpp

@@ -50,20 +50,18 @@ extern uint explicit_null_checks_elided;
 IfNode::IfNode(Node* control, Node* bol, float p, float fcnt)
     : MultiBranchNode(2),
       _prob(p),
-      _fcnt(fcnt)
-      NOT_PRODUCT(COMMA _assertion_predicate_type(AssertionPredicateType::None)) {
+      _fcnt(fcnt),
+      _assertion_predicate_type(AssertionPredicateType::None) {
   init_node(control, bol);
 }
 
-#ifndef PRODUCT
 IfNode::IfNode(Node* control, Node* bol, float p, float fcnt, AssertionPredicateType assertion_predicate_type)
     : MultiBranchNode(2),
       _prob(p),
       _fcnt(fcnt),
       _assertion_predicate_type(assertion_predicate_type) {
   init_node(control, bol);
 }
-#endif // NOT_PRODUCT
 
 //=============================================================================
 //------------------------------Value------------------------------------------

src/hotspot/share/opto/loopPredicate.cpp

@@ -100,8 +100,8 @@ void PhaseIdealLoop::register_control(Node* n, IdealLoopTree *loop, Node* pred,
 // is an IfTrue projection. This code is also used to clone predicates to cloned loops.
 IfTrueNode* PhaseIdealLoop::create_new_if_for_predicate(ParsePredicateSuccessProj* parse_predicate_success_proj,
                                                         Node* new_entry, const Deoptimization::DeoptReason reason,
-                                                        const int opcode, const bool rewire_uncommon_proj_phi_inputs
-                                                        NOT_PRODUCT (COMMA AssertionPredicateType assertion_predicate_type)) {
+                                                        const int opcode, const bool rewire_uncommon_proj_phi_inputs,
+                                                        AssertionPredicateType assertion_predicate_type) {
   assert(parse_predicate_success_proj->is_uncommon_trap_if_pattern(reason), "must be a uct if pattern!");
   ParsePredicateNode* parse_predicate = parse_predicate_success_proj->in(0)->as_ParsePredicate();
   ParsePredicateUncommonProj* uncommon_proj = parse_predicate->uncommon_proj();

src/hotspot/share/opto/loopTransform.cpp

@@ -2759,8 +2759,8 @@ void PhaseIdealLoop::do_range_check(IdealLoopTree *loop, Node_List &old_new) {
             // cannot remove an empty loop with a constant limit when init is not a constant as well. We will use
             // a LoopLimitCheck node that can only be folded if the zero grip guard is also foldable.
             loop_entry = initialized_assertion_predicate_creator.create(final_iv_placeholder, loop_entry, stride_con,
-                                                                        scale_con, int_offset, int_limit NOT_PRODUCT(
-                                                                        COMMA AssertionPredicateType::FinalIv));
+                                                                        scale_con, int_offset, int_limit,
+                                                                        AssertionPredicateType::FinalIv);
             assert(!assertion_predicate_has_loop_opaque_node(loop_entry->in(0)->as_If()), "unexpected");
           }
 
@@ -2773,8 +2773,8 @@ void PhaseIdealLoop::do_range_check(IdealLoopTree *loop, Node_List &old_new) {
 
           // Initialized Assertion Predicate for the value of the initial main-loop.
           loop_entry = initialized_assertion_predicate_creator.create(init, loop_entry, stride_con, scale_con,
-                                                                      int_offset, int_limit NOT_PRODUCT(COMMA
-                                                                      AssertionPredicateType::InitValue));
+                                                                      int_offset, int_limit,
+                                                                      AssertionPredicateType::InitValue);
           assert(!assertion_predicate_has_loop_opaque_node(loop_entry->in(0)->as_If()), "unexpected");
 
         } else {

src/hotspot/share/opto/loopnode.hpp

@@ -1352,8 +1352,8 @@ class PhaseIdealLoop : public PhaseTransform {
   // Create a new if above the uncommon_trap_if_pattern for the predicate to be promoted
   IfTrueNode* create_new_if_for_predicate(
       ParsePredicateSuccessProj* parse_predicate_proj, Node* new_entry, Deoptimization::DeoptReason reason, int opcode,
-      bool rewire_uncommon_proj_phi_inputs = false
-      NOT_PRODUCT (COMMA AssertionPredicateType assertion_predicate_type = AssertionPredicateType::None));
+      bool rewire_uncommon_proj_phi_inputs = false,
+      AssertionPredicateType assertion_predicate_type = AssertionPredicateType::None);
 
  private:
   // Helper functions for create_new_if_for_predicate()