Add verification for predicate blocks

src/hotspot/share/opto/predicates.cpp

@@ -108,6 +108,21 @@ ParsePredicateNode* ParsePredicateIterator::next() {
   return _parse_predicates.at(_current_index++);
 }
 
+#ifdef ASSERT
+// Check that the block has at most one Parse Predicate and that we only find Regular Predicate nodes (i.e. IfProj,
+// If, or RangeCheck nodes.
+void PredicateBlock::verify_block() {
+  Node* next = _parse_predicate.entry(); // Skip unique Parse Predicate of this block if present
+  while (next != _entry) {
+    assert(!next->is_ParsePredicate(), "can only have one Parse Predicate in a block");
+    const int opcode = next->Opcode();
+    assert(next->is_IfProj() || opcode == Op_If || opcode == Op_RangeCheck,
+           "Regular Predicates consist of an IfProj and an If or RangeCheck node");
+    next = next->in(0);
+  }
+}
+#endif // ASSERT
+
 // Walk over all Regular Predicates of this block (if any) and return the first node not belonging to the block
 // anymore (i.e. entry to the first Regular Predicate in this block if any or `regular_predicate_proj` otherwise).
 Node* PredicateBlock::skip_regular_predicates(Node* regular_predicate_proj, Deoptimization::DeoptReason deopt_reason) {

src/hotspot/share/opto/predicates.hpp

@@ -270,11 +270,14 @@ class PredicateBlock : public StackObj {
   Node* _entry;
 
   static Node* skip_regular_predicates(Node* regular_predicate_proj, Deoptimization::DeoptReason deopt_reason);
+  DEBUG_ONLY(void verify_block();)
 
  public:
   PredicateBlock(Node* predicate_proj, Deoptimization::DeoptReason deopt_reason)
       : _parse_predicate(predicate_proj, deopt_reason),
-        _entry(skip_regular_predicates(_parse_predicate.entry(), deopt_reason)) {}
+        _entry(skip_regular_predicates(_parse_predicate.entry(), deopt_reason)) {
+    DEBUG_ONLY(verify_block();)
+  }
 
   // Returns the control input node into this Regular Predicate block. This is either:
   // - The control input to the first If node in the block representing a Runtime Predicate if there is at least one