29 #include "gc/shared/cardTableRS.hpp" |
29 #include "gc/shared/cardTableRS.hpp" |
30 #include "gc/shared/genCollectedHeap.hpp" |
30 #include "gc/shared/genCollectedHeap.hpp" |
31 #include "gc/shared/genOopClosures.hpp" |
31 #include "gc/shared/genOopClosures.hpp" |
32 #include "gc/shared/generation.hpp" |
32 #include "gc/shared/generation.hpp" |
33 #include "gc/shared/space.hpp" |
33 #include "gc/shared/space.hpp" |
|
34 #include "oops/access.inline.hpp" |
|
35 #include "oops/compressedOops.inline.hpp" |
34 |
36 |
35 inline OopsInGenClosure::OopsInGenClosure(Generation* gen) : |
37 inline OopsInGenClosure::OopsInGenClosure(Generation* gen) : |
36 ExtendedOopClosure(gen->ref_processor()), _orig_gen(gen), _rs(NULL) { |
38 ExtendedOopClosure(gen->ref_processor()), _orig_gen(gen), _rs(NULL) { |
37 set_generation(gen); |
39 set_generation(gen); |
38 } |
40 } |
46 } |
48 } |
47 } |
49 } |
48 |
50 |
49 template <class T> inline void OopsInGenClosure::do_barrier(T* p) { |
51 template <class T> inline void OopsInGenClosure::do_barrier(T* p) { |
50 assert(generation()->is_in_reserved(p), "expected ref in generation"); |
52 assert(generation()->is_in_reserved(p), "expected ref in generation"); |
51 T heap_oop = oopDesc::load_heap_oop(p); |
53 T heap_oop = RawAccess<>::oop_load(p); |
52 assert(!oopDesc::is_null(heap_oop), "expected non-null oop"); |
54 assert(!CompressedOops::is_null(heap_oop), "expected non-null oop"); |
53 oop obj = oopDesc::decode_heap_oop_not_null(heap_oop); |
55 oop obj = CompressedOops::decode_not_null(heap_oop); |
54 // If p points to a younger generation, mark the card. |
56 // If p points to a younger generation, mark the card. |
55 if ((HeapWord*)obj < _gen_boundary) { |
57 if ((HeapWord*)obj < _gen_boundary) { |
56 _rs->inline_write_ref_field_gc(p, obj); |
58 _rs->inline_write_ref_field_gc(p, obj); |
57 } |
59 } |
58 } |
60 } |
59 |
61 |
60 template <class T> inline void OopsInGenClosure::par_do_barrier(T* p) { |
62 template <class T> inline void OopsInGenClosure::par_do_barrier(T* p) { |
61 assert(generation()->is_in_reserved(p), "expected ref in generation"); |
63 assert(generation()->is_in_reserved(p), "expected ref in generation"); |
62 T heap_oop = oopDesc::load_heap_oop(p); |
64 T heap_oop = RawAccess<>::oop_load(p); |
63 assert(!oopDesc::is_null(heap_oop), "expected non-null oop"); |
65 assert(!CompressedOops::is_null(heap_oop), "expected non-null oop"); |
64 oop obj = oopDesc::decode_heap_oop_not_null(heap_oop); |
66 oop obj = CompressedOops::decode_not_null(heap_oop); |
65 // If p points to a younger generation, mark the card. |
67 // If p points to a younger generation, mark the card. |
66 if ((HeapWord*)obj < gen_boundary()) { |
68 if ((HeapWord*)obj < gen_boundary()) { |
67 rs()->write_ref_field_gc_par(p, obj); |
69 rs()->write_ref_field_gc_par(p, obj); |
68 } |
70 } |
69 } |
71 } |
76 } |
78 } |
77 |
79 |
78 // NOTE! Any changes made here should also be made |
80 // NOTE! Any changes made here should also be made |
79 // in FastScanClosure::do_oop_work() |
81 // in FastScanClosure::do_oop_work() |
80 template <class T> inline void ScanClosure::do_oop_work(T* p) { |
82 template <class T> inline void ScanClosure::do_oop_work(T* p) { |
81 T heap_oop = oopDesc::load_heap_oop(p); |
83 T heap_oop = RawAccess<>::oop_load(p); |
82 // Should we copy the obj? |
84 // Should we copy the obj? |
83 if (!oopDesc::is_null(heap_oop)) { |
85 if (!CompressedOops::is_null(heap_oop)) { |
84 oop obj = oopDesc::decode_heap_oop_not_null(heap_oop); |
86 oop obj = CompressedOops::decode_not_null(heap_oop); |
85 if ((HeapWord*)obj < _boundary) { |
87 if ((HeapWord*)obj < _boundary) { |
86 assert(!_g->to()->is_in_reserved(obj), "Scanning field twice?"); |
88 assert(!_g->to()->is_in_reserved(obj), "Scanning field twice?"); |
87 oop new_obj = obj->is_forwarded() ? obj->forwardee() |
89 oop new_obj = obj->is_forwarded() ? obj->forwardee() |
88 : _g->copy_to_survivor_space(obj); |
90 : _g->copy_to_survivor_space(obj); |
89 oopDesc::encode_store_heap_oop_not_null(p, new_obj); |
91 RawAccess<OOP_NOT_NULL>::oop_store(p, new_obj); |
90 } |
92 } |
91 |
93 |
92 if (is_scanning_a_cld()) { |
94 if (is_scanning_a_cld()) { |
93 do_cld_barrier(); |
95 do_cld_barrier(); |
94 } else if (_gc_barrier) { |
96 } else if (_gc_barrier) { |
102 inline void ScanClosure::do_oop_nv(narrowOop* p) { ScanClosure::do_oop_work(p); } |
104 inline void ScanClosure::do_oop_nv(narrowOop* p) { ScanClosure::do_oop_work(p); } |
103 |
105 |
104 // NOTE! Any changes made here should also be made |
106 // NOTE! Any changes made here should also be made |
105 // in ScanClosure::do_oop_work() |
107 // in ScanClosure::do_oop_work() |
106 template <class T> inline void FastScanClosure::do_oop_work(T* p) { |
108 template <class T> inline void FastScanClosure::do_oop_work(T* p) { |
107 T heap_oop = oopDesc::load_heap_oop(p); |
109 T heap_oop = RawAccess<>::oop_load(p); |
108 // Should we copy the obj? |
110 // Should we copy the obj? |
109 if (!oopDesc::is_null(heap_oop)) { |
111 if (!CompressedOops::is_null(heap_oop)) { |
110 oop obj = oopDesc::decode_heap_oop_not_null(heap_oop); |
112 oop obj = CompressedOops::decode_not_null(heap_oop); |
111 if ((HeapWord*)obj < _boundary) { |
113 if ((HeapWord*)obj < _boundary) { |
112 assert(!_g->to()->is_in_reserved(obj), "Scanning field twice?"); |
114 assert(!_g->to()->is_in_reserved(obj), "Scanning field twice?"); |
113 oop new_obj = obj->is_forwarded() ? obj->forwardee() |
115 oop new_obj = obj->is_forwarded() ? obj->forwardee() |
114 : _g->copy_to_survivor_space(obj); |
116 : _g->copy_to_survivor_space(obj); |
115 oopDesc::encode_store_heap_oop_not_null(p, new_obj); |
117 RawAccess<OOP_NOT_NULL>::oop_store(p, new_obj); |
116 if (is_scanning_a_cld()) { |
118 if (is_scanning_a_cld()) { |
117 do_cld_barrier(); |
119 do_cld_barrier(); |
118 } else if (_gc_barrier) { |
120 } else if (_gc_barrier) { |
119 // Now call parent closure |
121 // Now call parent closure |
120 do_barrier(p); |
122 do_barrier(p); |
125 |
127 |
126 inline void FastScanClosure::do_oop_nv(oop* p) { FastScanClosure::do_oop_work(p); } |
128 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); } |
129 inline void FastScanClosure::do_oop_nv(narrowOop* p) { FastScanClosure::do_oop_work(p); } |
128 |
130 |
129 template <class T> void FilteringClosure::do_oop_work(T* p) { |
131 template <class T> void FilteringClosure::do_oop_work(T* p) { |
130 T heap_oop = oopDesc::load_heap_oop(p); |
132 T heap_oop = RawAccess<>::oop_load(p); |
131 if (!oopDesc::is_null(heap_oop)) { |
133 if (!CompressedOops::is_null(heap_oop)) { |
132 oop obj = oopDesc::decode_heap_oop_not_null(heap_oop); |
134 oop obj = CompressedOops::decode_not_null(heap_oop); |
133 if ((HeapWord*)obj < _boundary) { |
135 if ((HeapWord*)obj < _boundary) { |
134 _cl->do_oop(p); |
136 _cl->do_oop(p); |
135 } |
137 } |
136 } |
138 } |
137 } |
139 } |
140 void FilteringClosure::do_oop_nv(narrowOop* p) { FilteringClosure::do_oop_work(p); } |
142 void FilteringClosure::do_oop_nv(narrowOop* p) { FilteringClosure::do_oop_work(p); } |
141 |
143 |
142 // Note similarity to ScanClosure; the difference is that |
144 // Note similarity to ScanClosure; the difference is that |
143 // the barrier set is taken care of outside this closure. |
145 // the barrier set is taken care of outside this closure. |
144 template <class T> inline void ScanWeakRefClosure::do_oop_work(T* p) { |
146 template <class T> inline void ScanWeakRefClosure::do_oop_work(T* p) { |
145 assert(!oopDesc::is_null(*p), "null weak reference?"); |
147 oop obj = RawAccess<OOP_NOT_NULL>::oop_load(p); |
146 oop obj = oopDesc::load_decode_heap_oop_not_null(p); |
|
147 // weak references are sometimes scanned twice; must check |
148 // weak references are sometimes scanned twice; must check |
148 // that to-space doesn't already contain this object |
149 // that to-space doesn't already contain this object |
149 if ((HeapWord*)obj < _boundary && !_g->to()->is_in_reserved(obj)) { |
150 if ((HeapWord*)obj < _boundary && !_g->to()->is_in_reserved(obj)) { |
150 oop new_obj = obj->is_forwarded() ? obj->forwardee() |
151 oop new_obj = obj->is_forwarded() ? obj->forwardee() |
151 : _g->copy_to_survivor_space(obj); |
152 : _g->copy_to_survivor_space(obj); |
152 oopDesc::encode_store_heap_oop_not_null(p, new_obj); |
153 RawAccess<OOP_NOT_NULL>::oop_store(p, new_obj); |
153 } |
154 } |
154 } |
155 } |
155 |
156 |
156 inline void ScanWeakRefClosure::do_oop_nv(oop* p) { ScanWeakRefClosure::do_oop_work(p); } |
157 inline void ScanWeakRefClosure::do_oop_nv(oop* p) { ScanWeakRefClosure::do_oop_work(p); } |
157 inline void ScanWeakRefClosure::do_oop_nv(narrowOop* p) { ScanWeakRefClosure::do_oop_work(p); } |
158 inline void ScanWeakRefClosure::do_oop_nv(narrowOop* p) { ScanWeakRefClosure::do_oop_work(p); } |