21  * questions.
  22  *
  23  */
  24 
  25 #ifndef SHARE_VM_GC_SHARED_GENOOPCLOSURES_INLINE_HPP
  26 #define SHARE_VM_GC_SHARED_GENOOPCLOSURES_INLINE_HPP
  27 
  28 #include "gc/shared/cardTableRS.hpp"
  29 #include "gc/shared/genCollectedHeap.hpp"
  30 #include "gc/shared/genOopClosures.hpp"
  31 #include "gc/shared/generation.hpp"
  32 #include "gc/shared/space.hpp"
  33 #include "oops/access.inline.hpp"
  34 #include "oops/compressedOops.inline.hpp"
  35 #include "oops/oop.inline.hpp"
  36 #if INCLUDE_SERIALGC
  37 #include "gc/serial/defNewGeneration.inline.hpp"
  38 #endif
  39 
  40 inline OopsInGenClosure::OopsInGenClosure(Generation* gen) :
  41   ExtendedOopClosure(gen->ref_processor()), _orig_gen(gen), _rs(NULL) {
  42   set_generation(gen);
  43 }
  44 
  45 inline void OopsInGenClosure::set_generation(Generation* gen) {
  46   _gen = gen;
  47   _gen_boundary = _gen->reserved().start();
  48   // Barrier set for the heap, must be set after heap is initialized
  49   if (_rs == NULL) {
  50     _rs = GenCollectedHeap::heap()->rem_set();
  51   }
  52 }
  53 
  54 template <class T> inline void OopsInGenClosure::do_barrier(T* p) {
  55   assert(generation()->is_in_reserved(p), "expected ref in generation");
  56   T heap_oop = RawAccess<>::oop_load(p);
  57   assert(!CompressedOops::is_null(heap_oop), "expected non-null oop");
  58   oop obj = CompressedOops::decode_not_null(heap_oop);
  59   // If p points to a younger generation, mark the card.
  60   if ((HeapWord*)obj < _gen_boundary) {
  61     _rs->inline_write_ref_field_gc(p, obj);
  62   }
  63 }
  64 
  65 template <class T> inline void OopsInGenClosure::par_do_barrier(T* p) {
  66   assert(generation()->is_in_reserved(p), "expected ref in generation");
  67   T heap_oop = RawAccess<>::oop_load(p);
  68   assert(!CompressedOops::is_null(heap_oop), "expected non-null oop");
  69   oop obj = CompressedOops::decode_not_null(heap_oop);
  70   // If p points to a younger generation, mark the card.
  71   if ((HeapWord*)obj < gen_boundary()) {
  72     rs()->write_ref_field_gc_par(p, obj);
  73   }
  74 }
  75 



  76 inline void OopsInClassLoaderDataOrGenClosure::do_cld_barrier() {
  77   assert(_scanned_cld != NULL, "Must be");
  78   if (!_scanned_cld->has_modified_oops()) {
  79     _scanned_cld->record_modified_oops();
  80   }
  81 }
  82 
  83 #if INCLUDE_SERIALGC
  84 
  85 // NOTE! Any changes made here should also be made
  86 // in FastScanClosure::do_oop_work()
  87 template <class T> inline void ScanClosure::do_oop_work(T* p) {
  88   T heap_oop = RawAccess<>::oop_load(p);
  89   // Should we copy the obj?
  90   if (!CompressedOops::is_null(heap_oop)) {
  91     oop obj = CompressedOops::decode_not_null(heap_oop);
  92     if ((HeapWord*)obj < _boundary) {
  93       assert(!_g->to()->is_in_reserved(obj), "Scanning field twice?");
  94       oop new_obj = obj->is_forwarded() ? obj->forwardee()
  95                                         : _g->copy_to_survivor_space(obj);
  96       RawAccess<OOP_NOT_NULL>::oop_store(p, new_obj);
  97     }
  98 
  99     if (is_scanning_a_cld()) {
 100       do_cld_barrier();
 101     } else if (_gc_barrier) {
 102       // Now call parent closure
 103       do_barrier(p);
 104     }
 105   }
 106 }
 107 
 108 inline void ScanClosure::do_oop_nv(oop* p)       { ScanClosure::do_oop_work(p); }
 109 inline void ScanClosure::do_oop_nv(narrowOop* p) { ScanClosure::do_oop_work(p); }
 110 
 111 // NOTE! Any changes made here should also be made
 112 // in ScanClosure::do_oop_work()
 113 template <class T> inline void FastScanClosure::do_oop_work(T* p) {
 114   T heap_oop = RawAccess<>::oop_load(p);
 115   // Should we copy the obj?
 116   if (!CompressedOops::is_null(heap_oop)) {
 117     oop obj = CompressedOops::decode_not_null(heap_oop);
 118     if ((HeapWord*)obj < _boundary) {
 119       assert(!_g->to()->is_in_reserved(obj), "Scanning field twice?");
 120       oop new_obj = obj->is_forwarded() ? obj->forwardee()
 121                                         : _g->copy_to_survivor_space(obj);
 122       RawAccess<OOP_NOT_NULL>::oop_store(p, new_obj);
 123       if (is_scanning_a_cld()) {
 124         do_cld_barrier();
 125       } else if (_gc_barrier) {
 126         // Now call parent closure
 127         do_barrier(p);
 128       }
 129     }
 130   }
 131 }
 132 
 133 inline void FastScanClosure::do_oop_nv(oop* p)       { FastScanClosure::do_oop_work(p); }
 134 inline void FastScanClosure::do_oop_nv(narrowOop* p) { FastScanClosure::do_oop_work(p); }
 135 
 136 #endif // INCLUDE_SERIALGC
 137 
 138 template <class T> void FilteringClosure::do_oop_work(T* p) {
 139   T heap_oop = RawAccess<>::oop_load(p);
 140   if (!CompressedOops::is_null(heap_oop)) {
 141     oop obj = CompressedOops::decode_not_null(heap_oop);
 142     if ((HeapWord*)obj < _boundary) {
 143       _cl->do_oop(p);
 144     }
 145   }
 146 }
 147 
 148 void FilteringClosure::do_oop_nv(oop* p)       { FilteringClosure::do_oop_work(p); }
 149 void FilteringClosure::do_oop_nv(narrowOop* p) { FilteringClosure::do_oop_work(p); }
 150 
 151 #if INCLUDE_SERIALGC
 152 
 153 // Note similarity to ScanClosure; the difference is that
 154 // the barrier set is taken care of outside this closure.
 155 template <class T> inline void ScanWeakRefClosure::do_oop_work(T* p) {
 156   oop obj = RawAccess<OOP_NOT_NULL>::oop_load(p);
 157   // weak references are sometimes scanned twice; must check
 158   // that to-space doesn't already contain this object
 159   if ((HeapWord*)obj < _boundary && !_g->to()->is_in_reserved(obj)) {
 160     oop new_obj = obj->is_forwarded() ? obj->forwardee()
 161                                       : _g->copy_to_survivor_space(obj);
 162     RawAccess<OOP_NOT_NULL>::oop_store(p, new_obj);
 163   }
 164 }
 165 
 166 inline void ScanWeakRefClosure::do_oop_nv(oop* p)       { ScanWeakRefClosure::do_oop_work(p); }
 167 inline void ScanWeakRefClosure::do_oop_nv(narrowOop* p) { ScanWeakRefClosure::do_oop_work(p); }
 168 
 169 #endif // INCLUDE_SERIALGC
 170 
 171 #endif // SHARE_VM_GC_SHARED_GENOOPCLOSURES_INLINE_HPP

  21  * questions.
  22  *
  23  */
  24 
  25 #ifndef SHARE_VM_GC_SHARED_GENOOPCLOSURES_INLINE_HPP
  26 #define SHARE_VM_GC_SHARED_GENOOPCLOSURES_INLINE_HPP
  27 
  28 #include "gc/shared/cardTableRS.hpp"
  29 #include "gc/shared/genCollectedHeap.hpp"
  30 #include "gc/shared/genOopClosures.hpp"
  31 #include "gc/shared/generation.hpp"
  32 #include "gc/shared/space.hpp"
  33 #include "oops/access.inline.hpp"
  34 #include "oops/compressedOops.inline.hpp"
  35 #include "oops/oop.inline.hpp"
  36 #if INCLUDE_SERIALGC
  37 #include "gc/serial/defNewGeneration.inline.hpp"
  38 #endif
  39 
  40 inline OopsInGenClosure::OopsInGenClosure(Generation* gen) :
  41   OopIterateClosure(gen->ref_processor()), _orig_gen(gen), _rs(NULL) {
  42   set_generation(gen);
  43 }
  44 
  45 inline void OopsInGenClosure::set_generation(Generation* gen) {
  46   _gen = gen;
  47   _gen_boundary = _gen->reserved().start();
  48   // Barrier set for the heap, must be set after heap is initialized
  49   if (_rs == NULL) {
  50     _rs = GenCollectedHeap::heap()->rem_set();
  51   }
  52 }
  53 
  54 template <class T> inline void OopsInGenClosure::do_barrier(T* p) {
  55   assert(generation()->is_in_reserved(p), "expected ref in generation");
  56   T heap_oop = RawAccess<>::oop_load(p);
  57   assert(!CompressedOops::is_null(heap_oop), "expected non-null oop");
  58   oop obj = CompressedOops::decode_not_null(heap_oop);
  59   // If p points to a younger generation, mark the card.
  60   if ((HeapWord*)obj < _gen_boundary) {
  61     _rs->inline_write_ref_field_gc(p, obj);
  62   }
  63 }
  64 
  65 template <class T> inline void OopsInGenClosure::par_do_barrier(T* p) {
  66   assert(generation()->is_in_reserved(p), "expected ref in generation");
  67   T heap_oop = RawAccess<>::oop_load(p);
  68   assert(!CompressedOops::is_null(heap_oop), "expected non-null oop");
  69   oop obj = CompressedOops::decode_not_null(heap_oop);
  70   // If p points to a younger generation, mark the card.
  71   if ((HeapWord*)obj < gen_boundary()) {
  72     rs()->write_ref_field_gc_par(p, obj);
  73   }
  74 }
  75 
  76 inline BasicOopsInGenClosure::BasicOopsInGenClosure(Generation* gen) : OopsInGenClosure(gen) {
  77 }
  78 
  79 inline void OopsInClassLoaderDataOrGenClosure::do_cld_barrier() {
  80   assert(_scanned_cld != NULL, "Must be");
  81   if (!_scanned_cld->has_modified_oops()) {
  82     _scanned_cld->record_modified_oops();
  83   }
  84 }
  85 
  86 #if INCLUDE_SERIALGC
  87 
  88 // NOTE! Any changes made here should also be made
  89 // in FastScanClosure::do_oop_work()
  90 template <class T> inline void ScanClosure::do_oop_work(T* p) {
  91   T heap_oop = RawAccess<>::oop_load(p);
  92   // Should we copy the obj?
  93   if (!CompressedOops::is_null(heap_oop)) {
  94     oop obj = CompressedOops::decode_not_null(heap_oop);
  95     if ((HeapWord*)obj < _boundary) {
  96       assert(!_g->to()->is_in_reserved(obj), "Scanning field twice?");
  97       oop new_obj = obj->is_forwarded() ? obj->forwardee()
  98                                         : _g->copy_to_survivor_space(obj);
  99       RawAccess<OOP_NOT_NULL>::oop_store(p, new_obj);
 100     }
 101 
 102     if (is_scanning_a_cld()) {
 103       do_cld_barrier();
 104     } else if (_gc_barrier) {
 105       // Now call parent closure
 106       do_barrier(p);
 107     }
 108   }
 109 }
 110 
 111 inline void ScanClosure::do_oop(oop* p)       { ScanClosure::do_oop_work(p); }
 112 inline void ScanClosure::do_oop(narrowOop* p) { ScanClosure::do_oop_work(p); }
 113 
 114 // NOTE! Any changes made here should also be made
 115 // in ScanClosure::do_oop_work()
 116 template <class T> inline void FastScanClosure::do_oop_work(T* p) {
 117   T heap_oop = RawAccess<>::oop_load(p);
 118   // Should we copy the obj?
 119   if (!CompressedOops::is_null(heap_oop)) {
 120     oop obj = CompressedOops::decode_not_null(heap_oop);
 121     if ((HeapWord*)obj < _boundary) {
 122       assert(!_g->to()->is_in_reserved(obj), "Scanning field twice?");
 123       oop new_obj = obj->is_forwarded() ? obj->forwardee()
 124                                         : _g->copy_to_survivor_space(obj);
 125       RawAccess<OOP_NOT_NULL>::oop_store(p, new_obj);
 126       if (is_scanning_a_cld()) {
 127         do_cld_barrier();
 128       } else if (_gc_barrier) {
 129         // Now call parent closure
 130         do_barrier(p);
 131       }
 132     }
 133   }
 134 }
 135 
 136 inline void FastScanClosure::do_oop(oop* p)       { FastScanClosure::do_oop_work(p); }
 137 inline void FastScanClosure::do_oop(narrowOop* p) { FastScanClosure::do_oop_work(p); }
 138 
 139 #endif // INCLUDE_SERIALGC
 140 
 141 template <class T> void FilteringClosure::do_oop_work(T* p) {
 142   T heap_oop = RawAccess<>::oop_load(p);
 143   if (!CompressedOops::is_null(heap_oop)) {
 144     oop obj = CompressedOops::decode_not_null(heap_oop);
 145     if ((HeapWord*)obj < _boundary) {
 146       _cl->do_oop(p);
 147     }
 148   }
 149 }
 150 
 151 inline void FilteringClosure::do_oop(oop* p)       { FilteringClosure::do_oop_work(p); }
 152 inline void FilteringClosure::do_oop(narrowOop* p) { FilteringClosure::do_oop_work(p); }
 153 
 154 #if INCLUDE_SERIALGC
 155 
 156 // Note similarity to ScanClosure; the difference is that
 157 // the barrier set is taken care of outside this closure.
 158 template <class T> inline void ScanWeakRefClosure::do_oop_work(T* p) {
 159   oop obj = RawAccess<OOP_NOT_NULL>::oop_load(p);
 160   // weak references are sometimes scanned twice; must check
 161   // that to-space doesn't already contain this object
 162   if ((HeapWord*)obj < _boundary && !_g->to()->is_in_reserved(obj)) {
 163     oop new_obj = obj->is_forwarded() ? obj->forwardee()
 164                                       : _g->copy_to_survivor_space(obj);
 165     RawAccess<OOP_NOT_NULL>::oop_store(p, new_obj);
 166   }
 167 }
 168 
 169 inline void ScanWeakRefClosure::do_oop(oop* p)       { ScanWeakRefClosure::do_oop_work(p); }
 170 inline void ScanWeakRefClosure::do_oop(narrowOop* p) { ScanWeakRefClosure::do_oop_work(p); }
 171 
 172 #endif // INCLUDE_SERIALGC
 173 
 174 #endif // SHARE_VM_GC_SHARED_GENOOPCLOSURES_INLINE_HPP