src/hotspot/share/classfile/systemDictionaryShared.cpp

*** 36,45 ****
--- 36,46 ----
  #include "classfile/systemDictionaryShared.hpp"
  #include "classfile/verificationType.hpp"
  #include "classfile/vmSymbols.hpp"
  #include "logging/log.hpp"
  #include "memory/allocation.hpp"
+ #include "memory/archiveUtils.hpp"
  #include "memory/filemap.hpp"
  #include "memory/metadataFactory.hpp"
  #include "memory/metaspaceClosure.hpp"
  #include "memory/oopFactory.hpp"
  #include "memory/resourceArea.hpp"
*** 292,301 ****
--- 293,303 ----
        }
      }
      if (DynamicDumpSharedSpaces) {
        _klass = DynamicArchive::original_to_target(info._klass);
      }
+     ArchivePtrMarker::mark_pointer(&_klass);
    }
  
    bool matches(int clsfile_size, int clsfile_crc32) const {
      return crc()->_clsfile_size  == clsfile_size &&
             crc()->_clsfile_crc32 == clsfile_crc32;
*** 335,344 ****
--- 337,348 ----
        klass = DynamicArchive::original_to_buffer(klass);
        *info_pointer_addr(klass) = DynamicArchive::buffer_to_target(record);
      } else {
        *info_pointer_addr(klass) = record;
      }
+ 
+     ArchivePtrMarker::mark_pointer(info_pointer_addr(klass));
    }
  
    // Used by RunTimeSharedDictionary to implement OffsetCompactHashtable::EQUALS
    static inline bool EQUALS(
         const RunTimeSharedClassInfo* value, Symbol* key, int len_unused) {
*** 1352,1362 ****
        unsigned int hash;
        Symbol* name = info._klass->name();
        if (DynamicDumpSharedSpaces) {
          name = DynamicArchive::original_to_target(name);
        }
!       hash = primitive_hash<Symbol*>(name);
        u4 delta;
        if (DynamicDumpSharedSpaces) {
          delta = MetaspaceShared::object_delta_u4(DynamicArchive::buffer_to_target(record));
        } else {
          delta = MetaspaceShared::object_delta_u4(record);
--- 1356,1366 ----
        unsigned int hash;
        Symbol* name = info._klass->name();
        if (DynamicDumpSharedSpaces) {
          name = DynamicArchive::original_to_target(name);
        }
!       hash = SystemDictionaryShared::hash_for_shared_dictionary(name);
        u4 delta;
        if (DynamicDumpSharedSpaces) {
          delta = MetaspaceShared::object_delta_u4(DynamicArchive::buffer_to_target(record));
        } else {
          delta = MetaspaceShared::object_delta_u4(record);
*** 1411,1421 ****
    if (!UseSharedSpaces || !name->is_shared()) {
      // The names of all shared classes must also be a shared Symbol.
      return NULL;
    }
  
!   unsigned int hash = primitive_hash<Symbol*>(name);
    const RunTimeSharedClassInfo* record = NULL;
    if (!MetaspaceShared::is_shared_dynamic(name)) {
      // The names of all shared classes in the static dict must also be in the
      // static archive
      record = static_dict->lookup(name, hash, 0);
--- 1415,1425 ----
    if (!UseSharedSpaces || !name->is_shared()) {
      // The names of all shared classes must also be a shared Symbol.
      return NULL;
    }
  
!   unsigned int hash = SystemDictionaryShared::hash_for_shared_dictionary(name);
    const RunTimeSharedClassInfo* record = NULL;
    if (!MetaspaceShared::is_shared_dynamic(name)) {
      // The names of all shared classes in the static dict must also be in the
      // static archive
      record = static_dict->lookup(name, hash, 0);