jdk-sandbox: comparison hotspot/src/share/vm/oops/instanceKlassKlass.cpp

equal deleted inserted replaced

-:f3187578ddd3
+:48fd3da4025c
 /*
-* Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1997, 2012, Oracle and/or its affiliates. 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.
 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
+// We do not follow adr_implementor() 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);
 blk->do_oop(ik->adr_class_loader());
 blk->do_oop(ik->adr_protection_domain());
 blk->do_oop(ik->adr_host_klass());
 blk->do_oop(ik->adr_signers());
 blk->do_oop(ik->adr_inner_classes());
-for (int i = 0; i < instanceKlass::implementors_limit; i++) {
+if (ik->is_interface()) {
-blk->do_oop(&ik->adr_implementors()[i]);
+blk->do_oop(ik->adr_implementor());
 }
 blk->do_oop(ik->adr_class_annotations());
 blk->do_oop(ik->adr_fields_annotations());
 blk->do_oop(ik->adr_methods_annotations());
 blk->do_oop(ik->adr_methods_parameter_annotations());
 if (mr.contains(adr)) blk->do_oop(adr);
 adr = ik->adr_signers();
 if (mr.contains(adr)) blk->do_oop(adr);
 adr = ik->adr_inner_classes();
 if (mr.contains(adr)) blk->do_oop(adr);
-adr = ik->adr_implementors();
+if (ik->is_interface()) {
-for (int i = 0; i < instanceKlass::implementors_limit; i++) {
+adr = ik->adr_implementor();
-if (mr.contains(&adr[i])) blk->do_oop(&adr[i]);
+if (mr.contains(adr)) blk->do_oop(adr);
 }
 adr = ik->adr_class_annotations();
 if (mr.contains(adr)) blk->do_oop(adr);
 adr = ik->adr_fields_annotations();
 if (mr.contains(adr)) blk->do_oop(adr);
 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_inner_classes());
-for (int i = 0; i < instanceKlass::implementors_limit; i++) {
+if (ik->is_interface()) {
-MarkSweep::adjust_pointer(&ik->adr_implementors()[i]);
+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());
 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);
 }
+if (ik->is_interface()) {
+PSParallelCompact::adjust_pointer(ik->adr_implementor());
+}
 OopClosure* closure = PSParallelCompact::adjust_root_pointer_closure();
 iterate_c_heap_oops(ik, closure);
 klassKlass::oop_update_pointers(cm, obj);
 klassOop
 instanceKlassKlass::allocate_instance_klass(Symbol* name, int vtable_len, int itable_len,
 int static_field_size,
 unsigned nonstatic_oop_map_count,
+AccessFlags access_flags,
 ReferenceType rt, TRAPS) {
 const int nonstatic_oop_map_size =
 instanceKlass::nonstatic_oop_map_size(nonstatic_oop_map_count);
-int size = instanceKlass::object_size(align_object_offset(vtable_len) + align_object_offset(itable_len) + nonstatic_oop_map_size);
+int size = align_object_offset(vtable_len) + align_object_offset(itable_len);
+if (access_flags.is_interface()) {
+size += align_object_offset(nonstatic_oop_map_size) + (int)sizeof(klassOop)/HeapWordSize;
+} else {
+size += nonstatic_oop_map_size;
+}
+size = instanceKlass::object_size(size);
 // Allocation
 KlassHandle h_this_klass(THREAD, as_klassOop());
 KlassHandle k;
 if (rt == REF_NONE) {
 // sizes before the first GC, i.e., when we allocate the mirror.
 ik->set_vtable_length(vtable_len);
 ik->set_itable_length(itable_len);
 ik->set_static_field_size(static_field_size);
 ik->set_nonstatic_oop_map_size(nonstatic_oop_map_size);
+ik->set_access_flags(access_flags);
 assert(k()->size() == size, "wrong size for object");
 ik->set_array_klasses(NULL);
 ik->set_methods(NULL);
 ik->set_method_ordering(NULL);
 if (n >= MaxSubklassPrintSize) st->print("(%d more klasses...)", n - MaxSubklassPrintSize);
 st->cr();
 if (ik->is_interface()) {
 st->print_cr(BULLET"nof implementors:  %d", ik->nof_implementors());
-int print_impl = 0;
+if (ik->nof_implementors() == 1) {
-for (int i = 0; i < instanceKlass::implementors_limit; i++) {
+st->print_cr(BULLET"implementor:    ");
-if (ik->implementor(i) != NULL) {
+st->print("   ");
-if (++print_impl == 1)
+ik->implementor()->print_value_on(st);
-st->print_cr(BULLET"implementor:    ");
+st->cr();
-st->print("   ");
+}
-ik->implementor(i)->print_value_on(st);
-}
-}
-if (print_impl > 0)  st->cr();
 }
 st->print(BULLET"arrays:            "); ik->array_klasses()->print_value_on(st);     st->cr();
 st->print(BULLET"methods:           "); ik->methods()->print_value_on(st);           st->cr();
 if (Verbose) {
 guarantee(sib->super() == super, "siblings should have same superklass");
 sib = sib->next_sibling();
 }
 // Verify implementor fields
-bool saw_null_impl = false;
+klassOop im = ik->implementor();
-for (int i = 0; i < instanceKlass::implementors_limit; i++) {
+if (im != NULL) {
-klassOop im = ik->implementor(i);
-if (im == NULL) { saw_null_impl = true; continue; }
-guarantee(!saw_null_impl, "non-nulls must preceded all nulls");
 guarantee(ik->is_interface(), "only interfaces should have implementor set");
-guarantee(i < ik->nof_implementors(), "should only have one implementor");
 guarantee(im->is_perm(),  "should be in permspace");
 guarantee(im->is_klass(), "should be klass");
-guarantee(!Klass::cast(klassOop(im))->is_interface(), "implementors cannot be interfaces");
+guarantee(!Klass::cast(klassOop(im))->is_interface() || im == ik->as_klassOop(), "implementors cannot be interfaces");
 }
 // Verify local interfaces
 objArrayOop local_interfaces = ik->local_interfaces();
 guarantee(local_interfaces->is_perm(),          "should be in permspace");

changeset 12369	48fd3da4025c
parent 12231	6a9cfc59a18a
child 12587	8f819769ca1b