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

*** 29,38 ****
--- 29,40 ----
  #include "gc/shared/cardTableRS.hpp"
  #include "gc/shared/genCollectedHeap.hpp"
  #include "gc/shared/genOopClosures.hpp"
  #include "gc/shared/generation.hpp"
  #include "gc/shared/space.hpp"
+ #include "oops/access.inline.hpp"
+ #include "oops/compressedOops.inline.hpp"
  
  inline OopsInGenClosure::OopsInGenClosure(Generation* gen) :
    ExtendedOopClosure(gen->ref_processor()), _orig_gen(gen), _rs(NULL) {
    set_generation(gen);
  }
*** 46,69 ****
    }
  }
  
  template <class T> inline void OopsInGenClosure::do_barrier(T* p) {
    assert(generation()->is_in_reserved(p), "expected ref in generation");
!   T heap_oop = oopDesc::load_heap_oop(p);
!   assert(!oopDesc::is_null(heap_oop), "expected non-null oop");
!   oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
    // If p points to a younger generation, mark the card.
    if ((HeapWord*)obj < _gen_boundary) {
      _rs->inline_write_ref_field_gc(p, obj);
    }
  }
  
  template <class T> inline void OopsInGenClosure::par_do_barrier(T* p) {
    assert(generation()->is_in_reserved(p), "expected ref in generation");
!   T heap_oop = oopDesc::load_heap_oop(p);
!   assert(!oopDesc::is_null(heap_oop), "expected non-null oop");
!   oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
    // If p points to a younger generation, mark the card.
    if ((HeapWord*)obj < gen_boundary()) {
      rs()->write_ref_field_gc_par(p, obj);
    }
  }
--- 48,71 ----
    }
  }
  
  template <class T> inline void OopsInGenClosure::do_barrier(T* p) {
    assert(generation()->is_in_reserved(p), "expected ref in generation");
!   T heap_oop = RawAccess<>::oop_load(p);
!   assert(!CompressedOops::is_null(heap_oop), "expected non-null oop");
!   oop obj = CompressedOops::decode_not_null(heap_oop);
    // If p points to a younger generation, mark the card.
    if ((HeapWord*)obj < _gen_boundary) {
      _rs->inline_write_ref_field_gc(p, obj);
    }
  }
  
  template <class T> inline void OopsInGenClosure::par_do_barrier(T* p) {
    assert(generation()->is_in_reserved(p), "expected ref in generation");
!   T heap_oop = RawAccess<>::oop_load(p);
!   assert(!CompressedOops::is_null(heap_oop), "expected non-null oop");
!   oop obj = CompressedOops::decode_not_null(heap_oop);
    // If p points to a younger generation, mark the card.
    if ((HeapWord*)obj < gen_boundary()) {
      rs()->write_ref_field_gc_par(p, obj);
    }
  }
*** 76,94 ****
  }
  
  // NOTE! Any changes made here should also be made
  // in FastScanClosure::do_oop_work()
  template <class T> inline void ScanClosure::do_oop_work(T* p) {
!   T heap_oop = oopDesc::load_heap_oop(p);
    // Should we copy the obj?
!   if (!oopDesc::is_null(heap_oop)) {
!     oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
      if ((HeapWord*)obj < _boundary) {
        assert(!_g->to()->is_in_reserved(obj), "Scanning field twice?");
        oop new_obj = obj->is_forwarded() ? obj->forwardee()
                                          : _g->copy_to_survivor_space(obj);
!       oopDesc::encode_store_heap_oop_not_null(p, new_obj);
      }
  
      if (is_scanning_a_cld()) {
        do_cld_barrier();
      } else if (_gc_barrier) {
--- 78,96 ----
  }
  
  // NOTE! Any changes made here should also be made
  // in FastScanClosure::do_oop_work()
  template <class T> inline void ScanClosure::do_oop_work(T* p) {
!   T heap_oop = RawAccess<>::oop_load(p);
    // Should we copy the obj?
!   if (!CompressedOops::is_null(heap_oop)) {
!     oop obj = CompressedOops::decode_not_null(heap_oop);
      if ((HeapWord*)obj < _boundary) {
        assert(!_g->to()->is_in_reserved(obj), "Scanning field twice?");
        oop new_obj = obj->is_forwarded() ? obj->forwardee()
                                          : _g->copy_to_survivor_space(obj);
!       RawAccess<OOP_NOT_NULL>::oop_store(p, new_obj);
      }
  
      if (is_scanning_a_cld()) {
        do_cld_barrier();
      } else if (_gc_barrier) {
*** 102,120 ****
  inline void ScanClosure::do_oop_nv(narrowOop* p) { ScanClosure::do_oop_work(p); }
  
  // NOTE! Any changes made here should also be made
  // in ScanClosure::do_oop_work()
  template <class T> inline void FastScanClosure::do_oop_work(T* p) {
!   T heap_oop = oopDesc::load_heap_oop(p);
    // Should we copy the obj?
!   if (!oopDesc::is_null(heap_oop)) {
!     oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
      if ((HeapWord*)obj < _boundary) {
        assert(!_g->to()->is_in_reserved(obj), "Scanning field twice?");
        oop new_obj = obj->is_forwarded() ? obj->forwardee()
                                          : _g->copy_to_survivor_space(obj);
!       oopDesc::encode_store_heap_oop_not_null(p, new_obj);
        if (is_scanning_a_cld()) {
          do_cld_barrier();
        } else if (_gc_barrier) {
          // Now call parent closure
          do_barrier(p);
--- 104,122 ----
  inline void ScanClosure::do_oop_nv(narrowOop* p) { ScanClosure::do_oop_work(p); }
  
  // NOTE! Any changes made here should also be made
  // in ScanClosure::do_oop_work()
  template <class T> inline void FastScanClosure::do_oop_work(T* p) {
!   T heap_oop = RawAccess<>::oop_load(p);
    // Should we copy the obj?
!   if (!CompressedOops::is_null(heap_oop)) {
!     oop obj = CompressedOops::decode_not_null(heap_oop);
      if ((HeapWord*)obj < _boundary) {
        assert(!_g->to()->is_in_reserved(obj), "Scanning field twice?");
        oop new_obj = obj->is_forwarded() ? obj->forwardee()
                                          : _g->copy_to_survivor_space(obj);
!       RawAccess<OOP_NOT_NULL>::oop_store(p, new_obj);
        if (is_scanning_a_cld()) {
          do_cld_barrier();
        } else if (_gc_barrier) {
          // Now call parent closure
          do_barrier(p);
*** 125,137 ****
  
  inline void FastScanClosure::do_oop_nv(oop* p)       { FastScanClosure::do_oop_work(p); }
  inline void FastScanClosure::do_oop_nv(narrowOop* p) { FastScanClosure::do_oop_work(p); }
  
  template <class T> void FilteringClosure::do_oop_work(T* p) {
!   T heap_oop = oopDesc::load_heap_oop(p);
!   if (!oopDesc::is_null(heap_oop)) {
!     oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
      if ((HeapWord*)obj < _boundary) {
        _cl->do_oop(p);
      }
    }
  }
--- 127,139 ----
  
  inline void FastScanClosure::do_oop_nv(oop* p)       { FastScanClosure::do_oop_work(p); }
  inline void FastScanClosure::do_oop_nv(narrowOop* p) { FastScanClosure::do_oop_work(p); }
  
  template <class T> void FilteringClosure::do_oop_work(T* p) {
!   T heap_oop = RawAccess<>::oop_load(p);
!   if (!CompressedOops::is_null(heap_oop)) {
!     oop obj = CompressedOops::decode_not_null(heap_oop);
      if ((HeapWord*)obj < _boundary) {
        _cl->do_oop(p);
      }
    }
  }
*** 140,157 ****
  void FilteringClosure::do_oop_nv(narrowOop* p) { FilteringClosure::do_oop_work(p); }
  
  // Note similarity to ScanClosure; the difference is that
  // the barrier set is taken care of outside this closure.
  template <class T> inline void ScanWeakRefClosure::do_oop_work(T* p) {
!   assert(!oopDesc::is_null(*p), "null weak reference?");
!   oop obj = oopDesc::load_decode_heap_oop_not_null(p);
    // weak references are sometimes scanned twice; must check
    // that to-space doesn't already contain this object
    if ((HeapWord*)obj < _boundary && !_g->to()->is_in_reserved(obj)) {
      oop new_obj = obj->is_forwarded() ? obj->forwardee()
                                        : _g->copy_to_survivor_space(obj);
!     oopDesc::encode_store_heap_oop_not_null(p, new_obj);
    }
  }
  
  inline void ScanWeakRefClosure::do_oop_nv(oop* p)       { ScanWeakRefClosure::do_oop_work(p); }
  inline void ScanWeakRefClosure::do_oop_nv(narrowOop* p) { ScanWeakRefClosure::do_oop_work(p); }
--- 142,158 ----
  void FilteringClosure::do_oop_nv(narrowOop* p) { FilteringClosure::do_oop_work(p); }
  
  // Note similarity to ScanClosure; the difference is that
  // the barrier set is taken care of outside this closure.
  template <class T> inline void ScanWeakRefClosure::do_oop_work(T* p) {
!   oop obj = RawAccess<OOP_NOT_NULL>::oop_load(p);
    // weak references are sometimes scanned twice; must check
    // that to-space doesn't already contain this object
    if ((HeapWord*)obj < _boundary && !_g->to()->is_in_reserved(obj)) {
      oop new_obj = obj->is_forwarded() ? obj->forwardee()
                                        : _g->copy_to_survivor_space(obj);
!     RawAccess<OOP_NOT_NULL>::oop_store(p, new_obj);
    }
  }
  
  inline void ScanWeakRefClosure::do_oop_nv(oop* p)       { ScanWeakRefClosure::do_oop_work(p); }
  inline void ScanWeakRefClosure::do_oop_nv(narrowOop* p) { ScanWeakRefClosure::do_oop_work(p); }