8305189: C2 failed "assert(_outcnt==1) failed: not unique"

Reviewed-by: chagedorn, thartmann

Author: rwestrel

src/hotspot/share/opto/loopnode.cpp

@@ -4128,6 +4128,45 @@ void PhaseIdealLoop::eliminate_useless_predicates() {
   }
 }
 
+// If a post or main loop is removed due to an assert predicate, the opaque that guards the loop is not needed anymore
+void PhaseIdealLoop::eliminate_useless_zero_trip_guard() {
+  if (_zero_trip_guard_opaque_nodes.size() == 0) {
+    return;
+  }
+  Unique_Node_List useful_zero_trip_guard_opaques_nodes;
+  for (LoopTreeIterator iter(_ltree_root); !iter.done(); iter.next()) {
+    IdealLoopTree* lpt = iter.current();
+    if (lpt->_child == nullptr && lpt->is_counted()) {
+      CountedLoopNode* head = lpt->_head->as_CountedLoop();
+      Node* opaque = head->is_canonical_loop_entry();
+      if (opaque != nullptr) {
+        useful_zero_trip_guard_opaques_nodes.push(opaque);
+      }
+    }
+  }
+  for (uint i = 0; i < _zero_trip_guard_opaque_nodes.size(); ++i) {
+    OpaqueZeroTripGuardNode* opaque = ((OpaqueZeroTripGuardNode*)_zero_trip_guard_opaque_nodes.at(i));
+    DEBUG_ONLY(CountedLoopNode* guarded_loop = opaque->guarded_loop());
+    if (!useful_zero_trip_guard_opaques_nodes.member(opaque)) {
+      IfNode* iff = opaque->if_node();
+      IdealLoopTree* loop = get_loop(iff);
+      while (loop != _ltree_root && loop != nullptr) {
+        loop = loop->_parent;
+      }
+      if (loop == nullptr) {
+        // unreachable from _ltree_root: zero trip guard is in a newly discovered infinite loop.
+        // We can't tell if the opaque node is useful or not
+        assert(guarded_loop == nullptr || guarded_loop->is_in_infinite_subgraph(), "");
+      } else {
+        assert(guarded_loop == nullptr, "");
+        this->_igvn.replace_node(opaque, opaque->in(1));
+      }
+    } else {
+      assert(guarded_loop != nullptr, "");
+    }
+  }
+}
+
 //------------------------process_expensive_nodes-----------------------------
 // Expensive nodes have their control input set to prevent the GVN
 // from commoning them and as a result forcing the resulting node to
@@ -4416,6 +4455,8 @@ void PhaseIdealLoop::build_and_optimize() {
     _igvn.remove_globally_dead_node(_deadlist.pop());
   }
 
+  eliminate_useless_zero_trip_guard();
+
   if (stop_early) {
     assert(do_expensive_nodes, "why are we here?");
     if (process_expensive_nodes()) {
@@ -6144,6 +6185,11 @@ void PhaseIdealLoop::build_loop_late_post_work(Node *n, bool pinned) {
   IdealLoopTree *chosen_loop = get_loop(least);
   if( !chosen_loop->_child )   // Inner loop?
     chosen_loop->_body.push(n);// Collect inner loops
+
+  if (!_verify_only && n->Opcode() == Op_OpaqueZeroTripGuard) {
+    _zero_trip_guard_opaque_nodes.push(n);
+  }
+
 }
 
 #ifdef ASSERT

src/hotspot/share/opto/loopnode.hpp

@@ -898,6 +898,7 @@ class PhaseIdealLoop : public PhaseTransform {
 private:
   // clear out dead code after build_loop_late
   Node_List _deadlist;
+  Node_List _zero_trip_guard_opaque_nodes;
 
   // Support for faster execution of get_late_ctrl()/dom_lca()
   // when a node has many uses and dominator depth is deep.
@@ -1386,6 +1387,7 @@ class PhaseIdealLoop : public PhaseTransform {
   // Helper function to collect predicate for eliminating the useless ones
   void collect_potentially_useful_predicates(IdealLoopTree *loop, Unique_Node_List &predicate_opaque1);
   void eliminate_useless_predicates();
+  void eliminate_useless_zero_trip_guard();
 
   // Change the control input of expensive nodes to allow commoning by
   // IGVN when it is guaranteed to not result in a more frequent

src/hotspot/share/opto/opaquenode.cpp

@@ -23,6 +23,7 @@
  */
 
 #include "precompiled.hpp"
+#include "opto/loopnode.hpp"
 #include "opto/opaquenode.hpp"
 #include "opto/phaseX.hpp"
 
@@ -54,6 +55,43 @@ Node* Opaque3Node::Identity(PhaseGVN* phase) {
   return this;
 }
 
+#ifdef ASSERT
+CountedLoopNode* OpaqueZeroTripGuardNode::guarded_loop() const {
+  Node* iff = if_node();
+  ResourceMark rm;
+  Unique_Node_List wq;
+  wq.push(iff);
+  for (uint i = 0; i < wq.size(); ++i) {
+    Node* nn = wq.at(i);
+    for (DUIterator_Fast imax, i = nn->fast_outs(imax); i < imax; i++) {
+      Node* u = nn->fast_out(i);
+      if (u->is_OuterStripMinedLoop()) {
+        wq.push(u);
+      }
+      if (u->is_CountedLoop() && u->as_CountedLoop()->is_canonical_loop_entry() == this) {
+        return u->as_CountedLoop();
+      }
+      if (u->is_Region()) {
+        continue;
+      }
+      if (u->is_CFG()) {
+        wq.push(u);
+      }
+    }
+  }
+  return nullptr;
+}
+#endif
+
+IfNode* OpaqueZeroTripGuardNode::if_node() const {
+  Node* cmp = unique_out();
+  assert(cmp->Opcode() == Op_CmpI, "");
+  Node* bol = cmp->unique_out();
+  assert(bol->Opcode() == Op_Bool, "");
+  Node* iff = bol->unique_out();
+  return iff->as_If();
+}
+
 // Do not allow value-numbering
 uint Opaque3Node::hash() const { return NO_HASH; }
 bool Opaque3Node::cmp(const Node &n) const {

src/hotspot/share/opto/opaquenode.hpp

@@ -79,10 +79,14 @@ class OpaqueZeroTripGuardNode : public Opaque1Node {
   OpaqueZeroTripGuardNode(Compile* C, Node* n, BoolTest::mask loop_entered_test) :
           Opaque1Node(C, n), _loop_entered_mask(loop_entered_test) {
   }
+
+  DEBUG_ONLY(CountedLoopNode* guarded_loop() const);
   virtual int Opcode() const;
   virtual uint size_of() const {
     return sizeof(*this);
   }
+
+  IfNode* if_node() const;
 };
 
 //------------------------------Opaque3Node------------------------------------

test/hotspot/jtreg/compiler/loopopts/TestZeroTripGuardShared.java

@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2023, Red Hat, Inc. 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 8305189
+ * @summary C2 failed "assert(_outcnt==1) failed: not unique"
+ * @library /test/lib
+ * @run main/othervm -Xcomp -XX:CompileOnly=TestZeroTripGuardShared TestZeroTripGuardShared
+ */
+
+import jdk.test.lib.Utils;
+
+public class TestZeroTripGuardShared {
+    static double dFld1;
+    static int iArrFld[];
+
+    public static void main(String[] strArr) throws Exception {
+        Thread thread = new Thread() {
+                public void run() {
+                    test();
+                }
+            };
+        // Give thread some time to trigger compilation
+        thread.setDaemon(true);
+        thread.start();
+        Thread.sleep(Utils.adjustTimeout(500));
+    }
+
+    static void test() {
+        int i5 = 2, i8 = 2, i9, i11, i12;
+        while (i8 < 5) {
+            for (i9 = i8; 6 > i9; i9++) {
+                for (i11 = 1; i11 > i9; i11 -= 2) {
+                    try {
+                        i12 = iArrFld[i11];
+                    } catch (ArithmeticException a_e) {
+                    }
+                    i5 += dFld1;
+                }
+            }
+        }
+    }
+}