Remove stack chunk shrinking logic

Author: fisk

src/hotspot/share/gc/g1/g1FullGCCompactTask.cpp

@@ -86,8 +86,8 @@ size_t G1FullGCCompactTask::G1CompactRegionClosure::apply(oop obj) {
   // copy object and reinit its mark
   HeapWord* obj_addr = cast_from_oop<HeapWord*>(obj);
   assert(size <= INT_MAX, "sanity check");
-  assert(obj_addr != destination || size > (size_t)obj->compact_size((int)(uint)size), "everything in this pass should be moving or compressed in place");
-  obj->copy_conjoint_compact(destination); // TODO LOOM: see G1FullGCCompactionPoint::forward; Might want to reconsider compacting here.
+  assert(obj_addr != destination || size > (size_t)obj->size(), "everything in this pass should be moving or compressed in place");
+  obj->copy_conjoint(destination, size);
   cast_to_oop(destination)->init_mark();
   assert(cast_to_oop(destination)->klass() != NULL, "should have a class");
 

src/hotspot/share/gc/g1/g1FullGCCompactionPoint.cpp

@@ -92,18 +92,15 @@ void G1FullGCCompactionPoint::switch_region() {
 void G1FullGCCompactionPoint::forward(oop object, size_t size) {
   assert(_current_region != NULL, "Must have been initialized");
 
-  size_t csize = object->compact_size((int)size); // TODO LOOM TRICKY; CONSIDER
-
   // Ensure the object fit in the current region.
-  while (!object_will_fit(csize)) {
+  while (!object_will_fit(size)) {
     switch_region();
   }
 
   // Store a forwarding pointer if the object should be moved or compacted in place.
-  if (cast_from_oop<HeapWord*>(object) != _compaction_top || csize < size) {
+  if (cast_from_oop<HeapWord*>(object) != _compaction_top) {
     object->forward_to(cast_to_oop(_compaction_top));
     assert(object->is_forwarded(), "must be forwarded");
-    size = csize;
   } else {
     assert(!object->is_forwarded(), "must not be forwarded");
   }

src/hotspot/share/gc/g1/g1ParScanThreadState.cpp

@@ -452,7 +452,7 @@ oop G1ParScanThreadState::do_copy_to_survivor_space(G1HeapRegionAttr const regio
   // Get the klass once.  We'll need it again later, and this avoids
   // re-decoding when it's compressed.
   Klass* klass = old->klass();
-  const size_t word_sz = old->compact_size_given_klass(klass);
+  const size_t word_sz = old->size_given_klass(klass);
 
   uint age = 0;
   G1HeapRegionAttr dest_attr = next_region_attr(region_attr, old_mark, age);
@@ -485,7 +485,7 @@ oop G1ParScanThreadState::do_copy_to_survivor_space(G1HeapRegionAttr const regio
 
   // We're going to allocate linearly, so might as well prefetch ahead.
   Prefetch::write(obj_ptr, PrefetchCopyIntervalInBytes);
-  old->copy_disjoint_compact(obj_ptr, word_sz);
+  old->copy_disjoint(obj_ptr, word_sz);
 
   const oop obj = cast_to_oop(obj_ptr);
   // Because the forwarding is done with memory_order_relaxed there is no

src/hotspot/share/gc/parallel/psPromotionManager.inline.hpp

@@ -161,7 +161,7 @@ inline oop PSPromotionManager::copy_unmarked_to_survivor_space(oop o,
 
   oop new_obj = NULL;
   bool new_obj_is_tenured = false;
-  size_t new_obj_size = o->compact_size();
+  size_t new_obj_size = o->size();
 
   // Find the objects age, MT safe.
   uint age = (test_mark.has_displaced_mark_helper() /* o->has_displaced_mark() */) ?
@@ -243,7 +243,7 @@ inline oop PSPromotionManager::copy_unmarked_to_survivor_space(oop o,
   assert(new_obj != NULL, "allocation should have succeeded");
 
   // Copy obj
-  o->copy_disjoint_compact(cast_from_oop<HeapWord*>(new_obj), new_obj_size);
+  o->copy_disjoint(cast_from_oop<HeapWord*>(new_obj), new_obj_size);
 
   // Now we have to CAS in the header.
   // Make copy visible to threads reading the forwardee.

src/hotspot/share/gc/serial/defNewGeneration.cpp

@@ -712,7 +712,7 @@ void DefNewGeneration::handle_promotion_failure(oop old) {
 oop DefNewGeneration::copy_to_survivor_space(oop old) {
   assert(is_in_reserved(old) && !old->is_forwarded(),
          "shouldn't be scavenging this oop");
-  size_t s = old->compact_size();
+  size_t s = old->size();
   oop obj = NULL;
 
   // Try allocating obj in to-space (unless too old)
@@ -735,7 +735,7 @@ oop DefNewGeneration::copy_to_survivor_space(oop old) {
     Prefetch::write(obj, interval);
 
     // Copy obj
-    old->copy_disjoint_compact(cast_from_oop<HeapWord*>(obj), s);
+    old->copy_disjoint(cast_from_oop<HeapWord*>(obj), s);
 
     // Increment age if obj still in new generation
     obj->incr_age();

src/hotspot/share/gc/shared/genCollectedHeap.cpp

@@ -1233,13 +1233,13 @@ oop GenCollectedHeap::handle_failed_promotion(Generation* old_gen,
                                               oop obj,
                                               size_t obj_size) {
   guarantee(old_gen == _old_gen, "We only get here with an old generation");
-  assert(obj_size == obj->compact_size(), "bad obj_size passed in");
+  assert(obj_size == obj->size(), "bad obj_size passed in");
   HeapWord* result = NULL;
 
   result = old_gen->expand_and_allocate(obj_size, false);
 
   if (result != NULL) {
-    obj->copy_disjoint_compact(result, obj_size);
+    obj->copy_disjoint(result, obj_size);
   }
   return cast_to_oop(result);
 }

src/hotspot/share/gc/shared/generation.cpp

@@ -156,7 +156,7 @@ bool Generation::promotion_attempt_is_safe(size_t max_promotion_in_bytes) const
 
 // Ignores "ref" and calls allocate().
 oop Generation::promote(oop obj, size_t obj_size) {
-  assert(obj_size == obj->compact_size(), "bad obj_size passed in");
+  assert(obj_size == obj->size(), "bad obj_size passed in");
 
 #ifndef PRODUCT
   if (GenCollectedHeap::heap()->promotion_should_fail()) {
@@ -166,7 +166,7 @@ oop Generation::promote(oop obj, size_t obj_size) {
 
   HeapWord* result = allocate(obj_size, false);
   if (result != NULL) {
-    obj->copy_disjoint_compact(result, obj_size);
+    obj->copy_disjoint(result, obj_size);
     return cast_to_oop(result);
   } else {
     GenCollectedHeap* gch = GenCollectedHeap::heap();

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

@@ -338,7 +338,7 @@ void ZMark::mark_and_follow(ZMarkContext* context, ZMarkStackEntry entry) {
     // Update live objects/bytes for page. We use the aligned object
     // size since that is the actual number of bytes used on the page
     // and alignment paddings can never be reclaimed.
-    const size_t size = ZUtils::object_compact_size(addr);
+    const size_t size = ZUtils::object_size(addr);
     const size_t aligned_size = align_up(size, page->object_alignment());
     context->cache()->inc_live(page, aligned_size);
   }

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

@@ -64,15 +64,15 @@ static uintptr_t relocate_object_inner(ZForwarding* forwarding, uintptr_t from_a
   assert(ZHeap::heap()->is_object_live(from_addr), "Should be live");
 
   // Allocate object
-  const size_t size = ZUtils::object_compact_size(from_addr);
+  const size_t size = ZUtils::object_size(from_addr);
   const uintptr_t to_addr = ZHeap::heap()->alloc_object_for_relocation(size);
   if (to_addr == 0) {
     // Allocation failed
     return 0;
   }
 
   // Copy object
-  ZUtils::object_copy_disjoint_compact(from_addr, to_addr, size);
+  ZUtils::object_copy_disjoint(from_addr, to_addr, size);
 
   // Insert forwarding
   const uintptr_t to_addr_final = forwarding_insert(forwarding, from_addr, to_addr, cursor);
@@ -288,7 +288,7 @@ class ZRelocateClosure : public ObjectClosure {
     }
 
     // Allocate object
-    const size_t size = ZUtils::object_compact_size(from_addr);
+    const size_t size = ZUtils::object_size(from_addr);
     const uintptr_t to_addr = _allocator->alloc_object(_target, size);
     if (to_addr == 0) {
       // Allocation failed
@@ -298,9 +298,9 @@ class ZRelocateClosure : public ObjectClosure {
     // Copy object. Use conjoint copying if we are relocating
     // in-place and the new object overlapps with the old object.
     if (_forwarding->in_place() && to_addr + size > from_addr) {
-      ZUtils::object_copy_conjoint_compact(from_addr, to_addr, size);
+      ZUtils::object_copy_conjoint(from_addr, to_addr, size);
     } else {
-      ZUtils::object_copy_disjoint_compact(from_addr, to_addr, size);
+      ZUtils::object_copy_disjoint(from_addr, to_addr, size);
     }
 
     // Insert forwarding

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

@@ -40,10 +40,6 @@ class ZUtils : public AllStatic {
   static size_t object_size(uintptr_t addr);
   static void object_copy_disjoint(uintptr_t from, uintptr_t to, size_t size);
   static void object_copy_conjoint(uintptr_t from, uintptr_t to, size_t size);
-
-  static size_t object_compact_size(uintptr_t addr);
-  static void object_copy_disjoint_compact(uintptr_t from, uintptr_t to, size_t size);
-  static void object_copy_conjoint_compact(uintptr_t from, uintptr_t to, size_t size);
 };
 
 #endif // SHARE_GC_Z_ZUTILS_HPP

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

@@ -46,10 +46,6 @@ inline size_t ZUtils::object_size(uintptr_t addr) {
   return words_to_bytes(ZOop::from_address(addr)->size());
 }
 
-inline size_t ZUtils::object_compact_size(uintptr_t addr) {
-  return words_to_bytes(ZOop::from_address(addr)->compact_size());
-}
-
 inline void ZUtils::object_copy_disjoint(uintptr_t from, uintptr_t to, size_t size) {
   ZOop::from_address(from)->copy_disjoint((HeapWord*)to, bytes_to_words(size));
 }
@@ -60,14 +56,4 @@ inline void ZUtils::object_copy_conjoint(uintptr_t from, uintptr_t to, size_t si
   }
 }
 
-inline void ZUtils::object_copy_disjoint_compact(uintptr_t from, uintptr_t to, size_t size) {
-  ZOop::from_address(from)->copy_disjoint_compact((HeapWord*)to, bytes_to_words(size));
-}
-
-inline void ZUtils::object_copy_conjoint_compact(uintptr_t from, uintptr_t to, size_t size) {
-  if (from != to) {
-    ZOop::from_address(from)->copy_conjoint_compact((HeapWord*)to, bytes_to_words(size));
-  }
-}
-
 #endif // SHARE_GC_Z_ZUTILS_INLINE_HPP

src/hotspot/share/oops/instanceStackChunkKlass.cpp

@@ -95,105 +95,6 @@ size_t InstanceStackChunkKlass::copy(oop obj, HeapWord* to_addr, size_t word_siz
 template size_t InstanceStackChunkKlass::copy<InstanceStackChunkKlass::copy_type::CONJOINT>(oop obj, HeapWord* to_addr, size_t word_size);
 template size_t InstanceStackChunkKlass::copy<InstanceStackChunkKlass::copy_type::DISJOINT>(oop obj, HeapWord* to_addr, size_t word_size);
 
-size_t InstanceStackChunkKlass::compact_oop_size(oop obj) const {
-  assert (obj->is_stackChunk(), "");
-  stackChunkOop chunk = (stackChunkOop)obj;
-  int used_stack_in_words = chunk->stack_size() - chunk->sp() + metadata_words();
-  assert (used_stack_in_words <= chunk->stack_size(), "");
-  return align_object_size(size_helper() + used_stack_in_words + bitmap_size(used_stack_in_words));
-}
-
-template size_t InstanceStackChunkKlass::copy_compact<InstanceStackChunkKlass::copy_type::CONJOINT>(oop obj, HeapWord* to_addr);
-template size_t InstanceStackChunkKlass::copy_compact<InstanceStackChunkKlass::copy_type::DISJOINT>(oop obj, HeapWord* to_addr);
-
-template <InstanceStackChunkKlass::copy_type overlap>
-size_t InstanceStackChunkKlass::copy_compact(oop obj, HeapWord* to_addr) {
-  assert (obj->is_stackChunk(), "");
-  stackChunkOop chunk = (stackChunkOop)obj;
-
-  assert (chunk->verify(), "");
-
-#ifdef ASSERT
-  size_t old_compact_size = obj->compact_size();
-  size_t old_size = obj->size();
-  assert (old_compact_size <= old_size, "");
-#endif
-
-  const int from_sp = chunk->sp();
-  assert (from_sp >= metadata_words(), "");
-
-  if (from_sp <= metadata_words()) {
-    assert (oop_size(obj) == compact_oop_size(obj), "");
-    return copy<overlap>(obj, to_addr, oop_size(obj));
-  }
-
-  const int header = size_helper();
-  const int from_stack_size = chunk->stack_size();
-  const int to_stack_size = from_stack_size - from_sp + metadata_words();
-  const size_t from_bitmap_size = bitmap_size(from_stack_size);
-  const size_t to_bitmap_size = bitmap_size(to_stack_size);
-  const bool has_bitmap = chunk->has_bitmap();
-  assert (to_stack_size >= 0, "");
-  assert (to_stack_size <= from_stack_size, "");
-  assert (to_stack_size > 0 || chunk->argsize() == 0, "");
-#ifdef ASSERT
-  HeapWord* const start_of_stack0 = start_of_stack(obj);
-  HeapWord* const start_of_bitmap0 = start_of_bitmap(obj);
-#endif
-
-  stackChunkOop to_chunk = (stackChunkOop) cast_to_oop(to_addr);
-  HeapWord* from_addr = cast_from_oop<HeapWord*>(obj);
-
-  // copy header and stack in the appropriate order if conjoint; must not touch old chunk after we start b/c this can be a conjoint copy
-  const int first  = (overlap == copy_type::DISJOINT || to_addr <= from_addr) ? 0 : 2;
-  const int stride = 1 - first;
-  for (int i = first; 0 <= i && i <= 2; i += stride) {
-    switch(i) { // copy header and update it
-    case 0:
-      if (to_addr != from_addr) {
-        overlap == copy_type::DISJOINT ? Copy::aligned_disjoint_words(from_addr, to_addr, header)
-                                       : Copy::aligned_conjoint_words(from_addr, to_addr, header);
-      }
-
-      jdk_internal_vm_StackChunk::set_size(to_addr, to_stack_size);
-      to_chunk->set_sp(metadata_words());
-      break;
-    case 1: // copy stack
-      if (to_stack_size > 0) {
-        assert ((from_addr + header) == start_of_stack0, "");
-        HeapWord* from_start = from_addr + header + from_sp - metadata_words();
-        HeapWord* to_start = to_addr + header;
-        overlap == copy_type::DISJOINT ? Copy::aligned_disjoint_words(from_start, to_start, to_stack_size)
-                                       : Copy::aligned_conjoint_words(from_start, to_start, to_stack_size);
-      }
-      break;
-    case 2: // copy bitmap
-      if (to_stack_size > 0 && has_bitmap) {
-        assert ((from_addr + header + from_stack_size) == start_of_bitmap0, "");
-        assert (from_bitmap_size >= to_bitmap_size, "");
-        HeapWord* from_start = from_addr + header + from_stack_size + (from_bitmap_size - to_bitmap_size);
-        HeapWord* to_start = to_addr + header + to_stack_size;
-        overlap == copy_type::DISJOINT ? Copy::aligned_disjoint_words(from_start, to_start, to_bitmap_size)
-                                       : Copy::aligned_conjoint_words(from_start, to_start, to_bitmap_size);
-      }
-      break;
-    }
-  }
-
-  assert (!to_chunk->has_bitmap()|| to_chunk->is_gc_mode(), "");
-  assert (to_chunk->has_bitmap() == has_bitmap, "");
-  if (!to_chunk->has_bitmap()) {
-    build_bitmap(to_chunk);
-  }
-
-  assert (to_chunk->size() == old_compact_size, "");
-  assert (to_chunk->size() == instance_size(to_stack_size), "");
-  assert (from_sp <= metadata_words() ?  (to_chunk->size() == old_size) : (to_chunk->size() < old_size), "");
-  assert (to_chunk->verify(), "");
-
-  return align_object_size(header + to_stack_size + to_bitmap_size);
-}
-
 template <chunk_frames frame_kind>
 int InstanceStackChunkKlass::count_frames(stackChunkOop chunk) {
   int frames = 0;

src/hotspot/share/oops/instanceStackChunkKlass.hpp

@@ -143,13 +143,10 @@ class InstanceStackChunkKlass: public InstanceKlass {
 
   // Returns the size of the instance including the stack data.
   virtual size_t oop_size(oop obj) const override;
-  virtual size_t compact_oop_size(oop obj) const override;
 
-  virtual size_t copy_disjoint(oop obj, HeapWord* to, size_t word_size) override { return copy<copy_type::DISJOINT> (obj, to, word_size); }
-  virtual size_t copy_conjoint(oop obj, HeapWord* to, size_t word_size) override { return copy<copy_type::CONJOINT>(obj, to, word_size); }
+  virtual void copy_disjoint(oop obj, HeapWord* to, size_t word_size) override { copy<copy_type::DISJOINT> (obj, to, word_size); }
+  virtual void copy_conjoint(oop obj, HeapWord* to, size_t word_size) override { copy<copy_type::CONJOINT>(obj, to, word_size); }
 
-  virtual size_t copy_disjoint_compact(oop obj, HeapWord* to) override { return copy_compact<copy_type::DISJOINT> (obj, to); }
-  virtual size_t copy_conjoint_compact(oop obj, HeapWord* to) override { return copy_compact<copy_type::CONJOINT>(obj, to); }
 
   static void serialize_offsets(class SerializeClosure* f) NOT_CDS_RETURN;
 
@@ -215,7 +212,6 @@ class InstanceStackChunkKlass: public InstanceKlass {
   void build_bitmap(stackChunkOop chunk);
 
   template<copy_type disjoint> size_t copy(oop obj, HeapWord* to, size_t word_size);
-  template<copy_type disjoint> size_t copy_compact(oop obj, HeapWord* to);
 
   template <typename T, class OopClosureType>
   inline void oop_oop_iterate_header(stackChunkOop chunk, OopClosureType* closure);

src/hotspot/share/oops/klass.cpp

@@ -710,22 +710,12 @@ const char* Klass::signature_name() const {
   return name()->as_C_string();
 }
 
-size_t Klass::copy_disjoint(oop obj, HeapWord* to, size_t word_size) {
+void Klass::copy_disjoint(oop obj, HeapWord* to, size_t word_size) {
   Copy::aligned_disjoint_words(cast_from_oop<HeapWord*>(obj), to, word_size);
-  return word_size;
 }
 
-size_t Klass::copy_conjoint(oop obj, HeapWord* to, size_t word_size) {
+void Klass::copy_conjoint(oop obj, HeapWord* to, size_t word_size) {
   Copy::aligned_conjoint_words(cast_from_oop<HeapWord*>(obj), to, word_size);
-  return word_size;
-}
-
-size_t Klass::copy_disjoint_compact(oop obj, HeapWord* to) {
-  return obj->copy_disjoint(to);
-}
-
-size_t Klass::copy_conjoint_compact(oop obj, HeapWord* to) {
-  return obj->copy_conjoint(to);
 }
 
 const char* Klass::external_kind() const {

src/hotspot/share/oops/klass.hpp

@@ -597,10 +597,8 @@ class Klass : public Metadata {
   // Returns "interface", "abstract class" or "class".
   const char* external_kind() const;
 
-  virtual size_t copy_disjoint(oop obj, HeapWord* to, size_t word_size);
-  virtual size_t copy_conjoint(oop obj, HeapWord* to, size_t word_size);
-  virtual size_t copy_disjoint_compact(oop obj, HeapWord* to);
-  virtual size_t copy_conjoint_compact(oop obj, HeapWord* to);
+  virtual void copy_disjoint(oop obj, HeapWord* to, size_t word_size);
+  virtual void copy_conjoint(oop obj, HeapWord* to, size_t word_size);
 
   // type testing operations
 #ifdef ASSERT

src/hotspot/share/oops/oop.hpp

@@ -101,28 +101,14 @@ class oopDesc {
 
   // Returns the actual oop size of the object in machine words
   inline size_t size();
-  // Returns the size of the object after possible compression during GC promotion/compaction
-  inline size_t compact_size();
-  // Returns the given size in the common case where there is no special compact size
-  inline size_t compact_size(size_t size);
 
   // Sometimes (for complicated concurrency-related reasons), it is useful
   // to be able to figure out the size of an object knowing its klass.
   inline size_t size_given_klass(Klass* klass);
-  // Returns the size of the object after possible compression during GC promotion/compaction
-  inline size_t compact_size_given_klass(Klass* klass);
-  // Returns the given size in the common case where there is no special compact size
-  inline size_t compact_size_given_klass(Klass* klass, size_t size);
 
   // Copies the object
-  inline size_t copy_disjoint(HeapWord* to);
-  inline size_t copy_conjoint(HeapWord* to);
-  inline size_t copy_disjoint_compact(HeapWord* to);
-  inline size_t copy_conjoint_compact(HeapWord* to);
-  inline size_t copy_disjoint(HeapWord* to, size_t word_size);
-  inline size_t copy_disjoint_compact(HeapWord* to, size_t word_size);
-  inline size_t copy_conjoint(HeapWord* to, size_t word_size);
-  inline size_t copy_conjoint_compact(HeapWord* to, size_t word_size);
+  inline void copy_disjoint(HeapWord* to, size_t word_size);
+  inline void copy_conjoint(HeapWord* to, size_t word_size);
 
   // type test operations (inlined in oop.inline.hpp)
   inline bool is_instance()            const;

src/hotspot/share/oops/oop.inline.hpp

@@ -199,31 +199,6 @@ size_t oopDesc::size_given_klass(Klass* klass)  {
   return s;
 }
 
-size_t oopDesc::compact_size()  {
-  return compact_size_given_klass(klass());
-}
-
-size_t oopDesc::compact_size(size_t size)  {
-  return compact_size_given_klass(klass(), size);
-}
-
-size_t oopDesc::compact_size_given_klass(Klass* klass) {
-  int lh = klass->layout_helper();
-  if (lh > Klass::_lh_neutral_value && Klass::layout_helper_needs_slow_path(lh) && TrimContinuationChunksInGC) {
-    return klass->compact_oop_size(this);
-  }
-  return size_given_klass(klass);
-}
-
-size_t oopDesc::compact_size_given_klass(Klass* klass, size_t size) {
-  int lh = klass->layout_helper();
-  if (lh > Klass::_lh_neutral_value && Klass::layout_helper_needs_slow_path(lh) && TrimContinuationChunksInGC) {
-    return klass->compact_oop_size(this);
-  }
-  assert (size == size_given_klass(klass), "");
-  return size;
-}
-
 bool oopDesc::is_instance()  const { return klass()->is_instance_klass();  }
 bool oopDesc::is_array()     const { return klass()->is_array_klass();     }
 bool oopDesc::is_objArray()  const { return klass()->is_objArray_klass();  }
@@ -408,68 +383,24 @@ bool oopDesc::mark_must_be_preserved(markWord m) const {
   return m.must_be_preserved(this);
 }
 
-size_t oopDesc::copy_disjoint(HeapWord* to) {
-  return copy_disjoint(to, size());
-}
-
-size_t oopDesc::copy_conjoint(HeapWord* to) {
-  return copy_conjoint(to, size());
-}
-
-size_t oopDesc::copy_disjoint_compact(HeapWord* to) {
-  return copy_disjoint_compact(to, compact_size());
-}
-
-size_t oopDesc::copy_conjoint_compact(HeapWord* to) {
-  return copy_conjoint_compact(to, compact_size());
-}
-
-size_t oopDesc::copy_disjoint(HeapWord* to, size_t word_size) {
-  // if (is_stackChunk()) tty->print_cr(">>> copy_disjoint from: %p - %p to: %p - %p (word_size: %zu)", cast_from_oop<HeapWord*>(this), cast_from_oop<HeapWord*>(this) + word_size, to, to + word_size, word_size);
+void oopDesc::copy_disjoint(HeapWord* to, size_t word_size) {
   assert(word_size == (size_t)size() || size_might_change(), "");
   int lh = klass()->layout_helper();
   if (lh > Klass::_lh_neutral_value && Klass::layout_helper_needs_slow_path(lh)) {
-    size_t res = klass()->copy_disjoint(this, to, word_size);
-    assert (word_size == res, "");
-    return res;
-  }
-  Copy::aligned_disjoint_words(cast_from_oop<HeapWord*>(this), to, word_size);
-  return word_size;
-}
-
-size_t oopDesc::copy_disjoint_compact(HeapWord* to, size_t word_size) {
-  assert(word_size == (size_t)compact_size() || size_might_change(), "");
-  int lh = klass()->layout_helper();
-  if (lh > Klass::_lh_neutral_value && Klass::layout_helper_needs_slow_path(lh) && TrimContinuationChunksInGC) {
-    size_t res = klass()->copy_disjoint_compact(this, to);
-    assert (word_size == res, "");
-    return res;
+    klass()->copy_disjoint(this, to, word_size);
+  } else {
+    Copy::aligned_disjoint_words(cast_from_oop<HeapWord*>(this), to, word_size);
   }
-  return copy_disjoint(to, word_size);
 }
 
-size_t oopDesc::copy_conjoint(HeapWord* to, size_t word_size) {
-  // if (is_stackChunk()) tty->print_cr(">>> copy_conjoint from: %p - %p to: %p - %p (word_size: %zu)", cast_from_oop<HeapWord*>(this), cast_from_oop<HeapWord*>(this) + word_size, to, to + word_size, word_size);
+void oopDesc::copy_conjoint(HeapWord* to, size_t word_size) {
   assert(word_size == (size_t)size() || size_might_change(), "");
   int lh = klass()->layout_helper();
   if (lh > Klass::_lh_neutral_value && Klass::layout_helper_needs_slow_path(lh)) {
-    size_t res = klass()->copy_conjoint(this, to, word_size);
-    assert (word_size == res, "");
-    return res;
-  }
-  Copy::aligned_conjoint_words(cast_from_oop<HeapWord*>(this), to, word_size);
-  return word_size;
-}
-
-size_t oopDesc::copy_conjoint_compact(HeapWord* to, size_t word_size) {
-  assert(word_size == (size_t)compact_size() || size_might_change(), "");
-  int lh = klass()->layout_helper();
-  if (lh > Klass::_lh_neutral_value && Klass::layout_helper_needs_slow_path(lh) && TrimContinuationChunksInGC) {
-    size_t res = klass()->copy_conjoint_compact(this, to);
-    assert (word_size == res, "");
-    return res;
+    klass()->copy_conjoint(this, to, word_size);
+  } else {
+    Copy::aligned_conjoint_words(cast_from_oop<HeapWord*>(this), to, word_size);
   }
-  return copy_conjoint(to, word_size);
 }
 
 #endif // SHARE_OOPS_OOP_INLINE_HPP

src/hotspot/share/runtime/globals.hpp

@@ -2013,9 +2013,6 @@ const intx ObjectAlignmentInBytes = 8;
   develop(bool, UseContinuationFastPath, true,                              \
           "Use fast-path frame walking in continuations")                   \
                                                                             \
-  product(bool, TrimContinuationChunksInGC, false,                          \
-         "Trim stack chunks when copying objects in GC (PREVIEW)")          \
-                                                                            \
   product(bool, UseChunkBitmaps, false,                                     \
          "Generate oop bitmaps for continuation chunks (PREVIEW)")          \
                                                                             \