8230586: Encapsulate fields in filemap.hpp

Reviewed-by: ccheung

Author: iklam

src/hotspot/share/classfile/classLoaderExt.cpp

@@ -55,7 +55,7 @@ bool ClassLoaderExt::_has_platform_classes = false;
 void ClassLoaderExt::append_boot_classpath(ClassPathEntry* new_entry) {
   if (UseSharedSpaces) {
     warning("Sharing is only supported for boot loader classes because bootstrap classpath has been appended");
-    FileMapInfo::current_info()->header()->set_has_platform_or_app_classes(false);
+    FileMapInfo::current_info()->set_has_platform_or_app_classes(false);
   }
   ClassLoader::add_to_boot_append_entries(new_entry);
 }

src/hotspot/share/classfile/systemDictionaryShared.cpp

@@ -744,11 +744,11 @@ bool SystemDictionaryShared::is_shared_class_visible_for_classloader(
 }
 
 bool SystemDictionaryShared::has_platform_or_app_classes() {
-  if (FileMapInfo::current_info()->header()->has_platform_or_app_classes()) {
+  if (FileMapInfo::current_info()->has_platform_or_app_classes()) {
     return true;
   }
   if (DynamicArchive::is_mapped() &&
-      FileMapInfo::dynamic_info()->header()->has_platform_or_app_classes()) {
+      FileMapInfo::dynamic_info()->has_platform_or_app_classes()) {
     return true;
   }
   return false;

src/hotspot/share/include/cds.h

@@ -36,22 +36,23 @@
 #define NUM_CDS_REGIONS 8 // this must be the same as MetaspaceShared::n_regions
 #define CDS_ARCHIVE_MAGIC 0xf00baba2
 #define CDS_DYNAMIC_ARCHIVE_MAGIC 0xf00baba8
-#define CURRENT_CDS_ARCHIVE_VERSION 7
+#define CURRENT_CDS_ARCHIVE_VERSION 8
 #define INVALID_CDS_ARCHIVE_VERSION -1
 
 struct CDSFileMapRegion {
-  int        _crc;           // crc checksum of the current space
-  size_t     _file_offset;   // sizeof(this) rounded to vm page size
+  int        _crc;            // crc checksum of the current space
+  size_t     _file_offset;    // sizeof(this) rounded to vm page size
   union {
-    char*    _base;          // copy-on-write base address
-    size_t   _offset;        // offset from the compressed oop encoding base, only used
-                             // by archive heap space
+    char*    _base;           // copy-on-write base address
+    size_t   _offset;         // offset from the compressed oop encoding base, only used
+                              // by archive heap space
   } _addr;
-  size_t     _used;          // for setting space top on read
-  int        _read_only;     // read only space?
-  int        _allow_exec;    // executable code in space?
-  void*      _oopmap;        // bitmap for relocating embedded oops
+  size_t     _used;           // for setting space top on read
+  int        _read_only;      // read only space?
+  int        _allow_exec;     // executable code in space?
+  void*      _oopmap;         // bitmap for relocating embedded oops
   size_t     _oopmap_size_in_bits;
+  int        _is_heap_region; // used in debug build only.
 };
 
 struct CDSFileMapHeaderBase {

src/hotspot/share/interpreter/abstractInterpreter.cpp

@@ -208,7 +208,7 @@ AbstractInterpreter::MethodKind AbstractInterpreter::method_kind(const methodHan
 
 address AbstractInterpreter::get_trampoline_code_buffer(AbstractInterpreter::MethodKind kind) {
   const size_t trampoline_size = SharedRuntime::trampoline_size();
-  address addr = MetaspaceShared::cds_i2i_entry_code_buffers((size_t)(AbstractInterpreter::number_of_method_entries) * trampoline_size);
+  address addr = MetaspaceShared::i2i_entry_code_buffers((size_t)(AbstractInterpreter::number_of_method_entries) * trampoline_size);
   addr += (size_t)(kind) * trampoline_size;
 
   return addr;

src/hotspot/share/memory/dynamicArchive.cpp

@@ -652,7 +652,7 @@ class DynamicArchiveBuilder : ResourceObj {
       it->push(&_symbols->at(i));
     }
 
-    _header->_shared_path_table.metaspace_pointers_do(it);
+    _header->shared_path_table_metaspace_pointers_do(it);
 
     // Do not call these again, as we have already collected all the classes and symbols
     // that we want to archive. Also, these calls would corrupt the tables when
@@ -733,14 +733,13 @@ void DynamicArchiveBuilder::init_header(address reserved_bottom) {
   init_first_dump_space(reserved_bottom);
 
   FileMapInfo* mapinfo = new FileMapInfo(false);
-  _header = (DynamicArchiveHeader*)mapinfo->_header;
+  _header = mapinfo->dynamic_header();
 
   Thread* THREAD = Thread::current();
   FileMapInfo* base_info = FileMapInfo::current_info();
-  int* crc = _header->_base_archive_crc;
-  *crc++ = base_info->crc(); // base archive header crc
+  _header->set_base_header_crc(base_info->crc());
   for (int i = 0; i < MetaspaceShared::n_regions; i++) {
-    *crc++ = base_info->space_crc(i);
+    _header->set_base_region_crc(i, base_info->space_crc(i));
   }
   _header->populate(base_info, os::vm_allocation_granularity());
 }
@@ -907,9 +906,9 @@ void DynamicArchiveBuilder::relocate_buffer_to_target() {
   RelocateBufferToTarget patcher(this, (address*)_alloc_bottom, _buffer_to_target_delta);
   _ptrmap.iterate(&patcher);
 
-  Array<u8>* table = _header->_shared_path_table.table();
+  Array<u8>* table = _header->shared_path_table().table();
   table = to_target(table);
- _header->_shared_path_table.set_table(table);
+ _header->relocate_shared_path_table(table);
 }
 
 static void write_archive_info(FileMapInfo* dynamic_info, DynamicArchiveHeader *header) {
@@ -933,7 +932,7 @@ void DynamicArchiveBuilder::write_archive(char* read_only_tables_start) {
   int num_klasses = _klasses->length();
   int num_symbols = _symbols->length();
 
-  _header->_read_only_tables_start = to_target(read_only_tables_start);
+  _header->set_read_only_tables_start(to_target(read_only_tables_start));
 
   FileMapInfo* dynamic_info = FileMapInfo::dynamic_info();
   assert(dynamic_info != NULL, "Sanity");
@@ -953,10 +952,11 @@ void DynamicArchiveBuilder::write_archive(char* read_only_tables_start) {
 
   address base = to_target(_alloc_bottom);
   address top  = address(current_dump_space()->top()) + _buffer_to_target_delta;
-  int file_size = int(top - base);
+  size_t file_size = pointer_delta(top, base, sizeof(char));
 
-  log_info(cds, dynamic)("Written dynamic archive " PTR_FORMAT " - " PTR_FORMAT " [%d bytes header, %d bytes total]",
-                         p2i(base), p2i(top), (int)_header->_header_size, file_size);
+  log_info(cds, dynamic)("Written dynamic archive " PTR_FORMAT " - " PTR_FORMAT
+                         " [" SIZE_FORMAT " bytes header, " SIZE_FORMAT " bytes total]",
+                         p2i(base), p2i(top), _header->header_size(), file_size);
   log_info(cds, dynamic)("%d klasses; %d symbols", num_klasses, num_symbols);
 }
 
@@ -1046,8 +1046,8 @@ static DynamicArchiveHeader *_dynamic_header = NULL;
 DynamicArchiveBuilder* DynamicArchive::_builder = NULL;
 
 void DynamicArchive::map_failed(FileMapInfo* mapinfo) {
-  if (mapinfo->_header != NULL) {
-    os::free(mapinfo->_header);
+  if (mapinfo->dynamic_header() != NULL) {
+    os::free((void*)mapinfo->dynamic_header());
   }
   delete mapinfo;
 }
@@ -1081,15 +1081,12 @@ address DynamicArchive::map() {
 }
 
 address DynamicArchive::map_impl(FileMapInfo* mapinfo) {
-
-
   // Read header
   if (!mapinfo->initialize(false)) {
     return NULL;
   }
 
-  _dynamic_header = (DynamicArchiveHeader*)mapinfo->header();
-
+  _dynamic_header = mapinfo->dynamic_header();
   int regions[] = {MetaspaceShared::rw,
                    MetaspaceShared::ro,
                    MetaspaceShared::mc};
@@ -1111,7 +1108,7 @@ address DynamicArchive::map_impl(FileMapInfo* mapinfo) {
     return NULL;
   }
 
-  intptr_t* buffer = (intptr_t*)_dynamic_header->_read_only_tables_start;
+  intptr_t* buffer = (intptr_t*)_dynamic_header->read_only_tables_start();
   ReadClosure rc(&buffer);
   SymbolTable::serialize_shared_table_header(&rc, false);
   SystemDictionaryShared::serialize_dictionary_headers(&rc, false);
@@ -1122,18 +1119,17 @@ address DynamicArchive::map_impl(FileMapInfo* mapinfo) {
 bool DynamicArchive::validate(FileMapInfo* dynamic_info) {
   // Check if the recorded base archive matches with the current one
   FileMapInfo* base_info = FileMapInfo::current_info();
-  DynamicArchiveHeader* dynamic_header = (DynamicArchiveHeader*)dynamic_info->header();
-  int* crc = dynamic_header->_base_archive_crc;
+  DynamicArchiveHeader* dynamic_header = dynamic_info->dynamic_header();
 
   // Check the header crc
-  if (*crc++ != base_info->crc()) {
+  if (dynamic_header->base_header_crc() != base_info->crc()) {
     FileMapInfo::fail_continue("Archive header checksum verification failed.");
     return false;
   }
 
   // Check each space's crc
   for (int i = 0; i < MetaspaceShared::n_regions; i++) {
-    if (*crc++ != base_info->space_crc(i)) {
+    if (dynamic_header->base_region_crc(i) != base_info->space_crc(i)) {
       FileMapInfo::fail_continue("Archive region #%d checksum verification failed.", i);
       return false;
     }

src/hotspot/share/memory/dynamicArchive.hpp

@@ -37,12 +37,24 @@
 #include "utilities/macros.hpp"
 #include "utilities/resourceHash.hpp"
 
-// We want to include all archive header information in the dynamic archive.
-// This helps simplify the process if the base layer archive is missing at
-// dynamic archiving time.
-struct DynamicArchiveHeader : public FileMapHeader {
-  // crc for the base archive header and regions
-  int _base_archive_crc[MetaspaceShared::n_regions+1];
+class DynamicArchiveHeader : public FileMapHeader {
+  friend class CDSOffsets;
+private:
+  int _base_header_crc;
+  int _base_region_crc[MetaspaceShared::n_regions];
+
+public:
+  int base_header_crc() const { return _base_header_crc; }
+  int base_region_crc(int i) const {
+    assert(is_valid_region(i), "must be");
+    return _base_region_crc[i];
+  }
+
+  void set_base_header_crc(int c) { _base_header_crc = c; }
+  void set_base_region_crc(int i, int c) {
+    assert(is_valid_region(i), "must be");
+    _base_region_crc[i] = c;
+  }
 };
 
 class DynamicArchive : AllStatic {