diff --git a/src/hotspot/share/opto/loopnode.cpp b/src/hotspot/share/opto/loopnode.cpp
index c0e929ca1f4f4..90b15381f823b 100644
--- a/src/hotspot/share/opto/loopnode.cpp
+++ b/src/hotspot/share/opto/loopnode.cpp
@@ -2826,6 +2826,10 @@ SafePointNode* CountedLoopNode::outer_safepoint() const {
 
 Node* CountedLoopNode::skip_assertion_predicates_with_halt() {
   Node* ctrl = in(LoopNode::EntryControl);
+  if (ctrl == nullptr) {
+    // Dying loop.
+    return nullptr;
+  }
   if (is_main_loop()) {
     ctrl = skip_strip_mined()->in(LoopNode::EntryControl);
   }
diff --git a/src/hotspot/share/opto/predicates.cpp b/src/hotspot/share/opto/predicates.cpp
index 0e4f264f827d7..8fab7701c5461 100644
--- a/src/hotspot/share/opto/predicates.cpp
+++ b/src/hotspot/share/opto/predicates.cpp
@@ -34,6 +34,7 @@
 // Walk over all Initialized Assertion Predicates and return the entry into the first Initialized Assertion Predicate
 // (i.e. not belonging to an Initialized Assertion Predicate anymore)
 Node* AssertionPredicatesWithHalt::find_entry(Node* start_proj) {
+  assert(start_proj != nullptr, "should not be null");
   Node* entry = start_proj;
   while (AssertionPredicateWithHalt::is_predicate(entry)) {
     entry = entry->in(0)->in(0);
@@ -42,7 +43,7 @@ Node* AssertionPredicatesWithHalt::find_entry(Node* start_proj) {
 }
 
 bool AssertionPredicateWithHalt::is_predicate(const Node* maybe_success_proj) {
-  if (maybe_success_proj == nullptr || !maybe_success_proj->is_IfProj() || !maybe_success_proj->in(0)->is_If()) {
+  if (!AssertionPredicate::may_be_predicate_if(maybe_success_proj)) {
     return false;
   }
   return has_assertion_predicate_opaque(maybe_success_proj) && has_halt(maybe_success_proj);
@@ -130,10 +131,15 @@ bool RuntimePredicate::is_predicate(Node* node, Deoptimization::DeoptReason deop
   return RegularPredicateWithUCT::is_predicate(node, deopt_reason);
 }
 
+// An Assertion Predicate has always a true projection on the success path.
+bool AssertionPredicate::may_be_predicate_if(const Node* node) {
+  return node->is_IfTrue() && RegularPredicate::may_be_predicate_if(node->as_IfProj());
+}
+
 // A Template Assertion Predicate has an If/RangeCheckNode and either an UCT or a halt node depending on where it
 // was created.
 bool TemplateAssertionPredicate::is_predicate(Node* node) {
-  if (!RegularPredicate::may_be_predicate_if(node)) {
+  if (!AssertionPredicate::may_be_predicate_if(node)) {
     return false;
   }
   IfNode* if_node = node->in(0)->as_If();
diff --git a/src/hotspot/share/opto/predicates.hpp b/src/hotspot/share/opto/predicates.hpp
index 0a5d6226c8c94..08d96b1c55dd6 100644
--- a/src/hotspot/share/opto/predicates.hpp
+++ b/src/hotspot/share/opto/predicates.hpp
@@ -369,6 +369,12 @@ class RuntimePredicate : public Predicate {
   static bool is_predicate(Node* node, Deoptimization::DeoptReason deopt_reason);
 };
 
+// Utility class to represent an Assertion Predicate.
+class AssertionPredicate : public StackObj {
+ public:
+  static bool may_be_predicate_if(const Node* node);
+};
+
 // Class to represent a Template Assertion Predicate.
 class TemplateAssertionPredicate : public Predicate {
   IfTrueNode* _success_proj;
@@ -687,10 +693,15 @@ class PredicateIterator : public StackObj {
     Node* current = _start_node;
     PredicateBlockIterator loop_limit_check_predicate_iterator(current, Deoptimization::Reason_loop_limit_check);
     current = loop_limit_check_predicate_iterator.for_each(predicate_visitor);
-    PredicateBlockIterator profiled_loop_predicate_iterator(current, Deoptimization::Reason_profile_predicate);
-    current = profiled_loop_predicate_iterator.for_each(predicate_visitor);
-    PredicateBlockIterator loop_predicate_iterator(current, Deoptimization::Reason_predicate);
-    return loop_predicate_iterator.for_each(predicate_visitor);
+    if (UseLoopPredicate) {
+      if (UseProfiledLoopPredicate) {
+        PredicateBlockIterator profiled_loop_predicate_iterator(current, Deoptimization::Reason_profile_predicate);
+        current = profiled_loop_predicate_iterator.for_each(predicate_visitor);
+      }
+      PredicateBlockIterator loop_predicate_iterator(current, Deoptimization::Reason_predicate);
+      current = loop_predicate_iterator.for_each(predicate_visitor);
+    }
+    return current;
   }
 };
 
diff --git a/src/hotspot/test/hotspot/jtreg/compiler/predicates/TestTemplateAssertionPredicateWithTwoUCTs.java b/src/hotspot/test/hotspot/jtreg/compiler/predicates/TestTemplateAssertionPredicateWithTwoUCTs.java
new file mode 100644
index 0000000000000..3f7ef0931620d
--- /dev/null
+++ b/src/hotspot/test/hotspot/jtreg/compiler/predicates/TestTemplateAssertionPredicateWithTwoUCTs.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2024, 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 8342287
+ * @summary Test that a fail path projection of a Template Assertion Predicate is not treated as success path projection
+ * @run main/othervm -XX:-TieredCompilation -Xbatch
+ *                   -XX:CompileCommand=compileonly,compiler.predicates.TestTemplateAssertionPredicateWithTwoUCTs::test
+ *                   compiler.predicates.TestTemplateAssertionPredicateWithTwoUCTs
+ */
+
+package compiler.predicates;
+
+public class TestTemplateAssertionPredicateWithTwoUCTs {
+    static int iFld;
+
+    public static void main(String[] strArr) {
+        for (int i = 0; i < 1000; i++) {
+            test();
+        }
+    }
+
+    static void test() {
+        int lArr[][] = new int[100][1];
+        for (int i14 = 5; i14 < 273; ++i14) {
+            int i16 = 1;
+            while (++i16 < 94) {
+                lArr[i16][0] += 1;
+                switch (i14) {
+                    case 11:
+                    case 2:
+                    case 13:
+                        iFld = 34;
+                }
+            }
+        }
+    }
+}
+