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

equal deleted inserted replaced

-:5aeb07390c74
+:69c38b90014c
 #include "logging/logMessage.hpp"
 #include "memory/dynamicArchive.hpp"
 #include "memory/filemap.hpp"
 #include "memory/heapShared.inline.hpp"
 #include "memory/iterator.inline.hpp"
+#include "memory/metadataFactory.hpp"
 #include "memory/metaspace.hpp"
-#include "memory/metadataFactory.hpp"
 #include "memory/metaspaceClosure.hpp"
 #include "memory/metaspaceShared.hpp"
 #include "memory/oopFactory.hpp"
 #include "memory/universe.hpp"
 #include "oops/compressedOops.hpp"
 _dynamic_archive_info = this;
 header_size = sizeof(DynamicArchiveHeader);
 }
 _header = (FileMapHeader*)os::malloc(header_size, mtInternal);
 memset((void*)_header, 0, header_size);
-_header->_header_size = header_size;
+_header->set_header_size(header_size);
-_header->_version = INVALID_CDS_ARCHIVE_VERSION;
+_header->set_version(INVALID_CDS_ARCHIVE_VERSION);
-_header->_has_platform_or_app_classes = true;
+_header->set_has_platform_or_app_classes(true);
 _file_offset = 0;
 _file_open = false;
 }
 FileMapInfo::~FileMapInfo() {
 _dynamic_archive_info = NULL;
 }
 }
 void FileMapInfo::populate_header(size_t alignment) {
-_header->populate(this, alignment);
+header()->populate(this, alignment);
 }
 void FileMapHeader::populate(FileMapInfo* mapinfo, size_t alignment) {
 if (DynamicDumpSharedSpaces) {
 _magic = CDS_DYNAMIC_ARCHIVE_MAGIC;
 // after generating the shared archive), which is acceptable. For most
 // common cases, the dump time boot path might contain modules_image only.
 char* runtime_boot_path = Arguments::get_sysclasspath();
 char* rp = skip_first_path_entry(runtime_boot_path);
 assert(shared_path(0)->is_modules_image(), "first shared_path must be the modules image");
-int dp_len = _header->_app_class_paths_start_index - 1; // ignore the first path to the module image
+int dp_len = header()->app_class_paths_start_index() - 1; // ignore the first path to the module image
 bool mismatch = false;
 bool relaxed_check = !header()->has_platform_or_app_classes();
 if (dp_len == 0 && rp == NULL) {
 return true;   // ok, both runtime and dump time boot paths have modules_images only
 //
 // dump : -cp a.jar:NE1:NE2:b.jar  -> a.jar:b.jar -> recorded in archive.
 // run 1: -cp NE3:a.jar:NE4:b.jar  -> a.jar:b.jar -> matched
 // run 2: -cp x.jar:NE4:b.jar      -> x.jar:b.jar -> mismatched
-int j = _header->_app_class_paths_start_index;
+int j = header()->app_class_paths_start_index();
 mismatch = check_paths(j, shared_app_paths_len, rp_array);
 if (mismatch) {
 return fail("[APP classpath mismatch, actual: -Djava.class.path=", appcp);
 }
 }
 assert(UseSharedSpaces, "runtime only");
 _validating_shared_path_table = true;
 // Load the shared path table info from the archive header
-_shared_path_table = _header->_shared_path_table;
+_shared_path_table = header()->shared_path_table();
 if (DynamicDumpSharedSpaces) {
 // Only support dynamic dumping with the usage of the default CDS archive
 // or a simple base archive.
 // If the base layer archive contains additional path component besides
 // the runtime image and the -cp, dynamic dumping is disabled.
 //
 // When dynamic archiving is enabled, the _shared_path_table is overwritten
 // to include the application path and stored in the top layer archive.
 assert(shared_path(0)->is_modules_image(), "first shared_path must be the modules image");
-if (_header->_app_class_paths_start_index > 1) {
+if (header()->app_class_paths_start_index() > 1) {
 DynamicDumpSharedSpaces = false;
 warning(
 "Dynamic archiving is disabled because base layer archive has appended boot classpath");
 }
-if (_header->_num_module_paths > 0) {
+if (header()->num_module_paths() > 0) {
 DynamicDumpSharedSpaces = false;
 warning(
 "Dynamic archiving is disabled because base layer archive has module path");
 }
 }
-log_paths("Expecting BOOT path=", 0, _header->_app_class_paths_start_index);
+log_paths("Expecting BOOT path=", 0, header()->app_class_paths_start_index());
-log_paths("Expecting -Djava.class.path=", _header->_app_class_paths_start_index, _header->_app_module_paths_start_index);
+log_paths("Expecting -Djava.class.path=", header()->app_class_paths_start_index(), header()->app_module_paths_start_index());
-int module_paths_start_index = _header->_app_module_paths_start_index;
+int module_paths_start_index = header()->app_module_paths_start_index();
 int shared_app_paths_len = 0;
 // validate the path entries up to the _max_used_path_index
-for (int i=0; i < _header->_max_used_path_index + 1; i++) {
+for (int i=0; i < header()->max_used_path_index() + 1; i++) {
 if (i < module_paths_start_index) {
 if (shared_path(i)->validate()) {
 // Only count the app class paths not from the "Class-path" attribute of a jar manifest.
-if (!shared_path(i)->from_class_path_attr() && i >= _header->_app_class_paths_start_index) {
+if (!shared_path(i)->from_class_path_attr() && i >= header()->app_class_paths_start_index()) {
 shared_app_paths_len++;
 }
 log_info(class, path)("ok");
 } else {
 if (_dynamic_archive_info != NULL && _dynamic_archive_info->_is_static) {
 return false;
 }
 }
 }
-if (_header->_max_used_path_index == 0) {
+if (header()->max_used_path_index() == 0) {
 // default archive only contains the module image in the bootclasspath
 assert(shared_path(0)->is_modules_image(), "first shared_path must be the modules image");
 } else {
 if (!validate_boot_class_paths() || !validate_app_class_paths(shared_app_paths_len)) {
 fail_continue("shared class paths mismatch (hint: enable -Xlog:class+path=info to diagnose the failure)");
 // it will change how classes are loading for the app loader. For safety, disable
 // loading of archived platform/app classes (currently there's no way to disable just the
 // app classes).
 assert(UseSharedSpaces, "runtime only");
-for (int i = _header->_app_module_paths_start_index + _header->_num_module_paths;
+for (int i = header()->app_module_paths_start_index() + header()->num_module_paths();
 i < get_number_of_shared_paths();
 i++) {
 SharedClassPathEntry* ent = shared_path(i);
 if (!ent->check_non_existent()) {
 warning("Archived non-system classes are disabled because the "
 "file %s exists", ent->name());
-_header->_has_platform_or_app_classes = false;
+header()->set_has_platform_or_app_classes(false);
 }
 }
 }
 bool FileMapInfo::check_archive(const char* archive_name, bool is_static) {
 vm_exit_during_initialization("Unable to read header from shared archive", archive_name);
 return false;
 }
 if (is_static) {
 FileMapHeader* static_header = (FileMapHeader*)header;
-if (static_header->_magic != CDS_ARCHIVE_MAGIC) {
+if (static_header->magic() != CDS_ARCHIVE_MAGIC) {
 os::free(header);
 os::close(fd);
 vm_exit_during_initialization("Not a base shared archive", archive_name);
 return false;
 }
 } else {
 DynamicArchiveHeader* dynamic_header = (DynamicArchiveHeader*)header;
-if (dynamic_header->_magic != CDS_DYNAMIC_ARCHIVE_MAGIC) {
+if (dynamic_header->magic() != CDS_DYNAMIC_ARCHIVE_MAGIC) {
 os::free(header);
 os::close(fd);
 vm_exit_during_initialization("Not a top shared archive", archive_name);
 return false;
 }
 fail_continue("Unable to read the file header.");
 os::free(dynamic_header);
 os::close(fd);
 return false;
 }
-if (dynamic_header->_magic != CDS_DYNAMIC_ARCHIVE_MAGIC) {
+if (dynamic_header->magic() != CDS_DYNAMIC_ARCHIVE_MAGIC) {
 // Not a dynamic header, no need to proceed further.
 *size = 0;
 os::free(dynamic_header);
 os::close(fd);
 return false;
 }
-if (dynamic_header->_base_archive_is_default) {
+if (dynamic_header->base_archive_is_default()) {
 *base_archive_name = Arguments::get_default_shared_archive_path();
 } else {
 // read the base archive name
-size_t name_size = dynamic_header->_base_archive_name_size;
+size_t name_size = dynamic_header->base_archive_name_size();
 if (name_size == 0) {
 os::free(dynamic_header);
 os::close(fd);
 return false;
 }
 os::close(fd);
 return true;
 }
 void FileMapInfo::restore_shared_path_table() {
-_shared_path_table = _current_info->_header->_shared_path_table;
+_shared_path_table = _current_info->header()->shared_path_table();
 }
 // Read the FileMapInfo information from the file.
 bool FileMapInfo::init_from_file(int fd, bool is_static) {
 size_t sz = is_static ? sizeof(FileMapHeader) : sizeof(DynamicArchiveHeader);
-size_t n = os::read(fd, _header, (unsigned int)sz);
+size_t n = os::read(fd, header(), (unsigned int)sz);
 if (n != sz) {
 fail_continue("Unable to read the file header.");
 return false;
 }
 FileMapInfo::fail_continue("The shared archive file cannot be used with an exploded module build.");
 return false;
 }
 unsigned int expected_magic = is_static ? CDS_ARCHIVE_MAGIC : CDS_DYNAMIC_ARCHIVE_MAGIC;
-if (_header->_magic != expected_magic) {
+if (header()->magic() != expected_magic) {
 log_info(cds)("_magic expected: 0x%08x", expected_magic);
-log_info(cds)("         actual: 0x%08x", _header->_magic);
+log_info(cds)("         actual: 0x%08x", header()->magic());
 FileMapInfo::fail_continue("The shared archive file has a bad magic number.");
 return false;
 }
-if (_header->_version != CURRENT_CDS_ARCHIVE_VERSION) {
+if (header()->version() != CURRENT_CDS_ARCHIVE_VERSION) {
 log_info(cds)("_version expected: %d", CURRENT_CDS_ARCHIVE_VERSION);
-log_info(cds)("           actual: %d", _header->_version);
+log_info(cds)("           actual: %d", header()->version());
 fail_continue("The shared archive file has the wrong version.");
 return false;
 }
-if (_header->_header_size != sz) {
+if (header()->header_size() != sz) {
 log_info(cds)("_header_size expected: " SIZE_FORMAT, sz);
-log_info(cds)("               actual: " SIZE_FORMAT, _header->_header_size);
+log_info(cds)("               actual: " SIZE_FORMAT, header()->header_size());
 FileMapInfo::fail_continue("The shared archive file has an incorrect header size.");
 return false;
 }
-if (_header->_jvm_ident[JVM_IDENT_MAX-1] != 0) {
+const char* actual_ident = header()->jvm_ident();
+if (actual_ident[JVM_IDENT_MAX-1] != 0) {
 FileMapInfo::fail_continue("JVM version identifier is corrupted.");
 return false;
 }
-char header_version[JVM_IDENT_MAX];
+char expected_ident[JVM_IDENT_MAX];
-get_header_version(header_version);
+get_header_version(expected_ident);
-if (strncmp(_header->_jvm_ident, header_version, JVM_IDENT_MAX-1) != 0) {
+if (strncmp(actual_ident, expected_ident, JVM_IDENT_MAX-1) != 0) {
-log_info(cds)("_jvm_ident expected: %s", header_version);
+log_info(cds)("_jvm_ident expected: %s", expected_ident);
-log_info(cds)("             actual: %s", _header->_jvm_ident);
+log_info(cds)("             actual: %s", actual_ident);
 FileMapInfo::fail_continue("The shared archive file was created by a different"
 " version or build of HotSpot");
 return false;
 }
 if (VerifySharedSpaces) {
-int expected_crc = _header->compute_crc();
+int expected_crc = header()->compute_crc();
-if (expected_crc != _header->_crc) {
+if (expected_crc != header()->crc()) {
 log_info(cds)("_crc expected: %d", expected_crc);
-log_info(cds)("       actual: %d", _header->_crc);
+log_info(cds)("       actual: %d", header()->crc());
 FileMapInfo::fail_continue("Header checksum verification failed.");
 return false;
 }
 }
-_file_offset = n + _header->_base_archive_name_size; // accounts for the size of _base_archive_name
+_file_offset = n + header()->base_archive_name_size(); // accounts for the size of _base_archive_name
 if (is_static) {
 // just checking the last region is sufficient since the archive is written
 // in sequential order
 size_t len = lseek(fd, 0, SEEK_END);
-CDSFileMapRegion* si = space_at(MetaspaceShared::last_valid_region);
+FileMapRegion* si = space_at(MetaspaceShared::last_valid_region);
 // The last space might be empty
-if (si->_file_offset > len || len - si->_file_offset < si->_used) {
+if (si->file_offset() > len || len - si->file_offset() < si->used()) {
 fail_continue("The shared archive file has been truncated.");
 return false;
 }
-SharedBaseAddress = _header->_shared_base_address;
+SharedBaseAddress = header()->shared_base_address();
 }
 return true;
 }
 // Write the header to the file, seek to the next allocation boundary.
 void FileMapInfo::write_header() {
 char* base_archive_name = NULL;
-if (_header->_magic == CDS_DYNAMIC_ARCHIVE_MAGIC) {
+if (header()->magic() == CDS_DYNAMIC_ARCHIVE_MAGIC) {
 base_archive_name = (char*)Arguments::GetSharedArchivePath();
-_header->_base_archive_name_size = (int)strlen(base_archive_name) + 1;
+header()->set_base_archive_name_size(strlen(base_archive_name) + 1);
-_header->_base_archive_is_default = FLAG_IS_DEFAULT(SharedArchiveFile);
+header()->set_base_archive_is_default(FLAG_IS_DEFAULT(SharedArchiveFile));
 }
 assert(is_file_position_aligned(), "must be");
-write_bytes(_header, _header->_header_size);
+write_bytes(header(), header()->header_size());
 if (base_archive_name != NULL) {
-write_bytes(base_archive_name, (size_t)_header->_base_archive_name_size);
+write_bytes(base_archive_name, header()->base_archive_name_size());
 }
 align_file_position();
+}
+void FileMapRegion::init(bool is_heap_region, char* base, size_t size, bool read_only,
+bool allow_exec, int crc) {
+_is_heap_region = is_heap_region;
+if (is_heap_region) {
+assert(!DynamicDumpSharedSpaces, "must be");
+assert((base - (char*)CompressedKlassPointers::base()) % HeapWordSize == 0, "Sanity");
+if (base != NULL) {
+_addr._offset = (intx)CompressedOops::encode_not_null((oop)base);
+} else {
+_addr._offset = 0;
+}
+} else {
+_addr._base = base;
+}
+_used = size;
+_read_only = read_only;
+_allow_exec = allow_exec;
+_crc = crc;
 }
 // Dump region to file.
 // This is called twice for each region during archiving, once before
 // the archive file is open (_file_open is false) and once after.
 void FileMapInfo::write_region(int region, char* base, size_t size,
 bool read_only, bool allow_exec) {
 assert(DumpSharedSpaces || DynamicDumpSharedSpaces, "Dump time only");
-CDSFileMapRegion* si = space_at(region);
+FileMapRegion* si = space_at(region);
 char* target_base = base;
 if (DynamicDumpSharedSpaces) {
+assert(!HeapShared::is_heap_region(region), "dynamic archive doesn't support heap regions");
 target_base = DynamicArchive::buffer_to_target(base);
 }
 if (_file_open) {
-guarantee(si->_file_offset == _file_offset, "file offset mismatch.");
+guarantee(si->file_offset() == _file_offset, "file offset mismatch.");
 log_info(cds)("Shared file region %d: " SIZE_FORMAT_HEX_W(08)
 " bytes, addr " INTPTR_FORMAT " file offset " SIZE_FORMAT_HEX_W(08),
 region, size, p2i(target_base), _file_offset);
 } else {
-si->_file_offset = _file_offset;
+si->set_file_offset(_file_offset);
 }
-if (HeapShared::is_heap_region(region)) {
+int crc = ClassLoader::crc32(0, base, (jint)size);
-assert((target_base - (char*)CompressedKlassPointers::base()) % HeapWordSize == 0, "Sanity");
+si->init(HeapShared::is_heap_region(region), target_base, size, read_only, allow_exec, crc);
-if (target_base != NULL) {
-si->_addr._offset = (intx)CompressedOops::encode_not_null((oop)target_base);
-} else {
-si->_addr._offset = 0;
-}
-} else {
-si->_addr._base = target_base;
-}
-si->_used = size;
-si->_read_only = read_only;
-si->_allow_exec = allow_exec;
-// Use the current 'base' when computing the CRC value and writing out data
-si->_crc = ClassLoader::crc32(0, base, (jint)size);
 if (base != NULL) {
 write_bytes_aligned(base, size);
 }
 }
 log_info(cds)("Archive heap region %d " INTPTR_FORMAT " - " INTPTR_FORMAT " = " SIZE_FORMAT_W(8) " bytes",
 i, p2i(start), p2i(start + size), size);
 }
 write_region(i, start, size, false, false);
 if (size > 0) {
-space_at(i)->_oopmap = oopmaps->at(arr_idx)._oopmap;
+space_at(i)->init_oopmap(oopmaps->at(arr_idx)._oopmap,
-space_at(i)->_oopmap_size_in_bits = oopmaps->at(arr_idx)._oopmap_size_in_bits;
+oopmaps->at(arr_idx)._oopmap_size_in_bits);
 }
 }
 return total_size;
 }
 // JVM/TI RedefineClasses() support:
 // Remap the shared readonly space to shared readwrite, private.
 bool FileMapInfo::remap_shared_readonly_as_readwrite() {
 int idx = MetaspaceShared::ro;
-CDSFileMapRegion* si = space_at(idx);
+FileMapRegion* si = space_at(idx);
-if (!si->_read_only) {
+if (!si->read_only()) {
 // the space is already readwrite so we are done
 return true;
 }
-size_t used = si->_used;
+size_t used = si->used();
 size_t size = align_up(used, os::vm_allocation_granularity());
 if (!open_for_read()) {
 return false;
 }
 char *addr = region_addr(idx);
-char *base = os::remap_memory(_fd, _full_path, si->_file_offset,
+char *base = os::remap_memory(_fd, _full_path, si->file_offset(),
 addr, size, false /* !read_only */,
-si->_allow_exec);
+si->allow_exec());
 close();
 // These have to be errors because the shared region is now unmapped.
 if (base == NULL) {
 log_error(cds)("Unable to remap shared readonly space (errno=%d).", errno);
 vm_exit(1);
 }
 if (base != addr) {
 log_error(cds)("Unable to remap shared readonly space (errno=%d).", errno);
 vm_exit(1);
 }
-si->_read_only = false;
+si->set_read_only(false);
 return true;
 }
 // Map the whole region at once, assumed to be allocated contiguously.
 ReservedSpace FileMapInfo::reserve_shared_memory() {
 return curr_top;
 }
 char* FileMapInfo::map_region(int i, char** top_ret) {
 assert(!HeapShared::is_heap_region(i), "sanity");
-CDSFileMapRegion* si = space_at(i);
+FileMapRegion* si = space_at(i);
-size_t used = si->_used;
+size_t used = si->used();
 size_t alignment = Metaspace::reserve_alignment();
 size_t size = align_up(used, alignment);
 char *requested_addr = region_addr(i);
 #ifdef _WINDOWS
 // Windows cannot remap read-only shared memory to read-write when required for
 // RedefineClasses, which is also used by JFR.  Always map windows regions as RW.
-si->_read_only = false;
+si->set_read_only(false);
 #else
 // If a tool agent is in use (debugging enabled), or JFR, we must map the address space RW
 if (JvmtiExport::can_modify_any_class() || JvmtiExport::can_walk_any_space() ||
 Arguments::has_jfr_option()) {
-si->_read_only = false;
+si->set_read_only(false);
 }
 #endif // _WINDOWS
 // map the contents of the CDS archive in this memory
-char *base = os::map_memory(_fd, _full_path, si->_file_offset,
+char *base = os::map_memory(_fd, _full_path, si->file_offset(),
-requested_addr, size, si->_read_only,
+requested_addr, size, si->read_only(),
-si->_allow_exec);
+si->allow_exec());
 if (base == NULL || base != requested_addr) {
 fail_continue("Unable to map %s shared space at required address.", shared_region_name[i]);
 _memory_mapping_failed = true;
 return NULL;
 }
 }
 _file_offset += count;
 return count;
 }
-address FileMapInfo::decode_start_address(CDSFileMapRegion* spc, bool with_current_oop_encoding_mode) {
+address FileMapInfo::decode_start_address(FileMapRegion* spc, bool with_current_oop_encoding_mode) {
 if (with_current_oop_encoding_mode) {
-return (address)CompressedOops::decode_not_null(offset_of_space(spc));
+return (address)CompressedOops::decode_not_null(spc->offset());
 } else {
-return (address)HeapShared::decode_from_archive(offset_of_space(spc));
+return (address)HeapShared::decode_from_archive(spc->offset());
 }
 }
 static MemRegion *closed_archive_heap_ranges = NULL;
 static MemRegion *open_archive_heap_ranges = NULL;
 static int num_closed_archive_heap_ranges = 0;
 static int num_open_archive_heap_ranges = 0;
 #if INCLUDE_CDS_JAVA_HEAP
 bool FileMapInfo::has_heap_regions() {
-return (_header->_space[MetaspaceShared::first_closed_archive_heap_region]._used > 0);
+return (space_at(MetaspaceShared::first_closed_archive_heap_region)->used() > 0);
 }
 // Returns the address range of the archived heap regions computed using the
 // current oop encoding mode. This range may be different than the one seen at
 // dump time due to encoding mode differences. The result is used in determining
 address end   = NULL;
 for (int i = MetaspaceShared::first_closed_archive_heap_region;
 i <= MetaspaceShared::last_valid_region;
 i++) {
-CDSFileMapRegion* si = space_at(i);
+FileMapRegion* si = space_at(i);
-size_t size = si->_used;
+size_t size = si->used();
 if (size > 0) {
 address s = start_address_as_decoded_with_current_oop_encoding_mode(si);
 address e = s + size;
 if (start > s) {
 start = s;
 //
 // At dump time, the archived heap regions were near the top of the heap.
 // At run time, they may not be inside the heap, so we move them so
 // that they are now near the top of the runtime time. This can be done by
 // the simple math of adding the delta as shown above.
-address dumptime_heap_end = (address)_header->_heap_end;
+address dumptime_heap_end = header()->heap_end();
 address runtime_heap_end = (address)CompressedOops::end();
 delta = runtime_heap_end - dumptime_heap_end;
 }
 log_info(cds)("CDS heap data relocation delta = " INTX_FORMAT " bytes", delta);
 HeapShared::init_narrow_oop_decoding(narrow_oop_base() + delta, narrow_oop_shift());
-CDSFileMapRegion* si = space_at(MetaspaceShared::first_closed_archive_heap_region);
+FileMapRegion* si = space_at(MetaspaceShared::first_closed_archive_heap_region);
 address relocated_closed_heap_region_bottom = start_address_as_decoded_from_archive(si);
 if (!is_aligned(relocated_closed_heap_region_bottom, HeapRegion::GrainBytes)) {
 // Align the bottom of the closed archive heap regions at G1 region boundary.
 // This will avoid the situation where the highest open region and the lowest
 // closed region sharing the same G1 region. Otherwise we will fail to map the
 }
 bool FileMapInfo::map_heap_data(MemRegion **heap_mem, int first,
 int max, int* num, bool is_open_archive) {
 MemRegion * regions = new MemRegion[max];
-CDSFileMapRegion* si;
+FileMapRegion* si;
 int region_num = 0;
 for (int i = first;
 i < first + max; i++) {
 si = space_at(i);
-size_t size = si->_used;
+size_t size = si->used();
 if (size > 0) {
 HeapWord* start = (HeapWord*)start_address_as_decoded_from_archive(si);
 regions[region_num] = MemRegion(start, size / HeapWordSize);
 region_num ++;
 log_info(cds)("Trying to map heap data: region[%d] at " INTPTR_FORMAT ", size = " SIZE_FORMAT_W(8) " bytes",
 // for mapped regions as they are part of the reserved java heap, which is
 // already recorded.
 for (int i = 0; i < region_num; i++) {
 si = space_at(first + i);
 char* addr = (char*)regions[i].start();
-char* base = os::map_memory(_fd, _full_path, si->_file_offset,
+char* base = os::map_memory(_fd, _full_path, si->file_offset(),
-addr, regions[i].byte_size(), si->_read_only,
+addr, regions[i].byte_size(), si->read_only(),
-si->_allow_exec);
+si->allow_exec());
 if (base == NULL || base != addr) {
 // dealloc the regions from java heap
 dealloc_archive_heap_regions(regions, region_num, is_open_archive);
 log_info(cds)("UseSharedSpaces: Unable to map at required address in java heap. "
 INTPTR_FORMAT ", size = " SIZE_FORMAT " bytes",
 p2i(addr), regions[i].byte_size());
 return false;
 }
-if (VerifySharedSpaces && !region_crc_check(addr, regions[i].byte_size(), si->_crc)) {
+if (VerifySharedSpaces && !region_crc_check(addr, regions[i].byte_size(), si->crc())) {
 // dealloc the regions from java heap
 dealloc_archive_heap_regions(regions, region_num, is_open_archive);
 log_info(cds)("UseSharedSpaces: mapped heap regions are corrupt");
 return false;
 }
 }
 void FileMapInfo::patch_archived_heap_embedded_pointers(MemRegion* ranges, int num_ranges,
 int first_region_idx) {
 for (int i=0; i<num_ranges; i++) {
-CDSFileMapRegion* si = space_at(i + first_region_idx);
+FileMapRegion* si = space_at(i + first_region_idx);
-HeapShared::patch_archived_heap_embedded_pointers(ranges[i], (address)si->_oopmap,
+HeapShared::patch_archived_heap_embedded_pointers(ranges[i], (address)si->oopmap(),
-si->_oopmap_size_in_bits);
+si->oopmap_size_in_bits());
 }
 }
 // This internally allocates objects using SystemDictionary::Object_klass(), so it
 // must be called after the well-known classes are resolved.
 return true;
 }
 bool FileMapInfo::verify_region_checksum(int i) {
 assert(VerifySharedSpaces, "sanity");
+size_t sz = space_at(i)->used();
-size_t sz = space_at(i)->_used;
 if (sz == 0) {
 return true; // no data
-}
+} else {
+return region_crc_check(region_addr(i), sz, space_at(i)->crc());
-return region_crc_check(region_addr(i), sz, space_at(i)->_crc);
+}
 }
 void FileMapInfo::unmap_regions(int regions[], char* saved_base[], size_t len) {
 for (int i = 0; i < (int)len; i++) {
 if (saved_base[i] != NULL) {
 // Unmap a memory region in the address space.
 void FileMapInfo::unmap_region(int i) {
 assert(!HeapShared::is_heap_region(i), "sanity");
-CDSFileMapRegion* si = space_at(i);
+FileMapRegion* si = space_at(i);
-size_t used = si->_used;
+size_t used = si->used();
 size_t size = align_up(used, os::vm_allocation_granularity());
 if (used == 0) {
 return;
 }
 }
 return true;
 }
 char* FileMapInfo::region_addr(int idx) {
-CDSFileMapRegion* si = space_at(idx);
+FileMapRegion* si = space_at(idx);
 if (HeapShared::is_heap_region(idx)) {
 assert(DumpSharedSpaces, "The following doesn't work at runtime");
-return si->_used > 0 ?
+return si->used() > 0 ?
 (char*)start_address_as_decoded_with_current_oop_encoding_mode(si) : NULL;
 } else {
-return si->_addr._base;
+return si->base();
 }
 }
 int FileMapHeader::compute_crc() {
 char* start = (char*)this;
 return true;
 }
 bool FileMapInfo::validate_header(bool is_static) {
-return _header->validate();
+return header()->validate();
 }
 // Check if a given address is within one of the shared regions
 bool FileMapInfo::is_in_shared_region(const void* p, int idx) {
 assert(idx == MetaspaceShared::ro ||
 idx == MetaspaceShared::rw ||
 idx == MetaspaceShared::mc ||
 idx == MetaspaceShared::md, "invalid region index");
 char* base = region_addr(idx);
-if (p >= base && p < base + space_at(idx)->_used) {
+if (p >= base && p < base + space_at(idx)->used()) {
 return true;
 }
 return false;
 }
 for (int i = 0; i < MetaspaceShared::num_non_heap_spaces; i++) {
 if (!HeapShared::is_heap_region(i)) {
 char *addr = map_info->region_addr(i);
 if (addr != NULL) {
 map_info->unmap_region(i);
-map_info->space_at(i)->_addr._base = NULL;
+map_info->space_at(i)->mark_invalid();
 }
 }
 }
 // Dealloc the archive heap regions only without unmapping. The regions are part
 // of the java heap. Unmapping of the heap regions are managed by GC.

branch	stuefe-new-metaspace-branch
changeset 58107	69c38b90014c
parent 58063	bdf136b8ae0e
parent 58096	0d97bf7cf8a4
child 58199	595fcbebaa77