< prev index next >

src/share/vm/aot/aotCodeHeap.cpp

Print this page




 543     link_graal_runtime_symbols();
 544 
 545     // Link primitive array klasses.
 546     link_primitive_array_klasses();
 547   }
 548 }
 549 
 550 #ifndef PRODUCT
 551 int AOTCodeHeap::klasses_seen = 0;
 552 int AOTCodeHeap::aot_klasses_found = 0;
 553 int AOTCodeHeap::aot_klasses_fp_miss = 0;
 554 int AOTCodeHeap::aot_klasses_cl_miss = 0;
 555 int AOTCodeHeap::aot_methods_found = 0;
 556 
 557 void AOTCodeHeap::print_statistics() {
 558   tty->print_cr("Classes seen: %d  AOT classes found: %d  AOT methods found: %d", klasses_seen, aot_klasses_found, aot_methods_found);
 559   tty->print_cr("AOT fingerprint mismatches: %d  AOT class loader mismatches: %d", aot_klasses_fp_miss, aot_klasses_cl_miss);
 560 }
 561 #endif
 562 
 563 Method* AOTCodeHeap::find_method(KlassHandle klass, Thread* thread, const char* method_name) {
 564   int method_name_len = build_u2_from((address)method_name);
 565   method_name += 2;
 566   const char* signature_name = method_name + method_name_len;
 567   int signature_name_len = build_u2_from((address)signature_name);
 568   signature_name += 2;
 569   // The class should have been loaded so the method and signature should already be
 570   // in the symbol table.  If they're not there, the method doesn't exist.
 571   TempNewSymbol name = SymbolTable::probe(method_name, method_name_len);
 572   TempNewSymbol signature = SymbolTable::probe(signature_name, signature_name_len);
 573 
 574   Method* m;
 575   if (name == NULL || signature == NULL) {
 576     m = NULL;
 577   } else if (name == vmSymbols::object_initializer_name() ||
 578              name == vmSymbols::class_initializer_name()) {
 579     // Never search superclasses for constructors
 580     if (klass->is_instance_klass()) {
 581       m = InstanceKlass::cast(klass())->find_method(name, signature);
 582     } else {
 583       m = NULL;
 584     }
 585   } else {
 586     m = klass->lookup_method(name, signature);
 587     if (m == NULL && klass->is_instance_klass()) {
 588       m = InstanceKlass::cast(klass())->lookup_method_in_ordered_interfaces(name, signature);
 589     }
 590   }
 591   if (m == NULL) {
 592     // Fatal error because we assume classes and methods should not be changed since aot compilation.
 593     const char* klass_name = klass->external_name();
 594     int klass_len = (int)strlen(klass_name);
 595     char* meta_name = NEW_RESOURCE_ARRAY(char, klass_len + 1 + method_name_len + signature_name_len + 1);
 596     memcpy(meta_name, klass_name, klass_len);
 597     meta_name[klass_len] = '.';
 598     memcpy(&meta_name[klass_len + 1], method_name, method_name_len);
 599     memcpy(&meta_name[klass_len + 1 + method_name_len], signature_name, signature_name_len);
 600     meta_name[klass_len + 1 + method_name_len + signature_name_len] = '\0';
 601     Handle exception = Exceptions::new_exception(thread, vmSymbols::java_lang_NoSuchMethodError(), meta_name);
 602     java_lang_Throwable::print(exception(), tty);
 603     tty->cr();
 604     java_lang_Throwable::print_stack_trace(exception, tty);
 605     tty->cr();
 606     fatal("Failed to find method '%s'", meta_name);
 607   }
 608   NOT_PRODUCT( aot_methods_found++; )


 652       int code_id = indexes[i];
 653       // Invalidate aot code.
 654       if (Atomic::cmpxchg(invalid, (jint*)&_code_to_aot[code_id]._state, not_set) != not_set) {
 655         if (_code_to_aot[code_id]._state == in_use) {
 656           AOTCompiledMethod* aot = _code_to_aot[code_id]._aot;
 657           assert(aot != NULL, "aot should be set");
 658           if (!aot->is_runtime_stub()) { // Something is wrong - should not invalidate stubs.
 659             aot->mark_for_deoptimization(false);
 660             marked++;
 661           }
 662         }
 663       }
 664     }
 665     if (marked > 0) {
 666       VM_Deoptimize op;
 667       VMThread::execute(&op);
 668     }
 669   }
 670 }
 671 
 672 bool AOTCodeHeap::load_klass_data(instanceKlassHandle kh, Thread* thread) {
 673   ResourceMark rm;
 674 
 675   NOT_PRODUCT( klasses_seen++; )
 676 
 677   AOTKlassData* klass_data = find_klass(kh());
 678   if (klass_data == NULL) {
 679     return false;
 680   }
 681 
 682   if (!kh->has_passed_fingerprint_check()) {
 683     NOT_PRODUCT( aot_klasses_fp_miss++; )
 684     log_trace(aot, class, fingerprint)("class  %s%s  has bad fingerprint in  %s tid=" INTPTR_FORMAT,
 685                                    kh->internal_name(), kh->is_shared() ? " (shared)" : "",
 686                                    _lib->name(), p2i(thread));
 687     sweep_dependent_methods(klass_data);
 688     return false;
 689   }
 690 
 691   if (kh->has_been_redefined()) {
 692     log_trace(aot, class, load)("class  %s%s in %s  has been redefined tid=" INTPTR_FORMAT,
 693                                    kh->internal_name(), kh->is_shared() ? " (shared)" : "",
 694                                    _lib->name(), p2i(thread));
 695     sweep_dependent_methods(klass_data);
 696     return false;
 697   }
 698 
 699   assert(klass_data->_class_id < _class_count, "invalid class id");
 700   AOTClass* aot_class = &_classes[klass_data->_class_id];
 701   if (aot_class->_classloader != NULL && aot_class->_classloader != kh->class_loader_data()) {
 702     log_trace(aot, class, load)("class  %s  in  %s already loaded for classloader %p vs %p tid=" INTPTR_FORMAT,
 703                              kh->internal_name(), _lib->name(), aot_class->_classloader, kh->class_loader_data(), p2i(thread));
 704     NOT_PRODUCT( aot_klasses_cl_miss++; )
 705     return false;
 706   }
 707 
 708   if (_lib->config()->_omitAssertions && JavaAssertions::enabled(kh->name()->as_C_string(), kh->class_loader() == NULL)) {
 709     log_trace(aot, class, load)("class  %s  in  %s does not have java assertions in compiled code, but assertions are enabled for this execution.", kh->internal_name(), _lib->name());
 710     sweep_dependent_methods(klass_data);
 711     return false;
 712   }
 713 
 714   NOT_PRODUCT( aot_klasses_found++; )
 715 
 716   log_trace(aot, class, load)("found  %s  in  %s for classloader %p tid=" INTPTR_FORMAT, kh->internal_name(), _lib->name(), kh->class_loader_data(), p2i(thread));
 717 
 718   aot_class->_classloader = kh->class_loader_data();
 719   // Set klass's Resolve (second) got cell.
 720   _metaspace_got[klass_data->_got_index] = kh();
 721 
 722   // Initialize global symbols of the DSO to the corresponding VM symbol values.
 723   link_global_lib_symbols();
 724 
 725   int methods_offset = klass_data->_compiled_methods_offset;
 726   if (methods_offset >= 0) {
 727     address methods_cnt_adr = _methods_offsets + methods_offset;
 728     int methods_cnt = *(int*)methods_cnt_adr;
 729     // Collect data about compiled methods
 730     AOTMethodData* methods_data = NEW_RESOURCE_ARRAY(AOTMethodData, methods_cnt);
 731     AOTMethodOffsets* methods_offsets = (AOTMethodOffsets*)(methods_cnt_adr + 4);
 732     for (int i = 0; i < methods_cnt; ++i) {
 733       AOTMethodOffsets* method_offsets = &methods_offsets[i];
 734       int code_id = method_offsets->_code_id;
 735       if (_code_to_aot[code_id]._state == invalid) {
 736         continue; // skip AOT methods slots which have been invalidated
 737       }
 738       AOTMethodData* method_data = &methods_data[i];
 739       const char* aot_name = _metaspace_names + method_offsets->_name_offset;
 740       method_data->_name = aot_name;
 741       method_data->_code = _code_space  + method_offsets->_code_offset;
 742       method_data->_meta = (aot_metadata*)(_method_metadata + method_offsets->_meta_offset);
 743       method_data->_metadata_table = (address)_metadata_got + method_offsets->_metadata_got_offset;
 744       method_data->_metadata_size  = method_offsets->_metadata_got_size;
 745       // aot_name format: "<u2_size>Ljava/lang/ThreadGroup;<u2_size>addUnstarted<u2_size>()V"
 746       int klass_len = build_u2_from((address)aot_name);
 747       const char* method_name = aot_name + 2 + klass_len;
 748       Method* m = AOTCodeHeap::find_method(kh, thread, method_name);
 749       methodHandle mh(thread, m);
 750       if (mh->code() != NULL) { // Does it have already compiled code?
 751         continue; // Don't overwrite
 752       }
 753       publish_aot(mh, method_data, code_id);
 754     }
 755   }
 756   return true;
 757 }
 758 
 759 AOTCompiledMethod* AOTCodeHeap::next_in_use_at(int start) const {
 760   for (int index = start; index < _method_count; index++) {
 761     if (_code_to_aot[index]._state != in_use) {
 762       continue; // Skip uninitialized entries.
 763     }
 764     AOTCompiledMethod* aot = _code_to_aot[index]._aot;
 765     return aot;
 766   }
 767   return NULL;
 768 }


 868     }
 869     AOTCompiledMethod* aot = _code_to_aot[index]._aot;
 870     aot->cleanup_inline_caches();
 871   }
 872 }
 873 
 874 #ifdef ASSERT
 875 int AOTCodeHeap::verify_icholder_relocations() {
 876   int count = 0;
 877   for (int index = 0; index < _method_count; index++) {
 878     if (_code_to_aot[index]._state != in_use) {
 879       continue; // Skip uninitialized entries.
 880     }
 881     AOTCompiledMethod* aot = _code_to_aot[index]._aot;
 882     count += aot->verify_icholder_relocations();
 883   }
 884   return count;
 885 }
 886 #endif
 887 
 888 void AOTCodeHeap::flush_evol_dependents_on(instanceKlassHandle dependee) {
 889   for (int index = 0; index < _method_count; index++) {
 890     if (_code_to_aot[index]._state != in_use) {
 891       continue; // Skip uninitialized entries.
 892     }
 893     AOTCompiledMethod* aot = _code_to_aot[index]._aot;
 894     aot->flush_evol_dependents_on(dependee);
 895   }
 896 }
 897 
 898 void AOTCodeHeap::metadata_do(void f(Metadata*)) {
 899   for (int index = 0; index < _method_count; index++) {
 900     if (_code_to_aot[index]._state != in_use) {
 901       continue; // Skip uninitialized entries.
 902     }
 903     AOTCompiledMethod* aot = _code_to_aot[index]._aot;
 904     if (aot->_is_alive()) {
 905       aot->metadata_do(f);
 906     }
 907   }
 908 #if 0


 543     link_graal_runtime_symbols();
 544 
 545     // Link primitive array klasses.
 546     link_primitive_array_klasses();
 547   }
 548 }
 549 
 550 #ifndef PRODUCT
 551 int AOTCodeHeap::klasses_seen = 0;
 552 int AOTCodeHeap::aot_klasses_found = 0;
 553 int AOTCodeHeap::aot_klasses_fp_miss = 0;
 554 int AOTCodeHeap::aot_klasses_cl_miss = 0;
 555 int AOTCodeHeap::aot_methods_found = 0;
 556 
 557 void AOTCodeHeap::print_statistics() {
 558   tty->print_cr("Classes seen: %d  AOT classes found: %d  AOT methods found: %d", klasses_seen, aot_klasses_found, aot_methods_found);
 559   tty->print_cr("AOT fingerprint mismatches: %d  AOT class loader mismatches: %d", aot_klasses_fp_miss, aot_klasses_cl_miss);
 560 }
 561 #endif
 562 
 563 Method* AOTCodeHeap::find_method(Klass* klass, Thread* thread, const char* method_name) {
 564   int method_name_len = build_u2_from((address)method_name);
 565   method_name += 2;
 566   const char* signature_name = method_name + method_name_len;
 567   int signature_name_len = build_u2_from((address)signature_name);
 568   signature_name += 2;
 569   // The class should have been loaded so the method and signature should already be
 570   // in the symbol table.  If they're not there, the method doesn't exist.
 571   TempNewSymbol name = SymbolTable::probe(method_name, method_name_len);
 572   TempNewSymbol signature = SymbolTable::probe(signature_name, signature_name_len);
 573 
 574   Method* m;
 575   if (name == NULL || signature == NULL) {
 576     m = NULL;
 577   } else if (name == vmSymbols::object_initializer_name() ||
 578              name == vmSymbols::class_initializer_name()) {
 579     // Never search superclasses for constructors
 580     if (klass->is_instance_klass()) {
 581       m = InstanceKlass::cast(klass)->find_method(name, signature);
 582     } else {
 583       m = NULL;
 584     }
 585   } else {
 586     m = klass->lookup_method(name, signature);
 587     if (m == NULL && klass->is_instance_klass()) {
 588       m = InstanceKlass::cast(klass)->lookup_method_in_ordered_interfaces(name, signature);
 589     }
 590   }
 591   if (m == NULL) {
 592     // Fatal error because we assume classes and methods should not be changed since aot compilation.
 593     const char* klass_name = klass->external_name();
 594     int klass_len = (int)strlen(klass_name);
 595     char* meta_name = NEW_RESOURCE_ARRAY(char, klass_len + 1 + method_name_len + signature_name_len + 1);
 596     memcpy(meta_name, klass_name, klass_len);
 597     meta_name[klass_len] = '.';
 598     memcpy(&meta_name[klass_len + 1], method_name, method_name_len);
 599     memcpy(&meta_name[klass_len + 1 + method_name_len], signature_name, signature_name_len);
 600     meta_name[klass_len + 1 + method_name_len + signature_name_len] = '\0';
 601     Handle exception = Exceptions::new_exception(thread, vmSymbols::java_lang_NoSuchMethodError(), meta_name);
 602     java_lang_Throwable::print(exception(), tty);
 603     tty->cr();
 604     java_lang_Throwable::print_stack_trace(exception, tty);
 605     tty->cr();
 606     fatal("Failed to find method '%s'", meta_name);
 607   }
 608   NOT_PRODUCT( aot_methods_found++; )


 652       int code_id = indexes[i];
 653       // Invalidate aot code.
 654       if (Atomic::cmpxchg(invalid, (jint*)&_code_to_aot[code_id]._state, not_set) != not_set) {
 655         if (_code_to_aot[code_id]._state == in_use) {
 656           AOTCompiledMethod* aot = _code_to_aot[code_id]._aot;
 657           assert(aot != NULL, "aot should be set");
 658           if (!aot->is_runtime_stub()) { // Something is wrong - should not invalidate stubs.
 659             aot->mark_for_deoptimization(false);
 660             marked++;
 661           }
 662         }
 663       }
 664     }
 665     if (marked > 0) {
 666       VM_Deoptimize op;
 667       VMThread::execute(&op);
 668     }
 669   }
 670 }
 671 
 672 bool AOTCodeHeap::load_klass_data(InstanceKlass* ik, Thread* thread) {
 673   ResourceMark rm;
 674 
 675   NOT_PRODUCT( klasses_seen++; )
 676 
 677   AOTKlassData* klass_data = find_klass(ik);
 678   if (klass_data == NULL) {
 679     return false;
 680   }
 681 
 682   if (!ik->has_passed_fingerprint_check()) {
 683     NOT_PRODUCT( aot_klasses_fp_miss++; )
 684     log_trace(aot, class, fingerprint)("class  %s%s  has bad fingerprint in  %s tid=" INTPTR_FORMAT,
 685                                    ik->internal_name(), ik->is_shared() ? " (shared)" : "",
 686                                    _lib->name(), p2i(thread));
 687     sweep_dependent_methods(klass_data);
 688     return false;
 689   }
 690 
 691   if (ik->has_been_redefined()) {
 692     log_trace(aot, class, load)("class  %s%s in %s  has been redefined tid=" INTPTR_FORMAT,
 693                                    ik->internal_name(), ik->is_shared() ? " (shared)" : "",
 694                                    _lib->name(), p2i(thread));
 695     sweep_dependent_methods(klass_data);
 696     return false;
 697   }
 698 
 699   assert(klass_data->_class_id < _class_count, "invalid class id");
 700   AOTClass* aot_class = &_classes[klass_data->_class_id];
 701   if (aot_class->_classloader != NULL && aot_class->_classloader != ik->class_loader_data()) {
 702     log_trace(aot, class, load)("class  %s  in  %s already loaded for classloader %p vs %p tid=" INTPTR_FORMAT,
 703                              ik->internal_name(), _lib->name(), aot_class->_classloader, ik->class_loader_data(), p2i(thread));
 704     NOT_PRODUCT( aot_klasses_cl_miss++; )
 705     return false;
 706   }
 707 
 708   if (_lib->config()->_omitAssertions && JavaAssertions::enabled(ik->name()->as_C_string(), ik->class_loader() == NULL)) {
 709     log_trace(aot, class, load)("class  %s  in  %s does not have java assertions in compiled code, but assertions are enabled for this execution.", ik->internal_name(), _lib->name());
 710     sweep_dependent_methods(klass_data);
 711     return false;
 712   }
 713 
 714   NOT_PRODUCT( aot_klasses_found++; )
 715 
 716   log_trace(aot, class, load)("found  %s  in  %s for classloader %p tid=" INTPTR_FORMAT, ik->internal_name(), _lib->name(), ik->class_loader_data(), p2i(thread));
 717 
 718   aot_class->_classloader = ik->class_loader_data();
 719   // Set klass's Resolve (second) got cell.
 720   _metaspace_got[klass_data->_got_index] = ik;
 721 
 722   // Initialize global symbols of the DSO to the corresponding VM symbol values.
 723   link_global_lib_symbols();
 724 
 725   int methods_offset = klass_data->_compiled_methods_offset;
 726   if (methods_offset >= 0) {
 727     address methods_cnt_adr = _methods_offsets + methods_offset;
 728     int methods_cnt = *(int*)methods_cnt_adr;
 729     // Collect data about compiled methods
 730     AOTMethodData* methods_data = NEW_RESOURCE_ARRAY(AOTMethodData, methods_cnt);
 731     AOTMethodOffsets* methods_offsets = (AOTMethodOffsets*)(methods_cnt_adr + 4);
 732     for (int i = 0; i < methods_cnt; ++i) {
 733       AOTMethodOffsets* method_offsets = &methods_offsets[i];
 734       int code_id = method_offsets->_code_id;
 735       if (_code_to_aot[code_id]._state == invalid) {
 736         continue; // skip AOT methods slots which have been invalidated
 737       }
 738       AOTMethodData* method_data = &methods_data[i];
 739       const char* aot_name = _metaspace_names + method_offsets->_name_offset;
 740       method_data->_name = aot_name;
 741       method_data->_code = _code_space  + method_offsets->_code_offset;
 742       method_data->_meta = (aot_metadata*)(_method_metadata + method_offsets->_meta_offset);
 743       method_data->_metadata_table = (address)_metadata_got + method_offsets->_metadata_got_offset;
 744       method_data->_metadata_size  = method_offsets->_metadata_got_size;
 745       // aot_name format: "<u2_size>Ljava/lang/ThreadGroup;<u2_size>addUnstarted<u2_size>()V"
 746       int klass_len = build_u2_from((address)aot_name);
 747       const char* method_name = aot_name + 2 + klass_len;
 748       Method* m = AOTCodeHeap::find_method(ik, thread, method_name);
 749       methodHandle mh(thread, m);
 750       if (mh->code() != NULL) { // Does it have already compiled code?
 751         continue; // Don't overwrite
 752       }
 753       publish_aot(mh, method_data, code_id);
 754     }
 755   }
 756   return true;
 757 }
 758 
 759 AOTCompiledMethod* AOTCodeHeap::next_in_use_at(int start) const {
 760   for (int index = start; index < _method_count; index++) {
 761     if (_code_to_aot[index]._state != in_use) {
 762       continue; // Skip uninitialized entries.
 763     }
 764     AOTCompiledMethod* aot = _code_to_aot[index]._aot;
 765     return aot;
 766   }
 767   return NULL;
 768 }


 868     }
 869     AOTCompiledMethod* aot = _code_to_aot[index]._aot;
 870     aot->cleanup_inline_caches();
 871   }
 872 }
 873 
 874 #ifdef ASSERT
 875 int AOTCodeHeap::verify_icholder_relocations() {
 876   int count = 0;
 877   for (int index = 0; index < _method_count; index++) {
 878     if (_code_to_aot[index]._state != in_use) {
 879       continue; // Skip uninitialized entries.
 880     }
 881     AOTCompiledMethod* aot = _code_to_aot[index]._aot;
 882     count += aot->verify_icholder_relocations();
 883   }
 884   return count;
 885 }
 886 #endif
 887 
 888 void AOTCodeHeap::flush_evol_dependents_on(InstanceKlass* dependee) {
 889   for (int index = 0; index < _method_count; index++) {
 890     if (_code_to_aot[index]._state != in_use) {
 891       continue; // Skip uninitialized entries.
 892     }
 893     AOTCompiledMethod* aot = _code_to_aot[index]._aot;
 894     aot->flush_evol_dependents_on(dependee);
 895   }
 896 }
 897 
 898 void AOTCodeHeap::metadata_do(void f(Metadata*)) {
 899   for (int index = 0; index < _method_count; index++) {
 900     if (_code_to_aot[index]._state != in_use) {
 901       continue; // Skip uninitialized entries.
 902     }
 903     AOTCompiledMethod* aot = _code_to_aot[index]._aot;
 904     if (aot->_is_alive()) {
 905       aot->metadata_do(f);
 906     }
 907   }
 908 #if 0
< prev index next >