< prev index next >

src/hotspot/share/cds/filemap.cpp

Print this page

 217   _compact_headers = UseCompactObjectHeaders;
 218   if (CDSConfig::is_dumping_heap()) {
 219     _narrow_oop_mode = CompressedOops::mode();
 220     _narrow_oop_base = CompressedOops::base();
 221     _narrow_oop_shift = CompressedOops::shift();
 222   }
 223   _compressed_oops = UseCompressedOops;
 224   _compressed_class_ptrs = UseCompressedClassPointers;
 225   if (UseCompressedClassPointers) {
 226 #ifdef _LP64
 227     _narrow_klass_pointer_bits = CompressedKlassPointers::narrow_klass_pointer_bits();
 228     _narrow_klass_shift = ArchiveBuilder::precomputed_narrow_klass_shift();
 229 #endif
 230   } else {
 231     _narrow_klass_pointer_bits = _narrow_klass_shift = -1;
 232   }
 233   _max_heap_size = MaxHeapSize;
 234   _use_optimized_module_handling = CDSConfig::is_using_optimized_module_handling();
 235   _has_aot_linked_classes = CDSConfig::is_dumping_aot_linked_classes();
 236   _has_full_module_graph = CDSConfig::is_dumping_full_module_graph();




 237 
 238   // The following fields are for sanity checks for whether this archive
 239   // will function correctly with this JVM and the bootclasspath it's
 240   // invoked with.
 241 
 242   // JVM version string ... changes on each build.
 243   get_header_version(_jvm_ident);
 244 
 245   _verify_local = BytecodeVerificationLocal;
 246   _verify_remote = BytecodeVerificationRemote;
 247   _has_platform_or_app_classes = AOTClassLocationConfig::dumptime()->has_platform_or_app_classes();
 248   _requested_base_address = (char*)SharedBaseAddress;
 249   _mapped_base_address = (char*)SharedBaseAddress;
 250   _allow_archiving_with_java_agent = AllowArchivingWithJavaAgent;
 251 }
 252 
 253 void FileMapHeader::copy_base_archive_name(const char* archive) {
 254   assert(base_archive_name_size() != 0, "_base_archive_name_size not set");
 255   assert(base_archive_name_offset() != 0, "_base_archive_name_offset not set");
 256   assert(header_size() > sizeof(*this), "_base_archive_name_size not included in header size?");

 291   st->print_cr("- jvm_ident:                      %s", _jvm_ident);
 292   st->print_cr("- class_location_config_offset:   0x%zx", _class_location_config_offset);
 293   st->print_cr("- verify_local:                   %d", _verify_local);
 294   st->print_cr("- verify_remote:                  %d", _verify_remote);
 295   st->print_cr("- has_platform_or_app_classes:    %d", _has_platform_or_app_classes);
 296   st->print_cr("- requested_base_address:         " INTPTR_FORMAT, p2i(_requested_base_address));
 297   st->print_cr("- mapped_base_address:            " INTPTR_FORMAT, p2i(_mapped_base_address));
 298   st->print_cr("- heap_root_segments.roots_count: %d" , _heap_root_segments.roots_count());
 299   st->print_cr("- heap_root_segments.base_offset: 0x%zx", _heap_root_segments.base_offset());
 300   st->print_cr("- heap_root_segments.count:       %zu", _heap_root_segments.count());
 301   st->print_cr("- heap_root_segments.max_size_elems: %d", _heap_root_segments.max_size_in_elems());
 302   st->print_cr("- heap_root_segments.max_size_bytes: %d", _heap_root_segments.max_size_in_bytes());
 303   st->print_cr("- _heap_oopmap_start_pos:         %zu", _heap_oopmap_start_pos);
 304   st->print_cr("- _heap_ptrmap_start_pos:         %zu", _heap_ptrmap_start_pos);
 305   st->print_cr("- _rw_ptrmap_start_pos:           %zu", _rw_ptrmap_start_pos);
 306   st->print_cr("- _ro_ptrmap_start_pos:           %zu", _ro_ptrmap_start_pos);
 307   st->print_cr("- allow_archiving_with_java_agent:%d", _allow_archiving_with_java_agent);
 308   st->print_cr("- use_optimized_module_handling:  %d", _use_optimized_module_handling);
 309   st->print_cr("- has_full_module_graph           %d", _has_full_module_graph);
 310   st->print_cr("- has_aot_linked_classes          %d", _has_aot_linked_classes);



 311 }
 312 
 313 bool FileMapInfo::validate_class_location() {
 314   assert(CDSConfig::is_using_archive(), "runtime only");
 315 
 316   AOTClassLocationConfig* config = header()->class_location_config();
 317   bool has_extra_module_paths = false;
 318   if (!config->validate(header()->has_aot_linked_classes(), &has_extra_module_paths)) {
 319     if (PrintSharedArchiveAndExit) {
 320       MetaspaceShared::set_archive_loading_failed();
 321       return true;
 322     } else {
 323       return false;
 324     }
 325   }
 326 
 327   if (header()->has_full_module_graph() && has_extra_module_paths) {
 328     CDSConfig::stop_using_optimized_module_handling();
 329     log_info(cds)("optimized module handling: disabled because extra module path(s) are specified");
 330   }

 807 bool FileMapRegion::check_region_crc(char* base) const {
 808   // This function should be called after the region has been properly
 809   // loaded into memory via FileMapInfo::map_region() or FileMapInfo::read_region().
 810   // I.e., this->mapped_base() must be valid.
 811   size_t sz = used();
 812   if (sz == 0) {
 813     return true;
 814   }
 815 
 816   assert(base != nullptr, "must be initialized");
 817   int crc = ClassLoader::crc32(0, base, (jint)sz);
 818   if (crc != this->crc()) {
 819     log_warning(cds)("Checksum verification failed.");
 820     return false;
 821   }
 822   return true;
 823 }
 824 
 825 static const char* region_name(int region_index) {
 826   static const char* names[] = {
 827     "rw", "ro", "bm", "hp"
 828   };
 829   const int num_regions = sizeof(names)/sizeof(names[0]);
 830   assert(0 <= region_index && region_index < num_regions, "sanity");
 831 
 832   return names[region_index];
 833 }
 834 
 835 BitMapView FileMapInfo::bitmap_view(int region_index, bool is_oopmap) {
 836   FileMapRegion* r = region_at(region_index);
 837   char* bitmap_base = is_static() ? FileMapInfo::current_info()->map_bitmap_region() : FileMapInfo::dynamic_info()->map_bitmap_region();
 838   bitmap_base += is_oopmap ? r->oopmap_offset() : r->ptrmap_offset();
 839   size_t size_in_bits = is_oopmap ? r->oopmap_size_in_bits() : r->ptrmap_size_in_bits();
 840 
 841   log_debug(cds, reloc)("mapped %s relocation %smap @ " INTPTR_FORMAT " (%zu bits)",
 842                         region_name(region_index), is_oopmap ? "oop" : "ptr",
 843                         p2i(bitmap_base), size_in_bits);
 844 
 845   return BitMapView((BitMap::bm_word_t*)(bitmap_base), size_in_bits);
 846 }
 847 

 893       mapping_offset = (size_t)((address)requested_base - CompressedOops::base());
 894       assert((mapping_offset >> CompressedOops::shift()) << CompressedOops::shift() == mapping_offset, "must be");
 895     } else {
 896       mapping_offset = 0; // not used with !UseCompressedOops
 897     }
 898 #endif // INCLUDE_CDS_JAVA_HEAP
 899   } else {
 900     char* requested_SharedBaseAddress = (char*)MetaspaceShared::requested_base_address();
 901     requested_base = ArchiveBuilder::current()->to_requested(base);
 902     assert(requested_base >= requested_SharedBaseAddress, "must be");
 903     mapping_offset = requested_base - requested_SharedBaseAddress;
 904   }
 905 
 906   r->set_file_offset(_file_offset);
 907   int crc = ClassLoader::crc32(0, base, (jint)size);
 908   if (size > 0) {
 909     log_info(cds)("Shared file region (%s) %d: %8zu"
 910                    " bytes, addr " INTPTR_FORMAT " file offset 0x%08" PRIxPTR
 911                    " crc 0x%08x",
 912                    region_name(region), region, size, p2i(requested_base), _file_offset, crc);



 913   }
 914 
 915   r->init(region, mapping_offset, size, read_only, allow_exec, crc);
 916 
 917   if (base != nullptr) {
 918     write_bytes_aligned(base, size);
 919   }
 920 }
 921 
 922 static size_t write_bitmap(const CHeapBitMap* map, char* output, size_t offset) {
 923   size_t size_in_bytes = map->size_in_bytes();
 924   map->write_to((BitMap::bm_word_t*)(output + offset), size_in_bytes);
 925   return offset + size_in_bytes;
 926 }
 927 
 928 // The sorting code groups the objects with non-null oop/ptrs together.
 929 // Relevant bitmaps then have lots of leading and trailing zeros, which
 930 // we do not have to store.
 931 size_t FileMapInfo::remove_bitmap_zeros(CHeapBitMap* map) {
 932   BitMap::idx_t first_set = map->find_first_set_bit(0);
 933   BitMap::idx_t last_set  = map->find_last_set_bit(0);
 934   size_t old_size = map->size();
 935 
 936   // Slice and resize bitmap
 937   map->truncate(first_set, last_set + 1);
 938 
 939   assert(map->at(0), "First bit should be set");
 940   assert(map->at(map->size() - 1), "Last bit should be set");
 941   assert(map->size() <= old_size, "sanity");
 942 
 943   return first_set;
 944 }
 945 
 946 char* FileMapInfo::write_bitmap_region(CHeapBitMap* rw_ptrmap, CHeapBitMap* ro_ptrmap, ArchiveHeapInfo* heap_info,


 947                                        size_t &size_in_bytes) {
 948   size_t removed_rw_leading_zeros = remove_bitmap_zeros(rw_ptrmap);
 949   size_t removed_ro_leading_zeros = remove_bitmap_zeros(ro_ptrmap);
 950   header()->set_rw_ptrmap_start_pos(removed_rw_leading_zeros);
 951   header()->set_ro_ptrmap_start_pos(removed_ro_leading_zeros);
 952   size_in_bytes = rw_ptrmap->size_in_bytes() + ro_ptrmap->size_in_bytes();
 953 
 954   if (heap_info->is_used()) {
 955     // Remove leading and trailing zeros
 956     size_t removed_oop_leading_zeros = remove_bitmap_zeros(heap_info->oopmap());
 957     size_t removed_ptr_leading_zeros = remove_bitmap_zeros(heap_info->ptrmap());
 958     header()->set_heap_oopmap_start_pos(removed_oop_leading_zeros);
 959     header()->set_heap_ptrmap_start_pos(removed_ptr_leading_zeros);
 960 
 961     size_in_bytes += heap_info->oopmap()->size_in_bytes();
 962     size_in_bytes += heap_info->ptrmap()->size_in_bytes();
 963   }
 964 
 965   // The bitmap region contains up to 4 parts:
 966   // rw_ptrmap:           metaspace pointers inside the read-write region
 967   // ro_ptrmap:           metaspace pointers inside the read-only region
 968   // heap_info->oopmap(): Java oop pointers in the heap region
 969   // heap_info->ptrmap(): metaspace pointers in the heap region
 970   char* buffer = NEW_C_HEAP_ARRAY(char, size_in_bytes, mtClassShared);
 971   size_t written = 0;
 972 
 973   region_at(MetaspaceShared::rw)->init_ptrmap(0, rw_ptrmap->size());
 974   written = write_bitmap(rw_ptrmap, buffer, written);
 975 
 976   region_at(MetaspaceShared::ro)->init_ptrmap(written, ro_ptrmap->size());
 977   written = write_bitmap(ro_ptrmap, buffer, written);
 978 



 979   if (heap_info->is_used()) {
 980     FileMapRegion* r = region_at(MetaspaceShared::hp);
 981 
 982     r->init_oopmap(written, heap_info->oopmap()->size());
 983     written = write_bitmap(heap_info->oopmap(), buffer, written);
 984 
 985     r->init_ptrmap(written, heap_info->ptrmap()->size());
 986     written = write_bitmap(heap_info->ptrmap(), buffer, written);
 987   }
 988 
 989   write_region(MetaspaceShared::bm, (char*)buffer, size_in_bytes, /*read_only=*/true, /*allow_exec=*/false);
 990   return buffer;
 991 }
 992 
 993 size_t FileMapInfo::write_heap_region(ArchiveHeapInfo* heap_info) {
 994   char* buffer_start = heap_info->buffer_start();
 995   size_t buffer_size = heap_info->buffer_byte_size();
 996   write_region(MetaspaceShared::hp, buffer_start, buffer_size, false, false);
 997   header()->set_heap_root_segments(heap_info->heap_root_segments());
 998   return buffer_size;

1094   assert(WINDOWS_ONLY(false) NOT_WINDOWS(true), "Don't call on Windows");
1095   // Replace old mapping with new one that is writable.
1096   char *base = os::map_memory(_fd, _full_path, r->file_offset(),
1097                               addr, size, false /* !read_only */,
1098                               r->allow_exec());
1099   close();
1100   // These have to be errors because the shared region is now unmapped.
1101   if (base == nullptr) {
1102     log_error(cds)("Unable to remap shared readonly space (errno=%d).", errno);
1103     vm_exit(1);
1104   }
1105   if (base != addr) {
1106     log_error(cds)("Unable to remap shared readonly space (errno=%d).", errno);
1107     vm_exit(1);
1108   }
1109   r->set_read_only(false);
1110   return true;
1111 }
1112 
1113 // Memory map a region in the address space.
1114 static const char* shared_region_name[] = { "ReadWrite", "ReadOnly", "Bitmap", "Heap" };
1115 
1116 MapArchiveResult FileMapInfo::map_regions(int regions[], int num_regions, char* mapped_base_address, ReservedSpace rs) {
1117   DEBUG_ONLY(FileMapRegion* last_region = nullptr);
1118   intx addr_delta = mapped_base_address - header()->requested_base_address();
1119 
1120   // Make sure we don't attempt to use header()->mapped_base_address() unless
1121   // it's been successfully mapped.
1122   DEBUG_ONLY(header()->set_mapped_base_address((char*)(uintptr_t)0xdeadbeef);)
1123 
1124   for (int i = 0; i < num_regions; i++) {
1125     int idx = regions[i];
1126     MapArchiveResult result = map_region(idx, addr_delta, mapped_base_address, rs);
1127     if (result != MAP_ARCHIVE_SUCCESS) {
1128       return result;
1129     }
1130     FileMapRegion* r = region_at(idx);
1131     DEBUG_ONLY(if (last_region != nullptr) {
1132         // Ensure that the OS won't be able to allocate new memory spaces between any mapped
1133         // regions, or else it would mess up the simple comparison in MetaspaceObj::is_shared().
1134         assert(r->mapped_base() == last_region->mapped_end(), "must have no gaps");

1197   } else if (addr_delta != 0) {
1198     r->set_read_only(false); // Need to patch the pointers
1199   }
1200 
1201   if (MetaspaceShared::use_windows_memory_mapping() && rs.is_reserved()) {
1202     // This is the second time we try to map the archive(s). We have already created a ReservedSpace
1203     // that covers all the FileMapRegions to ensure all regions can be mapped. However, Windows
1204     // can't mmap into a ReservedSpace, so we just ::read() the data. We're going to patch all the
1205     // regions anyway, so there's no benefit for mmap anyway.
1206     if (!read_region(i, requested_addr, size, /* do_commit = */ true)) {
1207       log_info(cds)("Failed to read %s shared space into reserved space at " INTPTR_FORMAT,
1208                     shared_region_name[i], p2i(requested_addr));
1209       return MAP_ARCHIVE_OTHER_FAILURE; // oom or I/O error.
1210     } else {
1211       assert(r->mapped_base() != nullptr, "must be initialized");
1212     }
1213   } else {
1214     // Note that this may either be a "fresh" mapping into unreserved address
1215     // space (Windows, first mapping attempt), or a mapping into pre-reserved
1216     // space (Posix). See also comment in MetaspaceShared::map_archives().

1217     char* base = map_memory(_fd, _full_path, r->file_offset(),
1218                             requested_addr, size, r->read_only(),
1219                             r->allow_exec(), mtClassShared);
1220     if (base != requested_addr) {
1221       log_info(cds)("Unable to map %s shared space at " INTPTR_FORMAT,
1222                     shared_region_name[i], p2i(requested_addr));
1223       _memory_mapping_failed = true;
1224       return MAP_ARCHIVE_MMAP_FAILURE;
1225     }
1226 
1227     if (VerifySharedSpaces && !r->check_region_crc(requested_addr)) {
1228       return MAP_ARCHIVE_OTHER_FAILURE;
1229     }
1230 
1231     r->set_mapped_from_file(true);
1232     r->set_mapped_base(requested_addr);
1233   }
1234 
1235   if (rs.is_reserved()) {
1236     char* mapped_base = r->mapped_base();
1237     assert(rs.base() <= mapped_base && mapped_base + size <= rs.end(),
1238            PTR_FORMAT " <= " PTR_FORMAT " < " PTR_FORMAT " <= " PTR_FORMAT,

1257     return nullptr;
1258   }
1259 
1260   if (VerifySharedSpaces && !r->check_region_crc(bitmap_base)) {
1261     log_error(cds)("relocation bitmap CRC error");
1262     if (!os::unmap_memory(bitmap_base, r->used_aligned())) {
1263       fatal("os::unmap_memory of relocation bitmap failed");
1264     }
1265     return nullptr;
1266   }
1267 
1268   r->set_mapped_from_file(true);
1269   r->set_mapped_base(bitmap_base);
1270   log_info(cds)("Mapped %s region #%d at base " INTPTR_FORMAT " top " INTPTR_FORMAT " (%s)",
1271                 is_static() ? "static " : "dynamic",
1272                 MetaspaceShared::bm, p2i(r->mapped_base()), p2i(r->mapped_end()),
1273                 shared_region_name[MetaspaceShared::bm]);
1274   return bitmap_base;
1275 }
1276 




















































































1277 class SharedDataRelocationTask : public ArchiveWorkerTask {
1278 private:
1279   BitMapView* const _rw_bm;
1280   BitMapView* const _ro_bm;
1281   SharedDataRelocator* const _rw_reloc;
1282   SharedDataRelocator* const _ro_reloc;
1283 
1284 public:
1285   SharedDataRelocationTask(BitMapView* rw_bm, BitMapView* ro_bm, SharedDataRelocator* rw_reloc, SharedDataRelocator* ro_reloc) :
1286                            ArchiveWorkerTask("Shared Data Relocation"),
1287                            _rw_bm(rw_bm), _ro_bm(ro_bm), _rw_reloc(rw_reloc), _ro_reloc(ro_reloc) {}
1288 
1289   void work(int chunk, int max_chunks) override {
1290     work_on(chunk, max_chunks, _rw_bm, _rw_reloc);
1291     work_on(chunk, max_chunks, _ro_bm, _ro_reloc);
1292   }
1293 
1294   void work_on(int chunk, int max_chunks, BitMapView* bm, SharedDataRelocator* reloc) {
1295     BitMap::idx_t size  = bm->size();
1296     BitMap::idx_t start = MIN2(size, size * chunk / max_chunks);

1406 }
1407 
1408 void FileMapInfo::map_or_load_heap_region() {
1409   bool success = false;
1410 
1411   if (can_use_heap_region()) {
1412     if (ArchiveHeapLoader::can_map()) {
1413       success = map_heap_region();
1414     } else if (ArchiveHeapLoader::can_load()) {
1415       success = ArchiveHeapLoader::load_heap_region(this);
1416     } else {
1417       if (!UseCompressedOops && !ArchiveHeapLoader::can_map()) {
1418         log_info(cds)("Cannot use CDS heap data. Selected GC not compatible -XX:-UseCompressedOops");
1419       } else {
1420         log_info(cds)("Cannot use CDS heap data. UseEpsilonGC, UseG1GC, UseSerialGC, UseParallelGC, or UseShenandoahGC are required.");
1421       }
1422     }
1423   }
1424 
1425   if (!success) {
1426     if (CDSConfig::is_using_aot_linked_classes()) {
1427       // It's too late to recover -- we have already committed to use the archived metaspace objects, but
1428       // the archived heap objects cannot be loaded, so we don't have the archived FMG to guarantee that
1429       // all AOT-linked classes are visible.
1430       //
1431       // We get here because the heap is too small. The app will fail anyway. So let's quit.
1432       MetaspaceShared::unrecoverable_loading_error("CDS archive has aot-linked classes but the archived "
1433                                                    "heap objects cannot be loaded. Try increasing your heap size.");
1434     }
1435     CDSConfig::stop_using_full_module_graph("archive heap loading failed");
1436   }
1437 }
1438 
1439 bool FileMapInfo::can_use_heap_region() {
1440   if (!has_heap_region()) {
1441     return false;
1442   }
1443   if (JvmtiExport::should_post_class_file_load_hook() && JvmtiExport::has_early_class_hook_env()) {
1444     ShouldNotReachHere(); // CDS should have been disabled.
1445     // The archived objects are mapped at JVM start-up, but we don't know if
1446     // j.l.String or j.l.Class might be replaced by the ClassFileLoadHook,

1785       return false;
1786     }
1787   }
1788 
1789   return true;
1790 }
1791 
1792 bool FileMapInfo::validate_aot_class_linking() {
1793   // These checks need to be done after FileMapInfo::initialize(), which gets called before Universe::heap()
1794   // is available.
1795   if (header()->has_aot_linked_classes()) {
1796     CDSConfig::set_has_aot_linked_classes(true);
1797     if (JvmtiExport::should_post_class_file_load_hook()) {
1798       log_error(cds)("CDS archive has aot-linked classes. It cannot be used when JVMTI ClassFileLoadHook is in use.");
1799       return false;
1800     }
1801     if (JvmtiExport::has_early_vmstart_env()) {
1802       log_error(cds)("CDS archive has aot-linked classes. It cannot be used when JVMTI early vm start is in use.");
1803       return false;
1804     }
1805     if (!CDSConfig::is_using_full_module_graph()) {
1806       log_error(cds)("CDS archive has aot-linked classes. It cannot be used when archived full module graph is not used.");
1807       return false;
1808     }
1809 
1810     const char* prop = Arguments::get_property("java.security.manager");
1811     if (prop != nullptr && strcmp(prop, "disallow") != 0) {
1812       log_error(cds)("CDS archive has aot-linked classes. It cannot be used with -Djava.security.manager=%s.", prop);
1813       return false;
1814     }
1815 






1816 #if INCLUDE_JVMTI
1817     if (Arguments::has_jdwp_agent()) {
1818       log_error(cds)("CDS archive has aot-linked classes. It cannot be used with JDWP agent");
1819       return false;
1820     }
1821 #endif
1822   }
1823 
1824   return true;
1825 }
1826 
1827 // The 2 core spaces are RW->RO
1828 FileMapRegion* FileMapInfo::first_core_region() const {
1829   return region_at(MetaspaceShared::rw);
1830 }
1831 
1832 FileMapRegion* FileMapInfo::last_core_region() const {
1833   return region_at(MetaspaceShared::ro);
1834 }
1835 

1931   }
1932 
1933   if (compact_headers() != UseCompactObjectHeaders) {
1934     log_warning(cds)("Unable to use %s.\nThe %s's UseCompactObjectHeaders setting (%s)"
1935                      " does not equal the current UseCompactObjectHeaders setting (%s).", file_type, file_type,
1936                      _compact_headers          ? "enabled" : "disabled",
1937                      UseCompactObjectHeaders   ? "enabled" : "disabled");
1938     return false;
1939   }
1940 
1941   if (!_use_optimized_module_handling && !CDSConfig::is_dumping_final_static_archive()) {
1942     CDSConfig::stop_using_optimized_module_handling();
1943     log_info(cds)("optimized module handling: disabled because archive was created without optimized module handling");
1944   }
1945 
1946   if (is_static()) {
1947     // Only the static archive can contain the full module graph.
1948     if (!_has_full_module_graph) {
1949       CDSConfig::stop_using_full_module_graph("archive was created without full module graph");
1950     }







1951   }
1952 
1953   return true;
1954 }
1955 
1956 bool FileMapInfo::validate_header() {
1957   if (!header()->validate()) {
1958     return false;
1959   }
1960   if (_is_static) {
1961     return true;
1962   } else {
1963     return DynamicArchive::validate(this);
1964   }
1965 }
1966 
1967 #if INCLUDE_JVMTI
1968 ClassPathEntry** FileMapInfo::_classpath_entries_for_jvmti = nullptr;
1969 
1970 ClassPathEntry* FileMapInfo::get_classpath_entry_for_jvmti(int i, TRAPS) {

 217   _compact_headers = UseCompactObjectHeaders;
 218   if (CDSConfig::is_dumping_heap()) {
 219     _narrow_oop_mode = CompressedOops::mode();
 220     _narrow_oop_base = CompressedOops::base();
 221     _narrow_oop_shift = CompressedOops::shift();
 222   }
 223   _compressed_oops = UseCompressedOops;
 224   _compressed_class_ptrs = UseCompressedClassPointers;
 225   if (UseCompressedClassPointers) {
 226 #ifdef _LP64
 227     _narrow_klass_pointer_bits = CompressedKlassPointers::narrow_klass_pointer_bits();
 228     _narrow_klass_shift = ArchiveBuilder::precomputed_narrow_klass_shift();
 229 #endif
 230   } else {
 231     _narrow_klass_pointer_bits = _narrow_klass_shift = -1;
 232   }
 233   _max_heap_size = MaxHeapSize;
 234   _use_optimized_module_handling = CDSConfig::is_using_optimized_module_handling();
 235   _has_aot_linked_classes = CDSConfig::is_dumping_aot_linked_classes();
 236   _has_full_module_graph = CDSConfig::is_dumping_full_module_graph();
 237   _has_archived_packages = CDSConfig::is_dumping_packages();
 238   _has_archived_protection_domains = CDSConfig::is_dumping_protection_domains();
 239   _gc_kind = (int)Universe::heap()->kind();
 240   jio_snprintf(_gc_name, sizeof(_gc_name), Universe::heap()->name());
 241 
 242   // The following fields are for sanity checks for whether this archive
 243   // will function correctly with this JVM and the bootclasspath it's
 244   // invoked with.
 245 
 246   // JVM version string ... changes on each build.
 247   get_header_version(_jvm_ident);
 248 
 249   _verify_local = BytecodeVerificationLocal;
 250   _verify_remote = BytecodeVerificationRemote;
 251   _has_platform_or_app_classes = AOTClassLocationConfig::dumptime()->has_platform_or_app_classes();
 252   _requested_base_address = (char*)SharedBaseAddress;
 253   _mapped_base_address = (char*)SharedBaseAddress;
 254   _allow_archiving_with_java_agent = AllowArchivingWithJavaAgent;
 255 }
 256 
 257 void FileMapHeader::copy_base_archive_name(const char* archive) {
 258   assert(base_archive_name_size() != 0, "_base_archive_name_size not set");
 259   assert(base_archive_name_offset() != 0, "_base_archive_name_offset not set");
 260   assert(header_size() > sizeof(*this), "_base_archive_name_size not included in header size?");

 295   st->print_cr("- jvm_ident:                      %s", _jvm_ident);
 296   st->print_cr("- class_location_config_offset:   0x%zx", _class_location_config_offset);
 297   st->print_cr("- verify_local:                   %d", _verify_local);
 298   st->print_cr("- verify_remote:                  %d", _verify_remote);
 299   st->print_cr("- has_platform_or_app_classes:    %d", _has_platform_or_app_classes);
 300   st->print_cr("- requested_base_address:         " INTPTR_FORMAT, p2i(_requested_base_address));
 301   st->print_cr("- mapped_base_address:            " INTPTR_FORMAT, p2i(_mapped_base_address));
 302   st->print_cr("- heap_root_segments.roots_count: %d" , _heap_root_segments.roots_count());
 303   st->print_cr("- heap_root_segments.base_offset: 0x%zx", _heap_root_segments.base_offset());
 304   st->print_cr("- heap_root_segments.count:       %zu", _heap_root_segments.count());
 305   st->print_cr("- heap_root_segments.max_size_elems: %d", _heap_root_segments.max_size_in_elems());
 306   st->print_cr("- heap_root_segments.max_size_bytes: %d", _heap_root_segments.max_size_in_bytes());
 307   st->print_cr("- _heap_oopmap_start_pos:         %zu", _heap_oopmap_start_pos);
 308   st->print_cr("- _heap_ptrmap_start_pos:         %zu", _heap_ptrmap_start_pos);
 309   st->print_cr("- _rw_ptrmap_start_pos:           %zu", _rw_ptrmap_start_pos);
 310   st->print_cr("- _ro_ptrmap_start_pos:           %zu", _ro_ptrmap_start_pos);
 311   st->print_cr("- allow_archiving_with_java_agent:%d", _allow_archiving_with_java_agent);
 312   st->print_cr("- use_optimized_module_handling:  %d", _use_optimized_module_handling);
 313   st->print_cr("- has_full_module_graph           %d", _has_full_module_graph);
 314   st->print_cr("- has_aot_linked_classes          %d", _has_aot_linked_classes);
 315   st->print_cr("- has_archived_packages           %d", _has_archived_packages);
 316   st->print_cr("- has_archived_protection_domains %d", _has_archived_protection_domains);
 317   st->print_cr("- ptrmap_size_in_bits:            %zu", _ptrmap_size_in_bits);
 318 }
 319 
 320 bool FileMapInfo::validate_class_location() {
 321   assert(CDSConfig::is_using_archive(), "runtime only");
 322 
 323   AOTClassLocationConfig* config = header()->class_location_config();
 324   bool has_extra_module_paths = false;
 325   if (!config->validate(header()->has_aot_linked_classes(), &has_extra_module_paths)) {
 326     if (PrintSharedArchiveAndExit) {
 327       MetaspaceShared::set_archive_loading_failed();
 328       return true;
 329     } else {
 330       return false;
 331     }
 332   }
 333 
 334   if (header()->has_full_module_graph() && has_extra_module_paths) {
 335     CDSConfig::stop_using_optimized_module_handling();
 336     log_info(cds)("optimized module handling: disabled because extra module path(s) are specified");
 337   }

 814 bool FileMapRegion::check_region_crc(char* base) const {
 815   // This function should be called after the region has been properly
 816   // loaded into memory via FileMapInfo::map_region() or FileMapInfo::read_region().
 817   // I.e., this->mapped_base() must be valid.
 818   size_t sz = used();
 819   if (sz == 0) {
 820     return true;
 821   }
 822 
 823   assert(base != nullptr, "must be initialized");
 824   int crc = ClassLoader::crc32(0, base, (jint)sz);
 825   if (crc != this->crc()) {
 826     log_warning(cds)("Checksum verification failed.");
 827     return false;
 828   }
 829   return true;
 830 }
 831 
 832 static const char* region_name(int region_index) {
 833   static const char* names[] = {
 834     "rw", "ro", "bm", "hp", "cc",
 835   };
 836   const int num_regions = sizeof(names)/sizeof(names[0]);
 837   assert(0 <= region_index && region_index < num_regions, "sanity");
 838 
 839   return names[region_index];
 840 }
 841 
 842 BitMapView FileMapInfo::bitmap_view(int region_index, bool is_oopmap) {
 843   FileMapRegion* r = region_at(region_index);
 844   char* bitmap_base = is_static() ? FileMapInfo::current_info()->map_bitmap_region() : FileMapInfo::dynamic_info()->map_bitmap_region();
 845   bitmap_base += is_oopmap ? r->oopmap_offset() : r->ptrmap_offset();
 846   size_t size_in_bits = is_oopmap ? r->oopmap_size_in_bits() : r->ptrmap_size_in_bits();
 847 
 848   log_debug(cds, reloc)("mapped %s relocation %smap @ " INTPTR_FORMAT " (%zu bits)",
 849                         region_name(region_index), is_oopmap ? "oop" : "ptr",
 850                         p2i(bitmap_base), size_in_bits);
 851 
 852   return BitMapView((BitMap::bm_word_t*)(bitmap_base), size_in_bits);
 853 }
 854 

 900       mapping_offset = (size_t)((address)requested_base - CompressedOops::base());
 901       assert((mapping_offset >> CompressedOops::shift()) << CompressedOops::shift() == mapping_offset, "must be");
 902     } else {
 903       mapping_offset = 0; // not used with !UseCompressedOops
 904     }
 905 #endif // INCLUDE_CDS_JAVA_HEAP
 906   } else {
 907     char* requested_SharedBaseAddress = (char*)MetaspaceShared::requested_base_address();
 908     requested_base = ArchiveBuilder::current()->to_requested(base);
 909     assert(requested_base >= requested_SharedBaseAddress, "must be");
 910     mapping_offset = requested_base - requested_SharedBaseAddress;
 911   }
 912 
 913   r->set_file_offset(_file_offset);
 914   int crc = ClassLoader::crc32(0, base, (jint)size);
 915   if (size > 0) {
 916     log_info(cds)("Shared file region (%s) %d: %8zu"
 917                    " bytes, addr " INTPTR_FORMAT " file offset 0x%08" PRIxPTR
 918                    " crc 0x%08x",
 919                    region_name(region), region, size, p2i(requested_base), _file_offset, crc);
 920   } else {
 921     log_info(cds)("Shared file region (%s) %d: %8zu"
 922                   " bytes", region_name(region), region, size);
 923   }
 924 
 925   r->init(region, mapping_offset, size, read_only, allow_exec, crc);
 926 
 927   if (base != nullptr) {
 928     write_bytes_aligned(base, size);
 929   }
 930 }
 931 
 932 static size_t write_bitmap(const CHeapBitMap* map, char* output, size_t offset) {
 933   size_t size_in_bytes = map->size_in_bytes();
 934   map->write_to((BitMap::bm_word_t*)(output + offset), size_in_bytes);
 935   return offset + size_in_bytes;
 936 }
 937 
 938 // The sorting code groups the objects with non-null oop/ptrs together.
 939 // Relevant bitmaps then have lots of leading and trailing zeros, which
 940 // we do not have to store.
 941 size_t FileMapInfo::remove_bitmap_zeros(CHeapBitMap* map) {
 942   BitMap::idx_t first_set = map->find_first_set_bit(0);
 943   BitMap::idx_t last_set  = map->find_last_set_bit(0);
 944   size_t old_size = map->size();
 945 
 946   // Slice and resize bitmap
 947   map->truncate(first_set, last_set + 1);
 948 
 949   assert(map->at(0), "First bit should be set");
 950   assert(map->at(map->size() - 1), "Last bit should be set");
 951   assert(map->size() <= old_size, "sanity");
 952 
 953   return first_set;
 954 }
 955 
 956 char* FileMapInfo::write_bitmap_region(CHeapBitMap* rw_ptrmap, CHeapBitMap* ro_ptrmap,
 957                                        CHeapBitMap* cc_ptrmap,
 958                                        ArchiveHeapInfo* heap_info,
 959                                        size_t &size_in_bytes) {
 960   size_t removed_rw_leading_zeros = remove_bitmap_zeros(rw_ptrmap);
 961   size_t removed_ro_leading_zeros = remove_bitmap_zeros(ro_ptrmap);
 962   header()->set_rw_ptrmap_start_pos(removed_rw_leading_zeros);
 963   header()->set_ro_ptrmap_start_pos(removed_ro_leading_zeros);
 964   size_in_bytes = rw_ptrmap->size_in_bytes() + ro_ptrmap->size_in_bytes() + cc_ptrmap->size_in_bytes();
 965 
 966   if (heap_info->is_used()) {
 967     // Remove leading and trailing zeros
 968     size_t removed_oop_leading_zeros = remove_bitmap_zeros(heap_info->oopmap());
 969     size_t removed_ptr_leading_zeros = remove_bitmap_zeros(heap_info->ptrmap());
 970     header()->set_heap_oopmap_start_pos(removed_oop_leading_zeros);
 971     header()->set_heap_ptrmap_start_pos(removed_ptr_leading_zeros);
 972 
 973     size_in_bytes += heap_info->oopmap()->size_in_bytes();
 974     size_in_bytes += heap_info->ptrmap()->size_in_bytes();
 975   }
 976 
 977   // The bitmap region contains up to 4 parts:
 978   // rw_ptrmap:           metaspace pointers inside the read-write region
 979   // ro_ptrmap:           metaspace pointers inside the read-only region
 980   // heap_info->oopmap(): Java oop pointers in the heap region
 981   // heap_info->ptrmap(): metaspace pointers in the heap region
 982   char* buffer = NEW_C_HEAP_ARRAY(char, size_in_bytes, mtClassShared);
 983   size_t written = 0;
 984 
 985   region_at(MetaspaceShared::rw)->init_ptrmap(0, rw_ptrmap->size());
 986   written = write_bitmap(rw_ptrmap, buffer, written);
 987 
 988   region_at(MetaspaceShared::ro)->init_ptrmap(written, ro_ptrmap->size());
 989   written = write_bitmap(ro_ptrmap, buffer, written);
 990 
 991   region_at(MetaspaceShared::cc)->init_ptrmap(written, cc_ptrmap->size());
 992   written = write_bitmap(cc_ptrmap, buffer, written);
 993 
 994   if (heap_info->is_used()) {
 995     FileMapRegion* r = region_at(MetaspaceShared::hp);
 996 
 997     r->init_oopmap(written, heap_info->oopmap()->size());
 998     written = write_bitmap(heap_info->oopmap(), buffer, written);
 999 
1000     r->init_ptrmap(written, heap_info->ptrmap()->size());
1001     written = write_bitmap(heap_info->ptrmap(), buffer, written);
1002   }
1003 
1004   write_region(MetaspaceShared::bm, (char*)buffer, size_in_bytes, /*read_only=*/true, /*allow_exec=*/false);
1005   return buffer;
1006 }
1007 
1008 size_t FileMapInfo::write_heap_region(ArchiveHeapInfo* heap_info) {
1009   char* buffer_start = heap_info->buffer_start();
1010   size_t buffer_size = heap_info->buffer_byte_size();
1011   write_region(MetaspaceShared::hp, buffer_start, buffer_size, false, false);
1012   header()->set_heap_root_segments(heap_info->heap_root_segments());
1013   return buffer_size;

1109   assert(WINDOWS_ONLY(false) NOT_WINDOWS(true), "Don't call on Windows");
1110   // Replace old mapping with new one that is writable.
1111   char *base = os::map_memory(_fd, _full_path, r->file_offset(),
1112                               addr, size, false /* !read_only */,
1113                               r->allow_exec());
1114   close();
1115   // These have to be errors because the shared region is now unmapped.
1116   if (base == nullptr) {
1117     log_error(cds)("Unable to remap shared readonly space (errno=%d).", errno);
1118     vm_exit(1);
1119   }
1120   if (base != addr) {
1121     log_error(cds)("Unable to remap shared readonly space (errno=%d).", errno);
1122     vm_exit(1);
1123   }
1124   r->set_read_only(false);
1125   return true;
1126 }
1127 
1128 // Memory map a region in the address space.
1129 static const char* shared_region_name[] = { "ReadWrite", "ReadOnly", "Bitmap", "Heap", "Code" };
1130 
1131 MapArchiveResult FileMapInfo::map_regions(int regions[], int num_regions, char* mapped_base_address, ReservedSpace rs) {
1132   DEBUG_ONLY(FileMapRegion* last_region = nullptr);
1133   intx addr_delta = mapped_base_address - header()->requested_base_address();
1134 
1135   // Make sure we don't attempt to use header()->mapped_base_address() unless
1136   // it's been successfully mapped.
1137   DEBUG_ONLY(header()->set_mapped_base_address((char*)(uintptr_t)0xdeadbeef);)
1138 
1139   for (int i = 0; i < num_regions; i++) {
1140     int idx = regions[i];
1141     MapArchiveResult result = map_region(idx, addr_delta, mapped_base_address, rs);
1142     if (result != MAP_ARCHIVE_SUCCESS) {
1143       return result;
1144     }
1145     FileMapRegion* r = region_at(idx);
1146     DEBUG_ONLY(if (last_region != nullptr) {
1147         // Ensure that the OS won't be able to allocate new memory spaces between any mapped
1148         // regions, or else it would mess up the simple comparison in MetaspaceObj::is_shared().
1149         assert(r->mapped_base() == last_region->mapped_end(), "must have no gaps");

1212   } else if (addr_delta != 0) {
1213     r->set_read_only(false); // Need to patch the pointers
1214   }
1215 
1216   if (MetaspaceShared::use_windows_memory_mapping() && rs.is_reserved()) {
1217     // This is the second time we try to map the archive(s). We have already created a ReservedSpace
1218     // that covers all the FileMapRegions to ensure all regions can be mapped. However, Windows
1219     // can't mmap into a ReservedSpace, so we just ::read() the data. We're going to patch all the
1220     // regions anyway, so there's no benefit for mmap anyway.
1221     if (!read_region(i, requested_addr, size, /* do_commit = */ true)) {
1222       log_info(cds)("Failed to read %s shared space into reserved space at " INTPTR_FORMAT,
1223                     shared_region_name[i], p2i(requested_addr));
1224       return MAP_ARCHIVE_OTHER_FAILURE; // oom or I/O error.
1225     } else {
1226       assert(r->mapped_base() != nullptr, "must be initialized");
1227     }
1228   } else {
1229     // Note that this may either be a "fresh" mapping into unreserved address
1230     // space (Windows, first mapping attempt), or a mapping into pre-reserved
1231     // space (Posix). See also comment in MetaspaceShared::map_archives().
1232     bool read_only = r->read_only() && !CDSConfig::is_dumping_final_static_archive();
1233     char* base = map_memory(_fd, _full_path, r->file_offset(),
1234                             requested_addr, size, read_only,
1235                             r->allow_exec(), mtClassShared);
1236     if (base != requested_addr) {
1237       log_info(cds)("Unable to map %s shared space at " INTPTR_FORMAT,
1238                     shared_region_name[i], p2i(requested_addr));
1239       _memory_mapping_failed = true;
1240       return MAP_ARCHIVE_MMAP_FAILURE;
1241     }
1242 
1243     if (VerifySharedSpaces && !r->check_region_crc(requested_addr)) {
1244       return MAP_ARCHIVE_OTHER_FAILURE;
1245     }
1246 
1247     r->set_mapped_from_file(true);
1248     r->set_mapped_base(requested_addr);
1249   }
1250 
1251   if (rs.is_reserved()) {
1252     char* mapped_base = r->mapped_base();
1253     assert(rs.base() <= mapped_base && mapped_base + size <= rs.end(),
1254            PTR_FORMAT " <= " PTR_FORMAT " < " PTR_FORMAT " <= " PTR_FORMAT,

1273     return nullptr;
1274   }
1275 
1276   if (VerifySharedSpaces && !r->check_region_crc(bitmap_base)) {
1277     log_error(cds)("relocation bitmap CRC error");
1278     if (!os::unmap_memory(bitmap_base, r->used_aligned())) {
1279       fatal("os::unmap_memory of relocation bitmap failed");
1280     }
1281     return nullptr;
1282   }
1283 
1284   r->set_mapped_from_file(true);
1285   r->set_mapped_base(bitmap_base);
1286   log_info(cds)("Mapped %s region #%d at base " INTPTR_FORMAT " top " INTPTR_FORMAT " (%s)",
1287                 is_static() ? "static " : "dynamic",
1288                 MetaspaceShared::bm, p2i(r->mapped_base()), p2i(r->mapped_end()),
1289                 shared_region_name[MetaspaceShared::bm]);
1290   return bitmap_base;
1291 }
1292 
1293 bool FileMapInfo::map_cached_code_region(ReservedSpace rs) {
1294   FileMapRegion* r = region_at(MetaspaceShared::cc);
1295   assert(r->used() > 0 && r->used_aligned() == rs.size(), "must be");
1296 
1297   char* requested_base = rs.base();
1298   assert(requested_base != nullptr, "should be inside code cache");
1299 
1300   char* mapped_base;
1301   if (MetaspaceShared::use_windows_memory_mapping()) {
1302     if (!read_region(MetaspaceShared::cc, requested_base, r->used_aligned(), /* do_commit = */ true)) {
1303       log_info(cds)("Failed to read cc shared space into reserved space at " INTPTR_FORMAT,
1304                     p2i(requested_base));
1305       return false;
1306     }
1307     mapped_base = requested_base;
1308   } else {
1309     bool read_only = false, allow_exec = false;
1310     mapped_base = map_memory(_fd, _full_path, r->file_offset(),
1311                              requested_base, r->used_aligned(), read_only, allow_exec, mtClassShared);
1312   }
1313   if (mapped_base == nullptr) {
1314     log_info(cds)("failed to map cached code region");
1315     return false;
1316   } else {
1317     assert(mapped_base == requested_base, "must be");
1318     r->set_mapped_from_file(true);
1319     r->set_mapped_base(mapped_base);
1320     relocate_pointers_in_cached_code_region();
1321     log_info(cds)("Mapped static  region #%d at base " INTPTR_FORMAT " top " INTPTR_FORMAT " (%s)",
1322                   MetaspaceShared::cc, p2i(r->mapped_base()), p2i(r->mapped_end()),
1323                   shared_region_name[MetaspaceShared::cc]);
1324     return true;
1325   }
1326 }
1327 
1328 class CachedCodeRelocator: public BitMapClosure {
1329   address _code_requested_base;
1330   address* _patch_base;
1331   intx _code_delta;
1332   intx _metadata_delta;
1333 
1334 public:
1335   CachedCodeRelocator(address code_requested_base, address code_mapped_base,
1336                       intx metadata_delta) {
1337     _code_requested_base = code_requested_base;
1338     _patch_base = (address*)code_mapped_base;
1339     _code_delta = code_mapped_base - code_requested_base;
1340     _metadata_delta = metadata_delta;
1341   }
1342   
1343   bool do_bit(size_t offset) {
1344     address* p = _patch_base + offset;
1345     address requested_ptr = *p;
1346     if (requested_ptr < _code_requested_base) {
1347       *p = requested_ptr + _metadata_delta;
1348     } else {
1349       *p = requested_ptr + _code_delta;
1350     }
1351     return true; // keep iterating
1352   }
1353 };
1354 
1355 void FileMapInfo::relocate_pointers_in_cached_code_region() {
1356   FileMapRegion* r = region_at(MetaspaceShared::cc);
1357   char* bitmap_base = map_bitmap_region();
1358 
1359   BitMapView cc_ptrmap = ptrmap_view(MetaspaceShared::cc);
1360   if (cc_ptrmap.size() == 0) {
1361     return;
1362   }
1363 
1364   address core_regions_requested_base = (address)header()->requested_base_address();
1365   address core_regions_mapped_base = (address)header()->mapped_base_address();
1366   address cc_region_requested_base = core_regions_requested_base + r->mapping_offset();
1367   address cc_region_mapped_base = (address)r->mapped_base();
1368 
1369   size_t max_bits_for_core_regions = pointer_delta(mapped_end(), mapped_base(), // FIXME - renamed to core_regions_mapped_base(), etc
1370                                                    sizeof(address));
1371 
1372   CachedCodeRelocator patcher(cc_region_requested_base, cc_region_mapped_base,
1373                               core_regions_mapped_base - core_regions_requested_base);
1374   cc_ptrmap.iterate(&patcher);
1375 }
1376 
1377 class SharedDataRelocationTask : public ArchiveWorkerTask {
1378 private:
1379   BitMapView* const _rw_bm;
1380   BitMapView* const _ro_bm;
1381   SharedDataRelocator* const _rw_reloc;
1382   SharedDataRelocator* const _ro_reloc;
1383 
1384 public:
1385   SharedDataRelocationTask(BitMapView* rw_bm, BitMapView* ro_bm, SharedDataRelocator* rw_reloc, SharedDataRelocator* ro_reloc) :
1386                            ArchiveWorkerTask("Shared Data Relocation"),
1387                            _rw_bm(rw_bm), _ro_bm(ro_bm), _rw_reloc(rw_reloc), _ro_reloc(ro_reloc) {}
1388 
1389   void work(int chunk, int max_chunks) override {
1390     work_on(chunk, max_chunks, _rw_bm, _rw_reloc);
1391     work_on(chunk, max_chunks, _ro_bm, _ro_reloc);
1392   }
1393 
1394   void work_on(int chunk, int max_chunks, BitMapView* bm, SharedDataRelocator* reloc) {
1395     BitMap::idx_t size  = bm->size();
1396     BitMap::idx_t start = MIN2(size, size * chunk / max_chunks);

1506 }
1507 
1508 void FileMapInfo::map_or_load_heap_region() {
1509   bool success = false;
1510 
1511   if (can_use_heap_region()) {
1512     if (ArchiveHeapLoader::can_map()) {
1513       success = map_heap_region();
1514     } else if (ArchiveHeapLoader::can_load()) {
1515       success = ArchiveHeapLoader::load_heap_region(this);
1516     } else {
1517       if (!UseCompressedOops && !ArchiveHeapLoader::can_map()) {
1518         log_info(cds)("Cannot use CDS heap data. Selected GC not compatible -XX:-UseCompressedOops");
1519       } else {
1520         log_info(cds)("Cannot use CDS heap data. UseEpsilonGC, UseG1GC, UseSerialGC, UseParallelGC, or UseShenandoahGC are required.");
1521       }
1522     }
1523   }
1524 
1525   if (!success) {
1526     if (CDSConfig::is_using_aot_linked_classes() && !CDSConfig::is_dumping_final_static_archive()) {
1527       // It's too late to recover -- we have already committed to use the archived metaspace objects, but
1528       // the archived heap objects cannot be loaded, so we don't have the archived FMG to guarantee that
1529       // all AOT-linked classes are visible.
1530       //
1531       // We get here because the heap is too small. The app will fail anyway. So let's quit.
1532       MetaspaceShared::unrecoverable_loading_error("CDS archive has aot-linked classes but the archived "
1533                                                    "heap objects cannot be loaded. Try increasing your heap size.");
1534     }
1535     CDSConfig::stop_using_full_module_graph("archive heap loading failed");
1536   }
1537 }
1538 
1539 bool FileMapInfo::can_use_heap_region() {
1540   if (!has_heap_region()) {
1541     return false;
1542   }
1543   if (JvmtiExport::should_post_class_file_load_hook() && JvmtiExport::has_early_class_hook_env()) {
1544     ShouldNotReachHere(); // CDS should have been disabled.
1545     // The archived objects are mapped at JVM start-up, but we don't know if
1546     // j.l.String or j.l.Class might be replaced by the ClassFileLoadHook,

1885       return false;
1886     }
1887   }
1888 
1889   return true;
1890 }
1891 
1892 bool FileMapInfo::validate_aot_class_linking() {
1893   // These checks need to be done after FileMapInfo::initialize(), which gets called before Universe::heap()
1894   // is available.
1895   if (header()->has_aot_linked_classes()) {
1896     CDSConfig::set_has_aot_linked_classes(true);
1897     if (JvmtiExport::should_post_class_file_load_hook()) {
1898       log_error(cds)("CDS archive has aot-linked classes. It cannot be used when JVMTI ClassFileLoadHook is in use.");
1899       return false;
1900     }
1901     if (JvmtiExport::has_early_vmstart_env()) {
1902       log_error(cds)("CDS archive has aot-linked classes. It cannot be used when JVMTI early vm start is in use.");
1903       return false;
1904     }
1905     if (!CDSConfig::is_using_full_module_graph() && !CDSConfig::is_dumping_final_static_archive()) {
1906       log_error(cds)("CDS archive has aot-linked classes. It cannot be used when archived full module graph is not used.");
1907       return false;
1908     }
1909 
1910     const char* prop = Arguments::get_property("java.security.manager");
1911     if (prop != nullptr && strcmp(prop, "disallow") != 0) {
1912       log_error(cds)("CDS archive has aot-linked classes. It cannot be used with -Djava.security.manager=%s.", prop);
1913       return false;
1914     }
1915 
1916     if (header()->gc_kind() != (int)Universe::heap()->kind()) {
1917       log_error(cds)("CDS archive has aot-linked classes. It cannot be used because GC used during dump time (%s) is not the same as runtime (%s)",
1918                      header()->gc_name(), Universe::heap()->name());
1919       return false;
1920     }
1921 
1922 #if INCLUDE_JVMTI
1923     if (Arguments::has_jdwp_agent()) {
1924       log_error(cds)("CDS archive has aot-linked classes. It cannot be used with JDWP agent");
1925       return false;
1926     }
1927 #endif
1928   }
1929 
1930   return true;
1931 }
1932 
1933 // The 2 core spaces are RW->RO
1934 FileMapRegion* FileMapInfo::first_core_region() const {
1935   return region_at(MetaspaceShared::rw);
1936 }
1937 
1938 FileMapRegion* FileMapInfo::last_core_region() const {
1939   return region_at(MetaspaceShared::ro);
1940 }
1941 

2037   }
2038 
2039   if (compact_headers() != UseCompactObjectHeaders) {
2040     log_warning(cds)("Unable to use %s.\nThe %s's UseCompactObjectHeaders setting (%s)"
2041                      " does not equal the current UseCompactObjectHeaders setting (%s).", file_type, file_type,
2042                      _compact_headers          ? "enabled" : "disabled",
2043                      UseCompactObjectHeaders   ? "enabled" : "disabled");
2044     return false;
2045   }
2046 
2047   if (!_use_optimized_module_handling && !CDSConfig::is_dumping_final_static_archive()) {
2048     CDSConfig::stop_using_optimized_module_handling();
2049     log_info(cds)("optimized module handling: disabled because archive was created without optimized module handling");
2050   }
2051 
2052   if (is_static()) {
2053     // Only the static archive can contain the full module graph.
2054     if (!_has_full_module_graph) {
2055       CDSConfig::stop_using_full_module_graph("archive was created without full module graph");
2056     }
2057 
2058     if (_has_archived_packages) {
2059       CDSConfig::set_is_loading_packages();
2060     }
2061     if (_has_archived_protection_domains) {
2062       CDSConfig::set_is_loading_protection_domains();
2063     }
2064   }
2065 
2066   return true;
2067 }
2068 
2069 bool FileMapInfo::validate_header() {
2070   if (!header()->validate()) {
2071     return false;
2072   }
2073   if (_is_static) {
2074     return true;
2075   } else {
2076     return DynamicArchive::validate(this);
2077   }
2078 }
2079 
2080 #if INCLUDE_JVMTI
2081 ClassPathEntry** FileMapInfo::_classpath_entries_for_jvmti = nullptr;
2082 
2083 ClassPathEntry* FileMapInfo::get_classpath_entry_for_jvmti(int i, TRAPS) {
< prev index next >