8261730: C2 compilation fails with assert(store->find_edge(load) != -1) failed: missing precedence edge

Relax assertion in PhaseCFG::verify() to accept the case where a store is used
to implement an implicit null check and a load is placed in the null block.

Reviewed-by: thartmann, kvn

src/hotspot/share/opto/classes.hpp

@@ -200,6 +200,7 @@ macro(Lock)
 macro(Loop)
 macro(LoopLimit)
 macro(Mach)
+macro(MachNullCheck)
 macro(MachProj)
 macro(MulAddS2I)
 macro(MaxI)

src/hotspot/share/opto/gcm.cpp

@@ -770,7 +770,24 @@ Block* PhaseCFG::insert_anti_dependences(Block* LCA, Node* load, bool verify) {
       // Add an anti-dep edge, and squeeze 'load' into the highest block.
       assert(store != load->find_exact_control(load->in(0)), "dependence cycle found");
       if (verify) {
-        assert(store->find_edge(load) != -1, "missing precedence edge");
+#ifdef ASSERT
+        // We expect an anti-dependence edge from 'load' to 'store', except when
+        // implicit_null_check() has hoisted 'store' above its early block to
+        // perform an implicit null check, and 'load' is placed in the null
+        // block. In this case it is safe to ignore the anti-dependence, as the
+        // null block is only reached if 'store' tries to write to null.
+        Block* store_null_block = NULL;
+        Node* store_null_check = store->find_out_with(Op_MachNullCheck);
+        if (store_null_check != NULL) {
+          Node* if_true = store_null_check->find_out_with(Op_IfTrue);
+          assert(if_true != NULL, "null check without null projection");
+          Node* null_block_region = if_true->find_out_with(Op_Region);
+          assert(null_block_region != NULL, "null check without null region");
+          store_null_block = get_block_for_node(null_block_region);
+        }
+#endif
+        assert(LCA == store_null_block || store->find_edge(load) != -1,
+               "missing precedence edge");
       } else {
         store->add_prec(load);
       }

src/hotspot/share/opto/machnode.hpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2021, 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
@@ -699,6 +699,7 @@ public:
     add_req(ctrl);
     add_req(memop);
   }
+  virtual int Opcode() const;
   virtual uint size_of() const { return sizeof(*this); }
 
   virtual void emit(CodeBuffer &cbuf, PhaseRegAlloc *ra_) const;

test/hotspot/jtreg/compiler/uncommontrap/TestNullCheckAntiDependence.java

@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2021, 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.
+ */
+
+package compiler.uncommontrap;
+
+/**
+ * @test
+ * @bug 8261730
+ * @summary Test that no anti-dependence violation is reported between a store
+ *          used as an implicit null check and a load placed in the null block.
+ * @run main/othervm -XX:-BackgroundCompilation
+ *      compiler.uncommontrap.TestNullCheckAntiDependence
+ */
+
+public class TestNullCheckAntiDependence {
+
+    private static class MyInteger {
+        int val;
+    }
+
+    private static MyInteger foo = new MyInteger();
+    private static MyInteger bar = new MyInteger();
+
+    static void setFooToZero() {
+        for (int i = 0; i < 1; i++) {
+            // This load is placed in the null block.
+            foo.val = -bar.val;
+            for (int k = 0; k < 10; k++) {
+                // This store is hoisted and used as an implicit null check.
+                foo.val = 0;
+            }
+        }
+    }
+
+    public static void main(String[] args) {
+        for (int i = 0; i < 10_000; i++) {
+            setFooToZero();
+        }
+    }
+
+}