23 */
24
25 #include "precompiled.hpp"
26 #include "cds/archiveBuilder.hpp"
27 #include "cds/archiveHeapWriter.hpp"
28 #include "cds/archiveUtils.hpp"
29 #include "cds/cppVtables.hpp"
30 #include "cds/dumpAllocStats.hpp"
31 #include "cds/heapShared.hpp"
32 #include "cds/metaspaceShared.hpp"
33 #include "classfile/classLoaderDataShared.hpp"
34 #include "classfile/symbolTable.hpp"
35 #include "classfile/systemDictionaryShared.hpp"
36 #include "classfile/vmClasses.hpp"
37 #include "interpreter/abstractInterpreter.hpp"
38 #include "logging/log.hpp"
39 #include "logging/logStream.hpp"
40 #include "memory/allStatic.hpp"
41 #include "memory/memRegion.hpp"
42 #include "memory/resourceArea.hpp"
43 #include "oops/instanceKlass.hpp"
44 #include "oops/objArrayKlass.hpp"
45 #include "oops/objArrayOop.inline.hpp"
46 #include "oops/oopHandle.inline.hpp"
47 #include "runtime/arguments.hpp"
48 #include "runtime/globals_extension.hpp"
49 #include "runtime/javaThread.hpp"
50 #include "runtime/sharedRuntime.hpp"
51 #include "utilities/align.hpp"
52 #include "utilities/bitMap.inline.hpp"
53 #include "utilities/formatBuffer.hpp"
54
55 ArchiveBuilder* ArchiveBuilder::_current = nullptr;
56
57 ArchiveBuilder::OtherROAllocMark::~OtherROAllocMark() {
58 char* newtop = ArchiveBuilder::current()->_ro_region.top();
59 ArchiveBuilder::alloc_stats()->record_other_type(int(newtop - _oldtop), true);
60 }
61
62 ArchiveBuilder::SourceObjList::SourceObjList() : _ptrmap(16 * K, mtClassShared) {
63 _total_bytes = 0;
203 GatherKlassesAndSymbols(ArchiveBuilder* builder) : _builder(builder) {}
204
205 virtual bool do_unique_ref(Ref* ref, bool read_only) {
206 return _builder->gather_klass_and_symbol(ref, read_only);
207 }
208 };
209
210 bool ArchiveBuilder::gather_klass_and_symbol(MetaspaceClosure::Ref* ref, bool read_only) {
211 if (ref->obj() == nullptr) {
212 return false;
213 }
214 if (get_follow_mode(ref) != make_a_copy) {
215 return false;
216 }
217 if (ref->msotype() == MetaspaceObj::ClassType) {
218 Klass* klass = (Klass*)ref->obj();
219 assert(klass->is_klass(), "must be");
220 if (!is_excluded(klass)) {
221 _klasses->append(klass);
222 }
223 // See RunTimeClassInfo::get_for()
224 _estimated_metaspaceobj_bytes += align_up(BytesPerWord, SharedSpaceObjectAlignment);
225 } else if (ref->msotype() == MetaspaceObj::SymbolType) {
226 // Make sure the symbol won't be GC'ed while we are dumping the archive.
227 Symbol* sym = (Symbol*)ref->obj();
228 sym->increment_refcount();
229 _symbols->append(sym);
230 }
231
232 int bytes = ref->size() * BytesPerWord;
233 _estimated_metaspaceobj_bytes += align_up(bytes, SharedSpaceObjectAlignment);
234
235 return true; // recurse
236 }
237
238 void ArchiveBuilder::gather_klasses_and_symbols() {
239 ResourceMark rm;
240 log_info(cds)("Gathering classes and symbols ... ");
241 GatherKlassesAndSymbols doit(this);
242 iterate_roots(&doit, /*is_relocating_pointers=*/false);
243 #if INCLUDE_CDS_JAVA_HEAP
244 if (is_dumping_full_module_graph()) {
601 }
602
603 void ArchiveBuilder::make_shallow_copies(DumpRegion *dump_region,
604 const ArchiveBuilder::SourceObjList* src_objs) {
605 for (int i = 0; i < src_objs->objs()->length(); i++) {
606 make_shallow_copy(dump_region, src_objs->objs()->at(i));
607 }
608 log_info(cds)("done (%d objects)", src_objs->objs()->length());
609 }
610
611 void ArchiveBuilder::make_shallow_copy(DumpRegion *dump_region, SourceObjInfo* src_info) {
612 MetaspaceClosure::Ref* ref = src_info->ref();
613 address src = ref->obj();
614 int bytes = src_info->size_in_bytes();
615 char* dest;
616 char* oldtop;
617 char* newtop;
618
619 oldtop = dump_region->top();
620 if (ref->msotype() == MetaspaceObj::ClassType) {
621 // Save a pointer immediate in front of an InstanceKlass, so
622 // we can do a quick lookup from InstanceKlass* -> RunTimeClassInfo*
623 // without building another hashtable. See RunTimeClassInfo::get_for()
624 // in systemDictionaryShared.cpp.
625 Klass* klass = (Klass*)src;
626 if (klass->is_instance_klass()) {
627 SystemDictionaryShared::validate_before_archiving(InstanceKlass::cast(klass));
628 dump_region->allocate(sizeof(address));
629 }
630 }
631 dest = dump_region->allocate(bytes);
632 newtop = dump_region->top();
633
634 memcpy(dest, src, bytes);
635 {
636 bool created;
637 _buffered_to_src_table.put_if_absent((address)dest, src, &created);
638 assert(created, "must be");
639 if (_buffered_to_src_table.maybe_grow()) {
640 log_info(cds, hashtables)("Expanded _buffered_to_src_table table to %d", _buffered_to_src_table.table_size());
641 }
642 }
643
644 intptr_t* archived_vtable = CppVtables::get_archived_vtable(ref->msotype(), (address)dest);
645 if (archived_vtable != nullptr) {
646 *(address*)dest = (address)archived_vtable;
647 ArchivePtrMarker::mark_pointer((address*)dest);
648 }
649
650 log_trace(cds)("Copy: " PTR_FORMAT " ==> " PTR_FORMAT " %d", p2i(src), p2i(dest), bytes);
651 src_info->set_buffered_addr((address)dest);
652
653 _alloc_stats.record(ref->msotype(), int(newtop - oldtop), src_info->read_only());
654 }
655
656 address ArchiveBuilder::get_buffered_addr(address src_addr) const {
657 SourceObjInfo* p = _src_obj_table.get(src_addr);
658 assert(p != nullptr, "must be");
659
660 return p->buffered_addr();
661 }
662
663 address ArchiveBuilder::get_source_addr(address buffered_addr) const {
664 assert(is_in_buffer_space(buffered_addr), "must be");
665 address* src_p = _buffered_to_src_table.get(buffered_addr);
666 assert(src_p != nullptr && *src_p != nullptr, "must be");
667 return *src_p;
668 }
669
670 void ArchiveBuilder::relocate_embedded_pointers(ArchiveBuilder::SourceObjList* src_objs) {
671 for (int i = 0; i < src_objs->objs()->length(); i++) {
672 src_objs->relocate(i, this);
673 }
730 }
731
732 void ArchiveBuilder::make_klasses_shareable() {
733 int num_instance_klasses = 0;
734 int num_boot_klasses = 0;
735 int num_platform_klasses = 0;
736 int num_app_klasses = 0;
737 int num_hidden_klasses = 0;
738 int num_unlinked_klasses = 0;
739 int num_unregistered_klasses = 0;
740 int num_obj_array_klasses = 0;
741 int num_type_array_klasses = 0;
742
743 for (int i = 0; i < klasses()->length(); i++) {
744 const char* type;
745 const char* unlinked = "";
746 const char* hidden = "";
747 const char* generated = "";
748 Klass* k = klasses()->at(i);
749 k->remove_java_mirror();
750 if (k->is_objArray_klass()) {
751 // InstanceKlass and TypeArrayKlass will in turn call remove_unshareable_info
752 // on their array classes.
753 num_obj_array_klasses ++;
754 type = "array";
755 } else if (k->is_typeArray_klass()) {
756 num_type_array_klasses ++;
757 type = "array";
758 k->remove_unshareable_info();
759 } else {
760 assert(k->is_instance_klass(), " must be");
761 num_instance_klasses ++;
762 InstanceKlass* ik = InstanceKlass::cast(k);
763 if (DynamicDumpSharedSpaces) {
764 // For static dump, class loader type are already set.
765 ik->assign_class_loader_type();
766 }
767 if (ik->is_shared_boot_class()) {
768 type = "boot";
769 num_boot_klasses ++;
|
23 */
24
25 #include "precompiled.hpp"
26 #include "cds/archiveBuilder.hpp"
27 #include "cds/archiveHeapWriter.hpp"
28 #include "cds/archiveUtils.hpp"
29 #include "cds/cppVtables.hpp"
30 #include "cds/dumpAllocStats.hpp"
31 #include "cds/heapShared.hpp"
32 #include "cds/metaspaceShared.hpp"
33 #include "classfile/classLoaderDataShared.hpp"
34 #include "classfile/symbolTable.hpp"
35 #include "classfile/systemDictionaryShared.hpp"
36 #include "classfile/vmClasses.hpp"
37 #include "interpreter/abstractInterpreter.hpp"
38 #include "logging/log.hpp"
39 #include "logging/logStream.hpp"
40 #include "memory/allStatic.hpp"
41 #include "memory/memRegion.hpp"
42 #include "memory/resourceArea.hpp"
43 #include "oops/compressedKlass.inline.hpp"
44 #include "oops/instanceKlass.hpp"
45 #include "oops/klass.inline.hpp"
46 #include "oops/objArrayKlass.hpp"
47 #include "oops/objArrayOop.inline.hpp"
48 #include "oops/oopHandle.inline.hpp"
49 #include "runtime/arguments.hpp"
50 #include "runtime/globals_extension.hpp"
51 #include "runtime/javaThread.hpp"
52 #include "runtime/sharedRuntime.hpp"
53 #include "utilities/align.hpp"
54 #include "utilities/bitMap.inline.hpp"
55 #include "utilities/formatBuffer.hpp"
56
57 ArchiveBuilder* ArchiveBuilder::_current = nullptr;
58
59 ArchiveBuilder::OtherROAllocMark::~OtherROAllocMark() {
60 char* newtop = ArchiveBuilder::current()->_ro_region.top();
61 ArchiveBuilder::alloc_stats()->record_other_type(int(newtop - _oldtop), true);
62 }
63
64 ArchiveBuilder::SourceObjList::SourceObjList() : _ptrmap(16 * K, mtClassShared) {
65 _total_bytes = 0;
205 GatherKlassesAndSymbols(ArchiveBuilder* builder) : _builder(builder) {}
206
207 virtual bool do_unique_ref(Ref* ref, bool read_only) {
208 return _builder->gather_klass_and_symbol(ref, read_only);
209 }
210 };
211
212 bool ArchiveBuilder::gather_klass_and_symbol(MetaspaceClosure::Ref* ref, bool read_only) {
213 if (ref->obj() == nullptr) {
214 return false;
215 }
216 if (get_follow_mode(ref) != make_a_copy) {
217 return false;
218 }
219 if (ref->msotype() == MetaspaceObj::ClassType) {
220 Klass* klass = (Klass*)ref->obj();
221 assert(klass->is_klass(), "must be");
222 if (!is_excluded(klass)) {
223 _klasses->append(klass);
224 }
225 // See ArchiveBuilder::make_shallow_copies: make sure we have enough space for both maximum
226 // Klass alignment as well as the RuntimeInfo* pointer we will embed in front of a Klass.
227 _estimated_metaspaceobj_bytes += align_up(BytesPerWord, KlassAlignmentInBytes) +
228 align_up(sizeof(void*), SharedSpaceObjectAlignment);
229 } else if (ref->msotype() == MetaspaceObj::SymbolType) {
230 // Make sure the symbol won't be GC'ed while we are dumping the archive.
231 Symbol* sym = (Symbol*)ref->obj();
232 sym->increment_refcount();
233 _symbols->append(sym);
234 }
235
236 int bytes = ref->size() * BytesPerWord;
237 _estimated_metaspaceobj_bytes += align_up(bytes, SharedSpaceObjectAlignment);
238
239 return true; // recurse
240 }
241
242 void ArchiveBuilder::gather_klasses_and_symbols() {
243 ResourceMark rm;
244 log_info(cds)("Gathering classes and symbols ... ");
245 GatherKlassesAndSymbols doit(this);
246 iterate_roots(&doit, /*is_relocating_pointers=*/false);
247 #if INCLUDE_CDS_JAVA_HEAP
248 if (is_dumping_full_module_graph()) {
605 }
606
607 void ArchiveBuilder::make_shallow_copies(DumpRegion *dump_region,
608 const ArchiveBuilder::SourceObjList* src_objs) {
609 for (int i = 0; i < src_objs->objs()->length(); i++) {
610 make_shallow_copy(dump_region, src_objs->objs()->at(i));
611 }
612 log_info(cds)("done (%d objects)", src_objs->objs()->length());
613 }
614
615 void ArchiveBuilder::make_shallow_copy(DumpRegion *dump_region, SourceObjInfo* src_info) {
616 MetaspaceClosure::Ref* ref = src_info->ref();
617 address src = ref->obj();
618 int bytes = src_info->size_in_bytes();
619 char* dest;
620 char* oldtop;
621 char* newtop;
622
623 oldtop = dump_region->top();
624 if (ref->msotype() == MetaspaceObj::ClassType) {
625 // Reserve space for a pointer immediately in front of an InstanceKlass. That space will
626 // later be used to store the RuntimeClassInfo* pointer directly in front of the archived
627 // InstanceKlass, in order to have a quick lookup InstanceKlass* -> RunTimeClassInfo*
628 // without building another hashtable. See RunTimeClassInfo::get_for()/::set_for() for
629 // details.
630 Klass* klass = (Klass*)src;
631 if (klass->is_instance_klass()) {
632 SystemDictionaryShared::validate_before_archiving(InstanceKlass::cast(klass));
633 dump_region->allocate(sizeof(address));
634 }
635 dest = dump_region->allocate(bytes, KlassAlignmentInBytes);
636 } else {
637 dest = dump_region->allocate(bytes);
638 }
639 newtop = dump_region->top();
640
641 memcpy(dest, src, bytes);
642 {
643 bool created;
644 _buffered_to_src_table.put_if_absent((address)dest, src, &created);
645 assert(created, "must be");
646 if (_buffered_to_src_table.maybe_grow()) {
647 log_info(cds, hashtables)("Expanded _buffered_to_src_table table to %d", _buffered_to_src_table.table_size());
648 }
649 }
650
651 intptr_t* archived_vtable = CppVtables::get_archived_vtable(ref->msotype(), (address)dest);
652 if (archived_vtable != nullptr) {
653 *(address*)dest = (address)archived_vtable;
654 ArchivePtrMarker::mark_pointer((address*)dest);
655 }
656
657 log_trace(cds)("Copy: " PTR_FORMAT " ==> " PTR_FORMAT " %d (%s)", p2i(src), p2i(dest), bytes,
658 MetaspaceObj::type_name(ref->msotype()));
659 src_info->set_buffered_addr((address)dest);
660
661 _alloc_stats.record(ref->msotype(), int(newtop - oldtop), src_info->read_only());
662
663 DEBUG_ONLY(_alloc_stats.verify((int)dump_region->used(), src_info->read_only()));
664 }
665
666 address ArchiveBuilder::get_buffered_addr(address src_addr) const {
667 SourceObjInfo* p = _src_obj_table.get(src_addr);
668 assert(p != nullptr, "must be");
669
670 return p->buffered_addr();
671 }
672
673 address ArchiveBuilder::get_source_addr(address buffered_addr) const {
674 assert(is_in_buffer_space(buffered_addr), "must be");
675 address* src_p = _buffered_to_src_table.get(buffered_addr);
676 assert(src_p != nullptr && *src_p != nullptr, "must be");
677 return *src_p;
678 }
679
680 void ArchiveBuilder::relocate_embedded_pointers(ArchiveBuilder::SourceObjList* src_objs) {
681 for (int i = 0; i < src_objs->objs()->length(); i++) {
682 src_objs->relocate(i, this);
683 }
740 }
741
742 void ArchiveBuilder::make_klasses_shareable() {
743 int num_instance_klasses = 0;
744 int num_boot_klasses = 0;
745 int num_platform_klasses = 0;
746 int num_app_klasses = 0;
747 int num_hidden_klasses = 0;
748 int num_unlinked_klasses = 0;
749 int num_unregistered_klasses = 0;
750 int num_obj_array_klasses = 0;
751 int num_type_array_klasses = 0;
752
753 for (int i = 0; i < klasses()->length(); i++) {
754 const char* type;
755 const char* unlinked = "";
756 const char* hidden = "";
757 const char* generated = "";
758 Klass* k = klasses()->at(i);
759 k->remove_java_mirror();
760 #ifdef _LP64
761 if (UseCompactObjectHeaders) {
762 Klass* requested_k = to_requested(k);
763 narrowKlass nk = CompressedKlassPointers::encode_not_null(requested_k, _requested_static_archive_bottom);
764 k->set_prototype_header(markWord::prototype().set_narrow_klass(nk));
765 }
766 #endif //_LP64
767 if (k->is_objArray_klass()) {
768 // InstanceKlass and TypeArrayKlass will in turn call remove_unshareable_info
769 // on their array classes.
770 num_obj_array_klasses ++;
771 type = "array";
772 } else if (k->is_typeArray_klass()) {
773 num_type_array_klasses ++;
774 type = "array";
775 k->remove_unshareable_info();
776 } else {
777 assert(k->is_instance_klass(), " must be");
778 num_instance_klasses ++;
779 InstanceKlass* ik = InstanceKlass::cast(k);
780 if (DynamicDumpSharedSpaces) {
781 // For static dump, class loader type are already set.
782 ik->assign_class_loader_type();
783 }
784 if (ik->is_shared_boot_class()) {
785 type = "boot";
786 num_boot_klasses ++;
|