hotspot/src/share/vm/oops/instanceRefKlass.cpp
Print this page
rev 611 : Merge
*** 1,10 ****
#ifdef USE_PRAGMA_IDENT_SRC
#pragma ident "@(#)instanceRefKlass.cpp 1.90 07/05/29 09:44:20 JVM"
#endif
/*
! * Copyright 1997-2006 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
--- 1,10 ----
#ifdef USE_PRAGMA_IDENT_SRC
#pragma ident "@(#)instanceRefKlass.cpp 1.90 07/05/29 09:44:20 JVM"
#endif
/*
! * Copyright 1997-2008 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*** 26,323 ****
*/
# include "incls/_precompiled.incl"
# include "incls/_instanceRefKlass.cpp.incl"
! void instanceRefKlass::oop_follow_contents(oop obj) {
! oop* referent_addr = java_lang_ref_Reference::referent_addr(obj);
! oop referent = *referent_addr;
debug_only(
if(TraceReferenceGC && PrintGCDetails) {
! gclog_or_tty->print_cr("instanceRefKlass::oop_follow_contents " INTPTR_FORMAT, (address)obj);
}
)
if (referent != NULL) {
if (!referent->is_gc_marked() &&
MarkSweep::ref_processor()->
! discover_reference(obj, reference_type())) {
// reference already enqueued, referent will be traversed later
! instanceKlass::oop_follow_contents(obj);
debug_only(
if(TraceReferenceGC && PrintGCDetails) {
! gclog_or_tty->print_cr(" Non NULL enqueued " INTPTR_FORMAT, (address)obj);
}
)
return;
} else {
// treat referent as normal oop
debug_only(
if(TraceReferenceGC && PrintGCDetails) {
! gclog_or_tty->print_cr(" Non NULL normal " INTPTR_FORMAT, (address)obj);
}
)
MarkSweep::mark_and_push(referent_addr);
}
}
// treat next as normal oop. next is a link in the pending list.
! oop* next_addr = java_lang_ref_Reference::next_addr(obj);
debug_only(
if(TraceReferenceGC && PrintGCDetails) {
gclog_or_tty->print_cr(" Process next as normal " INTPTR_FORMAT, next_addr);
}
)
MarkSweep::mark_and_push(next_addr);
! instanceKlass::oop_follow_contents(obj);
}
#ifndef SERIALGC
! void instanceRefKlass::oop_follow_contents(ParCompactionManager* cm,
oop obj) {
! oop* referent_addr = java_lang_ref_Reference::referent_addr(obj);
! oop referent = *referent_addr;
debug_only(
if(TraceReferenceGC && PrintGCDetails) {
! gclog_or_tty->print_cr("instanceRefKlass::oop_follow_contents " INTPTR_FORMAT, (address)obj);
}
)
if (referent != NULL) {
if (PSParallelCompact::mark_bitmap()->is_unmarked(referent) &&
PSParallelCompact::ref_processor()->
! discover_reference(obj, reference_type())) {
// reference already enqueued, referent will be traversed later
! instanceKlass::oop_follow_contents(cm, obj);
debug_only(
if(TraceReferenceGC && PrintGCDetails) {
! gclog_or_tty->print_cr(" Non NULL enqueued " INTPTR_FORMAT, (address)obj);
}
)
return;
} else {
// treat referent as normal oop
debug_only(
if(TraceReferenceGC && PrintGCDetails) {
! gclog_or_tty->print_cr(" Non NULL normal " INTPTR_FORMAT, (address)obj);
}
)
PSParallelCompact::mark_and_push(cm, referent_addr);
}
}
// treat next as normal oop. next is a link in the pending list.
! oop* next_addr = java_lang_ref_Reference::next_addr(obj);
debug_only(
if(TraceReferenceGC && PrintGCDetails) {
gclog_or_tty->print_cr(" Process next as normal " INTPTR_FORMAT, next_addr);
}
)
PSParallelCompact::mark_and_push(cm, next_addr);
! instanceKlass::oop_follow_contents(cm, obj);
}
- #endif // SERIALGC
-
! int instanceRefKlass::oop_adjust_pointers(oop obj) {
! int size = size_helper();
! instanceKlass::oop_adjust_pointers(obj);
!
! oop* referent_addr = java_lang_ref_Reference::referent_addr(obj);
! MarkSweep::adjust_pointer(referent_addr);
! oop* next_addr = java_lang_ref_Reference::next_addr(obj);
! MarkSweep::adjust_pointer(next_addr);
! oop* discovered_addr = java_lang_ref_Reference::discovered_addr(obj);
! MarkSweep::adjust_pointer(discovered_addr);
#ifdef ASSERT
if(TraceReferenceGC && PrintGCDetails) {
! gclog_or_tty->print_cr("instanceRefKlass::oop_adjust_pointers obj "
! INTPTR_FORMAT, (address)obj);
gclog_or_tty->print_cr(" referent_addr/* " INTPTR_FORMAT " / "
INTPTR_FORMAT, referent_addr,
! referent_addr ? (address)*referent_addr : NULL);
gclog_or_tty->print_cr(" next_addr/* " INTPTR_FORMAT " / "
INTPTR_FORMAT, next_addr,
! next_addr ? (address)*next_addr : NULL);
gclog_or_tty->print_cr(" discovered_addr/* " INTPTR_FORMAT " / "
INTPTR_FORMAT, discovered_addr,
! discovered_addr ? (address)*discovered_addr : NULL);
}
#endif
return size;
}
! #define InstanceRefKlass_OOP_OOP_ITERATE_DEFN(OopClosureType, nv_suffix) \
! \
! int instanceRefKlass:: \
! oop_oop_iterate##nv_suffix(oop obj, OopClosureType* closure) { \
! /* Get size before changing pointers */ \
! SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::irk);\
! \
! int size = instanceKlass::oop_oop_iterate##nv_suffix(obj, closure); \
\
! oop* referent_addr = java_lang_ref_Reference::referent_addr(obj); \
! oop referent = *referent_addr; \
! if (referent != NULL) { \
ReferenceProcessor* rp = closure->_ref_processor; \
if (!referent->is_gc_marked() && (rp != NULL) && \
rp->discover_reference(obj, reference_type())) { \
return size; \
} else { \
/* treat referent as normal oop */ \
SpecializationStats::record_do_oop_call##nv_suffix(SpecializationStats::irk);\
closure->do_oop##nv_suffix(referent_addr); \
} \
} \
- \
/* treat next as normal oop */ \
! oop* next_addr = java_lang_ref_Reference::next_addr(obj); \
SpecializationStats::record_do_oop_call##nv_suffix(SpecializationStats::irk); \
closure->do_oop##nv_suffix(next_addr); \
return size; \
}
#define InstanceRefKlass_OOP_OOP_ITERATE_DEFN_m(OopClosureType, nv_suffix) \
\
int instanceRefKlass:: \
oop_oop_iterate##nv_suffix##_m(oop obj, \
OopClosureType* closure, \
MemRegion mr) { \
SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::irk);\
\
int size = instanceKlass::oop_oop_iterate##nv_suffix##_m(obj, closure, mr); \
! \
! oop* referent_addr = java_lang_ref_Reference::referent_addr(obj); \
! oop referent = *referent_addr; \
! if (referent != NULL && mr.contains(referent_addr)) { \
! ReferenceProcessor* rp = closure->_ref_processor; \
! if (!referent->is_gc_marked() && (rp != NULL) && \
! rp->discover_reference(obj, reference_type())) { \
! return size; \
} else { \
! /* treat referent as normal oop */ \
! SpecializationStats::record_do_oop_call##nv_suffix(SpecializationStats::irk);\
! closure->do_oop##nv_suffix(referent_addr); \
! } \
} \
- \
- /* treat next as normal oop */ \
- oop* next_addr = java_lang_ref_Reference::next_addr(obj); \
- if (mr.contains(next_addr)) { \
- SpecializationStats::record_do_oop_call##nv_suffix(SpecializationStats::irk);\
- closure->do_oop##nv_suffix(next_addr); \
- } \
- return size; \
}
ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceRefKlass_OOP_OOP_ITERATE_DEFN)
! ALL_OOP_OOP_ITERATE_CLOSURES_3(InstanceRefKlass_OOP_OOP_ITERATE_DEFN)
ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceRefKlass_OOP_OOP_ITERATE_DEFN_m)
! ALL_OOP_OOP_ITERATE_CLOSURES_3(InstanceRefKlass_OOP_OOP_ITERATE_DEFN_m)
!
#ifndef SERIALGC
! void instanceRefKlass::oop_copy_contents(PSPromotionManager* pm, oop obj) {
assert(!pm->depth_first(), "invariant");
! oop* referent_addr = java_lang_ref_Reference::referent_addr(obj);
! if (PSScavenge::should_scavenge(*referent_addr)) {
ReferenceProcessor* rp = PSScavenge::reference_processor();
! if (rp->discover_reference(obj, reference_type())) {
// reference already enqueued, referent and next will be traversed later
! instanceKlass::oop_copy_contents(pm, obj);
return;
} else {
// treat referent as normal oop
pm->claim_or_forward_breadth(referent_addr);
}
}
// treat next as normal oop
! oop* next_addr = java_lang_ref_Reference::next_addr(obj);
! if (PSScavenge::should_scavenge(*next_addr)) {
pm->claim_or_forward_breadth(next_addr);
}
! instanceKlass::oop_copy_contents(pm, obj);
}
! void instanceRefKlass::oop_push_contents(PSPromotionManager* pm, oop obj) {
assert(pm->depth_first(), "invariant");
! oop* referent_addr = java_lang_ref_Reference::referent_addr(obj);
! if (PSScavenge::should_scavenge(*referent_addr)) {
ReferenceProcessor* rp = PSScavenge::reference_processor();
! if (rp->discover_reference(obj, reference_type())) {
// reference already enqueued, referent and next will be traversed later
! instanceKlass::oop_push_contents(pm, obj);
return;
} else {
// treat referent as normal oop
pm->claim_or_forward_depth(referent_addr);
}
}
// treat next as normal oop
! oop* next_addr = java_lang_ref_Reference::next_addr(obj);
! if (PSScavenge::should_scavenge(*next_addr)) {
pm->claim_or_forward_depth(next_addr);
}
! instanceKlass::oop_push_contents(pm, obj);
}
! int instanceRefKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) {
! instanceKlass::oop_update_pointers(cm, obj);
! oop* referent_addr = java_lang_ref_Reference::referent_addr(obj);
PSParallelCompact::adjust_pointer(referent_addr);
! oop* next_addr = java_lang_ref_Reference::next_addr(obj);
PSParallelCompact::adjust_pointer(next_addr);
! oop* discovered_addr = java_lang_ref_Reference::discovered_addr(obj);
PSParallelCompact::adjust_pointer(discovered_addr);
! #ifdef ASSERT
! if(TraceReferenceGC && PrintGCDetails) {
! gclog_or_tty->print_cr("instanceRefKlass::oop_update_pointers obj "
! INTPTR_FORMAT, (oopDesc*) obj);
! gclog_or_tty->print_cr(" referent_addr/* " INTPTR_FORMAT " / "
! INTPTR_FORMAT, referent_addr,
! referent_addr ? (oopDesc*) *referent_addr : NULL);
! gclog_or_tty->print_cr(" next_addr/* " INTPTR_FORMAT " / "
! INTPTR_FORMAT, next_addr,
! next_addr ? (oopDesc*) *next_addr : NULL);
! gclog_or_tty->print_cr(" discovered_addr/* " INTPTR_FORMAT " / "
! INTPTR_FORMAT, discovered_addr,
! discovered_addr ? (oopDesc*) *discovered_addr : NULL);
}
- #endif
-
return size_helper();
}
- int
- instanceRefKlass::oop_update_pointers(ParCompactionManager* cm, oop obj,
- HeapWord* beg_addr, HeapWord* end_addr) {
- instanceKlass::oop_update_pointers(cm, obj, beg_addr, end_addr);
! oop* p;
! oop* referent_addr = p = java_lang_ref_Reference::referent_addr(obj);
PSParallelCompact::adjust_pointer(p, beg_addr, end_addr);
! oop* next_addr = p = java_lang_ref_Reference::next_addr(obj);
PSParallelCompact::adjust_pointer(p, beg_addr, end_addr);
! oop* discovered_addr = p = java_lang_ref_Reference::discovered_addr(obj);
PSParallelCompact::adjust_pointer(p, beg_addr, end_addr);
! #ifdef ASSERT
! if(TraceReferenceGC && PrintGCDetails) {
! gclog_or_tty->print_cr("instanceRefKlass::oop_update_pointers obj "
! INTPTR_FORMAT, (oopDesc*) obj);
! gclog_or_tty->print_cr(" referent_addr/* " INTPTR_FORMAT " / "
! INTPTR_FORMAT, referent_addr,
! referent_addr ? (oopDesc*) *referent_addr : NULL);
! gclog_or_tty->print_cr(" next_addr/* " INTPTR_FORMAT " / "
! INTPTR_FORMAT, next_addr,
! next_addr ? (oopDesc*) *next_addr : NULL);
! gclog_or_tty->print_cr(" discovered_addr/* " INTPTR_FORMAT " / "
! INTPTR_FORMAT, discovered_addr,
! discovered_addr ? (oopDesc*) *discovered_addr : NULL);
}
- #endif
-
return size_helper();
}
#endif // SERIALGC
void instanceRefKlass::update_nonstatic_oop_maps(klassOop k) {
--- 26,390 ----
*/
# include "incls/_precompiled.incl"
# include "incls/_instanceRefKlass.cpp.incl"
! template <class T>
! static void specialized_oop_follow_contents(instanceRefKlass* ref, oop obj) {
! T* referent_addr = (T*)java_lang_ref_Reference::referent_addr(obj);
! oop referent = oopDesc::load_decode_heap_oop(referent_addr);
debug_only(
if(TraceReferenceGC && PrintGCDetails) {
! gclog_or_tty->print_cr("instanceRefKlass::oop_follow_contents " INTPTR_FORMAT, obj);
}
)
if (referent != NULL) {
if (!referent->is_gc_marked() &&
MarkSweep::ref_processor()->
! discover_reference(obj, ref->reference_type())) {
// reference already enqueued, referent will be traversed later
! ref->instanceKlass::oop_follow_contents(obj);
debug_only(
if(TraceReferenceGC && PrintGCDetails) {
! gclog_or_tty->print_cr(" Non NULL enqueued " INTPTR_FORMAT, obj);
}
)
return;
} else {
// treat referent as normal oop
debug_only(
if(TraceReferenceGC && PrintGCDetails) {
! gclog_or_tty->print_cr(" Non NULL normal " INTPTR_FORMAT, obj);
}
)
MarkSweep::mark_and_push(referent_addr);
}
}
// treat next as normal oop. next is a link in the pending list.
! T* next_addr = (T*)java_lang_ref_Reference::next_addr(obj);
debug_only(
if(TraceReferenceGC && PrintGCDetails) {
gclog_or_tty->print_cr(" Process next as normal " INTPTR_FORMAT, next_addr);
}
)
MarkSweep::mark_and_push(next_addr);
! ref->instanceKlass::oop_follow_contents(obj);
! }
!
! void instanceRefKlass::oop_follow_contents(oop obj) {
! if (UseCompressedOops) {
! specialized_oop_follow_contents<narrowOop>(this, obj);
! } else {
! specialized_oop_follow_contents<oop>(this, obj);
! }
}
#ifndef SERIALGC
! template <class T>
! static void specialized_oop_follow_contents(instanceRefKlass* ref,
! ParCompactionManager* cm,
oop obj) {
! T* referent_addr = (T*)java_lang_ref_Reference::referent_addr(obj);
! oop referent = oopDesc::load_decode_heap_oop(referent_addr);
debug_only(
if(TraceReferenceGC && PrintGCDetails) {
! gclog_or_tty->print_cr("instanceRefKlass::oop_follow_contents " INTPTR_FORMAT, obj);
}
)
if (referent != NULL) {
if (PSParallelCompact::mark_bitmap()->is_unmarked(referent) &&
PSParallelCompact::ref_processor()->
! discover_reference(obj, ref->reference_type())) {
// reference already enqueued, referent will be traversed later
! ref->instanceKlass::oop_follow_contents(cm, obj);
debug_only(
if(TraceReferenceGC && PrintGCDetails) {
! gclog_or_tty->print_cr(" Non NULL enqueued " INTPTR_FORMAT, obj);
}
)
return;
} else {
// treat referent as normal oop
debug_only(
if(TraceReferenceGC && PrintGCDetails) {
! gclog_or_tty->print_cr(" Non NULL normal " INTPTR_FORMAT, obj);
}
)
PSParallelCompact::mark_and_push(cm, referent_addr);
}
}
// treat next as normal oop. next is a link in the pending list.
! T* next_addr = (T*)java_lang_ref_Reference::next_addr(obj);
debug_only(
if(TraceReferenceGC && PrintGCDetails) {
gclog_or_tty->print_cr(" Process next as normal " INTPTR_FORMAT, next_addr);
}
)
PSParallelCompact::mark_and_push(cm, next_addr);
! ref->instanceKlass::oop_follow_contents(cm, obj);
}
! void instanceRefKlass::oop_follow_contents(ParCompactionManager* cm,
! oop obj) {
! if (UseCompressedOops) {
! specialized_oop_follow_contents<narrowOop>(this, cm, obj);
! } else {
! specialized_oop_follow_contents<oop>(this, cm, obj);
! }
! }
! #endif // SERIALGC
#ifdef ASSERT
+ template <class T> void trace_reference_gc(const char *s, oop obj,
+ T* referent_addr,
+ T* next_addr,
+ T* discovered_addr) {
if(TraceReferenceGC && PrintGCDetails) {
! gclog_or_tty->print_cr("%s obj " INTPTR_FORMAT, s, (address)obj);
gclog_or_tty->print_cr(" referent_addr/* " INTPTR_FORMAT " / "
INTPTR_FORMAT, referent_addr,
! referent_addr ?
! (address)oopDesc::load_decode_heap_oop(referent_addr) : NULL);
gclog_or_tty->print_cr(" next_addr/* " INTPTR_FORMAT " / "
INTPTR_FORMAT, next_addr,
! next_addr ? (address)oopDesc::load_decode_heap_oop(next_addr) : NULL);
gclog_or_tty->print_cr(" discovered_addr/* " INTPTR_FORMAT " / "
INTPTR_FORMAT, discovered_addr,
! discovered_addr ?
! (address)oopDesc::load_decode_heap_oop(discovered_addr) : NULL);
}
+ }
#endif
+ template <class T> void specialized_oop_adjust_pointers(instanceRefKlass *ref, oop obj) {
+ T* referent_addr = (T*)java_lang_ref_Reference::referent_addr(obj);
+ MarkSweep::adjust_pointer(referent_addr);
+ T* next_addr = (T*)java_lang_ref_Reference::next_addr(obj);
+ MarkSweep::adjust_pointer(next_addr);
+ T* discovered_addr = (T*)java_lang_ref_Reference::discovered_addr(obj);
+ MarkSweep::adjust_pointer(discovered_addr);
+ debug_only(trace_reference_gc("instanceRefKlass::oop_adjust_pointers", obj,
+ referent_addr, next_addr, discovered_addr);)
+ }
+
+ int instanceRefKlass::oop_adjust_pointers(oop obj) {
+ int size = size_helper();
+ instanceKlass::oop_adjust_pointers(obj);
+
+ if (UseCompressedOops) {
+ specialized_oop_adjust_pointers<narrowOop>(this, obj);
+ } else {
+ specialized_oop_adjust_pointers<oop>(this, obj);
+ }
return size;
}
! #define InstanceRefKlass_SPECIALIZED_OOP_ITERATE(T, nv_suffix, contains) \
! if (closure->apply_to_weak_ref_discovered_field()) { \
! T* disc_addr = (T*)java_lang_ref_Reference::discovered_addr(obj); \
! closure->do_oop##nv_suffix(disc_addr); \
! } \
\
! T* referent_addr = (T*)java_lang_ref_Reference::referent_addr(obj); \
! oop referent = oopDesc::load_decode_heap_oop(referent_addr); \
! if (referent != NULL && contains(referent_addr)) { \
ReferenceProcessor* rp = closure->_ref_processor; \
if (!referent->is_gc_marked() && (rp != NULL) && \
rp->discover_reference(obj, reference_type())) { \
return size; \
} else { \
/* treat referent as normal oop */ \
SpecializationStats::record_do_oop_call##nv_suffix(SpecializationStats::irk);\
closure->do_oop##nv_suffix(referent_addr); \
} \
} \
/* treat next as normal oop */ \
! T* next_addr = (T*)java_lang_ref_Reference::next_addr(obj); \
! if (contains(next_addr)) { \
SpecializationStats::record_do_oop_call##nv_suffix(SpecializationStats::irk); \
closure->do_oop##nv_suffix(next_addr); \
+ } \
return size; \
+
+
+ template <class T> bool contains(T *t) { return true; }
+
+ // Macro to define instanceRefKlass::oop_oop_iterate for virtual/nonvirtual for
+ // all closures. Macros calling macros above for each oop size.
+
+ #define InstanceRefKlass_OOP_OOP_ITERATE_DEFN(OopClosureType, nv_suffix) \
+ \
+ int instanceRefKlass:: \
+ oop_oop_iterate##nv_suffix(oop obj, OopClosureType* closure) { \
+ /* Get size before changing pointers */ \
+ SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::irk);\
+ \
+ int size = instanceKlass::oop_oop_iterate##nv_suffix(obj, closure); \
+ \
+ if (UseCompressedOops) { \
+ InstanceRefKlass_SPECIALIZED_OOP_ITERATE(narrowOop, nv_suffix, contains); \
+ } else { \
+ InstanceRefKlass_SPECIALIZED_OOP_ITERATE(oop, nv_suffix, contains); \
+ } \
+ }
+
+ #ifndef SERIALGC
+ #define InstanceRefKlass_OOP_OOP_ITERATE_BACKWARDS_DEFN(OopClosureType, nv_suffix) \
+ \
+ int instanceRefKlass:: \
+ oop_oop_iterate_backwards##nv_suffix(oop obj, OopClosureType* closure) { \
+ /* Get size before changing pointers */ \
+ SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::irk);\
+ \
+ int size = instanceKlass::oop_oop_iterate_backwards##nv_suffix(obj, closure); \
+ \
+ if (UseCompressedOops) { \
+ InstanceRefKlass_SPECIALIZED_OOP_ITERATE(narrowOop, nv_suffix, contains); \
+ } else { \
+ InstanceRefKlass_SPECIALIZED_OOP_ITERATE(oop, nv_suffix, contains); \
+ } \
}
+ #endif // !SERIALGC
+
#define InstanceRefKlass_OOP_OOP_ITERATE_DEFN_m(OopClosureType, nv_suffix) \
\
int instanceRefKlass:: \
oop_oop_iterate##nv_suffix##_m(oop obj, \
OopClosureType* closure, \
MemRegion mr) { \
SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::irk);\
\
int size = instanceKlass::oop_oop_iterate##nv_suffix##_m(obj, closure, mr); \
! if (UseCompressedOops) { \
! InstanceRefKlass_SPECIALIZED_OOP_ITERATE(narrowOop, nv_suffix, mr.contains); \
} else { \
! InstanceRefKlass_SPECIALIZED_OOP_ITERATE(oop, nv_suffix, mr.contains); \
} \
}
ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceRefKlass_OOP_OOP_ITERATE_DEFN)
! ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceRefKlass_OOP_OOP_ITERATE_DEFN)
! #ifndef SERIALGC
! ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceRefKlass_OOP_OOP_ITERATE_BACKWARDS_DEFN)
! ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceRefKlass_OOP_OOP_ITERATE_BACKWARDS_DEFN)
! #endif // SERIALGC
ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceRefKlass_OOP_OOP_ITERATE_DEFN_m)
! ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceRefKlass_OOP_OOP_ITERATE_DEFN_m)
#ifndef SERIALGC
! template <class T>
! void specialized_oop_copy_contents(instanceRefKlass *ref,
! PSPromotionManager* pm, oop obj) {
assert(!pm->depth_first(), "invariant");
! T* referent_addr = (T*)java_lang_ref_Reference::referent_addr(obj);
! if (PSScavenge::should_scavenge(referent_addr)) {
ReferenceProcessor* rp = PSScavenge::reference_processor();
! if (rp->discover_reference(obj, ref->reference_type())) {
// reference already enqueued, referent and next will be traversed later
! ref->instanceKlass::oop_copy_contents(pm, obj);
return;
} else {
// treat referent as normal oop
pm->claim_or_forward_breadth(referent_addr);
}
}
// treat next as normal oop
! T* next_addr = (T*)java_lang_ref_Reference::next_addr(obj);
! if (PSScavenge::should_scavenge(next_addr)) {
pm->claim_or_forward_breadth(next_addr);
}
! ref->instanceKlass::oop_copy_contents(pm, obj);
}
! void instanceRefKlass::oop_copy_contents(PSPromotionManager* pm, oop obj) {
! if (UseCompressedOops) {
! specialized_oop_copy_contents<narrowOop>(this, pm, obj);
! } else {
! specialized_oop_copy_contents<oop>(this, pm, obj);
! }
! }
!
! template <class T>
! void specialized_oop_push_contents(instanceRefKlass *ref,
! PSPromotionManager* pm, oop obj) {
assert(pm->depth_first(), "invariant");
! T* referent_addr = (T*)java_lang_ref_Reference::referent_addr(obj);
! if (PSScavenge::should_scavenge(referent_addr)) {
ReferenceProcessor* rp = PSScavenge::reference_processor();
! if (rp->discover_reference(obj, ref->reference_type())) {
// reference already enqueued, referent and next will be traversed later
! ref->instanceKlass::oop_push_contents(pm, obj);
return;
} else {
// treat referent as normal oop
pm->claim_or_forward_depth(referent_addr);
}
}
// treat next as normal oop
! T* next_addr = (T*)java_lang_ref_Reference::next_addr(obj);
! if (PSScavenge::should_scavenge(next_addr)) {
pm->claim_or_forward_depth(next_addr);
}
! ref->instanceKlass::oop_push_contents(pm, obj);
}
! void instanceRefKlass::oop_push_contents(PSPromotionManager* pm, oop obj) {
! if (UseCompressedOops) {
! specialized_oop_push_contents<narrowOop>(this, pm, obj);
! } else {
! specialized_oop_push_contents<oop>(this, pm, obj);
! }
! }
! template <class T>
! void specialized_oop_update_pointers(instanceRefKlass *ref,
! ParCompactionManager* cm, oop obj) {
! T* referent_addr = (T*)java_lang_ref_Reference::referent_addr(obj);
PSParallelCompact::adjust_pointer(referent_addr);
! T* next_addr = (T*)java_lang_ref_Reference::next_addr(obj);
PSParallelCompact::adjust_pointer(next_addr);
! T* discovered_addr = (T*)java_lang_ref_Reference::discovered_addr(obj);
PSParallelCompact::adjust_pointer(discovered_addr);
+ debug_only(trace_reference_gc("instanceRefKlass::oop_update_ptrs", obj,
+ referent_addr, next_addr, discovered_addr);)
+ }
! int instanceRefKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) {
! instanceKlass::oop_update_pointers(cm, obj);
! if (UseCompressedOops) {
! specialized_oop_update_pointers<narrowOop>(this, cm, obj);
! } else {
! specialized_oop_update_pointers<oop>(this, cm, obj);
}
return size_helper();
}
! template <class T> void
! specialized_oop_update_pointers(ParCompactionManager* cm, oop obj,
! HeapWord* beg_addr, HeapWord* end_addr) {
! T* p;
! T* referent_addr = p = (T*)java_lang_ref_Reference::referent_addr(obj);
PSParallelCompact::adjust_pointer(p, beg_addr, end_addr);
! T* next_addr = p = (T*)java_lang_ref_Reference::next_addr(obj);
PSParallelCompact::adjust_pointer(p, beg_addr, end_addr);
! T* discovered_addr = p = (T*)java_lang_ref_Reference::discovered_addr(obj);
PSParallelCompact::adjust_pointer(p, beg_addr, end_addr);
+ debug_only(trace_reference_gc("instanceRefKlass::oop_update_ptrs", obj,
+ referent_addr, next_addr, discovered_addr);)
+ }
! int
! instanceRefKlass::oop_update_pointers(ParCompactionManager* cm, oop obj,
! HeapWord* beg_addr, HeapWord* end_addr) {
! instanceKlass::oop_update_pointers(cm, obj, beg_addr, end_addr);
! if (UseCompressedOops) {
! specialized_oop_update_pointers<narrowOop>(cm, obj, beg_addr, end_addr);
! } else {
! specialized_oop_update_pointers<oop>(cm, obj, beg_addr, end_addr);
}
return size_helper();
}
#endif // SERIALGC
void instanceRefKlass::update_nonstatic_oop_maps(klassOop k) {
*** 339,349 ****
// Check that the current map is (2,4) - currently points at field with
// offset 2 (words) and has 4 map entries.
debug_only(int offset = java_lang_ref_Reference::referent_offset);
debug_only(int length = ((java_lang_ref_Reference::discovered_offset -
! java_lang_ref_Reference::referent_offset)/wordSize) + 1);
if (UseSharedSpaces) {
assert(map->offset() == java_lang_ref_Reference::queue_offset &&
map->length() == 1, "just checking");
} else {
--- 406,416 ----
// Check that the current map is (2,4) - currently points at field with
// offset 2 (words) and has 4 map entries.
debug_only(int offset = java_lang_ref_Reference::referent_offset);
debug_only(int length = ((java_lang_ref_Reference::discovered_offset -
! java_lang_ref_Reference::referent_offset)/heapOopSize) + 1);
if (UseSharedSpaces) {
assert(map->offset() == java_lang_ref_Reference::queue_offset &&
map->length() == 1, "just checking");
} else {
*** 369,394 ****
if (Universe::heap()->kind() == CollectedHeap::GenCollectedHeap)
gch = GenCollectedHeap::heap();
if (referent != NULL) {
guarantee(referent->is_oop(), "referent field heap failed");
! if (gch != NULL && !gch->is_in_youngest(obj))
// We do a specific remembered set check here since the referent
// field is not part of the oop mask and therefore skipped by the
// regular verify code.
! obj->verify_old_oop(java_lang_ref_Reference::referent_addr(obj), true);
}
// Verify next field
oop next = java_lang_ref_Reference::next(obj);
if (next != NULL) {
guarantee(next->is_oop(), "next field verify failed");
guarantee(next->is_instanceRef(), "next field verify failed");
if (gch != NULL && !gch->is_in_youngest(obj)) {
// We do a specific remembered set check here since the next field is
// not part of the oop mask and therefore skipped by the regular
// verify code.
! obj->verify_old_oop(java_lang_ref_Reference::next_addr(obj), true);
}
}
}
void instanceRefKlass::acquire_pending_list_lock(BasicLock *pending_list_basic_lock) {
--- 436,474 ----
if (Universe::heap()->kind() == CollectedHeap::GenCollectedHeap)
gch = GenCollectedHeap::heap();
if (referent != NULL) {
guarantee(referent->is_oop(), "referent field heap failed");
! if (gch != NULL && !gch->is_in_youngest(obj)) {
// We do a specific remembered set check here since the referent
// field is not part of the oop mask and therefore skipped by the
// regular verify code.
! if (UseCompressedOops) {
! narrowOop* referent_addr = (narrowOop*)java_lang_ref_Reference::referent_addr(obj);
! obj->verify_old_oop(referent_addr, true);
! } else {
! oop* referent_addr = (oop*)java_lang_ref_Reference::referent_addr(obj);
! obj->verify_old_oop(referent_addr, true);
! }
! }
}
// Verify next field
oop next = java_lang_ref_Reference::next(obj);
if (next != NULL) {
guarantee(next->is_oop(), "next field verify failed");
guarantee(next->is_instanceRef(), "next field verify failed");
if (gch != NULL && !gch->is_in_youngest(obj)) {
// We do a specific remembered set check here since the next field is
// not part of the oop mask and therefore skipped by the regular
// verify code.
! if (UseCompressedOops) {
! narrowOop* next_addr = (narrowOop*)java_lang_ref_Reference::next_addr(obj);
! obj->verify_old_oop(next_addr, true);
! } else {
! oop* next_addr = (oop*)java_lang_ref_Reference::next_addr(obj);
! obj->verify_old_oop(next_addr, true);
! }
}
}
}
void instanceRefKlass::acquire_pending_list_lock(BasicLock *pending_list_basic_lock) {