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

*** 23,33 ****
   */
  
  #include "precompiled.hpp"
  #include "compiler/compileBroker.hpp"
  #include "gc/serial/markSweep.inline.hpp"
- #include "gc/serial/serial_specialized_oop_closures.hpp"
  #include "gc/shared/collectedHeap.inline.hpp"
  #include "gc/shared/gcTimer.hpp"
  #include "gc/shared/gcTrace.hpp"
  #include "memory/iterator.inline.hpp"
  #include "oops/access.inline.hpp"
--- 23,32 ----
*** 61,112 ****
  
  MarkAndPushClosure            MarkSweep::mark_and_push_closure;
  CLDToOopClosure               MarkSweep::follow_cld_closure(&mark_and_push_closure);
  CLDToOopClosure               MarkSweep::adjust_cld_closure(&adjust_pointer_closure);
  
- inline void MarkSweep::mark_object(oop obj) {
-   // some marks may contain information we need to preserve so we store them away
-   // and overwrite the mark.  We'll restore it at the end of markSweep.
-   markOop mark = obj->mark_raw();
-   obj->set_mark_raw(markOopDesc::prototype()->set_marked());
- 
-   if (mark->must_be_preserved(obj)) {
-     preserve_mark(obj, mark);
-   }
- }
- 
- template <class T> inline void MarkSweep::mark_and_push(T* p) {
-   T heap_oop = RawAccess<>::oop_load(p);
-   if (!CompressedOops::is_null(heap_oop)) {
-     oop obj = CompressedOops::decode_not_null(heap_oop);
-     if (!obj->mark_raw()->is_marked()) {
-       mark_object(obj);
-       _marking_stack.push(obj);
-     }
-   }
- }
- 
- inline void MarkSweep::follow_klass(Klass* klass) {
-   oop op = klass->klass_holder();
-   MarkSweep::mark_and_push(&op);
- }
- 
- inline void MarkSweep::follow_cld(ClassLoaderData* cld) {
-   MarkSweep::follow_cld_closure.do_cld(cld);
- }
- 
- template <typename T>
- inline void MarkAndPushClosure::do_oop_nv(T* p)                 { MarkSweep::mark_and_push(p); }
- void MarkAndPushClosure::do_oop(oop* p)                         { do_oop_nv(p); }
- void MarkAndPushClosure::do_oop(narrowOop* p)                   { do_oop_nv(p); }
- inline bool MarkAndPushClosure::do_metadata_nv()                { return true; }
- bool MarkAndPushClosure::do_metadata()                          { return do_metadata_nv(); }
- inline void MarkAndPushClosure::do_klass_nv(Klass* k)           { MarkSweep::follow_klass(k); }
- void MarkAndPushClosure::do_klass(Klass* k)                     { do_klass_nv(k); }
- inline void MarkAndPushClosure::do_cld_nv(ClassLoaderData* cld) { MarkSweep::follow_cld(cld); }
- void MarkAndPushClosure::do_cld(ClassLoaderData* cld)           { do_cld_nv(cld); }
- 
  template <class T> inline void MarkSweep::KeepAliveClosure::do_oop_work(T* p) {
    mark_and_push(p);
  }
  
  void MarkSweep::push_objarray(oop obj, size_t index) {
--- 60,69 ----
*** 214,228 ****
    mark_and_push_closure.set_ref_discoverer(_ref_processor);
  }
  
  AdjustPointerClosure MarkSweep::adjust_pointer_closure;
  
- template <typename T>
- void AdjustPointerClosure::do_oop_nv(T* p)      { MarkSweep::adjust_pointer(p); }
- void AdjustPointerClosure::do_oop(oop* p)       { do_oop_nv(p); }
- void AdjustPointerClosure::do_oop(narrowOop* p) { do_oop_nv(p); }
- 
  void MarkSweep::adjust_marks() {
    assert( _preserved_oop_stack.size() == _preserved_mark_stack.size(),
           "inconsistent preserved oop stacks");
  
    // adjust the oops we saved earlier
--- 171,180 ----
*** 267,274 ****
  
  void MarkSweep::initialize() {
    MarkSweep::_gc_timer = new (ResourceObj::C_HEAP, mtGC) STWGCTimer();
    MarkSweep::_gc_tracer = new (ResourceObj::C_HEAP, mtGC) SerialOldTracer();
  }
- 
- // Generate MS specialized oop_oop_iterate functions.
- SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_MS(ALL_KLASS_OOP_OOP_ITERATE_DEFN)
--- 219,223 ----