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

@@ -24,10 +24,11 @@
  
  #include "precompiled.hpp"
  #include "compiler/compileBroker.hpp"
  #include "gc/serial/markSweep.inline.hpp"
  #include "gc/shared/collectedHeap.inline.hpp"
+ #include "gc/shared/genCollectedHeap.hpp"
  #include "gc/shared/gcTimer.hpp"
  #include "gc/shared/gcTrace.hpp"
  #include "gc/shared/gc_globals.hpp"
  #include "memory/iterator.inline.hpp"
  #include "memory/universe.hpp"

@@ -60,11 +61,10 @@
  
  MarkSweep::FollowRootClosure  MarkSweep::follow_root_closure;
  
  MarkAndPushClosure MarkSweep::mark_and_push_closure;
  CLDToOopClosure    MarkSweep::follow_cld_closure(&mark_and_push_closure, ClassLoaderData::_claim_strong);
- CLDToOopClosure    MarkSweep::adjust_cld_closure(&adjust_pointer_closure, ClassLoaderData::_claim_strong);
  
  template <class T> inline void MarkSweep::KeepAliveClosure::do_oop_work(T* p) {
    mark_and_push(p);
  }
  

@@ -142,12 +142,12 @@
  }
  
  void MarkSweep::FollowRootClosure::do_oop(oop* p)       { follow_root(p); }
  void MarkSweep::FollowRootClosure::do_oop(narrowOop* p) { follow_root(p); }
  
- void PreservedMark::adjust_pointer() {
-   MarkSweep::adjust_pointer(&_obj);
+ void PreservedMark::adjust_pointer(const SlidingForwarding* const forwarding) {
+   MarkSweep::adjust_pointer(forwarding, &_obj);
  }
  
  void PreservedMark::restore() {
    _obj->set_mark(_mark);
  }

@@ -171,26 +171,26 @@
  void MarkSweep::set_ref_processor(ReferenceProcessor* rp) {
    _ref_processor = rp;
    mark_and_push_closure.set_ref_discoverer(_ref_processor);
  }
  
- AdjustPointerClosure MarkSweep::adjust_pointer_closure;
- 
  void MarkSweep::adjust_marks() {
+   const SlidingForwarding* const forwarding = GenCollectedHeap::heap()->forwarding();
+ 
    assert( _preserved_oop_stack.size() == _preserved_mark_stack.size(),
           "inconsistent preserved oop stacks");
  
    // adjust the oops we saved earlier
    for (size_t i = 0; i < _preserved_count; i++) {
-     _preserved_marks[i].adjust_pointer();
+     _preserved_marks[i].adjust_pointer(forwarding);
    }
  
    // deal with the overflow stack
    StackIterator<oop, mtGC> iter(_preserved_oop_stack);
    while (!iter.is_empty()) {
      oop* p = iter.next_addr();
-     adjust_pointer(p);
+     adjust_pointer(forwarding, p);
    }
  }
  
  void MarkSweep::restore_marks() {
    assert(_preserved_oop_stack.size() == _preserved_mark_stack.size(),