Mercurial > hg > graal-compiler

comparison src/share/vm/oops/cpCache.cpp @ 8021:8d9fc28831cc

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
7182152: Instrumentation hot swap test incorrect monitor count Summary: Add/refine new tracing support using -XX:TraceRedefineClasses=16384. Reviewed-by: coleenp, acorn, sspitsyn
author dcubed
date Wed, 06 Feb 2013 14:31:37 -0800
parents 80e866b1d053
children 461a3adac4d1
comparison
equal deleted inserted replaced
7988:f3ea1af9207a 8021:8d9fc28831cc
1 /* 1 /*
2 * Copyright (c) 1998, 2012, Oracle and/or its affiliates. All rights reserved. 2 * Copyright (c) 1998, 2013, 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.
399 objArrayOop resolved_references = cpool->resolved_references(); 399 objArrayOop resolved_references = cpool->resolved_references();
400 return resolved_references->obj_at(ref_index); 400 return resolved_references->obj_at(ref_index);
401 } 401 }
402 402
403 403
404 #if INCLUDE_JVMTI
404 // RedefineClasses() API support: 405 // RedefineClasses() API support:
405 // If this constantPoolCacheEntry refers to old_method then update it 406 // If this ConstantPoolCacheEntry refers to old_method then update it
406 // to refer to new_method. 407 // to refer to new_method.
407 bool ConstantPoolCacheEntry::adjust_method_entry(Method* old_method, 408 bool ConstantPoolCacheEntry::adjust_method_entry(Method* old_method,
408 Method* new_method, bool * trace_name_printed) { 409 Method* new_method, bool * trace_name_printed) {
409 410
410 if (is_vfinal()) { 411 if (is_vfinal()) {
458 } 459 }
459 460
460 return false; 461 return false;
461 } 462 }
462 463
463 #ifndef PRODUCT 464 // a constant pool cache entry should never contain old or obsolete methods
464 bool ConstantPoolCacheEntry::check_no_old_entries() { 465 bool ConstantPoolCacheEntry::check_no_old_or_obsolete_entries() {
465 if (is_vfinal()) { 466 if (is_vfinal()) {
467 // virtual and final so _f2 contains method ptr instead of vtable index
466 Metadata* f2 = (Metadata*)_f2; 468 Metadata* f2 = (Metadata*)_f2;
467 return (f2->is_valid() && f2->is_method() && !((Method*)f2)->is_old()); 469 // Return false if _f2 refers to an old or an obsolete method.
468 } else { 470 // _f2 == NULL || !_f2->is_method() are just as unexpected here.
469 return (_f1 == NULL || (_f1->is_valid() && _f1->is_method() && !((Method*)_f1)->is_old())); 471 return (f2 != NULL NOT_PRODUCT(&& f2->is_valid()) && f2->is_method() &&
470 } 472 !((Method*)f2)->is_old() && !((Method*)f2)->is_obsolete());
471 } 473 } else if (_f1 == NULL ||
472 #endif 474 (NOT_PRODUCT(_f1->is_valid() &&) !_f1->is_method())) {
475 // _f1 == NULL || !_f1->is_method() are OK here
476 return true;
477 }
478 // return false if _f1 refers to an old or an obsolete method
479 return (NOT_PRODUCT(_f1->is_valid() &&) _f1->is_method() &&
480 !((Method*)_f1)->is_old() && !((Method*)_f1)->is_obsolete());
481 }
473 482
474 bool ConstantPoolCacheEntry::is_interesting_method_entry(Klass* k) { 483 bool ConstantPoolCacheEntry::is_interesting_method_entry(Klass* k) {
475 if (!is_method_entry()) { 484 if (!is_method_entry()) {
476 // not a method entry so not interesting by default 485 // not a method entry so not interesting by default
477 return false; 486 return false;
500 } 509 }
501 510
502 // the method is in the interesting class so the entry is interesting 511 // the method is in the interesting class so the entry is interesting
503 return true; 512 return true;
504 } 513 }
514 #endif // INCLUDE_JVMTI
505 515
506 void ConstantPoolCacheEntry::print(outputStream* st, int index) const { 516 void ConstantPoolCacheEntry::print(outputStream* st, int index) const {
507 // print separator 517 // print separator
508 if (index == 0) st->print_cr(" -------------"); 518 if (index == 0) st->print_cr(" -------------");
509 // print entry 519 // print entry
510 st->print("%3d ("PTR_FORMAT") ", index, (intptr_t)this); 520 st->print("%3d ("PTR_FORMAT") ", index, (intptr_t)this);
511 st->print_cr("[%02x|%02x|%5d]", bytecode_2(), bytecode_1(), constant_pool_index()); 521 st->print_cr("[%02x|%02x|%5d]", bytecode_2(), bytecode_1(),
522 constant_pool_index());
512 st->print_cr(" [ "PTR_FORMAT"]", (intptr_t)_f1); 523 st->print_cr(" [ "PTR_FORMAT"]", (intptr_t)_f1);
513 st->print_cr(" [ "PTR_FORMAT"]", (intptr_t)_f2); 524 st->print_cr(" [ "PTR_FORMAT"]", (intptr_t)_f2);
514 st->print_cr(" [ "PTR_FORMAT"]", (intptr_t)_flags); 525 st->print_cr(" [ "PTR_FORMAT"]", (intptr_t)_flags);
515 st->print_cr(" -------------"); 526 st->print_cr(" -------------");
516 } 527 }
550 ref += ConstantPoolCacheEntry::_indy_resolved_references_entries - 1; // skip extra entries 561 ref += ConstantPoolCacheEntry::_indy_resolved_references_entries - 1; // skip extra entries
551 } 562 }
552 } 563 }
553 } 564 }
554 565
566 #if INCLUDE_JVMTI
555 // RedefineClasses() API support: 567 // RedefineClasses() API support:
556 // If any entry of this constantPoolCache points to any of 568 // If any entry of this ConstantPoolCache points to any of
557 // old_methods, replace it with the corresponding new_method. 569 // old_methods, replace it with the corresponding new_method.
558 void ConstantPoolCache::adjust_method_entries(Method** old_methods, Method** new_methods, 570 void ConstantPoolCache::adjust_method_entries(Method** old_methods, Method** new_methods,
559 int methods_length, bool * trace_name_printed) { 571 int methods_length, bool * trace_name_printed) {
560 572
561 if (methods_length == 0) { 573 if (methods_length == 0) {
570 if (!entry_at(i)->is_interesting_method_entry(old_holder)) { 582 if (!entry_at(i)->is_interesting_method_entry(old_holder)) {
571 // skip uninteresting methods 583 // skip uninteresting methods
572 continue; 584 continue;
573 } 585 }
574 586
575 // The constantPoolCache contains entries for several different 587 // The ConstantPoolCache contains entries for several different
576 // things, but we only care about methods. In fact, we only care 588 // things, but we only care about methods. In fact, we only care
577 // about methods in the same class as the one that contains the 589 // about methods in the same class as the one that contains the
578 // old_methods. At this point, we have an interesting entry. 590 // old_methods. At this point, we have an interesting entry.
579 591
580 for (int j = 0; j < methods_length; j++) { 592 for (int j = 0; j < methods_length; j++) {
589 } 601 }
590 } 602 }
591 } 603 }
592 } 604 }
593 605
594 #ifndef PRODUCT 606 // the constant pool cache should never contain old or obsolete methods
595 bool ConstantPoolCache::check_no_old_entries() { 607 bool ConstantPoolCache::check_no_old_or_obsolete_entries() {
596 for (int i = 1; i < length(); i++) { 608 for (int i = 1; i < length(); i++) {
597 if (entry_at(i)->is_interesting_method_entry(NULL) && 609 if (entry_at(i)->is_interesting_method_entry(NULL) &&
598 !entry_at(i)->check_no_old_entries()) { 610 !entry_at(i)->check_no_old_or_obsolete_entries()) {
599 return false; 611 return false;
600 } 612 }
601 } 613 }
602 return true; 614 return true;
603 } 615 }
604 #endif // PRODUCT 616
617 void ConstantPoolCache::dump_cache() {
618 for (int i = 1; i < length(); i++) {
619 if (entry_at(i)->is_interesting_method_entry(NULL)) {
620 entry_at(i)->print(tty, i);
621 }
622 }
623 }
624 #endif // INCLUDE_JVMTI
605 625
606 626
607 // Printing 627 // Printing
608 628
609 void ConstantPoolCache::print_on(outputStream* st) const { 629 void ConstantPoolCache::print_on(outputStream* st) const {