Merge branch 'premain' into premain-precompile

Author: iwanowww

src/hotspot/share/cds/heapShared.cpp

@@ -300,6 +300,11 @@ class ArchivedObjectPermanentIndexTable: public ResourceHashtable<OopHandle, int
 static ArchivedObjectPermanentIndexTable* _permanent_index_table = nullptr;
 
 int HeapShared::get_archived_object_permanent_index(oop obj) {
+  if (CDSConfig::is_dumping_final_static_archive()) {
+    log_warning(cds)("HeapShared::get_archived_object_permanent_index is not supported in new workflow yet");
+    return -1;
+  }
+
   if (_permobj_segments <= 0) {
     return -1;
   }

src/hotspot/share/cds/metaspaceShared.cpp

@@ -735,6 +735,8 @@ static void tmp_test_aot(ArchiveBuilder* builder, TRAPS) {
   }
 }
 
+void test_cds_heap_access_api(TRAPS);
+
 // Preload classes from a list, populate the shared spaces and dump to a
 // file.
 void MetaspaceShared::preload_and_dump() {
@@ -758,6 +760,9 @@ void MetaspaceShared::preload_and_dump() {
   if (CDSConfig::is_dumping_final_static_archive() && StoreCachedCode && CachedCodeFile != nullptr) {
     // We have just created the final image. Let's run the AOT compiler
     CDSConfig::enable_dumping_cached_code();
+    if (log_is_enabled(Info, cds, jit)) {
+      test_cds_heap_access_api(THREAD);
+    }
     int count = MAX2(1, (int)(NewCodeParameter & 0x7fffffff));
     for (int i = 0; i < count; i++) {
       tmp_test_aot(&builder, CHECK);
@@ -916,7 +921,7 @@ void MetaspaceShared::preload_and_dump_impl(StaticArchiveBuilder& builder, TRAPS
     st.print("%s%sbin%sjava", Arguments::get_java_home(), os::file_separator(), os::file_separator());
     const char* cp = Arguments::get_appclasspath();
     if (cp != nullptr && strlen(cp) > 0 && strcmp(cp, ".") != 0) {
-      st.print(" -cp %s", cp);
+      st.print(" -cp ");  st.print_raw(cp);
     }
     for (int i = 0; i < Arguments::num_jvm_flags(); i++) {
       st.print(" %s", Arguments::jvm_flags_array()[i]);
@@ -930,7 +935,7 @@ void MetaspaceShared::preload_and_dump_impl(StaticArchiveBuilder& builder, TRAPS
     if (CDSManualFinalImage) {
       tty->print_cr("-XX:+CDSManualFinalImage is specified");
       tty->print_cr("Please manually execute the following command to create the final CDS image:");
-      tty->print_cr("    %s", cmd);
+      tty->print("    "); tty->print_raw_cr(cmd);
     } else {
       log_info(cds)("Launching child process to create final CDS image:");
       log_info(cds)("    %s", cmd);

src/hotspot/share/classfile/systemDictionaryShared.cpp

@@ -204,13 +204,13 @@ InstanceKlass* SystemDictionaryShared::acquire_class_for_current_thread(
 // k must not be a shared class.
 DumpTimeClassInfo* SystemDictionaryShared::get_info(InstanceKlass* k) {
   MutexLocker ml(DumpTimeTable_lock, Mutex::_no_safepoint_check_flag);
-  assert(!k->is_shared(), "sanity");
+//assert(!k->is_shared(), "sanity"); // FIXME new workflow
   return get_info_locked(k);
 }
 
 DumpTimeClassInfo* SystemDictionaryShared::get_info_locked(InstanceKlass* k) {
   assert_lock_strong(DumpTimeTable_lock);
-//assert(!k->is_shared(), "sanity");
+//assert(!k->is_shared(), "sanity"); // FIXME new workflow
   DumpTimeClassInfo* info = _dumptime_table->get_info(k);
   assert(info != nullptr, "must be");
   return info;

src/hotspot/share/classfile/vmClasses.cpp

@@ -122,7 +122,7 @@ void vmClasses::resolve_until(vmClassID limit_id, vmClassID &start_id, TRAPS) {
 
 // TEMP: examples for using the HeapShared::get_archived_object_permanent_index() and HeapShared::get_archived_object()
 // APIs for the AOT compiler.
-static void test_cds_heap_access_api(TRAPS) {
+void test_cds_heap_access_api(TRAPS) {
 #ifdef INCLUDE_CDS_JAVA_HEAP
   const char* tests[] = {
     "",

src/hotspot/share/oops/constantPool.cpp

@@ -420,12 +420,10 @@ void ConstantPool::remove_unshareable_info() {
   // we always set _on_stack to true to avoid having to change _flags during runtime.
   _flags |= (_on_stack | _is_shared);
 
-// FIXME-hack
- if (CDSPreimage == nullptr) {
   if (!ArchiveBuilder::current()->get_source_addr(_pool_holder)->is_linked()) {
     return;
   }
- }
+
   if (is_for_method_handle_intrinsic()) {
     // This CP was created by Method::make_method_handle_intrinsic() and has nothing
     // that need to be removed/restored. It has no cpCache since the intrinsic methods
@@ -447,12 +445,14 @@ void ConstantPool::remove_unshareable_info() {
 }
 
 void ConstantPool::archive_entries() {
-  InstanceKlass* src_holder = ArchiveBuilder::current()->get_source_addr(_pool_holder);
+  InstanceKlass* src_holder = ArchiveBuilder::current()->get_source_addr(pool_holder());
   assert(src_holder->is_linked(), "must be");
   ResourceMark rm;
   GrowableArray<bool> keep_cpcache(cache()->length(), cache()->length(), false);
   bool archived = false;
   int method_cpcache_index = 0; // cpcache index for Methodref/InterfaceMethodref
+  bool preresolve = pool_holder()->is_shared_boot_class() || pool_holder()->is_shared_platform_class() ||
+                    pool_holder()->is_shared_app_class();
   for (int cp_index = 1; cp_index < length(); cp_index++) { // cp_index 0 is unused
     int cp_tag = tag_at(cp_index).value();
     switch (cp_tag) {
@@ -473,19 +473,30 @@ void ConstantPool::archive_entries() {
       tag_at_put(cp_index, JVM_CONSTANT_Dynamic);
       break;
     case JVM_CONSTANT_Class:
-      archived = maybe_archive_resolved_klass_at(cp_index);
+      if (preresolve) {
+        archived = maybe_archive_resolved_klass_at(cp_index);
+      } else {
+        archived = false;
+      }
+      if (!archived) {
+        // This referenced class cannot be archived. Revert the tag to UnresolvedClass,
+        // so that the proper class loading and initialization can happen at runtime.
+        int resolved_klass_index = klass_slot_at(cp_index).resolved_klass_index();
+        resolved_klasses()->at_put(resolved_klass_index, nullptr);
+        tag_at_put(cp_index, JVM_CONSTANT_UnresolvedClass);
+      }
       ArchiveBuilder::alloc_stats()->record_klass_cp_entry(archived);
       break;
     case JVM_CONSTANT_Methodref:
-      if (ArchiveMethodReferences) {
+      if (ArchiveMethodReferences && preresolve) {
         archived = maybe_archive_resolved_method_ref_at(cp_index, method_cpcache_index, cp_tag);
       } else {
         archived = false;
       }
       ArchiveBuilder::alloc_stats()->record_method_cp_entry(archived);
       break;
     case JVM_CONSTANT_InterfaceMethodref:
-      archived = false;
+      archived = false; // FIXME: TODO
       ArchiveBuilder::alloc_stats()->record_method_cp_entry(archived);
       break;
     default:
@@ -510,6 +521,7 @@ void ConstantPool::archive_entries() {
   }
 }
 
+#if 0
 static const char* get_type(Klass* buffered_k) {
   const char* type;
   Klass* src_k = ArchiveBuilder::current()->get_source_addr(buffered_k);
@@ -537,6 +549,7 @@ static const char* get_type(Klass* buffered_k) {
 
   return type;
 }
+#endif
 
 bool ConstantPool::maybe_archive_resolved_klass_at(int cp_index) {
   assert(ArchiveBuilder::current()->is_in_buffer_space(this), "must be");
@@ -560,19 +573,22 @@ bool ConstantPool::maybe_archive_resolved_klass_at(int cp_index) {
     if (ClassPrelinker::can_archive_resolved_klass(src_cp, cp_index)) {
       if (log_is_enabled(Debug, cds, resolve)) {
         ResourceMark rm;
+#if 0
+        // FIXME: get_type() fails with runtime/cds/appcds/loaderConstraints/DynamicLoaderConstraintsTest.java
         log_debug(cds, resolve)("archived klass  CP entry [%3d]: %s %s => %s %s%s", cp_index,
                                 get_type(pool_holder()), pool_holder()->name()->as_C_string(),
                                 get_type(k), k->name()->as_C_string(),
                                 pool_holder()->is_subtype_of(k) ? "" : " (not supertype)");
+#else
+        log_debug(cds, resolve)("archived klass  CP entry [%3d]: %s => %s%s", cp_index,
+                                pool_holder()->name()->as_C_string(),
+                                k->name()->as_C_string(),
+                                pool_holder()->is_subtype_of(k) ? "" : " (not supertype)");
+#endif
       }
       return true;
     }
   }
-
-  // This referenced class cannot be archived. Revert the tag to UnresolvedClass,
-  // so that the proper class loading and initialization can happen at runtime.
-  resolved_klasses()->at_put(resolved_klass_index, nullptr);
-  tag_at_put(cp_index, JVM_CONSTANT_UnresolvedClass);
   return false;
 }
 

test/hotspot/jtreg/premain/spring-petclinic/Makefile

@@ -38,7 +38,7 @@
 #
 #  *** NOTE: JDK 17 (or 21??) is needed to build spring-petclinic-3.1.0-SNAPSHOT.jar
 JDK17_HOME   = /jdk3/official/jdk17
-PREMAIN_HOME = /jdk3/bld/le3/images/jdk
+PREMAIN_HOME = /jdk3/bld/le4/images/jdk
 #===============================================================================
 
 # Usually there's no need to change the following
@@ -55,7 +55,12 @@ PC_STATIC_JSA    = spring-petclinic.static.jsa
 PC_DYNAMIC_JSA   = spring-petclinic.dynamic.jsa
 PC_CACHED_CODE   = spring-petclinic.code.jsa
 
-UNPACKED_CMDLINE = -cp @${PC_APP_UNPACKED}/classpath -DautoQuit=true -Dspring.aot.enabled=true ${PC_MAIN_CLASS}
+# new workflow
+PC_CDS_PREIMAGE  = spring-petclinic.cds.preimage
+PC_CDS          = spring-petclinic.cds
+
+HEAP_SIZE        = -Xmx2g
+UNPACKED_CMDLINE = $(HEAP_SIZE) -cp @${PC_APP_UNPACKED}/classpath -DautoQuit=true -Dspring.aot.enabled=true ${PC_MAIN_CLASS}
 
 all: check git app aot
 
@@ -111,23 +116,25 @@ ${PC_APP_UNPACKED}: ${PC_APP_JAR}
 	    | sed -e 's/ /:/g' > ${PC_APP_UNPACKED}/classpath
 	$(MAKE) run17
 
+#uncomment this to see the generated classes for dynamic proxies
+#SAVE_GEN_FILES=-Djdk.proxy.ProxyGenerator.saveGeneratedFiles=true
 
 ${PC_CLASSLIST}: ${PC_APP_UNPACKED}
 	${PREMAIN_JAVA} -Xshare:off -XX:DumpLoadedClassList=${PC_CLASSLIST} \
-	    -Xlog:class+load=debug:file=spring-petclinic.classload.log \
+	    -Xlog:class+load=debug:file=spring-petclinic.classload.log ${SAVE_GEN_FILES} \
 	    ${UNPACKED_CMDLINE}
 	wc -lc ${PC_CLASSLIST}
 
 ${PC_STATIC_JSA}: ${PC_CLASSLIST}
 	rm -f ${PC_STATIC_JSA}.log
-	${PREMAIN_JAVA} -Xshare:dump -XX:SharedClassListFile=${PC_CLASSLIST} -cp @${PC_APP_UNPACKED}/classpath \
-	    -XX:SharedArchiveFile=${PC_STATIC_JSA} -XX:+ArchiveInvokeDynamic -Xlog:cds=debug,cds+heap=warning,cds+resolve=debug:file=${PC_STATIC_JSA}.log
+	${PREMAIN_JAVA} -Xshare:dump -XX:SharedClassListFile=${PC_CLASSLIST} $(HEAP_SIZE) -cp @${PC_APP_UNPACKED}/classpath \
+	    -XX:SharedArchiveFile=${PC_STATIC_JSA} -XX:+ArchiveInvokeDynamic -Xlog:cds=debug,cds+class=debug,cds+heap=warning,cds+resolve=debug:file=${PC_STATIC_JSA}.log
 	ls -l ${PC_STATIC_JSA}
 
 ${PC_DYNAMIC_JSA}: ${PC_STATIC_JSA}
 	rm -f ${PC_DYNAMIC_JSA} ${PC_DYNAMIC_JSA}.log
 	${PREMAIN_JAVA} -XX:SharedArchiveFile=${PC_STATIC_JSA} -XX:ArchiveClassesAtExit=${PC_DYNAMIC_JSA} \
-	    -Xlog:cds:file=${PC_DYNAMIC_JSA}.log \
+	    -Xlog:cds=debug,cds+class=debug:file=${PC_DYNAMIC_JSA}.log \
 	    -XX:+RecordTraining ${UNPACKED_CMDLINE}
 	ls -l ${PC_DYNAMIC_JSA}
 
@@ -146,13 +153,41 @@ runs: ${PC_STATIC_JSA}
 	time ${PREMAIN_JAVA} -XX:SharedArchiveFile=${PC_STATIC_JSA} \
 		-Xlog:init ${UNPACKED_CMDLINE}
 
+# run with just dynamic CDS archive
+rund: ${PC_DYNAMIC_JSA}
+	time ${PREMAIN_JAVA} -XX:SharedArchiveFile=${PC_DYNAMIC_JSA} \
+		-Xlog:init ${UNPACKED_CMDLINE}
+
 # run WITHOUT premain optimizatipn
 run0: ${PC_APP_UNPACKED}
 	time ${PREMAIN_JAVA} -Xlog:init ${UNPACKED_CMDLINE}
 
 run17: ${PC_APP_UNPACKED}
 	${JDK17_JAVA} ${UNPACKED_CMDLINE}
 
+#======================================== new workflow
+pre: ${PC_CDS_PREIMAGE}
+cds: ${PC_CDS}
+
+${PC_CDS_PREIMAGE}: ${PC_APP_UNPACKED}
+	rm -f ${PC_CDS_PREIMAGE} ${PC_CDS}
+	${PREMAIN_JAVA} -XX:+ArchiveInvokeDynamic -XX:+UnlockDiagnosticVMOptions -XX:+CDSManualFinalImage -XX:CacheDataStore=${PC_CDS} \
+	    -Xlog:cds=debug,cds+class=debug,cds+heap=warning,cds+resolve=debug:file=${PC_CDS_PREIMAGE}.log \
+	    ${UNPACKED_CMDLINE}
+	ls -l ${PC_CDS_PREIMAGE}
+
+${PC_CDS}: ${PC_CDS_PREIMAGE}
+	rm -f ${PC_CDS}
+	${PREMAIN_JAVA} -XX:+ArchiveInvokeDynamic -XX:+UnlockDiagnosticVMOptions -XX:CDSPreimage=${PC_CDS_PREIMAGE} -XX:CacheDataStore=${PC_CDS} \
+	    -Xlog:cds=debug,cds+class=debug,cds+heap=warning,cds+resolve=debug:file=${PC_CDS}.log \
+	    ${UNPACKED_CMDLINE}
+	ls -l ${PC_CDS}
+
+# run with NEW workflow
+runn: ${PC_CDS}
+	time ${PREMAIN_JAVA} -XX:SharedArchiveFile=${PC_CDS} -XX:+ReplayTraining -XX:+LoadCachedCode \
+		-XX:CachedCodeFile=${PC_CDS}.jsa -Xlog:init -Xlog:scc=error ${UNPACKED_CMDLINE}
+
 clean: clean0
 	rm -rf *~ ${PC_REPO}