diff --git a/src/hotspot/share/opto/cfgnode.hpp b/src/hotspot/share/opto/cfgnode.hpp
index 81ac180dcfa..bc6f181aa07 100644
--- a/src/hotspot/share/opto/cfgnode.hpp
+++ b/src/hotspot/share/opto/cfgnode.hpp
@@ -431,6 +431,7 @@ public:
   Node* fold_compares(PhaseIterGVN* phase);
   static Node* up_one_dom(Node* curr, bool linear_only = false);
   Node* dominated_by(Node* prev_dom, PhaseIterGVN* igvn);
+  bool is_zero_trip_guard() const;
 
   // Takes the type of val and filters it through the test represented
   // by if_proj and returns a more refined type if one is produced.
diff --git a/src/hotspot/share/opto/ifnode.cpp b/src/hotspot/share/opto/ifnode.cpp
index beb11b65321..2751e891262 100644
--- a/src/hotspot/share/opto/ifnode.cpp
+++ b/src/hotspot/share/opto/ifnode.cpp
@@ -1774,6 +1774,13 @@ Node* IfProjNode::Identity(PhaseGVN* phase) {
   return this;
 }
 
+bool IfNode::is_zero_trip_guard() const {
+  if (in(1)->is_Bool() && in(1)->in(1)->is_Cmp()) {
+    return in(1)->in(1)->in(1)->Opcode() == Op_OpaqueZeroTripGuard;
+  }
+  return false;
+}
+
 #ifndef PRODUCT
 //------------------------------dump_spec--------------------------------------
 void IfNode::dump_spec(outputStream *st) const {
diff --git a/src/hotspot/share/opto/predicates.cpp b/src/hotspot/share/opto/predicates.cpp
index b8bdb221a75..c38ff4bcf02 100644
--- a/src/hotspot/share/opto/predicates.cpp
+++ b/src/hotspot/share/opto/predicates.cpp
@@ -77,13 +77,26 @@ Deoptimization::DeoptReason RuntimePredicate::uncommon_trap_reason(IfProjNode* i
 }
 
 bool RuntimePredicate::is_success_proj(Node* node, Deoptimization::DeoptReason deopt_reason) {
-  if (node->is_IfProj() && !node->in(0)->is_ParsePredicate()) {
+  if (may_be_runtime_predicate_if(node)) {
     return deopt_reason == uncommon_trap_reason(node->as_IfProj());
   } else {
     return false;
   }
 }
 
+// A Runtime Predicate must have an If or a RangeCheck node, while the If should not be a zero trip guard check.
+bool RuntimePredicate::may_be_runtime_predicate_if(Node* node) {
+  if (node->is_IfProj()) {
+    const IfNode* if_node = node->in(0)->as_If();
+    const int opcode_if = if_node->Opcode();
+    if ((opcode_if == Op_If && !if_node->is_zero_trip_guard())
+        || opcode_if == Op_RangeCheck) {
+      return true;
+    }
+  }
+  return false;
+}
+
 ParsePredicateIterator::ParsePredicateIterator(const Predicates& predicates) : _current_index(0) {
   const PredicateBlock* loop_limit_check_predicate_block = predicates.loop_limit_check_predicate_block();
   if (loop_limit_check_predicate_block->has_parse_predicate()) {
@@ -118,6 +131,7 @@ void PredicateBlock::verify_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");
+    assert(opcode != Op_If || !next->as_If()->is_zero_trip_guard(), "should not be zero trip guard");
     next = next->in(0);
   }
 }
diff --git a/src/hotspot/share/opto/predicates.hpp b/src/hotspot/share/opto/predicates.hpp
index d273ab09dc4..89d8bbad030 100644
--- a/src/hotspot/share/opto/predicates.hpp
+++ b/src/hotspot/share/opto/predicates.hpp
@@ -257,6 +257,7 @@ class ParsePredicate : public StackObj {
 // Utility class for queries on Runtime Predicates.
 class RuntimePredicate : public StackObj {
   static Deoptimization::DeoptReason uncommon_trap_reason(IfProjNode* if_proj);
+  static bool may_be_runtime_predicate_if(Node* node);
 
  public:
   static bool is_success_proj(Node* node, Deoptimization::DeoptReason deopt_reason);
diff --git a/test/hotspot/jtreg/compiler/predicates/TestWrongRuntimePredicateDetection.java b/test/hotspot/jtreg/compiler/predicates/TestWrongRuntimePredicateDetection.java
new file mode 100644
index 00000000000..55ad781aa4b
--- /dev/null
+++ b/test/hotspot/jtreg/compiler/predicates/TestWrongRuntimePredicateDetection.java
@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) 2023, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+
+/*
+ * @test
+ * @bug 8317723
+ * @library /test/lib
+ * @summary Test that CountedLoopEndNodes and zero trip guard check If nodes are not treated as Runtime Predicates.
+ * @run main/othervm -XX:-TieredCompilation -Xbatch
+ *                   -XX:CompileCommand=compileonly,compiler.predicates.TestWrongRuntimePredicateDetection::test*
+ *                   compiler.predicates.TestWrongRuntimePredicateDetection
+ */
+
+package compiler.predicates;
+
+public class TestWrongRuntimePredicateDetection {
+    static int[] iArr = new int[50];
+    static long instanceCount;
+    static boolean bFld = true;
+    static volatile byte byFld;
+    static long[][] lArrFld;
+
+
+    public static void main(String[] x) {
+        for (int i = 0; i < 1000; i++) {
+            testCountedLoopEndAsRuntimePredicate();
+        }
+        for (int i = 0; i < 10; i++) {
+            testZeroTripGuardAsRuntimePredicate();
+        }
+    }
+
+    static void testCountedLoopEndAsRuntimePredicate() {
+        int i22 = 7, i26, i28, i29 = 8, i31 = 1;
+        float f4;
+        do {
+            for (int i = 0; i < 10000; i++) {
+                if (bFld) {
+                    break;
+                }
+                instanceCount = byFld;
+            }
+            for (i26 = 4; 80 > i26; i26 += 2) ;
+        } while (++i22 < 315);
+        i28 = 6;
+        while ((i28 -= 3) > 0) {
+            for (f4 = i28; f4 < 53; f4++) {
+                bFld = false;
+            }
+            instanceCount = i26;
+            do {
+                switch ((i26 >>> 1) % 2 * 5 + 6) {
+                    case 12:
+                    case 10:
+                        lArrFld[i31][1] = i29;
+                }
+            } while (++i31 < 53);
+        }
+    }
+
+    static void testZeroTripGuardAsRuntimePredicate() {
+        int m;
+        int a[] = new int[50];
+        for (int j = 0; j < a.length; j++) {
+            a[j] = j;
+        }
+
+        for (int j = 4; j < 42; j++) {
+            for (int k = 1; k < 5; k++) {
+                iArr[1] = 34;
+                switch (j % 4) {
+                    case 0:
+                        iArr = iArr;
+                    case 1:
+                    case 3:
+                        m = 3;
+                }
+            }
+        }
+    }
+
+}