diff --git a/src/hotspot/share/opto/cfgnode.hpp b/src/hotspot/share/opto/cfgnode.hpp index ac8896705de..1d287c2f43d 100644 --- a/src/hotspot/share/opto/cfgnode.hpp +++ b/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 @@ public: // 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 @@ public: // 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 @@ public: 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); diff --git a/src/hotspot/share/opto/ifnode.cpp b/src/hotspot/share/opto/ifnode.cpp index 30834859d03..c0ed3f7e5d4 100644 --- a/src/hotspot/share/opto/ifnode.cpp +++ b/src/hotspot/share/opto/ifnode.cpp @@ -50,12 +50,11 @@ 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), @@ -63,7 +62,6 @@ IfNode::IfNode(Node* control, Node* bol, float p, float fcnt, AssertionPredicate _assertion_predicate_type(assertion_predicate_type) { init_node(control, bol); } -#endif // NOT_PRODUCT //============================================================================= //------------------------------Value------------------------------------------ diff --git a/src/hotspot/share/opto/loopPredicate.cpp b/src/hotspot/share/opto/loopPredicate.cpp index d60d44ff09c..a4bec870b18 100644 --- a/src/hotspot/share/opto/loopPredicate.cpp +++ b/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(); diff --git a/src/hotspot/share/opto/loopTransform.cpp b/src/hotspot/share/opto/loopTransform.cpp index 06c43697350..d6e93f3b068 100644 --- a/src/hotspot/share/opto/loopTransform.cpp +++ b/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 { diff --git a/src/hotspot/share/opto/loopnode.hpp b/src/hotspot/share/opto/loopnode.hpp index a28ccd628e8..8a26a1b49b9 100644 --- a/src/hotspot/share/opto/loopnode.hpp +++ b/src/hotspot/share/opto/loopnode.hpp @@ -1352,8 +1352,8 @@ public: // 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() diff --git a/src/hotspot/share/opto/predicates.cpp b/src/hotspot/share/opto/predicates.cpp index e8287299d0d..5e600eab2f0 100644 --- a/src/hotspot/share/opto/predicates.cpp +++ b/src/hotspot/share/opto/predicates.cpp @@ -171,8 +171,8 @@ IfTrueNode* TemplateAssertionPredicate::clone_and_replace_init(Node* new_control template_assertion_expression.clone_and_replace_init(new_opaque_init, new_control, phase); AssertionPredicateIfCreator assertion_predicate_if_creator(phase); IfTrueNode* success_proj = assertion_predicate_if_creator.create_for_template(new_control, _if_node->Opcode(), - new_opaque_node NOT_PRODUCT(COMMA - _if_node->assertion_predicate_type())); + new_opaque_node, + _if_node->assertion_predicate_type()); assert(PhaseIdealLoop::assertion_predicate_has_loop_opaque_node(success_proj->in(0)->as_If()), "Template Assertion Predicates must have OpaqueLoop* nodes in the bool expression"); return success_proj; @@ -546,19 +546,19 @@ class AssertionPredicateExpressionCreator : public StackObj { // Creates an If with a success and a fail path with the given assertion_expression. The only difference to // create_for_initialized() is that we use a template specific Halt message on the fail path. IfTrueNode* AssertionPredicateIfCreator::create_for_template(Node* new_control, const int if_opcode, - Node* assertion_expression NOT_PRODUCT(COMMA - const AssertionPredicateType assertion_predicate_type)) { + Node* assertion_expression, + const AssertionPredicateType assertion_predicate_type) { const char* halt_message = "Template Assertion Predicates are always removed before code generation"; - return create(new_control, if_opcode, assertion_expression, halt_message NOT_PRODUCT(COMMA assertion_predicate_type)); + return create(new_control, if_opcode, assertion_expression, halt_message, assertion_predicate_type); } // Creates an If with a success and a fail path with the given assertion_expression. The only difference to // create_for_template() is that we use a initialized specific Halt message on the fail path. IfTrueNode* AssertionPredicateIfCreator::create_for_initialized(Node* new_control, const int if_opcode, - Node* assertion_expression NOT_PRODUCT(COMMA - const AssertionPredicateType assertion_predicate_type)) { + Node* assertion_expression, + const AssertionPredicateType assertion_predicate_type) { const char* halt_message = "Initialized Assertion Predicate cannot fail"; - return create(new_control, if_opcode, assertion_expression, halt_message NOT_PRODUCT(COMMA assertion_predicate_type)); + return create(new_control, if_opcode, assertion_expression, halt_message, assertion_predicate_type); } // Creates the If node for an Assertion Predicate with a success path and a fail path having a Halt node: @@ -571,28 +571,25 @@ IfTrueNode* AssertionPredicateIfCreator::create_for_initialized(Node* new_contro // proj with Halt // IfTrueNode* AssertionPredicateIfCreator::create(Node* new_control, const int if_opcode, Node* assertion_expression, - const char* halt_message NOT_PRODUCT(COMMA - const AssertionPredicateType assertion_predicate_type)) { + const char* halt_message, + const AssertionPredicateType assertion_predicate_type) { assert(assertion_expression->is_OpaqueTemplateAssertionPredicate() || assertion_expression->is_OpaqueInitializedAssertionPredicate(), "not a valid assertion expression"); IdealLoopTree* loop = _phase->get_loop(new_control); - IfNode* if_node = create_if_node(new_control, if_opcode, assertion_expression, loop - NOT_PRODUCT(COMMA assertion_predicate_type)); + IfNode* if_node = create_if_node(new_control, if_opcode, assertion_expression, loop, assertion_predicate_type); create_fail_path(if_node, loop, halt_message); return create_success_path(if_node, loop); } IfNode* AssertionPredicateIfCreator::create_if_node(Node* new_control, const int if_opcode, Node* assertion_expression, - IdealLoopTree* loop NOT_PRODUCT(COMMA - const AssertionPredicateType assertion_predicate_type)) { + IdealLoopTree* loop, + const AssertionPredicateType assertion_predicate_type) { IfNode* if_node; if (if_opcode == Op_If) { - if_node = new IfNode(new_control, assertion_expression, PROB_MAX, COUNT_UNKNOWN - NOT_PRODUCT(COMMA assertion_predicate_type)); + if_node = new IfNode(new_control, assertion_expression, PROB_MAX, COUNT_UNKNOWN, assertion_predicate_type); } else { assert(if_opcode == Op_RangeCheck, "must be range check"); - if_node = new RangeCheckNode(new_control, assertion_expression, PROB_MAX, COUNT_UNKNOWN - NOT_PRODUCT(COMMA assertion_predicate_type)); + if_node = new RangeCheckNode(new_control, assertion_expression, PROB_MAX, COUNT_UNKNOWN, assertion_predicate_type); } _phase->register_control(if_node, loop, new_control); return if_node; @@ -631,13 +628,13 @@ IfTrueNode* TemplateAssertionPredicateCreator::create_with_uncommon_trap( create_for_init_value(new_control, opaque_init, does_overflow); IfTrueNode* template_predicate_success_proj = create_if_node_with_uncommon_trap(template_assertion_predicate_expression, parse_predicate_success_proj, - deopt_reason, if_opcode, does_overflow - NOT_PRODUCT(COMMA AssertionPredicateType::InitValue)); + deopt_reason, if_opcode, does_overflow, + AssertionPredicateType::InitValue); template_assertion_predicate_expression = create_for_last_value(template_predicate_success_proj, opaque_init, does_overflow); return create_if_node_with_uncommon_trap(template_assertion_predicate_expression, parse_predicate_success_proj, - deopt_reason, if_opcode, does_overflow - NOT_PRODUCT(COMMA AssertionPredicateType::LastValue)); + deopt_reason, if_opcode, does_overflow, + AssertionPredicateType::LastValue); } OpaqueLoopInitNode* TemplateAssertionPredicateCreator::create_opaque_init(Node* new_control) { @@ -656,11 +653,10 @@ TemplateAssertionPredicateCreator::create_for_init_value(Node* new_control, Opaq IfTrueNode* TemplateAssertionPredicateCreator::create_if_node_with_uncommon_trap( OpaqueTemplateAssertionPredicateNode* template_assertion_predicate_expression, ParsePredicateSuccessProj* parse_predicate_success_proj, const Deoptimization::DeoptReason deopt_reason, - const int if_opcode, const bool does_overflow - NOT_PRODUCT(COMMA AssertionPredicateType assertion_predicate_type)) { + const int if_opcode, const bool does_overflow, const AssertionPredicateType assertion_predicate_type) { IfTrueNode* success_proj = _phase->create_new_if_for_predicate(parse_predicate_success_proj, nullptr, deopt_reason, - does_overflow ? Op_If : if_opcode, false - NOT_PRODUCT(COMMA assertion_predicate_type)); + does_overflow ? Op_If : if_opcode, false, + assertion_predicate_type); _phase->igvn().replace_input_of(success_proj->in(0), 1, template_assertion_predicate_expression); return success_proj; } @@ -688,12 +684,12 @@ Node* TemplateAssertionPredicateCreator::create_last_value(Node* new_control, Op } IfTrueNode* TemplateAssertionPredicateCreator::create_if_node_with_halt( - Node* new_control, OpaqueTemplateAssertionPredicateNode* template_assertion_predicate_expression, bool does_overflow - NOT_PRODUCT(COMMA AssertionPredicateType assertion_predicate_type)) { + Node* new_control, OpaqueTemplateAssertionPredicateNode* template_assertion_predicate_expression, + const bool does_overflow, const AssertionPredicateType assertion_predicate_type) { AssertionPredicateIfCreator assertion_predicate_if_creator(_phase); return assertion_predicate_if_creator.create_for_template(new_control, does_overflow ? Op_If : Op_RangeCheck, - template_assertion_predicate_expression - NOT_PRODUCT(COMMA assertion_predicate_type)); + template_assertion_predicate_expression, + assertion_predicate_type); } // Creates an init and last value Template Assertion Predicate connected together with a Halt node on the failing path. @@ -704,12 +700,12 @@ IfTrueNode* TemplateAssertionPredicateCreator::create_with_halt(Node* new_contro OpaqueTemplateAssertionPredicateNode* template_assertion_predicate_expression = create_for_init_value(new_control, opaque_init, does_overflow); IfTrueNode* template_predicate_success_proj = - create_if_node_with_halt(new_control, template_assertion_predicate_expression, does_overflow - NOT_PRODUCT(COMMA AssertionPredicateType::InitValue)); + create_if_node_with_halt(new_control, template_assertion_predicate_expression, does_overflow, + AssertionPredicateType::InitValue); template_assertion_predicate_expression = create_for_last_value(template_predicate_success_proj, opaque_init, does_overflow); return create_if_node_with_halt(template_predicate_success_proj, template_assertion_predicate_expression, - does_overflow NOT_PRODUCT(COMMA AssertionPredicateType::LastValue)); + does_overflow, AssertionPredicateType::LastValue); } InitializedAssertionPredicateCreator::InitializedAssertionPredicateCreator(PhaseIdealLoop* phase) @@ -740,8 +736,8 @@ IfTrueNode* InitializedAssertionPredicateCreator::create_from_template(IfNode* t Node* new_stride) { OpaqueInitializedAssertionPredicateNode* assertion_expression = create_assertion_expression_from_template(template_assertion_predicate, new_control, new_init, new_stride); - return create_control_nodes(new_control, template_assertion_predicate->Opcode(), assertion_expression - NOT_PRODUCT(COMMA template_assertion_predicate->assertion_predicate_type())); + return create_control_nodes(new_control, template_assertion_predicate->Opcode(), assertion_expression, + template_assertion_predicate->assertion_predicate_type()); } // Create a new Initialized Assertion Predicate from 'template_assertion_predicate' by cloning it but omitting the @@ -753,29 +749,29 @@ IfTrueNode* InitializedAssertionPredicateCreator::create_from_template(IfNode* t TemplateAssertionExpression template_assertion_expression(template_opaque); OpaqueInitializedAssertionPredicateNode* assertion_expression = template_assertion_expression.clone_and_fold_opaque_loop_nodes(new_control, _phase); - return create_control_nodes(new_control, template_assertion_predicate->Opcode(), assertion_expression - NOT_PRODUCT(COMMA template_assertion_predicate->assertion_predicate_type())); + return create_control_nodes(new_control, template_assertion_predicate->Opcode(), assertion_expression, + template_assertion_predicate->assertion_predicate_type()); } // Create a new Initialized Assertion Predicate directly without a template. IfTrueNode* InitializedAssertionPredicateCreator::create(Node* operand, Node* new_control, const jint stride, - const int scale, Node* offset, Node* range NOT_PRODUCT(COMMA - AssertionPredicateType assertion_predicate_type)) { + const int scale, Node* offset, Node* range, + const AssertionPredicateType assertion_predicate_type) { AssertionPredicateExpressionCreator expression_creator(stride, scale, offset, range, _phase); bool does_overflow; OpaqueInitializedAssertionPredicateNode* assertion_expression = expression_creator.create_for_initialized(new_control, operand, does_overflow); - return create_control_nodes(new_control, does_overflow ? Op_If : Op_RangeCheck, assertion_expression - NOT_PRODUCT(COMMA assertion_predicate_type)); + return create_control_nodes(new_control, does_overflow ? Op_If : Op_RangeCheck, assertion_expression, + assertion_predicate_type); } // Creates the CFG nodes for the Initialized Assertion Predicate. IfTrueNode* InitializedAssertionPredicateCreator::create_control_nodes( - Node* new_control, const int if_opcode, OpaqueInitializedAssertionPredicateNode* assertion_expression - NOT_PRODUCT(COMMA AssertionPredicateType assertion_predicate_type)) { + Node* new_control, const int if_opcode, OpaqueInitializedAssertionPredicateNode* assertion_expression, + const AssertionPredicateType assertion_predicate_type) { AssertionPredicateIfCreator assertion_predicate_if_creator(_phase); - return assertion_predicate_if_creator.create_for_initialized(new_control, if_opcode, assertion_expression - NOT_PRODUCT(COMMA assertion_predicate_type)); + return assertion_predicate_if_creator.create_for_initialized(new_control, if_opcode, assertion_expression, + assertion_predicate_type); } // Create a new Assertion Expression based from the given template to be used as bool input for the Initialized @@ -879,6 +875,10 @@ IfTrueNode* CreateAssertionPredicatesVisitor::clone_template_and_replace_init_in // Clone the Template Assertion Predicate and set a new input for the OpaqueLoopStrideNode. void UpdateStrideForAssertionPredicates::visit(const TemplateAssertionPredicate& template_assertion_predicate) { + if (!template_assertion_predicate.is_last_value()) { + // Only Last Value Assertion Predicates have an OpaqueLoopStrideNode. + return; + } replace_opaque_stride_input(template_assertion_predicate); Node* template_tail_control_out = template_assertion_predicate.tail()->unique_ctrl_out(); IfTrueNode* initialized_success_proj = initialize_from_updated_template(template_assertion_predicate); diff --git a/src/hotspot/share/opto/predicates.hpp b/src/hotspot/share/opto/predicates.hpp index d7171db7115..342650cd966 100644 --- a/src/hotspot/share/opto/predicates.hpp +++ b/src/hotspot/share/opto/predicates.hpp @@ -201,7 +201,6 @@ class TemplateAssertionPredicate; * Main Loop Head */ -#ifndef PRODUCT // Assertion Predicates are either emitted to check the initial value of a range check in the first iteration or the last // value of a range check in the last iteration of a loop. enum class AssertionPredicateType { @@ -211,7 +210,6 @@ enum class AssertionPredicateType { // Used for the Initialized Assertion Predicate emitted during Range Check Elimination for the final IV value. FinalIv }; -#endif // NOT PRODUCT // Interface to represent a C2 predicate. A predicate is always represented by two CFG nodes: // - An If node (head) @@ -377,8 +375,8 @@ class RuntimePredicate : public Predicate { // Class to represent a Template Assertion Predicate. class TemplateAssertionPredicate : public Predicate { - IfTrueNode* _success_proj; - IfNode* _if_node; + IfTrueNode* const _success_proj; + IfNode* const _if_node; public: explicit TemplateAssertionPredicate(IfTrueNode* success_proj) @@ -403,6 +401,10 @@ class TemplateAssertionPredicate : public Predicate { return _success_proj; } + bool is_last_value() const { + return _if_node->assertion_predicate_type() == AssertionPredicateType::LastValue; + } + IfTrueNode* clone_and_replace_init(Node* new_control, OpaqueLoopInitNode* new_opaque_init, PhaseIdealLoop* phase) const; void replace_opaque_stride_input(Node* new_stride, PhaseIterGVN& igvn) const; IfTrueNode* initialize(PhaseIdealLoop* phase, Node* new_control) const; @@ -414,8 +416,8 @@ class TemplateAssertionPredicate : public Predicate { // Class to represent an Initialized Assertion Predicate which always has a halt node on the failing path. // This predicate should never fail at runtime by design. class InitializedAssertionPredicate : public Predicate { - IfTrueNode* _success_proj; - IfNode* _if_node; + IfTrueNode* const _success_proj; + IfNode* const _if_node; public: explicit InitializedAssertionPredicate(IfTrueNode* success_proj) @@ -436,6 +438,10 @@ class InitializedAssertionPredicate : public Predicate { return _success_proj; } + bool is_last_value() const { + return _if_node->assertion_predicate_type() == AssertionPredicateType::LastValue; + } + void kill(PhaseIdealLoop* phase) const; static bool is_predicate(Node* node); }; @@ -550,15 +556,15 @@ class AssertionPredicateIfCreator : public StackObj { explicit AssertionPredicateIfCreator(PhaseIdealLoop* const phase) : _phase(phase) {} NONCOPYABLE(AssertionPredicateIfCreator); - IfTrueNode* create_for_initialized(Node* new_control, int if_opcode, Node* assertion_expression - NOT_PRODUCT(COMMA const AssertionPredicateType assertion_predicate_type)); - IfTrueNode* create_for_template(Node* new_control, int if_opcode, Node* assertion_expression - NOT_PRODUCT(COMMA const AssertionPredicateType assertion_predicate_type)); + IfTrueNode* create_for_initialized(Node* new_control, int if_opcode, Node* assertion_expression, + AssertionPredicateType assertion_predicate_type); + IfTrueNode* create_for_template(Node* new_control, int if_opcode, Node* assertion_expression, + AssertionPredicateType assertion_predicate_type); private: - IfTrueNode* create(Node* new_control, int if_opcode, Node* assertion_expression, const char* halt_message - NOT_PRODUCT(COMMA const AssertionPredicateType assertion_predicate_type)); - IfNode* create_if_node(Node* new_control, int if_opcode, Node* assertion_expression, IdealLoopTree* loop - NOT_PRODUCT(COMMA const AssertionPredicateType assertion_predicate_type)); + IfTrueNode* create(Node* new_control, int if_opcode, Node* assertion_expression, const char* halt_message, + AssertionPredicateType assertion_predicate_type); + IfNode* create_if_node(Node* new_control, int if_opcode, Node* assertion_expression, IdealLoopTree* loop, + AssertionPredicateType assertion_predicate_type); IfTrueNode* create_success_path(IfNode* if_node, IdealLoopTree* loop); void create_fail_path(IfNode* if_node, IdealLoopTree* loop, const char* halt_message); void create_halt_node(IfFalseNode* fail_proj, IdealLoopTree* loop, const char* halt_message); @@ -581,12 +587,10 @@ class TemplateAssertionPredicateCreator : public StackObj { IfTrueNode* create_if_node_with_uncommon_trap(OpaqueTemplateAssertionPredicateNode* template_assertion_predicate_expression, ParsePredicateSuccessProj* parse_predicate_success_proj, Deoptimization::DeoptReason deopt_reason, int if_opcode, - bool does_overflow - NOT_PRODUCT(COMMA AssertionPredicateType assertion_predicate_type)); + bool does_overflow, AssertionPredicateType assertion_predicate_type); IfTrueNode* create_if_node_with_halt(Node* new_control, OpaqueTemplateAssertionPredicateNode* template_assertion_predicate_expression, - bool does_overflow - NOT_PRODUCT(COMMA AssertionPredicateType assertion_predicate_type)); + bool does_overflow, AssertionPredicateType assertion_predicate_type); public: TemplateAssertionPredicateCreator(CountedLoopNode* loop_head, int scale, Node* offset, Node* range, @@ -614,16 +618,16 @@ class InitializedAssertionPredicateCreator : public StackObj { IfTrueNode* create_from_template(IfNode* template_assertion_predicate, Node* new_control, Node* new_init, Node* new_stride); IfTrueNode* create_from_template(IfNode* template_assertion_predicate, Node* new_control); - IfTrueNode* create(Node* operand, Node* new_control, jint stride, int scale, Node* offset, Node* range - NOT_PRODUCT(COMMA AssertionPredicateType assertion_predicate_type)); + IfTrueNode* create(Node* operand, Node* new_control, jint stride, int scale, Node* offset, Node* range, + AssertionPredicateType assertion_predicate_type); private: OpaqueInitializedAssertionPredicateNode* create_assertion_expression_from_template(IfNode* template_assertion_predicate, Node* new_control, Node* new_init, Node* new_stride); IfTrueNode* create_control_nodes(Node* new_control, int if_opcode, - OpaqueInitializedAssertionPredicateNode* assertion_expression - NOT_PRODUCT(COMMA AssertionPredicateType assertion_predicate_type)); + OpaqueInitializedAssertionPredicateNode* assertion_expression, + AssertionPredicateType assertion_predicate_type); }; // This class iterates through all predicates of a Regular Predicate Block and applies the given visitor to each. @@ -1063,7 +1067,10 @@ class UpdateStrideForAssertionPredicates : public PredicateVisitor { // Predicates are inserted after the Template Assertion Predicate which ensures that we are not accidentally visiting // and killing a newly created Initialized Assertion Predicate here. void visit(const InitializedAssertionPredicate& initialized_assertion_predicate) override { - initialized_assertion_predicate.kill(_phase); + if (initialized_assertion_predicate.is_last_value()) { + // Only Last Value Initialized Assertion Predicates need to be killed and updated. + initialized_assertion_predicate.kill(_phase); + } } }; #endif // SHARE_OPTO_PREDICATES_HPP