src/share/vm/oops/constantPool.cpp

@@ -30,10 +30,11 @@
 #include "classfile/systemDictionary.hpp"
 #include "classfile/vmSymbols.hpp"
 #include "interpreter/linkResolver.hpp"
 #include "memory/heapInspection.hpp"
 #include "memory/metadataFactory.hpp"
+#include "memory/metaspaceClosure.hpp"
 #include "memory/oopFactory.hpp"
 #include "memory/resourceArea.hpp"
 #include "oops/constantPool.hpp"
 #include "oops/instanceKlass.hpp"
 #include "oops/objArrayKlass.hpp"

@@ -45,13 +46,13 @@
 #include "runtime/signature.hpp"
 #include "runtime/vframe.hpp"
 #include "utilities/copy.hpp"
 
 ConstantPool* ConstantPool::allocate(ClassLoaderData* loader_data, int length, TRAPS) {
-  Array<u1>* tags = MetadataFactory::new_writeable_array<u1>(loader_data, length, 0, CHECK_NULL);
+  Array<u1>* tags = MetadataFactory::new_array<u1>(loader_data, length, 0, CHECK_NULL);
   int size = ConstantPool::size(length);
-  return new (loader_data, size, true, MetaspaceObj::ConstantPoolType, THREAD) ConstantPool(tags);
+  return new (loader_data, size, MetaspaceObj::ConstantPoolType, THREAD) ConstantPool(tags);
 }
 
 #ifdef ASSERT
 
 // MetaspaceObj allocation invariant is calloc equivalent memory

@@ -105,10 +106,30 @@
 void ConstantPool::release_C_heap_structures() {
   // walk constant pool and decrement symbol reference counts
   unreference_symbols();
 }
 
+void ConstantPool::metaspace_pointers_do(MetaspaceClosure* it) {
+  log_trace(cds)("Iter(ConstantPool): %p", this);
+
+  it->push(&_tags, MetaspaceClosure::_writable);
+  it->push(&_cache);
+  it->push(&_pool_holder);
+  it->push(&_operands);
+  it->push(&_resolved_klasses, MetaspaceClosure::_writable);
+
+  for (int i = 0; i < length(); i++) {
+    // The only MSO's embedded in the CP entries are Symbols:
+    //   JVM_CONSTANT_String (normal and pseudo)
+    //   JVM_CONSTANT_Utf8
+    constantTag ctag = tag_at(i);
+    if (ctag.is_string() || ctag.is_utf8()) {
+      it->push(symbol_at_addr(i));
+    }
+  }
+}
+
 objArrayOop ConstantPool::resolved_references() const {
   return (objArrayOop)JNIHandles::resolve(_cache->resolved_references());
 }
 
 // Create resolved_references array and mapping array for original cp indexes

@@ -151,11 +172,11 @@
   // entry for the class's name. So at most we will have 0xfffe class entries.
   // This allows us to use 0xffff (ConstantPool::_temp_resolved_klass_index) to indicate
   // UnresolvedKlass entries that are temporarily created during class redefinition.
   assert(num_klasses < CPKlassSlot::_temp_resolved_klass_index, "sanity");
   assert(resolved_klasses() == NULL, "sanity");
-  Array<Klass*>* rk = MetadataFactory::new_writeable_array<Klass*>(loader_data, num_klasses, CHECK);
+  Array<Klass*>* rk = MetadataFactory::new_array<Klass*>(loader_data, num_klasses, CHECK);
   set_resolved_klasses(rk);
 }
 
 void ConstantPool::initialize_unresolved_klasses(ClassLoaderData* loader_data, TRAPS) {
   int len = length();