src/share/vm/classfile/symbolTable.cpp

*** 30,39 ****
--- 30,40 ----
  #include "classfile/systemDictionary.hpp"
  #include "gc/shared/collectedHeap.inline.hpp"
  #include "gc/shared/gcLocker.inline.hpp"
  #include "memory/allocation.inline.hpp"
  #include "memory/filemap.hpp"
+ #include "memory/metaspaceClosure.hpp"
  #include "memory/resourceArea.hpp"
  #include "oops/oop.inline.hpp"
  #include "runtime/atomic.hpp"
  #include "runtime/mutexLocker.hpp"
  #include "utilities/hashtable.inline.hpp"
*** 54,66 ****
    assert (len <= Symbol::max_length(), "should be checked by caller");
  
    Symbol* sym;
  
    if (DumpSharedSpaces) {
!     // Allocate all symbols to CLD shared metaspace
!     sym = new (len, ClassLoaderData::the_null_class_loader_data(), THREAD) Symbol(name, len, PERM_REFCOUNT);
!   } else if (c_heap) {
      // refcount starts as 1
      sym = new (len, THREAD) Symbol(name, len, 1);
      assert(sym != NULL, "new should call vm_exit_out_of_memory if C_HEAP is exhausted");
    } else {
      // Allocate to global arena
--- 55,67 ----
    assert (len <= Symbol::max_length(), "should be checked by caller");
  
    Symbol* sym;
  
    if (DumpSharedSpaces) {
!     c_heap = false;
!   }
!   if (c_heap) {
      // refcount starts as 1
      sym = new (len, THREAD) Symbol(name, len, 1);
      assert(sym != NULL, "new should call vm_exit_out_of_memory if C_HEAP is exhausted");
    } else {
      // Allocate to global arena
*** 78,89 ****
--- 79,92 ----
    }
  }
  
  // Call function for all symbols in the symbol table.
  void SymbolTable::symbols_do(SymbolClosure *cl) {
+   if (!DumpSharedSpaces) {
      // all symbols from shared table
      _shared_table.symbols_do(cl);
+   }
  
    // all symbols from the dynamic table
    const int n = the_table()->table_size();
    for (int i = 0; i < n; i++) {
      for (HashtableEntry<Symbol*, mtSymbol>* p = the_table()->bucket(i);
*** 92,101 ****
--- 95,116 ----
        cl->do_symbol(p->literal_addr());
      }
    }
  }
  
+ void SymbolTable::metaspace_pointers_do(MetaspaceClosure* it) {
+   assert(DumpSharedSpaces, "called only during dump time");
+   const int n = the_table()->table_size();
+   for (int i = 0; i < n; i++) {
+     for (HashtableEntry<Symbol*, mtSymbol>* p = the_table()->bucket(i);
+          p != NULL;
+          p = p->next()) {
+       it->push(p->literal_addr());
+     }
+   }
+ }
+ 
  int SymbolTable::_symbols_removed = 0;
  int SymbolTable::_symbols_counted = 0;
  volatile int SymbolTable::_parallel_claimed_idx = 0;
  
  void SymbolTable::buckets_unlink(int start_idx, int end_idx, BucketUnlinkContext* context) {
*** 565,578 ****
        }
      }
    }
  }
  
! void SymbolTable::serialize(SerializeClosure* soc) {
  #if INCLUDE_CDS
    _shared_table.reset();
!   if (soc->writing()) {
      int num_buckets = the_table()->number_of_entries() /
                              SharedSymbolTableBucketSize;
      CompactSymbolTableWriter writer(num_buckets,
                                      &MetaspaceShared::stats()->symbol);
      for (int i = 0; i < the_table()->table_size(); ++i) {
--- 580,593 ----
        }
      }
    }
  }
  
! void SymbolTable::write_to_archive() {
  #if INCLUDE_CDS
      _shared_table.reset();
! 
      int num_buckets = the_table()->number_of_entries() /
                              SharedSymbolTableBucketSize;
      CompactSymbolTableWriter writer(num_buckets,
                                      &MetaspaceShared::stats()->symbol);
      for (int i = 0; i < the_table()->table_size(); ++i) {
*** 584,606 ****
          writer.add(fixed_hash, s);
        }
      }
  
      writer.dump(&_shared_table);
-   }
  
-   _shared_table.set_type(CompactHashtable<Symbol*, char>::_symbol_table);
-   _shared_table.serialize(soc);
- 
-   if (soc->writing()) {
      // Verify table is correct
      Symbol* sym = vmSymbols::java_lang_Object();
      const char* name = (const char*)sym->bytes();
      int len = sym->utf8_length();
      unsigned int hash = hash_symbol(name, len);
      assert(sym == _shared_table.lookup(name, hash, len), "sanity");
  
      // Sanity. Make sure we don't use the shared table at dump time
      _shared_table.reset();
    }
  #endif
  }
--- 599,624 ----
          writer.add(fixed_hash, s);
        }
      }
  
      writer.dump(&_shared_table);
  
      // Verify table is correct
      Symbol* sym = vmSymbols::java_lang_Object();
      const char* name = (const char*)sym->bytes();
      int len = sym->utf8_length();
      unsigned int hash = hash_symbol(name, len);
      assert(sym == _shared_table.lookup(name, hash, len), "sanity");
+ #endif
+ }
  
+ void SymbolTable::serialize(SerializeClosure* soc) {
+ #if INCLUDE_CDS
+   _shared_table.set_type(CompactHashtable<Symbol*, char>::_symbol_table);
+   _shared_table.serialize(soc);
+ 
+   if (soc->writing()) {
      // Sanity. Make sure we don't use the shared table at dump time
      _shared_table.reset();
    }
  #endif
  }