8370479: [lworld] OOP-related crashes via mvn surefire

src/hotspot/share/classfile/javaClasses.hpp

@@ -213,6 +213,7 @@ class java_lang_String : AllStatic {
 
   // Tester
   static inline bool is_instance(oop obj);
+  static inline bool is_instance_without_asserts(oop obj);
 
   // Debugging
   static void print(oop java_string, outputStream* st, int max_length = MaxStringPrintSize);

src/hotspot/share/classfile/javaClasses.inline.hpp

@@ -126,6 +126,13 @@ bool java_lang_String::is_instance(oop obj) {
   return obj != nullptr && obj->klass() == vmClasses::String_klass();
 }
 
+// We need to be able to check if this is a string even when we are in an
+// erroneous state where the klass is corrupted/can't be read safely.
+// This happens when printing an oop during GC error reporting.
+bool java_lang_String::is_instance_without_asserts(oop obj) {
+  return obj != nullptr && obj->klass_without_asserts() == vmClasses::String_klass();
+}
+
 // Accessors
 
 oop java_lang_ref_Reference::weak_referent_no_keepalive(oop ref) {

src/hotspot/share/gc/shared/modRefBarrierSet.inline.hpp

@@ -159,7 +159,8 @@ clone_in_heap(oop src, oop dst, size_t size) {
 template <DecoratorSet decorators, typename BarrierSetT>
 inline void ModRefBarrierSet::AccessBarrier<decorators, BarrierSetT>::
 value_copy_in_heap(void* src, void* dst, InlineKlass* md, LayoutKind lk) {
-  if (HasDecorator<decorators, IS_DEST_UNINITIALIZED>::value || (!md->contains_oops())) {
+  if (!md->contains_oops()) {
+    // If we do not have oops in the flat array, we can just do a raw copy.
     Raw::value_copy(src, dst, md, lk);
   } else {
     BarrierSetT* bs = barrier_set_cast<BarrierSetT>(BarrierSet::barrier_set());
@@ -170,9 +171,13 @@ value_copy_in_heap(void* src, void* dst, InlineKlass* md, LayoutKind lk) {
     // Pre-barriers...
     OopMapBlock* map = md->start_of_nonstatic_oop_maps();
     OopMapBlock* const end = map + md->nonstatic_oop_map_count();
+    bool is_uninitialized = HasDecorator<decorators, IS_DEST_UNINITIALIZED>::value;
     while (map != end) {
       address doop_address = dst_oop_addr_offset + map->offset();
-      bs->write_ref_array_pre((OopType*) doop_address, map->count(), false);
+      // The pre-barrier only impacts G1, which will emit a barrier if the destination is
+      // initialized. Note that we should not emit a barrier if the destination is uninitialized,
+      // as doing so will fill the SATB queue with garbage data.
+      bs->write_ref_array_pre((OopType*) doop_address, map->count(), is_uninitialized);
       map++;
     }
 
@@ -182,6 +187,7 @@ value_copy_in_heap(void* src, void* dst, InlineKlass* md, LayoutKind lk) {
     map = md->start_of_nonstatic_oop_maps();
     while (map != end) {
       address doop_address = dst_oop_addr_offset + map->offset();
+      // The post-barrier needs to be called for initialized and uninitialized destinations.
       bs->write_ref_array((HeapWord*) doop_address, map->count());
       map++;
     }

src/hotspot/share/oops/oop.cpp

@@ -83,7 +83,7 @@ char* oopDesc::print_value_string() {
 
 void oopDesc::print_value_on(outputStream* st) const {
   oop obj = const_cast<oopDesc*>(this);
-  if (java_lang_String::is_instance(obj)) {
+  if (java_lang_String::is_instance_without_asserts(obj)) {
     java_lang_String::print(obj, st);
     print_address_on(st);
   } else {

test/hotspot/jtreg/runtime/valhalla/inlinetypes/FlatArrayCopyingTest.java

@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) 2025, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+
+/*
+ * @test id=serial
+ * @summary Ensures that value arrays can get arraycopied properly with Serial.
+ *          This test will likely crash if that is not the case.
+ * @bug 8370479
+ * @enablePreview
+ * @requires vm.flagless
+ * @library /test/lib /
+ * @modules java.base/jdk.internal.value
+            java.management
+ * @build jdk.test.whitebox.WhiteBox
+ * @run driver jdk.test.lib.helpers.ClassFileInstaller jdk.test.whitebox.WhiteBox
+ * @run junit/othervm/timeout=480 -Xint -XX:+UseSerialGC -XX:+UseCompressedOops -Xlog:gc*=info
+                                  -XX:+UseCompressedClassPointers
+                                  -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI
+                                  runtime.valhalla.inlinetypes.FlatArrayCopyingTest
+ */
+
+/*
+ * @test id=parallel
+ * @summary Ensures that value arrays can get arraycopied properly with Parallel.
+ *          This test will likely crash if that is not the case.
+ * @bug 8370479
+ * @enablePreview
+ * @requires vm.flagless
+ * @library /test/lib /
+ * @modules java.base/jdk.internal.value
+            java.management
+ * @build jdk.test.whitebox.WhiteBox
+ * @run driver jdk.test.lib.helpers.ClassFileInstaller jdk.test.whitebox.WhiteBox
+ * @run junit/othervm/timeout=480 -Xint -XX:+UseParallelGC -XX:+UseCompressedOops -Xlog:gc*=info
+                                  -XX:ParallelGCThreads=1 -XX:-UseDynamicNumberOfGCThreads
+                                  -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI
+                                  runtime.valhalla.inlinetypes.FlatArrayCopyingTest
+ */
+
+/*
+ * @test id=g1
+ * @summary Ensures that value arrays can get arraycopied properly with G1.
+ *          This test will likely crash if that is not the case.
+ * @bug 8370479
+ * @enablePreview
+ * @requires vm.flagless
+ * @library /test/lib /
+ * @modules java.base/jdk.internal.value
+            java.management
+ * @build jdk.test.whitebox.WhiteBox
+ * @run driver jdk.test.lib.helpers.ClassFileInstaller jdk.test.whitebox.WhiteBox
+ * @run junit/othervm/timeout=480 -Xint -XX:+UseG1GC -XX:+UseCompressedOops -Xlog:gc*=info
+                                  -XX:ParallelGCThreads=1 -XX:ConcGCThreads=1 -XX:-UseDynamicNumberOfGCThreads
+                                  -XX:-G1UseConcRefinement -XX:+UseCompressedClassPointers
+                                  -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI
+                                  runtime.valhalla.inlinetypes.FlatArrayCopyingTest
+ */
+
+package runtime.valhalla.inlinetypes;
+
+import java.util.Arrays;
+import jdk.internal.value.ValueClass;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import jdk.test.whitebox.WhiteBox;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public final class FlatArrayCopyingTest {
+    private static final WhiteBox WB = WhiteBox.getWhiteBox();
+
+    public static value record Element(Identity underlying) {}
+    public static class Identity {}
+
+    @Test
+    public void testCopyingOften() {
+        Object[] array = ValueClass.newNullableAtomicArray(Element.class, 16);
+        for (int i = 0; i < 1_000_000; i++) {
+            if (i == array.length) {
+                array = Arrays.copyOf(array, array.length << 1);
+            }
+            // Do a very "random" full GC.
+            if (i == 5123123) {
+                WB.fullGC();
+            }
+            array[i] = new Element(new Identity());
+        }
+        // Smallest power of 2 that fits 1 million elements.
+        assertEquals(1_048_576, array.length);
+    }
+
+}