68 if (G1StringDedup::is_enabled()) { 69 // We must enqueue the object before it is marked 70 // as we otherwise can't read the object's age. 71 G1StringDedup::enqueue_from_mark(obj); 72 } 73 #endif 74 // some marks may contain information we need to preserve so we store them away 75 // and overwrite the mark. We'll restore it at the end of markSweep. 76 markOop mark = obj->mark(); 77 obj->set_mark(markOopDesc::prototype()->set_marked()); 78 79 if (mark->must_be_preserved(obj)) { 80 preserve_mark(obj, mark); 81 } 82 } 83 84 template <class T> inline void MarkSweep::mark_and_push(T* p) { 85 T heap_oop = oopDesc::load_heap_oop(p); 86 if (!oopDesc::is_null(heap_oop)) { 87 oop obj = oopDesc::decode_heap_oop_not_null(heap_oop); 88 if (!obj->mark()->is_marked() && 89 !is_archive_object(obj)) { 90 mark_object(obj); 91 _marking_stack.push(obj); 92 } 93 } 94 } 95 96 inline void MarkSweep::follow_klass(Klass* klass) { 97 oop op = klass->klass_holder(); 98 MarkSweep::mark_and_push(&op); 99 } 100 101 inline void MarkSweep::follow_cld(ClassLoaderData* cld) { 102 MarkSweep::follow_cld_closure.do_cld(cld); 103 } 104 105 template <typename T> 106 inline void MarkAndPushClosure::do_oop_nv(T* p) { MarkSweep::mark_and_push(p); } 107 void MarkAndPushClosure::do_oop(oop* p) { do_oop_nv(p); } 165 follow_object(obj); 166 } 167 // Process ObjArrays one at a time to avoid marking stack bloat. 168 if (!_objarray_stack.is_empty()) { 169 ObjArrayTask task = _objarray_stack.pop(); 170 follow_array_chunk(objArrayOop(task.obj()), task.index()); 171 } 172 } while (!_marking_stack.is_empty() || !_objarray_stack.is_empty()); 173 } 174 175 MarkSweep::FollowStackClosure MarkSweep::follow_stack_closure; 176 177 void MarkSweep::FollowStackClosure::do_void() { follow_stack(); } 178 179 template <class T> inline void MarkSweep::follow_root(T* p) { 180 assert(!Universe::heap()->is_in_reserved(p), 181 "roots shouldn't be things within the heap"); 182 T heap_oop = oopDesc::load_heap_oop(p); 183 if (!oopDesc::is_null(heap_oop)) { 184 oop obj = oopDesc::decode_heap_oop_not_null(heap_oop); 185 if (!obj->mark()->is_marked() && 186 !is_archive_object(obj)) { 187 mark_object(obj); 188 follow_object(obj); 189 } 190 } 191 follow_stack(); 192 } 193 194 void MarkSweep::FollowRootClosure::do_oop(oop* p) { follow_root(p); } 195 void MarkSweep::FollowRootClosure::do_oop(narrowOop* p) { follow_root(p); } 196 197 void PreservedMark::adjust_pointer() { 198 MarkSweep::adjust_pointer(&_obj); 199 } 200 201 void PreservedMark::restore() { 202 _obj->set_mark(_mark); 203 } 204 | 68 if (G1StringDedup::is_enabled()) { 69 // We must enqueue the object before it is marked 70 // as we otherwise can't read the object's age. 71 G1StringDedup::enqueue_from_mark(obj); 72 } 73 #endif 74 // some marks may contain information we need to preserve so we store them away 75 // and overwrite the mark. We'll restore it at the end of markSweep. 76 markOop mark = obj->mark(); 77 obj->set_mark(markOopDesc::prototype()->set_marked()); 78 79 if (mark->must_be_preserved(obj)) { 80 preserve_mark(obj, mark); 81 } 82 } 83 84 template <class T> inline void MarkSweep::mark_and_push(T* p) { 85 T heap_oop = oopDesc::load_heap_oop(p); 86 if (!oopDesc::is_null(heap_oop)) { 87 oop obj = oopDesc::decode_heap_oop_not_null(heap_oop); 88 if (UseShenandoahGC) { 89 obj = ShenandoahBarrierSet::resolve_and_update_oop_static(p, obj); 90 } 91 if (!obj->mark()->is_marked() && 92 !is_archive_object(obj)) { 93 mark_object(obj); 94 _marking_stack.push(obj); 95 } 96 } 97 } 98 99 inline void MarkSweep::follow_klass(Klass* klass) { 100 oop op = klass->klass_holder(); 101 MarkSweep::mark_and_push(&op); 102 } 103 104 inline void MarkSweep::follow_cld(ClassLoaderData* cld) { 105 MarkSweep::follow_cld_closure.do_cld(cld); 106 } 107 108 template <typename T> 109 inline void MarkAndPushClosure::do_oop_nv(T* p) { MarkSweep::mark_and_push(p); } 110 void MarkAndPushClosure::do_oop(oop* p) { do_oop_nv(p); } 168 follow_object(obj); 169 } 170 // Process ObjArrays one at a time to avoid marking stack bloat. 171 if (!_objarray_stack.is_empty()) { 172 ObjArrayTask task = _objarray_stack.pop(); 173 follow_array_chunk(objArrayOop(task.obj()), task.index()); 174 } 175 } while (!_marking_stack.is_empty() || !_objarray_stack.is_empty()); 176 } 177 178 MarkSweep::FollowStackClosure MarkSweep::follow_stack_closure; 179 180 void MarkSweep::FollowStackClosure::do_void() { follow_stack(); } 181 182 template <class T> inline void MarkSweep::follow_root(T* p) { 183 assert(!Universe::heap()->is_in_reserved(p), 184 "roots shouldn't be things within the heap"); 185 T heap_oop = oopDesc::load_heap_oop(p); 186 if (!oopDesc::is_null(heap_oop)) { 187 oop obj = oopDesc::decode_heap_oop_not_null(heap_oop); 188 if (UseShenandoahGC) { 189 obj = ShenandoahBarrierSet::resolve_and_update_oop_static(p, obj); 190 } 191 if (!obj->mark()->is_marked() && 192 !is_archive_object(obj)) { 193 mark_object(obj); 194 follow_object(obj); 195 } 196 } 197 follow_stack(); 198 } 199 200 void MarkSweep::FollowRootClosure::do_oop(oop* p) { follow_root(p); } 201 void MarkSweep::FollowRootClosure::do_oop(narrowOop* p) { follow_root(p); } 202 203 void PreservedMark::adjust_pointer() { 204 MarkSweep::adjust_pointer(&_obj); 205 } 206 207 void PreservedMark::restore() { 208 _obj->set_mark(_mark); 209 } 210 |