233 void MarkSweep::adjust_marks() {
234 assert( _preserved_oop_stack.size() == _preserved_mark_stack.size(),
235 "inconsistent preserved oop stacks");
236
237 // adjust the oops we saved earlier
238 for (size_t i = 0; i < _preserved_count; i++) {
239 _preserved_marks[i].adjust_pointer();
240 }
241
242 // deal with the overflow stack
243 StackIterator<oop, mtGC> iter(_preserved_oop_stack);
244 while (!iter.is_empty()) {
245 oop* p = iter.next_addr();
246 adjust_pointer(p);
247 }
248 }
249
250 void MarkSweep::restore_marks() {
251 assert(_preserved_oop_stack.size() == _preserved_mark_stack.size(),
252 "inconsistent preserved oop stacks");
253 if (PrintGC && Verbose) {
254 gclog_or_tty->print_cr("Restoring " SIZE_FORMAT " marks",
255 _preserved_count + _preserved_oop_stack.size());
256 }
257
258 // restore the marks we saved earlier
259 for (size_t i = 0; i < _preserved_count; i++) {
260 _preserved_marks[i].restore();
261 }
262
263 // deal with the overflow
264 while (!_preserved_oop_stack.is_empty()) {
265 oop obj = _preserved_oop_stack.pop();
266 markOop mark = _preserved_mark_stack.pop();
267 obj->set_mark(mark);
268 }
269 }
270
271 MarkSweep::IsAliveClosure MarkSweep::is_alive;
272
273 bool MarkSweep::IsAliveClosure::do_object_b(oop p) { return p->is_gc_marked() || is_archive_object(p); }
274
275 MarkSweep::KeepAliveClosure MarkSweep::keep_alive;
276
288 return size;
289 }
290
291 int InstanceMirrorKlass::oop_ms_adjust_pointers(oop obj) {
292 int size = oop_size(obj);
293 InstanceKlass::oop_ms_adjust_pointers(obj);
294
295 oop_oop_iterate_statics<true>(obj, &MarkSweep::adjust_pointer_closure);
296 return size;
297 }
298
299 int InstanceClassLoaderKlass::oop_ms_adjust_pointers(oop obj) {
300 return InstanceKlass::oop_ms_adjust_pointers(obj);
301 }
302
303 #ifdef ASSERT
304 template <class T> static void trace_reference_gc(const char *s, oop obj,
305 T* referent_addr,
306 T* next_addr,
307 T* discovered_addr) {
308 if(TraceReferenceGC && PrintGCDetails) {
309 gclog_or_tty->print_cr("%s obj " PTR_FORMAT, s, p2i(obj));
310 gclog_or_tty->print_cr(" referent_addr/* " PTR_FORMAT " / "
311 PTR_FORMAT, p2i(referent_addr),
312 p2i(referent_addr ?
313 (address)oopDesc::load_decode_heap_oop(referent_addr) : NULL));
314 gclog_or_tty->print_cr(" next_addr/* " PTR_FORMAT " / "
315 PTR_FORMAT, p2i(next_addr),
316 p2i(next_addr ? (address)oopDesc::load_decode_heap_oop(next_addr) : NULL));
317 gclog_or_tty->print_cr(" discovered_addr/* " PTR_FORMAT " / "
318 PTR_FORMAT, p2i(discovered_addr),
319 p2i(discovered_addr ?
320 (address)oopDesc::load_decode_heap_oop(discovered_addr) : NULL));
321 }
322 }
323 #endif
324
325 template <class T> void static adjust_object_specialized(oop obj) {
326 T* referent_addr = (T*)java_lang_ref_Reference::referent_addr(obj);
327 MarkSweep::adjust_pointer(referent_addr);
328 T* next_addr = (T*)java_lang_ref_Reference::next_addr(obj);
329 MarkSweep::adjust_pointer(next_addr);
330 T* discovered_addr = (T*)java_lang_ref_Reference::discovered_addr(obj);
331 MarkSweep::adjust_pointer(discovered_addr);
332 debug_only(trace_reference_gc("InstanceRefKlass::oop_ms_adjust_pointers", obj,
333 referent_addr, next_addr, discovered_addr);)
334 }
335
336 int InstanceRefKlass::oop_ms_adjust_pointers(oop obj) {
337 int size = size_helper();
338 InstanceKlass::oop_ms_adjust_pointers(obj);
339
340 if (UseCompressedOops) {
341 adjust_object_specialized<narrowOop>(obj);
|
233 void MarkSweep::adjust_marks() {
234 assert( _preserved_oop_stack.size() == _preserved_mark_stack.size(),
235 "inconsistent preserved oop stacks");
236
237 // adjust the oops we saved earlier
238 for (size_t i = 0; i < _preserved_count; i++) {
239 _preserved_marks[i].adjust_pointer();
240 }
241
242 // deal with the overflow stack
243 StackIterator<oop, mtGC> iter(_preserved_oop_stack);
244 while (!iter.is_empty()) {
245 oop* p = iter.next_addr();
246 adjust_pointer(p);
247 }
248 }
249
250 void MarkSweep::restore_marks() {
251 assert(_preserved_oop_stack.size() == _preserved_mark_stack.size(),
252 "inconsistent preserved oop stacks");
253 log_trace(gc)("Restoring " SIZE_FORMAT " marks", _preserved_count + _preserved_oop_stack.size());
254
255 // restore the marks we saved earlier
256 for (size_t i = 0; i < _preserved_count; i++) {
257 _preserved_marks[i].restore();
258 }
259
260 // deal with the overflow
261 while (!_preserved_oop_stack.is_empty()) {
262 oop obj = _preserved_oop_stack.pop();
263 markOop mark = _preserved_mark_stack.pop();
264 obj->set_mark(mark);
265 }
266 }
267
268 MarkSweep::IsAliveClosure MarkSweep::is_alive;
269
270 bool MarkSweep::IsAliveClosure::do_object_b(oop p) { return p->is_gc_marked() || is_archive_object(p); }
271
272 MarkSweep::KeepAliveClosure MarkSweep::keep_alive;
273
285 return size;
286 }
287
288 int InstanceMirrorKlass::oop_ms_adjust_pointers(oop obj) {
289 int size = oop_size(obj);
290 InstanceKlass::oop_ms_adjust_pointers(obj);
291
292 oop_oop_iterate_statics<true>(obj, &MarkSweep::adjust_pointer_closure);
293 return size;
294 }
295
296 int InstanceClassLoaderKlass::oop_ms_adjust_pointers(oop obj) {
297 return InstanceKlass::oop_ms_adjust_pointers(obj);
298 }
299
300 #ifdef ASSERT
301 template <class T> static void trace_reference_gc(const char *s, oop obj,
302 T* referent_addr,
303 T* next_addr,
304 T* discovered_addr) {
305 log_develop(gc, ref)("%s obj " PTR_FORMAT, s, p2i(obj));
306 log_develop(gc, ref)(" referent_addr/* " PTR_FORMAT " / " PTR_FORMAT,
307 p2i(referent_addr), p2i(referent_addr ? (address)oopDesc::load_decode_heap_oop(referent_addr) : NULL));
308 log_develop(gc, ref)(" next_addr/* " PTR_FORMAT " / " PTR_FORMAT,
309 p2i(next_addr), p2i(next_addr ? (address)oopDesc::load_decode_heap_oop(next_addr) : NULL));
310 log_develop(gc, ref)(" discovered_addr/* " PTR_FORMAT " / " PTR_FORMAT,
311 p2i(discovered_addr), p2i(discovered_addr ? (address)oopDesc::load_decode_heap_oop(discovered_addr) : NULL));
312 }
313 #endif
314
315 template <class T> void static adjust_object_specialized(oop obj) {
316 T* referent_addr = (T*)java_lang_ref_Reference::referent_addr(obj);
317 MarkSweep::adjust_pointer(referent_addr);
318 T* next_addr = (T*)java_lang_ref_Reference::next_addr(obj);
319 MarkSweep::adjust_pointer(next_addr);
320 T* discovered_addr = (T*)java_lang_ref_Reference::discovered_addr(obj);
321 MarkSweep::adjust_pointer(discovered_addr);
322 debug_only(trace_reference_gc("InstanceRefKlass::oop_ms_adjust_pointers", obj,
323 referent_addr, next_addr, discovered_addr);)
324 }
325
326 int InstanceRefKlass::oop_ms_adjust_pointers(oop obj) {
327 int size = size_helper();
328 InstanceKlass::oop_ms_adjust_pointers(obj);
329
330 if (UseCompressedOops) {
331 adjust_object_specialized<narrowOop>(obj);
|