94 if (!CompressedOops::is_null(o)) {
95 oop obj = CompressedOops::decode_not_null(o);
96 if (_heap->in_collection_set(obj) || _traversal_set->is_in((HeapWord*)obj)) {
97 obj = ShenandoahBarrierSet::resolve_forwarded_not_null(obj);
98 RawAccess<IS_NOT_NULL>::oop_store(p, obj);
99 } else {
100 shenandoah_assert_not_forwarded(p, obj);
101 }
102 }
103 }
104
105 void ShenandoahTraversalUpdateRefsClosure::do_oop(oop* p) { do_oop_work(p); }
106 void ShenandoahTraversalUpdateRefsClosure::do_oop(narrowOop* p) { do_oop_work(p); }
107
108 ShenandoahEvacuateUpdateRootsClosure::ShenandoahEvacuateUpdateRootsClosure() :
109 _heap(ShenandoahHeap::heap()), _thread(Thread::current()) {
110 }
111
112 template <class T>
113 void ShenandoahEvacuateUpdateRootsClosure::do_oop_work(T* p) {
114 assert(_heap->is_evacuation_in_progress(), "Only do this when evacuation is in progress");
115
116 T o = RawAccess<>::oop_load(p);
117 if (! CompressedOops::is_null(o)) {
118 oop obj = CompressedOops::decode_not_null(o);
119 if (_heap->in_collection_set(obj)) {
120 shenandoah_assert_marked(p, obj);
121 oop resolved = ShenandoahBarrierSet::resolve_forwarded_not_null(obj);
122 if (resolved == obj) {
123 resolved = _heap->evacuate_object(obj, _thread);
124 }
125 RawAccess<IS_NOT_NULL>::oop_store(p, resolved);
126 }
127 }
128 }
129 void ShenandoahEvacuateUpdateRootsClosure::do_oop(oop* p) {
130 do_oop_work(p);
131 }
132
133 void ShenandoahEvacuateUpdateRootsClosure::do_oop(narrowOop* p) {
134 do_oop_work(p);
135 }
136
137 ShenandoahEvacUpdateOopStorageRootsClosure::ShenandoahEvacUpdateOopStorageRootsClosure() :
138 _heap(ShenandoahHeap::heap()), _thread(Thread::current()) {
139 }
140
141 void ShenandoahEvacUpdateOopStorageRootsClosure::do_oop(oop* p) {
142 assert(_heap->is_evacuation_in_progress(), "Only do this when evacuation is in progress");
143
144 oop obj = RawAccess<>::oop_load(p);
145 if (! CompressedOops::is_null(obj)) {
146 if (_heap->in_collection_set(obj)) {
147 shenandoah_assert_marked(p, obj);
148 oop resolved = ShenandoahBarrierSet::resolve_forwarded_not_null(obj);
149 if (resolved == obj) {
150 resolved = _heap->evacuate_object(obj, _thread);
151 }
152
153 Atomic::cmpxchg(p, obj, resolved);
154 }
155 }
156 }
157
158 void ShenandoahEvacUpdateOopStorageRootsClosure::do_oop(narrowOop* p) {
159 ShouldNotReachHere();
160 }
161
162 ShenandoahCodeBlobAndDisarmClosure::ShenandoahCodeBlobAndDisarmClosure(OopClosure* cl) :
163 CodeBlobToOopClosure(cl, true /* fix_relocations */),
164 _bs(BarrierSet::barrier_set()->barrier_set_nmethod()) {
165 }
166
167 void ShenandoahCodeBlobAndDisarmClosure::do_code_blob(CodeBlob* cb) {
168 nmethod* const nm = cb->as_nmethod_or_null();
169 if (nm != NULL && nm->oops_do_try_claim()) {
170 assert(!ShenandoahNMethod::gc_data(nm)->is_unregistered(), "Should not be here");
171 CodeBlobToOopClosure::do_code_blob(cb);
172 _bs->disarm(nm);
173 }
174 }
175
176 #ifdef ASSERT
177 template <class T>
178 void ShenandoahAssertNotForwardedClosure::do_oop_work(T* p) {
|
94 if (!CompressedOops::is_null(o)) {
95 oop obj = CompressedOops::decode_not_null(o);
96 if (_heap->in_collection_set(obj) || _traversal_set->is_in((HeapWord*)obj)) {
97 obj = ShenandoahBarrierSet::resolve_forwarded_not_null(obj);
98 RawAccess<IS_NOT_NULL>::oop_store(p, obj);
99 } else {
100 shenandoah_assert_not_forwarded(p, obj);
101 }
102 }
103 }
104
105 void ShenandoahTraversalUpdateRefsClosure::do_oop(oop* p) { do_oop_work(p); }
106 void ShenandoahTraversalUpdateRefsClosure::do_oop(narrowOop* p) { do_oop_work(p); }
107
108 ShenandoahEvacuateUpdateRootsClosure::ShenandoahEvacuateUpdateRootsClosure() :
109 _heap(ShenandoahHeap::heap()), _thread(Thread::current()) {
110 }
111
112 template <class T>
113 void ShenandoahEvacuateUpdateRootsClosure::do_oop_work(T* p) {
114 assert(_heap->is_concurrent_root_in_progress(), "Only do this when evacuation is in progress");
115
116 T o = RawAccess<>::oop_load(p);
117 if (! CompressedOops::is_null(o)) {
118 oop obj = CompressedOops::decode_not_null(o);
119 if (_heap->in_collection_set(obj)) {
120 assert(_heap->is_evacuation_in_progress(), "Only do this when evacuation is in progress");
121 shenandoah_assert_marked(p, obj);
122 oop resolved = ShenandoahBarrierSet::resolve_forwarded_not_null(obj);
123 if (resolved == obj) {
124 resolved = _heap->evacuate_object(obj, _thread);
125 }
126 RawAccess<IS_NOT_NULL>::oop_store(p, resolved);
127 }
128 }
129 }
130 void ShenandoahEvacuateUpdateRootsClosure::do_oop(oop* p) {
131 do_oop_work(p);
132 }
133
134 void ShenandoahEvacuateUpdateRootsClosure::do_oop(narrowOop* p) {
135 do_oop_work(p);
136 }
137
138 ShenandoahEvacUpdateCleanupRootsClosure::ShenandoahEvacUpdateCleanupRootsClosure() :
139 _heap(ShenandoahHeap::heap()), _thread(Thread::current()), _context(_heap->complete_marking_context()) {
140 }
141
142 void ShenandoahEvacUpdateCleanupRootsClosure::do_oop(oop* p) {
143 assert(_heap->is_concurrent_root_in_progress(), "Only do this when evacuation is in progress");
144
145 oop obj = RawAccess<>::oop_load(p);
146 if (! CompressedOops::is_null(obj)) {
147 if (!_context->is_marked(obj)) {
148 Atomic::cmpxchg(p, obj, (oop)NULL);
149 } else if (_heap->in_collection_set(obj)) {
150 assert(_heap->is_evacuation_in_progress(), "Only do this when evacuation is in progress");
151 shenandoah_assert_marked(p, obj);
152 oop resolved = ShenandoahBarrierSet::resolve_forwarded_not_null(obj);
153 if (resolved == obj) {
154 resolved = _heap->evacuate_object(obj, _thread);
155 }
156 Atomic::cmpxchg(p, obj, resolved);
157 }
158 }
159 }
160
161 void ShenandoahEvacUpdateCleanupRootsClosure::do_oop(narrowOop* p) {
162 ShouldNotReachHere();
163 }
164
165 ShenandoahCodeBlobAndDisarmClosure::ShenandoahCodeBlobAndDisarmClosure(OopClosure* cl) :
166 CodeBlobToOopClosure(cl, true /* fix_relocations */),
167 _bs(BarrierSet::barrier_set()->barrier_set_nmethod()) {
168 }
169
170 void ShenandoahCodeBlobAndDisarmClosure::do_code_blob(CodeBlob* cb) {
171 nmethod* const nm = cb->as_nmethod_or_null();
172 if (nm != NULL && nm->oops_do_try_claim()) {
173 assert(!ShenandoahNMethod::gc_data(nm)->is_unregistered(), "Should not be here");
174 CodeBlobToOopClosure::do_code_blob(cb);
175 _bs->disarm(nm);
176 }
177 }
178
179 #ifdef ASSERT
180 template <class T>
181 void ShenandoahAssertNotForwardedClosure::do_oop_work(T* p) {
|