< prev index next >

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

Print this page




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


  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 (cast_from_oop<HeapWord*>(obj) < _gen_boundary) {
  61     _rs->inline_write_ref_field_gc(p, obj);
  62   }
  63 }
  64 
  65 inline BasicOopsInGenClosure::BasicOopsInGenClosure(Generation* gen) : OopsInGenClosure(gen) {
  66 }
  67 
  68 inline void OopsInClassLoaderDataOrGenClosure::do_cld_barrier() {
  69   assert(_scanned_cld != NULL, "Must be");
  70   if (!_scanned_cld->has_modified_oops()) {
  71     _scanned_cld->record_modified_oops();
  72   }
  73 }
  74 
  75 #if INCLUDE_SERIALGC
  76 




























  77 template <class T> inline void FastScanClosure::do_oop_work(T* p) {
  78   T heap_oop = RawAccess<>::oop_load(p);
  79   // Should we copy the obj?
  80   if (!CompressedOops::is_null(heap_oop)) {
  81     oop obj = CompressedOops::decode_not_null(heap_oop);
  82     if (cast_from_oop<HeapWord*>(obj) < _boundary) {
  83       assert(!_g->to()->is_in_reserved(obj), "Scanning field twice?");
  84       oop new_obj = obj->is_forwarded() ? obj->forwardee()
  85                                         : _g->copy_to_survivor_space(obj);
  86       RawAccess<IS_NOT_NULL>::oop_store(p, new_obj);
  87       if (is_scanning_a_cld()) {
  88         do_cld_barrier();
  89       } else if (_gc_barrier) {
  90         // Now call parent closure
  91         do_barrier(p);
  92       }
  93     }
  94   }
  95 }
  96 
  97 inline void FastScanClosure::do_oop(oop* p)       { FastScanClosure::do_oop_work(p); }
  98 inline void FastScanClosure::do_oop(narrowOop* p) { FastScanClosure::do_oop_work(p); }
  99 
 100 #endif // INCLUDE_SERIALGC
 101 
 102 template <class T> void FilteringClosure::do_oop_work(T* p) {
 103   T heap_oop = RawAccess<>::oop_load(p);
 104   if (!CompressedOops::is_null(heap_oop)) {
 105     oop obj = CompressedOops::decode_not_null(heap_oop);
 106     if (cast_from_oop<HeapWord*>(obj) < _boundary) {
 107       _cl->do_oop(p);
 108     }
 109   }
 110 }
 111 
 112 inline void FilteringClosure::do_oop(oop* p)       { FilteringClosure::do_oop_work(p); }
 113 inline void FilteringClosure::do_oop(narrowOop* p) { FilteringClosure::do_oop_work(p); }
 114 
 115 #if INCLUDE_SERIALGC
 116 
 117 // Note similarity to FastScanClosure; the difference is that
 118 // the barrier set is taken care of outside this closure.
 119 template <class T> inline void ScanWeakRefClosure::do_oop_work(T* p) {
 120   oop obj = RawAccess<IS_NOT_NULL>::oop_load(p);
 121   // weak references are sometimes scanned twice; must check
 122   // that to-space doesn't already contain this object
 123   if (cast_from_oop<HeapWord*>(obj) < _boundary && !_g->to()->is_in_reserved(obj)) {
 124     oop new_obj = obj->is_forwarded() ? obj->forwardee()
 125                                       : _g->copy_to_survivor_space(obj);
 126     RawAccess<IS_NOT_NULL>::oop_store(p, new_obj);
 127   }
 128 }
 129 
 130 inline void ScanWeakRefClosure::do_oop(oop* p)       { ScanWeakRefClosure::do_oop_work(p); }
 131 inline void ScanWeakRefClosure::do_oop(narrowOop* p) { ScanWeakRefClosure::do_oop_work(p); }
 132 
 133 #endif // INCLUDE_SERIALGC
 134 
 135 #endif // SHARE_GC_SHARED_GENOOPCLOSURES_INLINE_HPP
< prev index next >