int instanceKlassKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) {
assert(obj->is_klass(),"must be a klass");
assert(klassOop(obj)->klass_part()->oop_is_instance_slow(),
"must be instance klass");
instanceKlass* ik = instanceKlass::cast(klassOop(obj));
ik->vtable()->oop_update_pointers(cm);
ik->itable()->oop_update_pointers(cm);
oop* const beg_oop = ik->oop_block_beg();
oop* const end_oop = ik->oop_block_end();
for (oop* cur_oop = beg_oop; cur_oop < end_oop; ++cur_oop) {
PSParallelCompact::adjust_pointer(cur_oop);
}
// embedded oops
if (ik->adr_implementor() != NULL) {
PSParallelCompact::adjust_pointer(ik->adr_implementor());
}
if (ik->adr_host_klass() != NULL) {
PSParallelCompact::adjust_pointer(ik->adr_host_klass());
}
OopClosure* closure = PSParallelCompact::adjust_root_pointer_closure();
iterate_c_heap_oops(ik, closure);
klassKlass::oop_update_pointers(cm, obj);
return ik->object_size();
}
int instanceKlassKlass::oop_adjust_pointers(oop obj) {
assert(obj->is_klass(),"must be a klass");
assert(klassOop(obj)->klass_part()->oop_is_instance_slow(), "must be instance klass");
instanceKlass* ik = instanceKlass::cast(klassOop(obj));
ik->vtable()->oop_adjust_pointers();
ik->itable()->oop_adjust_pointers();
MarkSweep::adjust_pointer(ik->adr_array_klasses());
MarkSweep::adjust_pointer(ik->adr_methods());
MarkSweep::adjust_pointer(ik->adr_method_ordering());
MarkSweep::adjust_pointer(ik->adr_local_interfaces());
MarkSweep::adjust_pointer(ik->adr_transitive_interfaces());
MarkSweep::adjust_pointer(ik->adr_fields());
MarkSweep::adjust_pointer(ik->adr_constants());
MarkSweep::adjust_pointer(ik->adr_class_loader());
MarkSweep::adjust_pointer(ik->adr_protection_domain());
if (ik->adr_host_klass() != NULL) {
MarkSweep::adjust_pointer(ik->adr_host_klass());
}
MarkSweep::adjust_pointer(ik->adr_signers());
MarkSweep::adjust_pointer(ik->adr_inner_classes());
if (ik->adr_implementor() != NULL) {
MarkSweep::adjust_pointer(ik->adr_implementor());
}
MarkSweep::adjust_pointer(ik->adr_class_annotations());
MarkSweep::adjust_pointer(ik->adr_fields_annotations());
MarkSweep::adjust_pointer(ik->adr_methods_annotations());
MarkSweep::adjust_pointer(ik->adr_methods_parameter_annotations());
MarkSweep::adjust_pointer(ik->adr_methods_default_annotations());
iterate_c_heap_oops(ik, &MarkSweep::adjust_root_pointer_closure);
return klassKlass::oop_adjust_pointers(obj);
}
int instanceKlassKlass::oop_update_pointers(ParCompactionManager* cm, oop obj,
HeapWord* beg_addr,
HeapWord* end_addr) {
assert(obj->is_klass(),"must be a klass");
assert(klassOop(obj)->klass_part()->oop_is_instance_slow(),
"must be instance klass");
instanceKlass* ik = instanceKlass::cast(klassOop(obj));
ik->update_static_fields(beg_addr, end_addr);
ik->vtable()->oop_update_pointers(cm, beg_addr, end_addr);
ik->itable()->oop_update_pointers(cm, beg_addr, end_addr);
oop* const beg_oop = MAX2((oop*)beg_addr, ik->oop_block_beg());
oop* const end_oop = MIN2((oop*)end_addr, ik->oop_block_end());
for (oop* cur_oop = beg_oop; cur_oop < end_oop; ++cur_oop) {
PSParallelCompact::adjust_pointer(cur_oop);
}
// The oop_map_cache, jni_ids and jni_id_map are allocated from the C heap,
// and so don't lie within any 'Chunk' boundaries. Update them when the
// lowest addressed oop in the instanceKlass 'oop_block' is updated.
if (beg_oop == ik->oop_block_beg()) {
OopClosure* closure = PSParallelCompact::adjust_root_pointer_closure();
iterate_c_heap_oops(ik, closure);
}
klassKlass::oop_update_pointers(cm, obj, beg_addr, end_addr);
return ik->object_size();
}
void instanceKlassKlass::oop_follow_contents(oop obj) {
assert(obj->is_klass(),"must be a klass");
assert(klassOop(obj)->klass_part()->oop_is_instance_slow(), "must be instance klass");
instanceKlass* ik = instanceKlass::cast(klassOop(obj));
ik->follow_static_fields();
{
HandleMark hm;
ik->vtable()->oop_follow_contents();
ik->itable()->oop_follow_contents();
}
MarkSweep::mark_and_push(ik->adr_array_klasses());
MarkSweep::mark_and_push(ik->adr_methods());
MarkSweep::mark_and_push(ik->adr_method_ordering());
MarkSweep::mark_and_push(ik->adr_local_interfaces());
MarkSweep::mark_and_push(ik->adr_transitive_interfaces());
MarkSweep::mark_and_push(ik->adr_fields());
MarkSweep::mark_and_push(ik->adr_constants());
MarkSweep::mark_and_push(ik->adr_class_loader());
MarkSweep::mark_and_push(ik->adr_source_file_name());
MarkSweep::mark_and_push(ik->adr_source_debug_extension());
MarkSweep::mark_and_push(ik->adr_inner_classes());
MarkSweep::mark_and_push(ik->adr_protection_domain());
MarkSweep::mark_and_push(ik->adr_host_klass());
MarkSweep::mark_and_push(ik->adr_signers());
MarkSweep::mark_and_push(ik->adr_generic_signature());
MarkSweep::mark_and_push(ik->adr_bootstrap_method());
MarkSweep::mark_and_push(ik->adr_class_annotations());
MarkSweep::mark_and_push(ik->adr_fields_annotations());
MarkSweep::mark_and_push(ik->adr_methods_annotations());
MarkSweep::mark_and_push(ik->adr_methods_parameter_annotations());
MarkSweep::mark_and_push(ik->adr_methods_default_annotations());
// We do not follow adr_implementors() here. It is followed later
// in instanceKlass::follow_weak_klass_links()
klassKlass::oop_follow_contents(obj);
iterate_c_heap_oops(ik, &MarkSweep::mark_and_push_closure);
}
int instanceKlassKlass::oop_adjust_pointers(oop obj) {
assert(obj->is_klass(),"must be a klass");
assert(klassOop(obj)->klass_part()->oop_is_instance_slow(), "must be instance klass");
instanceKlass* ik = instanceKlass::cast(klassOop(obj));
ik->adjust_static_fields();
ik->vtable()->oop_adjust_pointers();
ik->itable()->oop_adjust_pointers();
MarkSweep::adjust_pointer(ik->adr_array_klasses());
MarkSweep::adjust_pointer(ik->adr_methods());
MarkSweep::adjust_pointer(ik->adr_method_ordering());
MarkSweep::adjust_pointer(ik->adr_local_interfaces());
MarkSweep::adjust_pointer(ik->adr_transitive_interfaces());
MarkSweep::adjust_pointer(ik->adr_fields());
MarkSweep::adjust_pointer(ik->adr_constants());
MarkSweep::adjust_pointer(ik->adr_class_loader());
MarkSweep::adjust_pointer(ik->adr_protection_domain());
MarkSweep::adjust_pointer(ik->adr_host_klass());
MarkSweep::adjust_pointer(ik->adr_signers());
MarkSweep::adjust_pointer(ik->adr_source_file_name());
MarkSweep::adjust_pointer(ik->adr_source_debug_extension());
MarkSweep::adjust_pointer(ik->adr_inner_classes());
for (int i = 0; i < instanceKlass::implementors_limit; i++) {
MarkSweep::adjust_pointer(&ik->adr_implementors()[i]);
}
MarkSweep::adjust_pointer(ik->adr_generic_signature());
MarkSweep::adjust_pointer(ik->adr_bootstrap_method());
MarkSweep::adjust_pointer(ik->adr_class_annotations());
MarkSweep::adjust_pointer(ik->adr_fields_annotations());
MarkSweep::adjust_pointer(ik->adr_methods_annotations());
MarkSweep::adjust_pointer(ik->adr_methods_parameter_annotations());
MarkSweep::adjust_pointer(ik->adr_methods_default_annotations());
iterate_c_heap_oops(ik, &MarkSweep::adjust_root_pointer_closure);
return klassKlass::oop_adjust_pointers(obj);
}
void instanceKlassKlass::oop_follow_contents(ParCompactionManager* cm,
oop obj) {
assert(obj->is_klass(),"must be a klass");
assert(klassOop(obj)->klass_part()->oop_is_instance_slow(), "must be instance klass");
instanceKlass* ik = instanceKlass::cast(klassOop(obj));
ik->vtable()->oop_follow_contents(cm);
ik->itable()->oop_follow_contents(cm);
PSParallelCompact::mark_and_push(cm, ik->adr_array_klasses());
PSParallelCompact::mark_and_push(cm, ik->adr_methods());
PSParallelCompact::mark_and_push(cm, ik->adr_method_ordering());
PSParallelCompact::mark_and_push(cm, ik->adr_local_interfaces());
PSParallelCompact::mark_and_push(cm, ik->adr_transitive_interfaces());
PSParallelCompact::mark_and_push(cm, ik->adr_fields());
PSParallelCompact::mark_and_push(cm, ik->adr_constants());
PSParallelCompact::mark_and_push(cm, ik->adr_class_loader());
PSParallelCompact::mark_and_push(cm, ik->adr_inner_classes());
PSParallelCompact::mark_and_push(cm, ik->adr_protection_domain());
if (ik->adr_host_klass() != NULL) {
PSParallelCompact::mark_and_push(cm, ik->adr_host_klass());
}
PSParallelCompact::mark_and_push(cm, ik->adr_signers());
PSParallelCompact::mark_and_push(cm, ik->adr_class_annotations());
PSParallelCompact::mark_and_push(cm, ik->adr_fields_annotations());
PSParallelCompact::mark_and_push(cm, ik->adr_methods_annotations());
PSParallelCompact::mark_and_push(cm, ik->adr_methods_parameter_annotations());
PSParallelCompact::mark_and_push(cm, ik->adr_methods_default_annotations());
// We do not follow adr_implementor() here. It is followed later
// in instanceKlass::follow_weak_klass_links()
klassKlass::oop_follow_contents(cm, obj);
PSParallelCompact::MarkAndPushClosure mark_and_push_closure(cm);
iterate_c_heap_oops(ik, &mark_and_push_closure);
}
