450 _reads = (GrowableArray<ModuleEntry*>*)archived_reads;
451 if (_version != NULL) {
452 _version = ArchiveBuilder::get_relocated_symbol(_version);
453 }
454 if (_location != NULL) {
455 _location = ArchiveBuilder::get_relocated_symbol(_location);
456 }
457 JFR_ONLY(set_trace_id(0));// re-init at runtime
458
459 ArchivePtrMarker::mark_pointer((address*)&_reads);
460 ArchivePtrMarker::mark_pointer((address*)&_version);
461 ArchivePtrMarker::mark_pointer((address*)&_location);
462 }
463
464 void ModuleEntry::init_archived_oops() {
465 assert(DumpSharedSpaces, "static dump only");
466 oop module_obj = module();
467 if (module_obj != NULL) {
468 oop m = HeapShared::find_archived_heap_object(module_obj);
469 assert(m != NULL, "sanity");
470 _archived_module_narrow_oop = CompressedOops::encode(m);
471 }
472 assert(shared_protection_domain() == NULL, "never set during -Xshare:dump");
473 // Clear handles and restore at run time. Handles cannot be archived.
474 OopHandle null_handle;
475 _module = null_handle;
476 }
477
478 void ModuleEntry::load_from_archive(ClassLoaderData* loader_data) {
479 set_loader_data(loader_data);
480 _reads = restore_growable_array((Array<ModuleEntry*>*)_reads);
481 JFR_ONLY(INIT_ID(this);)
482 }
483
484 void ModuleEntry::restore_archive_oops(ClassLoaderData* loader_data) {
485 Handle module_handle(Thread::current(), HeapShared::materialize_archived_object(_archived_module_narrow_oop));
486 assert(module_handle.not_null(), "huh");
487 set_module(loader_data->add_handle(module_handle));
488
489 // This was cleared to zero during dump time -- we didn't save the value
490 // because it may be affected by archive relocation.
491 java_lang_Module::set_module_entry(module_handle(), this);
492
493 if (loader_data->class_loader() != NULL) {
494 java_lang_Module::set_loader(module_handle(), loader_data->class_loader());
495 }
496 }
497
498 static int compare_module_by_name(ModuleEntry* a, ModuleEntry* b) {
499 assert(a == b || a->name() != b->name(), "no duplicated names");
500 return a->name()->fast_compare(b->name());
501 }
502
503 void ModuleEntryTable::iterate_symbols(MetaspaceClosure* closure) {
504 for (int i = 0; i < table_size(); ++i) {
505 for (ModuleEntry* m = bucket(i); m != NULL; m = m->next()) {
506 m->iterate_symbols(closure);
507 }
508 }
509 }
510
511 Array<ModuleEntry*>* ModuleEntryTable::allocate_archived_entries() {
512 Array<ModuleEntry*>* archived_modules = MetaspaceShared::new_rw_array<ModuleEntry*>(number_of_entries());
513 int n = 0;
514 for (int i = 0; i < table_size(); ++i) {
515 for (ModuleEntry* m = bucket(i); m != NULL; m = m->next()) {
516 archived_modules->at_put(n++, m);
517 }
544 }
545
546 void ModuleEntryTable::load_archived_entries(ClassLoaderData* loader_data,
547 Array<ModuleEntry*>* archived_modules) {
548 assert(UseSharedSpaces, "runtime only");
549
550 for (int i = 0; i < archived_modules->length(); i++) {
551 ModuleEntry* archived_entry = archived_modules->at(i);
552 archived_entry->load_from_archive(loader_data);
553
554 unsigned int hash = compute_hash(archived_entry->name());
555 archived_entry->set_hash(hash);
556 add_entry(hash_to_index(hash), archived_entry);
557 }
558 }
559
560 void ModuleEntryTable::restore_archived_oops(ClassLoaderData* loader_data, Array<ModuleEntry*>* archived_modules) {
561 assert(UseSharedSpaces, "runtime only");
562 for (int i = 0; i < archived_modules->length(); i++) {
563 ModuleEntry* archived_entry = archived_modules->at(i);
564 archived_entry->restore_archive_oops(loader_data);
565 }
566 }
567 #endif // INCLUDE_CDS_JAVA_HEAP
568
569 ModuleEntry* ModuleEntryTable::new_entry(unsigned int hash, Handle module_handle,
570 bool is_open, Symbol* name,
571 Symbol* version, Symbol* location,
572 ClassLoaderData* loader_data) {
573 assert(Module_lock->owned_by_self(), "should have the Module_lock");
574 ModuleEntry* entry = (ModuleEntry*)Hashtable<Symbol*, mtModule>::allocate_new_entry(hash, name);
575
576 // Initialize fields specific to a ModuleEntry
577 entry->init();
578 if (name != NULL) {
579 name->increment_refcount();
580 } else {
581 // Unnamed modules can read all other unnamed modules.
582 entry->set_can_read_all_unnamed();
583 }
584
|
450 _reads = (GrowableArray<ModuleEntry*>*)archived_reads;
451 if (_version != NULL) {
452 _version = ArchiveBuilder::get_relocated_symbol(_version);
453 }
454 if (_location != NULL) {
455 _location = ArchiveBuilder::get_relocated_symbol(_location);
456 }
457 JFR_ONLY(set_trace_id(0));// re-init at runtime
458
459 ArchivePtrMarker::mark_pointer((address*)&_reads);
460 ArchivePtrMarker::mark_pointer((address*)&_version);
461 ArchivePtrMarker::mark_pointer((address*)&_location);
462 }
463
464 void ModuleEntry::init_archived_oops() {
465 assert(DumpSharedSpaces, "static dump only");
466 oop module_obj = module();
467 if (module_obj != NULL) {
468 oop m = HeapShared::find_archived_heap_object(module_obj);
469 assert(m != NULL, "sanity");
470 _archived_module_index = HeapShared::append_root(m);
471 }
472 assert(shared_protection_domain() == NULL, "never set during -Xshare:dump");
473 // Clear handles and restore at run time. Handles cannot be archived.
474 OopHandle null_handle;
475 _module = null_handle;
476 }
477
478 void ModuleEntry::load_from_archive(ClassLoaderData* loader_data) {
479 set_loader_data(loader_data);
480 _reads = restore_growable_array((Array<ModuleEntry*>*)_reads);
481 JFR_ONLY(INIT_ID(this);)
482 }
483
484 void ModuleEntry::restore_archived_oops(ClassLoaderData* loader_data) {
485 Handle module_handle(Thread::current(), HeapShared::get_root(_archived_module_index, /*clear=*/true));
486 assert(module_handle.not_null(), "huh");
487 set_module(loader_data->add_handle(module_handle));
488
489 // This was cleared to zero during dump time -- we didn't save the value
490 // because it may be affected by archive relocation.
491 java_lang_Module::set_module_entry(module_handle(), this);
492
493 if (loader_data->class_loader() != NULL) {
494 java_lang_Module::set_loader(module_handle(), loader_data->class_loader());
495 }
496 }
497
498 void ModuleEntry::clear_archived_oops() {
499 HeapShared::clear_root(_archived_module_index);
500 }
501
502 static int compare_module_by_name(ModuleEntry* a, ModuleEntry* b) {
503 assert(a == b || a->name() != b->name(), "no duplicated names");
504 return a->name()->fast_compare(b->name());
505 }
506
507 void ModuleEntryTable::iterate_symbols(MetaspaceClosure* closure) {
508 for (int i = 0; i < table_size(); ++i) {
509 for (ModuleEntry* m = bucket(i); m != NULL; m = m->next()) {
510 m->iterate_symbols(closure);
511 }
512 }
513 }
514
515 Array<ModuleEntry*>* ModuleEntryTable::allocate_archived_entries() {
516 Array<ModuleEntry*>* archived_modules = MetaspaceShared::new_rw_array<ModuleEntry*>(number_of_entries());
517 int n = 0;
518 for (int i = 0; i < table_size(); ++i) {
519 for (ModuleEntry* m = bucket(i); m != NULL; m = m->next()) {
520 archived_modules->at_put(n++, m);
521 }
548 }
549
550 void ModuleEntryTable::load_archived_entries(ClassLoaderData* loader_data,
551 Array<ModuleEntry*>* archived_modules) {
552 assert(UseSharedSpaces, "runtime only");
553
554 for (int i = 0; i < archived_modules->length(); i++) {
555 ModuleEntry* archived_entry = archived_modules->at(i);
556 archived_entry->load_from_archive(loader_data);
557
558 unsigned int hash = compute_hash(archived_entry->name());
559 archived_entry->set_hash(hash);
560 add_entry(hash_to_index(hash), archived_entry);
561 }
562 }
563
564 void ModuleEntryTable::restore_archived_oops(ClassLoaderData* loader_data, Array<ModuleEntry*>* archived_modules) {
565 assert(UseSharedSpaces, "runtime only");
566 for (int i = 0; i < archived_modules->length(); i++) {
567 ModuleEntry* archived_entry = archived_modules->at(i);
568 archived_entry->restore_archived_oops(loader_data);
569 }
570 }
571 #endif // INCLUDE_CDS_JAVA_HEAP
572
573 ModuleEntry* ModuleEntryTable::new_entry(unsigned int hash, Handle module_handle,
574 bool is_open, Symbol* name,
575 Symbol* version, Symbol* location,
576 ClassLoaderData* loader_data) {
577 assert(Module_lock->owned_by_self(), "should have the Module_lock");
578 ModuleEntry* entry = (ModuleEntry*)Hashtable<Symbol*, mtModule>::allocate_new_entry(hash, name);
579
580 // Initialize fields specific to a ModuleEntry
581 entry->init();
582 if (name != NULL) {
583 name->increment_refcount();
584 } else {
585 // Unnamed modules can read all other unnamed modules.
586 entry->set_can_read_all_unnamed();
587 }
588
|