< prev index next >

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

Print this page




  51   T heap_oop = oopDesc::load_heap_oop(p);
  52   assert(!oopDesc::is_null(heap_oop), "expected non-null oop");
  53   oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
  54   // If p points to a younger generation, mark the card.
  55   if ((HeapWord*)obj < _gen_boundary) {
  56     _rs->inline_write_ref_field_gc(p, obj);
  57   }
  58 }
  59 
  60 template <class T> inline void OopsInGenClosure::par_do_barrier(T* p) {
  61   assert(generation()->is_in_reserved(p), "expected ref in generation");
  62   T heap_oop = oopDesc::load_heap_oop(p);
  63   assert(!oopDesc::is_null(heap_oop), "expected non-null oop");
  64   oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
  65   // If p points to a younger generation, mark the card.
  66   if ((HeapWord*)obj < gen_boundary()) {
  67     rs()->write_ref_field_gc_par(p, obj);
  68   }
  69 }
  70 
  71 inline void OopsInKlassOrGenClosure::do_klass_barrier() {
  72   assert(_scanned_klass != NULL, "Must be");
  73   _scanned_klass->record_modified_oops();


  74 }
  75 
  76 // NOTE! Any changes made here should also be made
  77 // in FastScanClosure::do_oop_work()
  78 template <class T> inline void ScanClosure::do_oop_work(T* p) {
  79   T heap_oop = oopDesc::load_heap_oop(p);
  80   // Should we copy the obj?
  81   if (!oopDesc::is_null(heap_oop)) {
  82     oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
  83     if ((HeapWord*)obj < _boundary) {
  84       assert(!_g->to()->is_in_reserved(obj), "Scanning field twice?");
  85       oop new_obj = obj->is_forwarded() ? obj->forwardee()
  86                                         : _g->copy_to_survivor_space(obj);
  87       oopDesc::encode_store_heap_oop_not_null(p, new_obj);
  88     }
  89 
  90     if (is_scanning_a_klass()) {
  91       do_klass_barrier();
  92     } else if (_gc_barrier) {
  93       // Now call parent closure
  94       do_barrier(p);
  95     }
  96   }
  97 }
  98 
  99 inline void ScanClosure::do_oop_nv(oop* p)       { ScanClosure::do_oop_work(p); }
 100 inline void ScanClosure::do_oop_nv(narrowOop* p) { ScanClosure::do_oop_work(p); }
 101 
 102 // NOTE! Any changes made here should also be made
 103 // in ScanClosure::do_oop_work()
 104 template <class T> inline void FastScanClosure::do_oop_work(T* p) {
 105   T heap_oop = oopDesc::load_heap_oop(p);
 106   // Should we copy the obj?
 107   if (!oopDesc::is_null(heap_oop)) {
 108     oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
 109     if ((HeapWord*)obj < _boundary) {
 110       assert(!_g->to()->is_in_reserved(obj), "Scanning field twice?");
 111       oop new_obj = obj->is_forwarded() ? obj->forwardee()
 112                                         : _g->copy_to_survivor_space(obj);
 113       oopDesc::encode_store_heap_oop_not_null(p, new_obj);
 114       if (is_scanning_a_klass()) {
 115         do_klass_barrier();
 116       } else if (_gc_barrier) {
 117         // Now call parent closure
 118         do_barrier(p);
 119       }
 120     }
 121   }
 122 }
 123 
 124 inline void FastScanClosure::do_oop_nv(oop* p)       { FastScanClosure::do_oop_work(p); }
 125 inline void FastScanClosure::do_oop_nv(narrowOop* p) { FastScanClosure::do_oop_work(p); }
 126 
 127 template <class T> void FilteringClosure::do_oop_work(T* p) {
 128   T heap_oop = oopDesc::load_heap_oop(p);
 129   if (!oopDesc::is_null(heap_oop)) {
 130     oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
 131     if ((HeapWord*)obj < _boundary) {
 132       _cl->do_oop(p);
 133     }
 134   }
 135 }




  51   T heap_oop = oopDesc::load_heap_oop(p);
  52   assert(!oopDesc::is_null(heap_oop), "expected non-null oop");
  53   oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
  54   // If p points to a younger generation, mark the card.
  55   if ((HeapWord*)obj < _gen_boundary) {
  56     _rs->inline_write_ref_field_gc(p, obj);
  57   }
  58 }
  59 
  60 template <class T> inline void OopsInGenClosure::par_do_barrier(T* p) {
  61   assert(generation()->is_in_reserved(p), "expected ref in generation");
  62   T heap_oop = oopDesc::load_heap_oop(p);
  63   assert(!oopDesc::is_null(heap_oop), "expected non-null oop");
  64   oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
  65   // If p points to a younger generation, mark the card.
  66   if ((HeapWord*)obj < gen_boundary()) {
  67     rs()->write_ref_field_gc_par(p, obj);
  68   }
  69 }
  70 
  71 inline void OopsInClassLoaderDataOrGenClosure::do_cld_barrier() {
  72   assert(_scanned_cld != NULL, "Must be");
  73   if (!_scanned_cld->has_modified_oops()) {
  74     _scanned_cld->record_modified_oops();
  75   }
  76 }
  77 
  78 // NOTE! Any changes made here should also be made
  79 // in FastScanClosure::do_oop_work()
  80 template <class T> inline void ScanClosure::do_oop_work(T* p) {
  81   T heap_oop = oopDesc::load_heap_oop(p);
  82   // Should we copy the obj?
  83   if (!oopDesc::is_null(heap_oop)) {
  84     oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
  85     if ((HeapWord*)obj < _boundary) {
  86       assert(!_g->to()->is_in_reserved(obj), "Scanning field twice?");
  87       oop new_obj = obj->is_forwarded() ? obj->forwardee()
  88                                         : _g->copy_to_survivor_space(obj);
  89       oopDesc::encode_store_heap_oop_not_null(p, new_obj);
  90     }
  91 
  92     if (is_scanning_a_cld()) {
  93       do_cld_barrier();
  94     } else if (_gc_barrier) {
  95       // Now call parent closure
  96       do_barrier(p);
  97     }
  98   }
  99 }
 100 
 101 inline void ScanClosure::do_oop_nv(oop* p)       { ScanClosure::do_oop_work(p); }
 102 inline void ScanClosure::do_oop_nv(narrowOop* p) { ScanClosure::do_oop_work(p); }
 103 
 104 // NOTE! Any changes made here should also be made
 105 // in ScanClosure::do_oop_work()
 106 template <class T> inline void FastScanClosure::do_oop_work(T* p) {
 107   T heap_oop = oopDesc::load_heap_oop(p);
 108   // Should we copy the obj?
 109   if (!oopDesc::is_null(heap_oop)) {
 110     oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
 111     if ((HeapWord*)obj < _boundary) {
 112       assert(!_g->to()->is_in_reserved(obj), "Scanning field twice?");
 113       oop new_obj = obj->is_forwarded() ? obj->forwardee()
 114                                         : _g->copy_to_survivor_space(obj);
 115       oopDesc::encode_store_heap_oop_not_null(p, new_obj);
 116       if (is_scanning_a_cld()) {
 117         do_cld_barrier();
 118       } else if (_gc_barrier) {
 119         // Now call parent closure
 120         do_barrier(p);
 121       }
 122     }
 123   }
 124 }
 125 
 126 inline void FastScanClosure::do_oop_nv(oop* p)       { FastScanClosure::do_oop_work(p); }
 127 inline void FastScanClosure::do_oop_nv(narrowOop* p) { FastScanClosure::do_oop_work(p); }
 128 
 129 template <class T> void FilteringClosure::do_oop_work(T* p) {
 130   T heap_oop = oopDesc::load_heap_oop(p);
 131   if (!oopDesc::is_null(heap_oop)) {
 132     oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
 133     if ((HeapWord*)obj < _boundary) {
 134       _cl->do_oop(p);
 135     }
 136   }
 137 }


< prev index next >