< prev index next >

src/share/vm/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 }
 136 




  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 // NOTE! Any changes made here should also be made
  72 // in FastScanClosure::do_oop_work()
  73 template <class T> inline void ScanClosure::do_oop_work(T* p) {
  74   T heap_oop = oopDesc::load_heap_oop(p);
  75   // Should we copy the obj?
  76   if (!oopDesc::is_null(heap_oop)) {
  77     oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
  78     if ((HeapWord*)obj < _boundary) {
  79       assert(!_g->to()->is_in_reserved(obj), "Scanning field twice?");
  80       oop new_obj = obj->is_forwarded() ? obj->forwardee()
  81                                         : _g->copy_to_survivor_space(obj);
  82       oopDesc::encode_store_heap_oop_not_null(p, new_obj);
  83     }
  84 
  85     if (_gc_barrier) {


  86       // Now call parent closure
  87       do_barrier(p);
  88     }
  89   }
  90 }
  91 
  92 inline void ScanClosure::do_oop_nv(oop* p)       { ScanClosure::do_oop_work(p); }
  93 inline void ScanClosure::do_oop_nv(narrowOop* p) { ScanClosure::do_oop_work(p); }
  94 
  95 // NOTE! Any changes made here should also be made
  96 // in ScanClosure::do_oop_work()
  97 template <class T> inline void FastScanClosure::do_oop_work(T* p) {
  98   T heap_oop = oopDesc::load_heap_oop(p);
  99   // Should we copy the obj?
 100   if (!oopDesc::is_null(heap_oop)) {
 101     oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
 102     if ((HeapWord*)obj < _boundary) {
 103       assert(!_g->to()->is_in_reserved(obj), "Scanning field twice?");
 104       oop new_obj = obj->is_forwarded() ? obj->forwardee()
 105                                         : _g->copy_to_survivor_space(obj);
 106       oopDesc::encode_store_heap_oop_not_null(p, new_obj);
 107       if (_gc_barrier) {


 108         // Now call parent closure
 109         do_barrier(p);
 110       }
 111     }
 112   }
 113 }
 114 
 115 inline void FastScanClosure::do_oop_nv(oop* p)       { FastScanClosure::do_oop_work(p); }
 116 inline void FastScanClosure::do_oop_nv(narrowOop* p) { FastScanClosure::do_oop_work(p); }
 117 
 118 template <class T> void FilteringClosure::do_oop_work(T* p) {
 119   T heap_oop = oopDesc::load_heap_oop(p);
 120   if (!oopDesc::is_null(heap_oop)) {
 121     oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
 122     if ((HeapWord*)obj < _boundary) {
 123       _cl->do_oop(p);
 124     }
 125   }
 126 }
 127 


< prev index next >