Loom compile times minimal

Reviewed-by: eosterlund

Author: stefank

src/hotspot/share/classfile/javaClasses.inline.hpp

@@ -29,6 +29,7 @@
 
 #include "oops/access.inline.hpp"
 #include "oops/instanceKlass.inline.hpp"
+#include "logging/log.hpp"
 #include "oops/method.hpp"
 #include "oops/oop.inline.hpp"
 #include "oops/oopsHierarchy.hpp"

src/hotspot/share/gc/g1/g1BarrierSet.hpp

@@ -55,9 +55,6 @@ class G1BarrierSet: public CardTableBarrierSet {
     return true;
   }
 
-  // Loom support
-  static bool requires_barriers(stackChunkOop obj);
-
   // Add "pre_val" to a set of objects that may have been disconnected from the
   // pre-marking object graph.
   static void enqueue(oop pre_val);

src/hotspot/share/gc/g1/g1BarrierSet.inline.hpp

@@ -28,7 +28,6 @@
 #include "gc/g1/g1BarrierSet.hpp"
 
 #include "gc/g1/g1CardTable.hpp"
-#include "gc/g1/g1CollectedHeap.inline.hpp"
 #include "gc/shared/accessBarrierSupport.inline.hpp"
 #include "oops/access.inline.hpp"
 #include "oops/compressedOops.inline.hpp"
@@ -107,8 +106,4 @@ oop_store_not_in_heap(T* addr, oop new_value) {
   Raw::oop_store(addr, new_value);
 }
 
-inline bool G1BarrierSet::requires_barriers(stackChunkOop obj) {
-  return G1CollectedHeap::heap()->G1CollectedHeap::requires_barriers(obj);
-}
-
 #endif // SHARE_GC_G1_G1BARRIERSET_INLINE_HPP

src/hotspot/share/gc/shared/barrierSet.hpp

@@ -91,9 +91,6 @@ class BarrierSet: public CHeapObj<mtGC> {
   // Test whether this object is of the type corresponding to bsn.
   bool is_a(BarrierSet::Name bsn) const { return _fake_rtti.has_tag(bsn); }
 
-  // Loom support
-  static bool requires_barriers(stackChunkOop obj);
-
   // End of fake RTTI support.
 
 protected:

src/hotspot/share/gc/shared/barrierSet.inline.hpp

@@ -26,7 +26,6 @@
 
 #include "gc/shared/barrierSet.hpp"
 
-#include "gc/shared/collectedHeap.hpp"
 #include "oops/accessDecorators.hpp"
 #include "oops/arrayOop.hpp"
 #include "oops/compressedOops.inline.hpp"
@@ -59,8 +58,4 @@ inline bool BarrierSet::AccessBarrier<decorators, BarrierSetT>::oop_arraycopy_in
   return true;
 }
 
-inline bool BarrierSet::requires_barriers(stackChunkOop obj) {
-  return Universe::heap()->requires_barriers(obj);
-}
-
 #endif // SHARE_GC_SHARED_BARRIERSET_INLINE_HPP

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

@@ -37,7 +37,6 @@ class ZBarrierSet : public BarrierSet {
 
   // Loom support
   static constexpr bool is_concurrent_gc() { return true; }
-  static bool requires_barriers(stackChunkOop obj);
 
   virtual void on_thread_create(Thread* thread);
   virtual void on_thread_destroy(Thread* thread);

src/hotspot/share/gc/z/zBarrierSet.inline.hpp

@@ -28,7 +28,6 @@
 
 #include "gc/shared/accessBarrierSupport.inline.hpp"
 #include "gc/z/zBarrier.inline.hpp"
-#include "gc/z/zCollectedHeap.inline.hpp"
 #include "utilities/debug.hpp"
 
 template <DecoratorSet decorators, typename BarrierSetT>
@@ -240,8 +239,4 @@ inline oop ZBarrierSet::AccessBarrier<decorators, BarrierSetT>::oop_atomic_xchg_
   return Raw::oop_atomic_xchg_not_in_heap(addr, new_value);
 }
 
-inline bool ZBarrierSet::requires_barriers(stackChunkOop obj) {
-  return ZCollectedHeap::heap()->ZCollectedHeap::requires_barriers(obj);
-}
-
 #endif // SHARE_GC_Z_ZBARRIERSET_INLINE_HPP

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

@@ -122,6 +122,27 @@ bool ZCollectedHeap::is_in(const void* p) const {
   return _heap.is_in((uintptr_t)p);
 }
 
+bool ZCollectedHeap::requires_barriers(stackChunkOop obj) const {
+  uintptr_t* cont_addr = obj->field_addr<uintptr_t>(jdk_internal_vm_StackChunk::cont_offset());
+
+  if (!_heap.is_allocating(cast_from_oop<uintptr_t>(obj))) {
+    // An object that isn't allocating, is visible from GC tracing. Such
+    // stack chunks require barriers.
+    return true;
+  }
+
+  if (!ZAddress::is_good_or_null(*cont_addr)) {
+    // If a chunk is allocated after a GC started, but before relocate start
+    // we can have an allocating chunk that isn't deeply good. That means that
+    // the contained oops might be bad and require GC barriers.
+    return true;
+  }
+
+  // The chunk is allocating and its pointers are good. This chunk needs no
+  // GC barriers
+  return false;
+}
+
 uint32_t ZCollectedHeap::hash_oop(oop obj) const {
   return _heap.hash_oop(ZOop::to_address(obj));
 }

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

@@ -72,7 +72,7 @@ class ZCollectedHeap : public CollectedHeap {
 
   virtual bool is_maximal_no_gc() const;
   virtual bool is_in(const void* p) const;
-  virtual inline bool requires_barriers(stackChunkOop obj) const;
+  virtual bool requires_barriers(stackChunkOop obj) const;
 
   // Continuation support
   virtual void collect_for_codecache();

src/hotspot/share/gc/z/zCollectedHeap.inline.hpp

@@ -33,6 +33,8 @@
 #include "memory/oopFactory.hpp"
 #include "memory/resourceArea.hpp"
 #include "jfr/jfrEvents.hpp"
+#include "logging/log.hpp"
+#include "logging/logStream.hpp"
 #include "oops/compressedOops.hpp"
 #include "oops/instanceKlass.hpp"
 #include "oops/instanceOop.hpp"

src/hotspot/share/oops/instanceStackChunkKlass.cpp

@@ -241,7 +241,7 @@ class Config {
   }
 
   static bool requires_barriers(stackChunkOop obj) {
-    return BarrierSetT::requires_barriers(obj);
+    return obj->requires_barriers();
   }
 };
 

src/hotspot/share/runtime/continuation.cpp

@@ -23,6 +23,7 @@
  */
 
 #include "precompiled.hpp"
+#include "classfile/javaClasses.inline.hpp"
 #include "logging/logStream.hpp"
 #include "memory/allocation.inline.hpp"
 #include "runtime/atomic.hpp"