16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "cds/aotArtifactFinder.hpp"
26 #include "cds/aotClassLinker.hpp"
27 #include "cds/aotLinkedClassBulkLoader.hpp"
28 #include "cds/aotLogging.hpp"
29 #include "cds/archiveBuilder.hpp"
30 #include "cds/archiveHeapWriter.hpp"
31 #include "cds/archiveUtils.hpp"
32 #include "cds/cdsConfig.hpp"
33 #include "cds/cppVtables.hpp"
34 #include "cds/dumpAllocStats.hpp"
35 #include "cds/dynamicArchive.hpp"
36 #include "cds/heapShared.hpp"
37 #include "cds/metaspaceShared.hpp"
38 #include "cds/regeneratedClasses.hpp"
39 #include "classfile/classLoader.hpp"
40 #include "classfile/classLoaderDataShared.hpp"
41 #include "classfile/classLoaderExt.hpp"
42 #include "classfile/javaClasses.hpp"
43 #include "classfile/symbolTable.hpp"
44 #include "classfile/systemDictionaryShared.hpp"
45 #include "classfile/vmClasses.hpp"
46 #include "code/aotCodeCache.hpp"
47 #include "interpreter/abstractInterpreter.hpp"
48 #include "jvm.h"
49 #include "logging/log.hpp"
50 #include "logging/logStream.hpp"
51 #include "memory/allStatic.hpp"
52 #include "memory/memoryReserver.hpp"
53 #include "memory/memRegion.hpp"
54 #include "memory/resourceArea.hpp"
55 #include "oops/compressedKlass.inline.hpp"
169 _ptrmap.iterate(&relocator, start, end);
170 }
171
172 ArchiveBuilder::ArchiveBuilder() :
173 _current_dump_region(nullptr),
174 _buffer_bottom(nullptr),
175 _requested_static_archive_bottom(nullptr),
176 _requested_static_archive_top(nullptr),
177 _requested_dynamic_archive_bottom(nullptr),
178 _requested_dynamic_archive_top(nullptr),
179 _mapped_static_archive_bottom(nullptr),
180 _mapped_static_archive_top(nullptr),
181 _buffer_to_requested_delta(0),
182 _pz_region("pz", MAX_SHARED_DELTA), // protection zone -- used only during dumping; does NOT exist in cds archive.
183 _rw_region("rw", MAX_SHARED_DELTA),
184 _ro_region("ro", MAX_SHARED_DELTA),
185 _ac_region("ac", MAX_SHARED_DELTA),
186 _ptrmap(mtClassShared),
187 _rw_ptrmap(mtClassShared),
188 _ro_ptrmap(mtClassShared),
189 _rw_src_objs(),
190 _ro_src_objs(),
191 _src_obj_table(INITIAL_TABLE_SIZE, MAX_TABLE_SIZE),
192 _buffered_to_src_table(INITIAL_TABLE_SIZE, MAX_TABLE_SIZE),
193 _total_heap_region_size(0)
194 {
195 _klasses = new (mtClassShared) GrowableArray<Klass*>(4 * K, mtClassShared);
196 _symbols = new (mtClassShared) GrowableArray<Symbol*>(256 * K, mtClassShared);
197 _entropy_seed = 0x12345678;
198 _relocated_ptr_info._num_ptrs = 0;
199 _relocated_ptr_info._num_tagged_ptrs = 0;
200 _relocated_ptr_info._num_nulled_ptrs = 0;
201 assert(_current == nullptr, "must be");
202 _current = this;
203 }
204
205 ArchiveBuilder::~ArchiveBuilder() {
206 assert(_current == this, "must be");
207 _current = nullptr;
208
1467 assert(java_lang_Class::is_instance(scratch_mirror), "sanity");
1468 if (java_lang_Class::is_primitive(scratch_mirror)) {
1469 for (int i = T_BOOLEAN; i < T_VOID+1; i++) {
1470 BasicType bt = (BasicType)i;
1471 if (!is_reference_type(bt) && scratch_mirror == HeapShared::scratch_java_mirror(bt)) {
1472 oop orig_mirror = Universe::java_mirror(bt);
1473 java_lang_Class::print_signature(orig_mirror, st);
1474 return;
1475 }
1476 }
1477 ShouldNotReachHere();
1478 }
1479 java_lang_Class::print_signature(scratch_mirror, st);
1480 }
1481
1482 static void log_heap_roots() {
1483 LogStreamHandle(Trace, aot, map, oops) st;
1484 if (st.is_enabled()) {
1485 for (int i = 0; i < HeapShared::pending_roots()->length(); i++) {
1486 st.print("roots[%4d]: ", i);
1487 print_oop_info_cr(&st, HeapShared::pending_roots()->at(i));
1488 }
1489 }
1490 }
1491
1492 // Example output:
1493 // - The first number is the requested address (if print_requested_addr == true)
1494 // - The second number is the narrowOop version of the requested address (if UseCompressedOops == true)
1495 // 0x00000007ffc7e840 (0xfff8fd08) java.lang.Class Ljava/util/Array;
1496 // 0x00000007ffc000f8 (0xfff8001f) [B length: 11
1497 static void print_oop_info_cr(outputStream* st, oop source_oop, bool print_requested_addr = true) {
1498 if (source_oop == nullptr) {
1499 st->print_cr("null");
1500 } else {
1501 ResourceMark rm;
1502 oop requested_obj = ArchiveHeapWriter::source_obj_to_requested_obj(source_oop);
1503 if (print_requested_addr) {
1504 st->print(PTR_FORMAT " ", p2i(requested_obj));
1505 }
1506 if (UseCompressedOops) {
1507 st->print("(0x%08x) ", CompressedOops::narrow_oop_value(requested_obj));
1508 }
1509 if (source_oop->is_array()) {
1510 int array_len = arrayOop(source_oop)->length();
1511 st->print_cr("%s length: %d", source_oop->klass()->external_name(), array_len);
1512 } else {
1513 st->print("%s", source_oop->klass()->external_name());
1514
1515 if (java_lang_String::is_instance(source_oop)) {
1516 st->print(" ");
1517 java_lang_String::print(source_oop, st);
1518 } else if (java_lang_Class::is_instance(source_oop)) {
1519 oop scratch_mirror = source_oop;
1520
1521 st->print(" ");
1522 print_class_signature_for_mirror(st, scratch_mirror);
1523
1524 Klass* src_klass = java_lang_Class::as_Klass(scratch_mirror);
1525 if (src_klass != nullptr && src_klass->is_instance_klass()) {
1526 InstanceKlass* buffered_klass =
1527 ArchiveBuilder::current()->get_buffered_addr(InstanceKlass::cast(src_klass));
1528 if (buffered_klass->has_aot_initialized_mirror()) {
1529 st->print(" (aot-inited)");
1530 }
1531 }
1532 }
1533 st->cr();
1534 }
1535 }
1536 }
1537 #endif // INCLUDE_CDS_JAVA_HEAP
1589 #endif
1590
1591 log_info(aot, map)("[End of CDS archive map]");
1592 }
1593 }; // end ArchiveBuilder::CDSMapLogger
1594
1595 void ArchiveBuilder::print_stats() {
1596 _alloc_stats.print_stats(int(_ro_region.used()), int(_rw_region.used()));
1597 }
1598
1599 void ArchiveBuilder::write_archive(FileMapInfo* mapinfo, ArchiveHeapInfo* heap_info) {
1600 // Make sure NUM_CDS_REGIONS (exported in cds.h) agrees with
1601 // MetaspaceShared::n_regions (internal to hotspot).
1602 assert(NUM_CDS_REGIONS == MetaspaceShared::n_regions, "sanity");
1603
1604 write_region(mapinfo, MetaspaceShared::rw, &_rw_region, /*read_only=*/false,/*allow_exec=*/false);
1605 write_region(mapinfo, MetaspaceShared::ro, &_ro_region, /*read_only=*/true, /*allow_exec=*/false);
1606 write_region(mapinfo, MetaspaceShared::ac, &_ac_region, /*read_only=*/false,/*allow_exec=*/false);
1607
1608 // Split pointer map into read-write and read-only bitmaps
1609 ArchivePtrMarker::initialize_rw_ro_maps(&_rw_ptrmap, &_ro_ptrmap);
1610
1611 size_t bitmap_size_in_bytes;
1612 char* bitmap = mapinfo->write_bitmap_region(ArchivePtrMarker::rw_ptrmap(), ArchivePtrMarker::ro_ptrmap(), heap_info,
1613 bitmap_size_in_bytes);
1614
1615 if (heap_info->is_used()) {
1616 _total_heap_region_size = mapinfo->write_heap_region(heap_info);
1617 }
1618
1619 print_region_stats(mapinfo, heap_info);
1620
1621 mapinfo->set_requested_base((char*)MetaspaceShared::requested_base_address());
1622 mapinfo->set_header_crc(mapinfo->compute_header_crc());
1623 // After this point, we should not write any data into mapinfo->header() since this
1624 // would corrupt its checksum we have calculated before.
1625 mapinfo->write_header();
1626 mapinfo->close();
1627
1628 if (log_is_enabled(Info, aot)) {
1629 log_info(aot)("Full module graph = %s", CDSConfig::is_dumping_full_module_graph() ? "enabled" : "disabled");
1630 print_stats();
1631 }
1632
1633 if (log_is_enabled(Info, aot, map)) {
1634 CDSMapLogger::log(this, mapinfo, heap_info,
1635 bitmap, bitmap_size_in_bytes);
1636 }
1637 CDS_JAVA_HEAP_ONLY(HeapShared::destroy_archived_object_cache());
1638 FREE_C_HEAP_ARRAY(char, bitmap);
1639 }
1640
1641 void ArchiveBuilder::write_region(FileMapInfo* mapinfo, int region_idx, DumpRegion* dump_region, bool read_only, bool allow_exec) {
1642 mapinfo->write_region(region_idx, dump_region->base(), dump_region->used(), read_only, allow_exec);
1643 }
1644
1645 void ArchiveBuilder::count_relocated_pointer(bool tagged, bool nulled) {
1646 _relocated_ptr_info._num_ptrs ++;
1647 _relocated_ptr_info._num_tagged_ptrs += tagged ? 1 : 0;
1648 _relocated_ptr_info._num_nulled_ptrs += nulled ? 1 : 0;
1649 }
|
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "cds/aotArtifactFinder.hpp"
26 #include "cds/aotClassLinker.hpp"
27 #include "cds/aotLinkedClassBulkLoader.hpp"
28 #include "cds/aotLogging.hpp"
29 #include "cds/archiveBuilder.hpp"
30 #include "cds/archiveHeapWriter.hpp"
31 #include "cds/archiveUtils.hpp"
32 #include "cds/cdsConfig.hpp"
33 #include "cds/cppVtables.hpp"
34 #include "cds/dumpAllocStats.hpp"
35 #include "cds/dynamicArchive.hpp"
36 #include "cds/finalImageRecipes.hpp"
37 #include "cds/heapShared.hpp"
38 #include "cds/metaspaceShared.hpp"
39 #include "cds/regeneratedClasses.hpp"
40 #include "classfile/classLoader.hpp"
41 #include "classfile/classLoaderDataShared.hpp"
42 #include "classfile/classLoaderExt.hpp"
43 #include "classfile/javaClasses.hpp"
44 #include "classfile/symbolTable.hpp"
45 #include "classfile/systemDictionaryShared.hpp"
46 #include "classfile/vmClasses.hpp"
47 #include "code/aotCodeCache.hpp"
48 #include "interpreter/abstractInterpreter.hpp"
49 #include "jvm.h"
50 #include "logging/log.hpp"
51 #include "logging/logStream.hpp"
52 #include "memory/allStatic.hpp"
53 #include "memory/memoryReserver.hpp"
54 #include "memory/memRegion.hpp"
55 #include "memory/resourceArea.hpp"
56 #include "oops/compressedKlass.inline.hpp"
170 _ptrmap.iterate(&relocator, start, end);
171 }
172
173 ArchiveBuilder::ArchiveBuilder() :
174 _current_dump_region(nullptr),
175 _buffer_bottom(nullptr),
176 _requested_static_archive_bottom(nullptr),
177 _requested_static_archive_top(nullptr),
178 _requested_dynamic_archive_bottom(nullptr),
179 _requested_dynamic_archive_top(nullptr),
180 _mapped_static_archive_bottom(nullptr),
181 _mapped_static_archive_top(nullptr),
182 _buffer_to_requested_delta(0),
183 _pz_region("pz", MAX_SHARED_DELTA), // protection zone -- used only during dumping; does NOT exist in cds archive.
184 _rw_region("rw", MAX_SHARED_DELTA),
185 _ro_region("ro", MAX_SHARED_DELTA),
186 _ac_region("ac", MAX_SHARED_DELTA),
187 _ptrmap(mtClassShared),
188 _rw_ptrmap(mtClassShared),
189 _ro_ptrmap(mtClassShared),
190 _ac_ptrmap(mtClassShared),
191 _rw_src_objs(),
192 _ro_src_objs(),
193 _src_obj_table(INITIAL_TABLE_SIZE, MAX_TABLE_SIZE),
194 _buffered_to_src_table(INITIAL_TABLE_SIZE, MAX_TABLE_SIZE),
195 _total_heap_region_size(0)
196 {
197 _klasses = new (mtClassShared) GrowableArray<Klass*>(4 * K, mtClassShared);
198 _symbols = new (mtClassShared) GrowableArray<Symbol*>(256 * K, mtClassShared);
199 _entropy_seed = 0x12345678;
200 _relocated_ptr_info._num_ptrs = 0;
201 _relocated_ptr_info._num_tagged_ptrs = 0;
202 _relocated_ptr_info._num_nulled_ptrs = 0;
203 assert(_current == nullptr, "must be");
204 _current = this;
205 }
206
207 ArchiveBuilder::~ArchiveBuilder() {
208 assert(_current == this, "must be");
209 _current = nullptr;
210
1469 assert(java_lang_Class::is_instance(scratch_mirror), "sanity");
1470 if (java_lang_Class::is_primitive(scratch_mirror)) {
1471 for (int i = T_BOOLEAN; i < T_VOID+1; i++) {
1472 BasicType bt = (BasicType)i;
1473 if (!is_reference_type(bt) && scratch_mirror == HeapShared::scratch_java_mirror(bt)) {
1474 oop orig_mirror = Universe::java_mirror(bt);
1475 java_lang_Class::print_signature(orig_mirror, st);
1476 return;
1477 }
1478 }
1479 ShouldNotReachHere();
1480 }
1481 java_lang_Class::print_signature(scratch_mirror, st);
1482 }
1483
1484 static void log_heap_roots() {
1485 LogStreamHandle(Trace, aot, map, oops) st;
1486 if (st.is_enabled()) {
1487 for (int i = 0; i < HeapShared::pending_roots()->length(); i++) {
1488 st.print("roots[%4d]: ", i);
1489 print_oop_info_cr(&st, HeapShared::pending_roots()->at(i).resolve());
1490 }
1491 }
1492 }
1493
1494 // Example output:
1495 // - The first number is the requested address (if print_requested_addr == true)
1496 // - The second number is the narrowOop version of the requested address (if UseCompressedOops == true)
1497 // 0x00000007ffc7e840 (0xfff8fd08) java.lang.Class Ljava/util/Array;
1498 // 0x00000007ffc000f8 (0xfff8001f) [B length: 11
1499 static void print_oop_info_cr(outputStream* st, oop source_oop, bool print_requested_addr = true) {
1500 if (source_oop == nullptr) {
1501 st->print_cr("null");
1502 } else {
1503 ResourceMark rm;
1504 oop requested_obj = ArchiveHeapWriter::source_obj_to_requested_obj(source_oop);
1505 if (print_requested_addr) {
1506 st->print(PTR_FORMAT " ", p2i(requested_obj));
1507 }
1508 if (UseCompressedOops) {
1509 st->print("(0x%08x) ", CompressedOops::narrow_oop_value(requested_obj));
1510 }
1511 if (source_oop->is_array()) {
1512 int array_len = arrayOop(source_oop)->length();
1513 st->print_cr("%s length: %d", source_oop->klass()->external_name(), array_len);
1514 } else {
1515 st->print("%s", source_oop->klass()->external_name());
1516
1517 if (java_lang_String::is_instance(source_oop)) {
1518 st->print(" ");
1519 java_lang_String::print(source_oop, st);
1520 } else if (java_lang_invoke_MethodType::is_instance(source_oop)) {
1521 st->print(" ");
1522 java_lang_invoke_MethodType::print_signature(source_oop, st);
1523 } else if (java_lang_Class::is_instance(source_oop)) {
1524 oop scratch_mirror = source_oop;
1525
1526 st->print(" ");
1527 print_class_signature_for_mirror(st, scratch_mirror);
1528
1529 Klass* src_klass = java_lang_Class::as_Klass(scratch_mirror);
1530 if (src_klass != nullptr && src_klass->is_instance_klass()) {
1531 InstanceKlass* buffered_klass =
1532 ArchiveBuilder::current()->get_buffered_addr(InstanceKlass::cast(src_klass));
1533 if (buffered_klass->has_aot_initialized_mirror()) {
1534 st->print(" (aot-inited)");
1535 }
1536 }
1537 }
1538 st->cr();
1539 }
1540 }
1541 }
1542 #endif // INCLUDE_CDS_JAVA_HEAP
1594 #endif
1595
1596 log_info(aot, map)("[End of CDS archive map]");
1597 }
1598 }; // end ArchiveBuilder::CDSMapLogger
1599
1600 void ArchiveBuilder::print_stats() {
1601 _alloc_stats.print_stats(int(_ro_region.used()), int(_rw_region.used()));
1602 }
1603
1604 void ArchiveBuilder::write_archive(FileMapInfo* mapinfo, ArchiveHeapInfo* heap_info) {
1605 // Make sure NUM_CDS_REGIONS (exported in cds.h) agrees with
1606 // MetaspaceShared::n_regions (internal to hotspot).
1607 assert(NUM_CDS_REGIONS == MetaspaceShared::n_regions, "sanity");
1608
1609 write_region(mapinfo, MetaspaceShared::rw, &_rw_region, /*read_only=*/false,/*allow_exec=*/false);
1610 write_region(mapinfo, MetaspaceShared::ro, &_ro_region, /*read_only=*/true, /*allow_exec=*/false);
1611 write_region(mapinfo, MetaspaceShared::ac, &_ac_region, /*read_only=*/false,/*allow_exec=*/false);
1612
1613 // Split pointer map into read-write and read-only bitmaps
1614 ArchivePtrMarker::initialize_rw_ro_ac_maps(&_rw_ptrmap, &_ro_ptrmap, &_ac_ptrmap);
1615
1616 size_t bitmap_size_in_bytes;
1617 char* bitmap = mapinfo->write_bitmap_region(ArchivePtrMarker::rw_ptrmap(),
1618 ArchivePtrMarker::ro_ptrmap(),
1619 ArchivePtrMarker::ac_ptrmap(),
1620 heap_info,
1621 bitmap_size_in_bytes);
1622
1623 if (heap_info->is_used()) {
1624 _total_heap_region_size = mapinfo->write_heap_region(heap_info);
1625 }
1626
1627 print_region_stats(mapinfo, heap_info);
1628
1629 mapinfo->set_requested_base((char*)MetaspaceShared::requested_base_address());
1630 mapinfo->set_header_crc(mapinfo->compute_header_crc());
1631 // After this point, we should not write any data into mapinfo->header() since this
1632 // would corrupt its checksum we have calculated before.
1633 mapinfo->write_header();
1634 mapinfo->close();
1635
1636 aot_log_info(aot)("Full module graph = %s", CDSConfig::is_dumping_full_module_graph() ? "enabled" : "disabled");
1637 if (log_is_enabled(Info, aot)) {
1638 print_stats();
1639 }
1640
1641 if (log_is_enabled(Info, aot, map)) {
1642 CDSMapLogger::log(this, mapinfo, heap_info,
1643 bitmap, bitmap_size_in_bytes);
1644 }
1645 CDS_JAVA_HEAP_ONLY(HeapShared::destroy_archived_object_cache());
1646 FREE_C_HEAP_ARRAY(char, bitmap);
1647 }
1648
1649 void ArchiveBuilder::write_region(FileMapInfo* mapinfo, int region_idx, DumpRegion* dump_region, bool read_only, bool allow_exec) {
1650 mapinfo->write_region(region_idx, dump_region->base(), dump_region->used(), read_only, allow_exec);
1651 }
1652
1653 void ArchiveBuilder::count_relocated_pointer(bool tagged, bool nulled) {
1654 _relocated_ptr_info._num_ptrs ++;
1655 _relocated_ptr_info._num_tagged_ptrs += tagged ? 1 : 0;
1656 _relocated_ptr_info._num_nulled_ptrs += nulled ? 1 : 0;
1657 }
|