jdk-sandbox: comparison hotspot/src/share/vm/memory/metaspaceShared.cpp

equal deleted inserted replaced

-:e704f55561c3
+:a993ec29ec75
 // CDS code for dumping shared archive.
 // Global object for holding classes that have been loaded.  Since this
 // is run at a safepoint just before exit, this is the entire set of classes.
 static GrowableArray<Klass*>* _global_klass_objects;
+static void collect_array_classes(Klass* k) {
+_global_klass_objects->append_if_missing(k);
+if (k->is_array_klass()) {
+// Add in the array classes too
+ArrayKlass* ak = ArrayKlass::cast(k);
+Klass* h = ak->higher_dimension();
+if (h != NULL) {
+h->array_klasses_do(collect_array_classes);
+}
+}
+}
 class CollectClassesClosure : public KlassClosure {
 void do_klass(Klass* k) {
 if (!(k->is_instance_klass() && InstanceKlass::cast(k)->is_in_error_state())) {
 _global_klass_objects->append_if_missing(k);
 }
+if (k->is_array_klass()) {
+// Add in the array classes too
+ArrayKlass* ak = ArrayKlass::cast(k);
+Klass* h = ak->higher_dimension();
+if (h != NULL) {
+h->array_klasses_do(collect_array_classes);
+}
+}
 }
 };
 static void remove_unshareable_in_classes() {
 for (int i = 0; i < _global_klass_objects->length(); i++) {
 Klass* k = _global_klass_objects->at(i);
-k->remove_unshareable_info();
+if (!k->is_objArray_klass()) {
+// InstanceKlass and TypeArrayKlass will in turn call remove_unshareable_info
+// on their array classes.
+assert(k->is_instance_klass() || k->is_typeArray_klass(), "must be");
+k->remove_unshareable_info();
+}
+}
+}
+static void remove_java_mirror_in_classes() {
+for (int i = 0; i < _global_klass_objects->length(); i++) {
+Klass* k = _global_klass_objects->at(i);
+if (!k->is_objArray_klass()) {
+// InstanceKlass and TypeArrayKlass will in turn call remove_unshareable_info
+// on their array classes.
+assert(k->is_instance_klass() || k->is_typeArray_klass(), "must be");
+k->remove_java_mirror();
+}
 }
 }
 static void rewrite_nofast_bytecode(Method* method) {
-RawBytecodeStream bcs(method);
+BytecodeStream bcs(method);
 while (!bcs.is_last_bytecode()) {
-Bytecodes::Code opcode = bcs.raw_next();
+Bytecodes::Code opcode = bcs.next();
 switch (opcode) {
 case Bytecodes::_getfield:      *bcs.bcp() = Bytecodes::_nofast_getfield;      break;
 case Bytecodes::_putfield:      *bcs.bcp() = Bytecodes::_nofast_putfield;      break;
 case Bytecodes::_aload_0:       *bcs.bcp() = Bytecodes::_nofast_aload_0;       break;
 case Bytecodes::_iload: {
 ik->set_archived_class_data(q);
 }
 }
 }
 }
+NOT_PRODUCT(
+static void assert_not_anonymous_class(InstanceKlass* k) {
+assert(!(k->is_anonymous()), "cannot archive anonymous classes");
+}
+// Anonymous classes are not stored inside any dictionaries. They are created by
+// SystemDictionary::parse_stream() with a non-null host_klass.
+static void assert_no_anonymoys_classes_in_dictionaries() {
+ClassLoaderDataGraph::dictionary_classes_do(assert_not_anonymous_class);
+})
 // Objects of the Metadata types (such as Klass and ConstantPool) have C++ vtables.
 // (In GCC this is the field <Type>::_vptr, i.e., first word in the object.)
 //
 // Addresses of the vtables and the methods may be different across JVM runs,
 p = _rw_region.allocate(bytes, alignment);
 newtop = _rw_region.top();
 }
 memcpy(p, obj, bytes);
 bool isnew = _new_loc_table->put(obj, (address)p);
+log_trace(cds)("Copy: " PTR_FORMAT " ==> " PTR_FORMAT " %d", p2i(obj), p2i(p), bytes);
 assert(isnew, "must be");
-log_trace(cds)("Copy: " PTR_FORMAT " ==> " PTR_FORMAT " %d", p2i(obj), p2i(p), bytes);
 _alloc_stats->record(ref->msotype(), int(newtop - oldtop), read_only);
 if (ref->msotype() == MetaspaceObj::SymbolType) {
 uintx delta = MetaspaceShared::object_delta(p);
 if (delta > MAX_SHARED_DELTA) {
 char* VM_PopulateDumpSharedSpace::dump_read_only_tables() {
 char* oldtop = _ro_region.top();
 // Reorder the system dictionary. Moving the symbols affects
 // how the hash table indices are calculated.
 SystemDictionary::reorder_dictionary_for_sharing();
+tty->print("Removing java_mirror ... ");
+remove_java_mirror_in_classes();
+tty->print_cr("done. ");
 NOT_PRODUCT(SystemDictionary::verify();)
 size_t buckets_bytes = SystemDictionary::count_bytes_for_buckets();
 char* buckets_top = _ro_region.allocate(buckets_bytes, sizeof(intptr_t));
 SystemDictionary::copy_buckets(buckets_top, _ro_region.top());
 // Ensure the ConstMethods won't be modified at run-time
 tty->print("Updating ConstMethods ... ");
 rewrite_nofast_bytecodes_and_calculate_fingerprints();
 tty->print_cr("done. ");
+// Move classes from platform/system dictionaries into the boot dictionary
+SystemDictionary::combine_shared_dictionaries();
 // Remove all references outside the metadata
 tty->print("Removing unshareable information ... ");
 remove_unshareable_in_classes();
 tty->print_cr("done. ");
+// We don't support archiving anonymous classes. Verify that they are not stored in
+// the any dictionaries.
+NOT_PRODUCT(assert_no_anonymoys_classes_in_dictionaries());
+SystemDictionaryShared::finalize_verification_constraints();
 ArchiveCompactor::initialize();
 ArchiveCompactor::copy_and_compact();
 dump_symbols();
 if (log_is_enabled(Info, cds)) {
 ArchiveCompactor::alloc_stats()->print_stats(int(_ro_region.used()), int(_rw_region.used()),
 int(_mc_region.used()), int(_md_region.used()));
 }
+if (PrintSystemDictionaryAtExit) {
+SystemDictionary::print();
+}
+// There may be other pending VM operations that operate on the InstanceKlasses,
+// which will fail because InstanceKlasses::remove_unshareable_info()
+// has been called. Forget these operations and exit the VM directly.
+vm_direct_exit(0);
 }
 void VM_PopulateDumpSharedSpace::print_region_stats() {
 // Print statistics of all the regions
 const size_t total_reserved = _ro_region.reserved()  + _rw_region.reserved() +
 } else {
 tty->print_cr("Please remove the unverifiable classes from your class list and try again");
 exit(1);
 }
 }
-// Copy the verification constraints from C_HEAP-alloced GrowableArrays to RO-alloced
-// Arrays
-SystemDictionaryShared::finalize_verification_constraints();
 }
 void MetaspaceShared::prepare_for_dumping() {
 Arguments::check_unsupported_dumping_properties();
 ClassLoader::initialize_shared_path();
 // fails verification, all other interfaces that were not specified in the classlist but
 // are implemented by K are not verified.
 link_and_cleanup_shared_classes(CATCH);
 tty->print_cr("Rewriting and linking classes: done");
+SystemDictionary::clear_invoke_method_table();
 VM_PopulateDumpSharedSpace op;
 VMThread::execute(&op);
 }
-if (PrintSystemDictionaryAtExit) {
-SystemDictionary::print();
-}
-// Since various initialization steps have been undone by this process,
-// it is not reasonable to continue running a java process.
-exit(0);
 }
 int MetaspaceShared::preload_classes(const char* class_list_path, TRAPS) {
 ClassListParser parser(class_list_path);
 int class_count = 0;
 while (parser.parse_one_line()) {
 Klass* klass = ClassLoaderExt::load_one_class(&parser, THREAD);
+if (HAS_PENDING_EXCEPTION) {
-CLEAR_PENDING_EXCEPTION;
+if (klass == NULL &&
+(PENDING_EXCEPTION->klass()->name() == vmSymbols::java_lang_ClassNotFoundException())) {
+// print a warning only when the pending exception is class not found
+tty->print_cr("Preload Warning: Cannot find %s", parser.current_class_name());
+}
+CLEAR_PENDING_EXCEPTION;
+}
 if (klass != NULL) {
 if (log_is_enabled(Trace, cds)) {
 ResourceMark rm;
 log_trace(cds)("Shared spaces preloaded: %s", klass->external_name());
 }

changeset 47103	a993ec29ec75
parent 46989	119e1e88cf15