src/share/vm/oops/constantPool.cpp

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

@@ -45,10 +46,13 @@
 #include "runtime/init.hpp"
 #include "runtime/javaCalls.hpp"
 #include "runtime/signature.hpp"
 #include "runtime/vframe.hpp"
 #include "utilities/copy.hpp"
+#if INCLUDE_ALL_GCS
+#include "gc/g1/g1SATBCardTableModRefBS.hpp"
+#endif // INCLUDE_ALL_GCS
 
 ConstantPool* ConstantPool::allocate(ClassLoaderData* loader_data, int length, TRAPS) {
   Array<u1>* tags = MetadataFactory::new_array<u1>(loader_data, length, 0, CHECK_NULL);
   int size = ConstantPool::size(length);
   return new (loader_data, size, MetaspaceObj::ConstantPoolType, THREAD) ConstantPool(tags);

@@ -236,42 +240,108 @@
   // The interpreter assumes when the tag is stored, the klass is resolved
   // and the Klass* non-NULL, so we need hardware store ordering here.
   release_tag_at_put(class_index, JVM_CONSTANT_Class);
 }
 
+#if INCLUDE_CDS_JAVA_HEAP
+// Archive the resolved references
+void ConstantPool::archive_resolved_references(Thread* THREAD) {
+  if (_cache == NULL) {
+    return; // nothing to do
+  }
+
+  InstanceKlass *ik = pool_holder();
+  if (!(ik->is_shared_boot_class() || ik->is_shared_platform_class() ||
+        ik->is_shared_app_class())) {
+    // Archiving resolved references for classes from non-builtin loaders
+    // is not yet supported.
+    set_resolved_references(NULL);
+    return;
+  }
+
+  objArrayOop rr = resolved_references();
+  if (rr != NULL) {
+    for (int i = 0; i < rr->length(); i++) {
+      oop p = rr->obj_at(i);
+      if (p != NULL) {
+        int index = object_to_cp_index(i);
+        if (tag_at(index).is_string()) {
+          oop op = StringTable::create_archived_string(p, THREAD);
+          // If the String object is not archived (possibly too large),
+          // NULL is returned. Also set it in the array, so we won't
+          // have a 'bad' reference in the archived resolved_reference
+          // array.
+          rr->obj_at_put(i, op);
+        } else {
+          rr->obj_at_put(i, NULL);
+        }
+      }
+    }
+    oop archived = MetaspaceShared::archive_heap_object(rr, THREAD);
+    _cache->set_archived_references(archived);
+    set_resolved_references(NULL);
+  }
+}
+#endif
+
 // CDS support. Create a new resolved_references array.
 void ConstantPool::restore_unshareable_info(TRAPS) {
   assert(is_constantPool(), "ensure C++ vtable is restored");
   assert(on_stack(), "should always be set for shared constant pools");
   assert(is_shared(), "should always be set for shared constant pools");
+  assert(_cache != NULL, "constant pool _cache should not be NULL");
 
   // Only create the new resolved references array if it hasn't been attempted before
   if (resolved_references() != NULL) return;
 
   // restore the C++ vtable from the shared archive
   restore_vtable();
 
   if (SystemDictionary::Object_klass_loaded()) {
+    ClassLoaderData* loader_data = pool_holder()->class_loader_data();
+#if INCLUDE_CDS_JAVA_HEAP
+    if (MetaspaceShared::open_archive_heap_region_mapped() &&
+        _cache->archived_references() != NULL) {
+      oop archived = _cache->archived_references();
+      // Make sure GC knows the cached object is now live. This is necessary after
+      // initial GC marking and during concurrent marking as strong roots are only
+      // scanned during initial marking (at the start of the GC marking).
+      assert(UseG1GC, "Requires G1 GC");
+      G1SATBCardTableModRefBS::enqueue(archived);
+      // Create handle for the archived resolved reference array object
+      Handle refs_handle(THREAD, (oop)archived);
+      set_resolved_references(loader_data->add_handle(refs_handle));
+    } else
+#endif
+    {
+      // No mapped archived resolved reference array
     // Recreate the object array and add to ClassLoaderData.
     int map_length = resolved_reference_length();
     if (map_length > 0) {
       objArrayOop stom = oopFactory::new_objArray(SystemDictionary::Object_klass(), map_length, CHECK);
-      Handle refs_handle (THREAD, (oop)stom);  // must handleize.
-
-      ClassLoaderData* loader_data = pool_holder()->class_loader_data();
+        Handle refs_handle(THREAD, (oop)stom);  // must handleize.
       set_resolved_references(loader_data->add_handle(refs_handle));
     }
   }
+  }
 }
 
 void ConstantPool::remove_unshareable_info() {
   // Resolved references are not in the shared archive.
   // Save the length for restoration.  It is not necessarily the same length
-  // as reference_map.length() if invokedynamic is saved.
+  // as reference_map.length() if invokedynamic is saved. It is needed when
+  // re-creating the resolved reference array if archived heap data cannot be map
+  // at runtime.
   set_resolved_reference_length(
     resolved_references() != NULL ? resolved_references()->length() : 0);
+
+  // If archiving heap objects is not allowed, clear the resolved references.
+  // Otherwise, it is cleared after the resolved references array is cached
+  // (see archive_resolved_references()).
+  if (!MetaspaceShared::is_heap_object_archiving_allowed()) {
   set_resolved_references(NULL);
+  }
 
   // Shared ConstantPools are in the RO region, so the _flags cannot be modified.
   // The _on_stack flag is used to prevent ConstantPools from deallocation during
   // class redefinition. Since shared ConstantPools cannot be deallocated anyway,
   // we always set _on_stack to true to avoid having to change _flags during runtime.

@@ -617,23 +687,23 @@
       this_cp->string_at(index, CHECK);
     }
   }
 }
 
-// Resolve all the classes in the constant pool.  If they are all resolved,
-// the constant pool is read-only.  Enhancement: allocate cp entries to
-// another metaspace, and copy to read-only or read-write space if this
-// bit is set.
 bool ConstantPool::resolve_class_constants(TRAPS) {
   constantPoolHandle cp(THREAD, this);
   for (int index = 1; index < length(); index++) { // Index 0 is unused
-    if (tag_at(index).is_unresolved_klass() &&
-        klass_at_if_loaded(cp, index) == NULL) {
-      return false;
+    if (tag_at(index).is_string()) {
+      Symbol* sym = cp->unresolved_string_at(index);
+      // Look up only. Only resolve references to already interned strings.
+      oop str = StringTable::lookup(sym);
+      if (str != NULL) {
+        int cache_index = cp->cp_to_object_index(index);
+        cp->string_at_put(index, cache_index, str);
+      }
   }
   }
-  // set_preresolution(); or some bit for future use
   return true;
 }
 
 Symbol* ConstantPool::exception_message(const constantPoolHandle& this_cp, int which, constantTag tag, oop pending_exception) {
   // Dig out the detailed message to reuse if possible