8256740: ZGC: Move closures out of zOopClosure files

Reviewed-by: pliden

Author: stefank

src/hotspot/share/gc/z/zBarrier.cpp

@@ -25,7 +25,6 @@
 #include "gc/z/zBarrier.inline.hpp"
 #include "gc/z/zHeap.inline.hpp"
 #include "gc/z/zOop.inline.hpp"
-#include "gc/z/zOopClosures.inline.hpp"
 #include "memory/iterator.inline.hpp"
 #include "oops/oop.inline.hpp"
 #include "runtime/safepoint.hpp"
@@ -239,3 +238,11 @@ oop ZBarrier::weak_load_barrier_on_phantom_oop_field_preloaded(volatile narrowOo
   ShouldNotReachHere();
   return NULL;
 }
+
+void ZLoadBarrierOopClosure::do_oop(oop* p) {
+  ZBarrier::load_barrier_on_oop_field(p);
+}
+
+void ZLoadBarrierOopClosure::do_oop(narrowOop* p) {
+  ShouldNotReachHere();
+}

src/hotspot/share/gc/z/zBarrier.hpp

@@ -25,6 +25,7 @@
 #define SHARE_GC_Z_ZBARRIER_HPP
 
 #include "memory/allocation.hpp"
+#include "memory/iterator.hpp"
 #include "oops/oop.hpp"
 
 typedef bool (*ZBarrierFastPath)(uintptr_t);
@@ -122,4 +123,10 @@ class ZBarrier : public AllStatic {
   static oop  weak_load_barrier_on_phantom_oop_field_preloaded(volatile narrowOop* p, oop o);
 };
 
+class ZLoadBarrierOopClosure : public BasicOopIterateClosure {
+public:
+  virtual void do_oop(oop* p);
+  virtual void do_oop(narrowOop* p);
+};
+
 #endif // SHARE_GC_Z_ZBARRIER_HPP

src/hotspot/share/gc/z/zBarrierSetNMethod.cpp

@@ -26,7 +26,6 @@
 #include "gc/z/zBarrierSetNMethod.hpp"
 #include "gc/z/zGlobals.hpp"
 #include "gc/z/zLock.inline.hpp"
-#include "gc/z/zOopClosures.hpp"
 #include "gc/z/zNMethod.hpp"
 #include "gc/z/zThreadLocalData.hpp"
 #include "logging/log.hpp"
@@ -53,9 +52,10 @@ bool ZBarrierSetNMethod::nmethod_entry_barrier(nmethod* nm) {
     return false;
   }
 
-  // Heal oops and disarm
-  ZNMethodOopClosure cl;
-  ZNMethod::nmethod_oops_do_inner(nm, &cl);
+  // Heal oops
+  ZNMethod::nmethod_oops_barrier(nm);
+
+  // Disarm
   disarm(nm);
 
   return true;

src/hotspot/share/gc/z/zMark.cpp

@@ -22,17 +22,19 @@
  */
 
 #include "precompiled.hpp"
+#include "classfile/classLoaderData.hpp"
 #include "classfile/classLoaderDataGraph.hpp"
 #include "code/nmethod.hpp"
 #include "gc/shared/suspendibleThreadSet.hpp"
 #include "gc/z/zBarrier.inline.hpp"
+#include "gc/z/zHeap.inline.hpp"
 #include "gc/z/zLock.inline.hpp"
 #include "gc/z/zMark.inline.hpp"
 #include "gc/z/zMarkCache.inline.hpp"
 #include "gc/z/zMarkStack.inline.hpp"
 #include "gc/z/zMarkTerminate.inline.hpp"
 #include "gc/z/zNMethod.hpp"
-#include "gc/z/zOopClosures.inline.hpp"
+#include "gc/z/zOop.inline.hpp"
 #include "gc/z/zPage.hpp"
 #include "gc/z/zPageTable.inline.hpp"
 #include "gc/z/zRootsIterator.hpp"
@@ -236,6 +238,26 @@ void ZMark::follow_partial_array(ZMarkStackEntry entry, bool finalizable) {
   follow_array(addr, size, finalizable);
 }
 
+template <bool finalizable>
+class ZMarkBarrierOopClosure : public ClaimMetadataVisitingOopIterateClosure {
+public:
+  ZMarkBarrierOopClosure() :
+      ClaimMetadataVisitingOopIterateClosure(finalizable
+                                                 ? ClassLoaderData::_claim_finalizable
+                                                 : ClassLoaderData::_claim_strong,
+                                             finalizable
+                                                 ? NULL
+                                                 : ZHeap::heap()->reference_discoverer()) {}
+
+  virtual void do_oop(oop* p) {
+    ZBarrier::mark_barrier_on_oop_field(p, finalizable);
+  }
+
+  virtual void do_oop(narrowOop* p) {
+    ShouldNotReachHere();
+  }
+};
+
 void ZMark::follow_array_object(objArrayOop obj, bool finalizable) {
   if (finalizable) {
     ZMarkBarrierOopClosure<true /* finalizable */> cl;

src/hotspot/share/gc/z/zNMethod.cpp

@@ -28,19 +28,20 @@
 #include "gc/shared/barrierSet.hpp"
 #include "gc/shared/barrierSetNMethod.hpp"
 #include "gc/shared/suspendibleThreadSet.hpp"
+#include "gc/z/zBarrier.inline.hpp"
 #include "gc/z/zGlobals.hpp"
 #include "gc/z/zLock.inline.hpp"
 #include "gc/z/zNMethod.hpp"
 #include "gc/z/zNMethodData.hpp"
 #include "gc/z/zNMethodTable.hpp"
-#include "gc/z/zOopClosures.inline.hpp"
 #include "gc/z/zTask.hpp"
 #include "gc/z/zWorkers.hpp"
 #include "logging/log.hpp"
 #include "memory/allocation.inline.hpp"
 #include "memory/iterator.hpp"
 #include "memory/resourceArea.hpp"
 #include "memory/universe.hpp"
+#include "oops/oop.inline.hpp"
 #include "runtime/atomic.hpp"
 #include "utilities/debug.hpp"
 
@@ -243,6 +244,26 @@ void ZNMethod::nmethod_oops_do_inner(nmethod* nm, OopClosure* cl) {
   }
 }
 
+class ZNMethodOopClosure : public OopClosure {
+public:
+  virtual void do_oop(oop* p) {
+    if (ZResurrection::is_blocked()) {
+      ZBarrier::keep_alive_barrier_on_phantom_root_oop_field(p);
+    } else {
+      ZBarrier::load_barrier_on_root_oop_field(p);
+    }
+  }
+
+  virtual void do_oop(narrowOop* p) {
+    ShouldNotReachHere();
+  }
+};
+
+void ZNMethod::nmethod_oops_barrier(nmethod* nm) {
+  ZNMethodOopClosure cl;
+  nmethod_oops_do_inner(nm, &cl);
+}
+
 void ZNMethod::nmethods_do_begin() {
   ZNMethodTable::nmethods_do_begin();
 }
@@ -307,8 +328,7 @@ class ZNMethodUnlinkClosure : public NMethodClosure {
 
     if (ZNMethod::is_armed(nm)) {
       // Heal oops and disarm
-      ZNMethodOopClosure cl;
-      ZNMethod::nmethod_oops_do(nm, &cl);
+      ZNMethod::nmethod_oops_barrier(nm);
       ZNMethod::disarm(nm);
     }
 

src/hotspot/share/gc/z/zNMethod.hpp

@@ -51,6 +51,8 @@ class ZNMethod : public AllStatic {
   static void nmethod_oops_do(nmethod* nm, OopClosure* cl);
   static void nmethod_oops_do_inner(nmethod* nm, OopClosure* cl);
 
+  static void nmethod_oops_barrier(nmethod* nm);
+
   static void nmethods_do_begin();
   static void nmethods_do_end();
   static void nmethods_do(NMethodClosure* cl);

src/hotspot/share/gc/z/zNMethodTable.cpp

@@ -34,7 +34,6 @@
 #include "gc/z/zNMethodTable.hpp"
 #include "gc/z/zNMethodTableEntry.hpp"
 #include "gc/z/zNMethodTableIteration.hpp"
-#include "gc/z/zOopClosures.inline.hpp"
 #include "gc/z/zSafeDelete.inline.hpp"
 #include "gc/z/zTask.hpp"
 #include "gc/z/zWorkers.hpp"

src/hotspot/share/gc/z/zOopClosures.hpp

@@ -26,7 +26,6 @@
 #include "gc/shared/referencePolicy.hpp"
 #include "gc/shared/referenceProcessorStats.hpp"
 #include "gc/z/zHeap.inline.hpp"
-#include "gc/z/zOopClosures.inline.hpp"
 #include "gc/z/zReferenceProcessor.hpp"
 #include "gc/z/zStat.hpp"
 #include "gc/z/zTask.hpp"