94   enum {

   167   friend struct FileMapHeader;

    95     _invalid_version = -1,

   168 

    96     _current_version = 3

   169   bool    _file_open;

    97   };

   170   int     _fd;

    98 

    99   bool  _file_open;

   100   int   _fd;

   119   struct FileMapHeader : FileMapHeaderBase {

   189 

   120     // Use data() and data_size() to memcopy to/from the FileMapHeader. We need to

   121     // avoid read/writing the C++ vtable pointer.

   122     static size_t data_size() {

   123       return sizeof(FileMapHeader) - sizeof(FileMapInfo::FileMapHeaderBase);

   124     }

   125     char* data() {

   126       return ((char*)this) + sizeof(FileMapHeaderBase);

   127     }

   128 

   129     int    _magic;                    // identify file type.

   130     int    _crc;                      // header crc checksum.

   131     int    _version;                  // (from enum, above.)

   132     size_t _alignment;                // how shared archive should be aligned

   133     int    _obj_alignment;            // value of ObjectAlignmentInBytes

   134     address _narrow_oop_base;         // compressed oop encoding base

   135     int    _narrow_oop_shift;         // compressed oop encoding shift

   136     bool    _compact_strings;         // value of CompactStrings

   137     uintx  _max_heap_size;            // java max heap size during dumping

   138     Universe::NARROW_OOP_MODE _narrow_oop_mode; // compressed oop encoding mode

   139     int     _narrow_klass_shift;      // save narrow klass base and shift

   140     address _narrow_klass_base;

   141     char*   _misc_data_patching_start;

   142     char*   _read_only_tables_start;

   143     address _cds_i2i_entry_code_buffers;

   144     size_t  _cds_i2i_entry_code_buffers_size;

   145     size_t  _core_spaces_size;        // number of bytes allocated by the core spaces

   146                                       // (mc, md, ro, rw and od).

   147     struct space_info {

   148       int    _crc;           // crc checksum of the current space

   149       size_t _file_offset;   // sizeof(this) rounded to vm page size

   150       union {

   151         char*  _base;        // copy-on-write base address

   152         intx   _offset;      // offset from the compressed oop encoding base, only used

   153                              // by archive heap space

   154       } _addr;

   155       size_t _used;          // for setting space top on read

   156       bool   _read_only;     // read only space?

   157       bool   _allow_exec;    // executable code in space?

   158     } _space[MetaspaceShared::n_regions];

   159 

   160     // The following fields are all sanity checks for whether this archive

   161     // will function correctly with this JVM and the bootclasspath it's

   162     // invoked with.

   163     char  _jvm_ident[JVM_IDENT_MAX];      // identifier for jvm

   164 

   165     // The _paths_misc_info is a variable-size structure that records "miscellaneous"

   166     // information during dumping. It is generated and validated by the

   167     // SharedPathsMiscInfo class. See SharedPathsMiscInfo.hpp for

   168     // detailed description.

   169     //

   170     // The _paths_misc_info data is stored as a byte array in the archive file header,

   171     // immediately after the _header field. This information is used only when

   172     // checking the validity of the archive and is deallocated after the archive is loaded.

   173     //

   174     // Note that the _paths_misc_info does NOT include information for JAR files

   175     // that existed during dump time. Their information is stored in _shared_path_table.

   176     int _paths_misc_info_size;

   177 

   178     // The following is a table of all the class path entries that were used

   179     // during dumping. At run time, we require these files to exist and have the same

   180     // size/modification time, or else the archive will refuse to load.

   181     //

   182     // All of these entries must be JAR files. The dumping process would fail if a non-empty

   183     // directory was specified in the classpaths. If an empty directory was specified

   184     // it is checked by the _paths_misc_info as described above.

   185     //

   186     // FIXME -- if JAR files in the tail of the list were specified but not used during dumping,

   187     // they should be removed from this table, to save space and to avoid spurious

   188     // loading failures during runtime.

   189     int _shared_path_table_size;

   190     size_t _shared_path_entry_size;

   191     Array<u8>* _shared_path_table;

   192 

   193     jshort _app_class_paths_start_index;  // Index of first app classpath entry

   194     jshort _app_module_paths_start_index; // Index of first module path entry

   195     jshort _max_used_path_index;          // max path index referenced during CDS dump

   196     bool   _verify_local;                 // BytecodeVerificationLocal setting

   197     bool   _verify_remote;                // BytecodeVerificationRemote setting

   198     bool   _has_platform_or_app_classes;  // Archive contains app classes

   199 

   200     void set_has_platform_or_app_classes(bool v) {

   201       _has_platform_or_app_classes = v;

   202     }

   203     bool has_platform_or_app_classes() { return _has_platform_or_app_classes; }

   204     jshort max_used_path_index()       { return _max_used_path_index; }

   205     jshort app_module_paths_start_index() { return _app_module_paths_start_index; }

   206 

   207     char* region_addr(int idx);

   208 

   209     bool validate();

   210     void populate(FileMapInfo* info, size_t alignment);

   211     int compute_crc();

   212   };

   281   void  write_bytes(const void* buffer, int count);

   257   void  write_bytes(const void* buffer, size_t count);

   282   void  write_bytes_aligned(const void* buffer, int count);

   258   void  write_bytes_aligned(const void* buffer, size_t count);