Mercurial > hg > truffle

comparison src/share/vm/oops/instanceKlassKlass.cpp @ 5998:49036505ab5f

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. Summary: Change implementor to embedded instanceKlass field. Reviewed-by: sspitsyn, minqi, coleenp
author jiangli
date Thu, 29 Mar 2012 22:18:56 -0400
parents f7c4174b33ba
children 8bafad97cd26
comparison
equal deleted inserted replaced
5970:0698f5ef5535 5998:49036505ab5f
1 /* 1 /*
2 * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. 2 * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 * 4 *
5 * This code is free software; you can redistribute it and/or modify it 5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as 6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. 7 * published by the Free Software Foundation.
109 MarkSweep::mark_and_push(ik->adr_fields_annotations()); 109 MarkSweep::mark_and_push(ik->adr_fields_annotations());
110 MarkSweep::mark_and_push(ik->adr_methods_annotations()); 110 MarkSweep::mark_and_push(ik->adr_methods_annotations());
111 MarkSweep::mark_and_push(ik->adr_methods_parameter_annotations()); 111 MarkSweep::mark_and_push(ik->adr_methods_parameter_annotations());
112 MarkSweep::mark_and_push(ik->adr_methods_default_annotations()); 112 MarkSweep::mark_and_push(ik->adr_methods_default_annotations());
113 113
114 // We do not follow adr_implementors() here. It is followed later 114 // We do not follow adr_implementor() here. It is followed later
115 // in instanceKlass::follow_weak_klass_links() 115 // in instanceKlass::follow_weak_klass_links()
116 116
117 klassKlass::oop_follow_contents(obj); 117 klassKlass::oop_follow_contents(obj);
118 118
119 iterate_c_heap_oops(ik, &MarkSweep::mark_and_push_closure); 119 iterate_c_heap_oops(ik, &MarkSweep::mark_and_push_closure);
178 blk->do_oop(ik->adr_class_loader()); 178 blk->do_oop(ik->adr_class_loader());
179 blk->do_oop(ik->adr_protection_domain()); 179 blk->do_oop(ik->adr_protection_domain());
180 blk->do_oop(ik->adr_host_klass()); 180 blk->do_oop(ik->adr_host_klass());
181 blk->do_oop(ik->adr_signers()); 181 blk->do_oop(ik->adr_signers());
182 blk->do_oop(ik->adr_inner_classes()); 182 blk->do_oop(ik->adr_inner_classes());
183 for (int i = 0; i < instanceKlass::implementors_limit; i++) { 183 if (ik->is_interface()) {
184 blk->do_oop(&ik->adr_implementors()[i]); 184 blk->do_oop(ik->adr_implementor());
185 } 185 }
186 blk->do_oop(ik->adr_class_annotations()); 186 blk->do_oop(ik->adr_class_annotations());
187 blk->do_oop(ik->adr_fields_annotations()); 187 blk->do_oop(ik->adr_fields_annotations());
188 blk->do_oop(ik->adr_methods_annotations()); 188 blk->do_oop(ik->adr_methods_annotations());
189 blk->do_oop(ik->adr_methods_parameter_annotations()); 189 blk->do_oop(ik->adr_methods_parameter_annotations());
230 if (mr.contains(adr)) blk->do_oop(adr); 230 if (mr.contains(adr)) blk->do_oop(adr);
231 adr = ik->adr_signers(); 231 adr = ik->adr_signers();
232 if (mr.contains(adr)) blk->do_oop(adr); 232 if (mr.contains(adr)) blk->do_oop(adr);
233 adr = ik->adr_inner_classes(); 233 adr = ik->adr_inner_classes();
234 if (mr.contains(adr)) blk->do_oop(adr); 234 if (mr.contains(adr)) blk->do_oop(adr);
235 adr = ik->adr_implementors(); 235 if (ik->is_interface()) {
236 for (int i = 0; i < instanceKlass::implementors_limit; i++) { 236 adr = ik->adr_implementor();
237 if (mr.contains(&adr[i])) blk->do_oop(&adr[i]); 237 if (mr.contains(adr)) blk->do_oop(adr);
238 } 238 }
239 adr = ik->adr_class_annotations(); 239 adr = ik->adr_class_annotations();
240 if (mr.contains(adr)) blk->do_oop(adr); 240 if (mr.contains(adr)) blk->do_oop(adr);
241 adr = ik->adr_fields_annotations(); 241 adr = ik->adr_fields_annotations();
242 if (mr.contains(adr)) blk->do_oop(adr); 242 if (mr.contains(adr)) blk->do_oop(adr);
271 MarkSweep::adjust_pointer(ik->adr_class_loader()); 271 MarkSweep::adjust_pointer(ik->adr_class_loader());
272 MarkSweep::adjust_pointer(ik->adr_protection_domain()); 272 MarkSweep::adjust_pointer(ik->adr_protection_domain());
273 MarkSweep::adjust_pointer(ik->adr_host_klass()); 273 MarkSweep::adjust_pointer(ik->adr_host_klass());
274 MarkSweep::adjust_pointer(ik->adr_signers()); 274 MarkSweep::adjust_pointer(ik->adr_signers());
275 MarkSweep::adjust_pointer(ik->adr_inner_classes()); 275 MarkSweep::adjust_pointer(ik->adr_inner_classes());
276 for (int i = 0; i < instanceKlass::implementors_limit; i++) { 276 if (ik->is_interface()) {
277 MarkSweep::adjust_pointer(&ik->adr_implementors()[i]); 277 MarkSweep::adjust_pointer(ik->adr_implementor());
278 } 278 }
279 MarkSweep::adjust_pointer(ik->adr_class_annotations()); 279 MarkSweep::adjust_pointer(ik->adr_class_annotations());
280 MarkSweep::adjust_pointer(ik->adr_fields_annotations()); 280 MarkSweep::adjust_pointer(ik->adr_fields_annotations());
281 MarkSweep::adjust_pointer(ik->adr_methods_annotations()); 281 MarkSweep::adjust_pointer(ik->adr_methods_annotations());
282 MarkSweep::adjust_pointer(ik->adr_methods_parameter_annotations()); 282 MarkSweep::adjust_pointer(ik->adr_methods_parameter_annotations());
326 oop* const beg_oop = ik->oop_block_beg(); 326 oop* const beg_oop = ik->oop_block_beg();
327 oop* const end_oop = ik->oop_block_end(); 327 oop* const end_oop = ik->oop_block_end();
328 for (oop* cur_oop = beg_oop; cur_oop < end_oop; ++cur_oop) { 328 for (oop* cur_oop = beg_oop; cur_oop < end_oop; ++cur_oop) {
329 PSParallelCompact::adjust_pointer(cur_oop); 329 PSParallelCompact::adjust_pointer(cur_oop);
330 } 330 }
331 if (ik->is_interface()) {
332 PSParallelCompact::adjust_pointer(ik->adr_implementor());
333 }
331 334
332 OopClosure* closure = PSParallelCompact::adjust_root_pointer_closure(); 335 OopClosure* closure = PSParallelCompact::adjust_root_pointer_closure();
333 iterate_c_heap_oops(ik, closure); 336 iterate_c_heap_oops(ik, closure);
334 337
335 klassKlass::oop_update_pointers(cm, obj); 338 klassKlass::oop_update_pointers(cm, obj);
340 343
341 klassOop 344 klassOop
342 instanceKlassKlass::allocate_instance_klass(Symbol* name, int vtable_len, int itable_len, 345 instanceKlassKlass::allocate_instance_klass(Symbol* name, int vtable_len, int itable_len,
343 int static_field_size, 346 int static_field_size,
344 unsigned nonstatic_oop_map_count, 347 unsigned nonstatic_oop_map_count,
348 AccessFlags access_flags,
345 ReferenceType rt, TRAPS) { 349 ReferenceType rt, TRAPS) {
346 350
347 const int nonstatic_oop_map_size = 351 const int nonstatic_oop_map_size =
348 instanceKlass::nonstatic_oop_map_size(nonstatic_oop_map_count); 352 instanceKlass::nonstatic_oop_map_size(nonstatic_oop_map_count);
349 int size = instanceKlass::object_size(align_object_offset(vtable_len) + align_object_offset(itable_len) + nonstatic_oop_map_size); 353 int size = align_object_offset(vtable_len) + align_object_offset(itable_len);
354 if (access_flags.is_interface()) {
355 size += align_object_offset(nonstatic_oop_map_size) + (int)sizeof(klassOop)/HeapWordSize;
356 } else {
357 size += nonstatic_oop_map_size;
358 }
359 size = instanceKlass::object_size(size);
350 360
351 // Allocation 361 // Allocation
352 KlassHandle h_this_klass(THREAD, as_klassOop()); 362 KlassHandle h_this_klass(THREAD, as_klassOop());
353 KlassHandle k; 363 KlassHandle k;
354 if (rt == REF_NONE) { 364 if (rt == REF_NONE) {
376 // sizes before the first GC, i.e., when we allocate the mirror. 386 // sizes before the first GC, i.e., when we allocate the mirror.
377 ik->set_vtable_length(vtable_len); 387 ik->set_vtable_length(vtable_len);
378 ik->set_itable_length(itable_len); 388 ik->set_itable_length(itable_len);
379 ik->set_static_field_size(static_field_size); 389 ik->set_static_field_size(static_field_size);
380 ik->set_nonstatic_oop_map_size(nonstatic_oop_map_size); 390 ik->set_nonstatic_oop_map_size(nonstatic_oop_map_size);
391 ik->set_access_flags(access_flags);
381 assert(k()->size() == size, "wrong size for object"); 392 assert(k()->size() == size, "wrong size for object");
382 393
383 ik->set_array_klasses(NULL); 394 ik->set_array_klasses(NULL);
384 ik->set_methods(NULL); 395 ik->set_methods(NULL);
385 ik->set_method_ordering(NULL); 396 ik->set_method_ordering(NULL);
468 if (n >= MaxSubklassPrintSize) st->print("(%d more klasses...)", n - MaxSubklassPrintSize); 479 if (n >= MaxSubklassPrintSize) st->print("(%d more klasses...)", n - MaxSubklassPrintSize);
469 st->cr(); 480 st->cr();
470 481
471 if (ik->is_interface()) { 482 if (ik->is_interface()) {
472 st->print_cr(BULLET"nof implementors: %d", ik->nof_implementors()); 483 st->print_cr(BULLET"nof implementors: %d", ik->nof_implementors());
473 int print_impl = 0; 484 if (ik->nof_implementors() == 1) {
474 for (int i = 0; i < instanceKlass::implementors_limit; i++) { 485 st->print_cr(BULLET"implementor: ");
475 if (ik->implementor(i) != NULL) { 486 st->print(" ");
476 if (++print_impl == 1) 487 ik->implementor()->print_value_on(st);
477 st->print_cr(BULLET"implementor: "); 488 st->cr();
478 st->print(" "); 489 }
479 ik->implementor(i)->print_value_on(st);
480 }
481 }
482 if (print_impl > 0) st->cr();
483 } 490 }
484 491
485 st->print(BULLET"arrays: "); ik->array_klasses()->print_value_on(st); st->cr(); 492 st->print(BULLET"arrays: "); ik->array_klasses()->print_value_on(st); st->cr();
486 st->print(BULLET"methods: "); ik->methods()->print_value_on(st); st->cr(); 493 st->print(BULLET"methods: "); ik->methods()->print_value_on(st); st->cr();
487 if (Verbose) { 494 if (Verbose) {
638 guarantee(sib->super() == super, "siblings should have same superklass"); 645 guarantee(sib->super() == super, "siblings should have same superklass");
639 sib = sib->next_sibling(); 646 sib = sib->next_sibling();
640 } 647 }
641 648
642 // Verify implementor fields 649 // Verify implementor fields
643 bool saw_null_impl = false; 650 klassOop im = ik->implementor();
644 for (int i = 0; i < instanceKlass::implementors_limit; i++) { 651 if (im != NULL) {
645 klassOop im = ik->implementor(i);
646 if (im == NULL) { saw_null_impl = true; continue; }
647 guarantee(!saw_null_impl, "non-nulls must preceded all nulls");
648 guarantee(ik->is_interface(), "only interfaces should have implementor set"); 652 guarantee(ik->is_interface(), "only interfaces should have implementor set");
649 guarantee(i < ik->nof_implementors(), "should only have one implementor");
650 guarantee(im->is_perm(), "should be in permspace"); 653 guarantee(im->is_perm(), "should be in permspace");
651 guarantee(im->is_klass(), "should be klass"); 654 guarantee(im->is_klass(), "should be klass");
652 guarantee(!Klass::cast(klassOop(im))->is_interface(), "implementors cannot be interfaces"); 655 guarantee(!Klass::cast(klassOop(im))->is_interface() || im == ik->as_klassOop(), "implementors cannot be interfaces");
653 } 656 }
654 657
655 // Verify local interfaces 658 // Verify local interfaces
656 objArrayOop local_interfaces = ik->local_interfaces(); 659 objArrayOop local_interfaces = ik->local_interfaces();
657 guarantee(local_interfaces->is_perm(), "should be in permspace"); 660 guarantee(local_interfaces->is_perm(), "should be in permspace");