8352613: [lworld] New Unsafe API for special array creation needed by VarHandle

Reviewed-by: mcimadamore

Author: fparain

src/hotspot/share/prims/unsafe.cpp

@@ -32,6 +32,7 @@
 #include "jni.h"
 #include "jvm.h"
 #include "memory/allocation.inline.hpp"
+#include "memory/oopFactory.hpp"
 #include "memory/resourceArea.hpp"
 #include "logging/log.hpp"
 #include "logging/logStream.hpp"
@@ -405,6 +406,33 @@ UNSAFE_ENTRY(jint, Unsafe_FieldLayout(JNIEnv *env, jobject unsafe, jobject field
   }
 } UNSAFE_END
 
+UNSAFE_ENTRY(jarray, Unsafe_NewSpecialArray(JNIEnv *env, jobject unsafe, jclass elmClass, jint len, jint layoutKind)) {
+  oop mirror = JNIHandles::resolve_non_null(elmClass);
+  Klass* klass = java_lang_Class::as_Klass(mirror);
+  klass->initialize(CHECK_NULL);
+  if (len < 0) {
+    THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Array length is negative");
+  }
+  if (klass->is_identity_class()) {
+    THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Element class is not a value class");
+  }
+  if (klass->is_abstract()) {
+    THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Element class is abstract");
+  }
+  LayoutKind lk = static_cast<LayoutKind>(layoutKind);
+  if (lk <= LayoutKind::REFERENCE || lk >= LayoutKind::UNKNOWN) {
+    THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), "Invalid layout kind");
+  }
+  InlineKlass* vk = InlineKlass::cast(klass);
+  // WARNING: test below will need modifications when flat layouts supported for fields
+  // but not for arrays are introduce (NULLABLE_NON_ATOMIC_FLAT for instance)
+  if (!UseArrayFlattening || !vk->is_layout_supported(lk)) {
+    THROW_MSG_NULL(vmSymbols::java_lang_UnsupportedOperationException(), "Layout not supported");
+  }
+  oop array = oopFactory::new_flatArray(vk, len, lk, CHECK_NULL);
+  return (jarray) JNIHandles::make_local(THREAD, array);
+} UNSAFE_END
+
 UNSAFE_ENTRY(jboolean, Unsafe_IsFlatArray(JNIEnv *env, jobject unsafe, jclass c)) {
   Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(c));
   return k->is_flatArray_klass();
@@ -1114,6 +1142,7 @@ static JNINativeMethod jdk_internal_misc_Unsafe_methods[] = {
     {CC "nullMarkerOffset0",    CC "(" OBJ ")I",          FN_PTR(Unsafe_NullMarkerOffset)},
     {CC "arrayLayout0",         CC "(" OBJ ")I",          FN_PTR(Unsafe_ArrayLayout)},
     {CC "fieldLayout0",         CC "(" OBJ ")I",          FN_PTR(Unsafe_FieldLayout)},
+    {CC "newSpecialArray",      CC "(" CLS "II)[" OBJ,    FN_PTR(Unsafe_NewSpecialArray)},
     {CC "getValue",             CC "(" OBJ "J" CLS ")" OBJ, FN_PTR(Unsafe_GetValue)},
     {CC "getFlatValue",         CC "(" OBJ "JI" CLS ")" OBJ, FN_PTR(Unsafe_GetFlatValue)},
     {CC "putValue",             CC "(" OBJ "J" CLS OBJ ")V", FN_PTR(Unsafe_PutValue)},

src/java.base/share/classes/jdk/internal/misc/Unsafe.java

@@ -259,6 +259,9 @@ public int fieldLayout(Field f) {
 
     private native int fieldLayout0(Object o);
 
+    public native Object[] newSpecialArray(Class<?> componentType,
+                                                  int length, int layoutKind);
+
     /**
      * Returns true if the given class is a flattened array.
      */

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

@@ -23,13 +23,15 @@
 
 package runtime.valhalla.inlinetypes;
 
+import jdk.internal.misc.Unsafe;
 import jdk.internal.value.ValueClass;
 import jdk.internal.vm.annotation.ImplicitlyConstructible;
 import jdk.internal.vm.annotation.LooselyConsistentValue;
 import jdk.internal.vm.annotation.NullRestricted;
 import java.lang.management.ManagementFactory;
 import java.lang.management.RuntimeMXBean;
 import java.lang.reflect.Array;
+import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.util.Arrays;
@@ -43,8 +45,10 @@
 /*
  * @test FlatArraysTest
  * @summary Plain array test for Inline Types
+ * @requires vm.flagless
  * @modules java.base/jdk.internal.value
  *          java.base/jdk.internal.vm.annotation
+ *          java.base/jdk.internal.misc
  * @library /test/lib
  * @enablePreview
  * @compile --source 25 FlatArraysTest.java
@@ -54,6 +58,7 @@
 
 public class FlatArraysTest {
   static final int ARRAY_SIZE = 100;
+  static final Unsafe UNSAFE = Unsafe.getUnsafe();
 
   @ImplicitlyConstructible
   @LooselyConsistentValue
@@ -451,10 +456,103 @@ static void testArrayAccesses() throws NoSuchMethodException, InstantiationExcep
     }
   }
 
+  @ImplicitlyConstructible
+  static value class AtomicValue {
+    int i = 0;
+  }
+
+  static value class FieldsHolder {
+    @NullRestricted
+    SmallValue sv = new SmallValue();
+
+    @NullRestricted
+    AtomicValue av = new AtomicValue();
+
+    AtomicValue nav = new AtomicValue();
+  }
+
+  static void testSpecialArrayLayoutFromArray(Object[] array, boolean expectException) {
+    int lk = UNSAFE.arrayLayout(array.getClass());
+    boolean exception = false;
+    try {
+      Object[] newArray = UNSAFE.newSpecialArray(array.getClass().getComponentType(), 10, lk);
+      int newLk = UNSAFE.arrayLayout(newArray.getClass());
+      assertEquals(newLk, lk);
+    } catch(IllegalArgumentException e) {
+      e.printStackTrace();
+      exception = true;
+    }
+    assertEquals(exception, expectException, "Exception not matching expectations");
+  }
+
+  static void testSpecialArrayFromFieldLayout(Class c, int layout, boolean expectException) {
+    boolean exception = false;
+    try {
+      Object[] array = UNSAFE.newSpecialArray(c, 10, layout);
+      int lk = UNSAFE.arrayLayout(array.getClass());
+      assertEquals(lk, layout);
+    } catch (IllegalArgumentException e) {
+      e.printStackTrace();
+      throw new RuntimeException(e);
+    } catch (UnsupportedOperationException e) {
+      e.printStackTrace();
+      exception = true;
+    }
+    assertEquals(exception, expectException, "Exception not matching expectations");
+  }
+
+  static void testSpecialArrayCreation() {
+    RuntimeMXBean runtimeMXBean = ManagementFactory.getRuntimeMXBean();
+    List<String> jvmArgs = runtimeMXBean.getInputArguments();
+    boolean arrayFlatteningEnabled = true;
+    for (String s : jvmArgs) {
+      if (s.compareTo("-XX:-UseArrayFlattening") == 0) arrayFlatteningEnabled = false;
+    }
+
+    // Test array creation from another array
+    Object[] array0 = new SmallValue[10];
+    testSpecialArrayLayoutFromArray(array0, true);
+    if (arrayFlatteningEnabled) {
+      Object[] array1 = ValueClass.newNullRestrictedArray(SmallValue.class, 10);
+      testSpecialArrayLayoutFromArray(array1, false);
+      Object[] array2 = ValueClass.newNullRestrictedAtomicArray(SmallValue.class, 10);
+      testSpecialArrayLayoutFromArray(array2, false);
+      Object[] array3 = ValueClass.newNullableAtomicArray(SmallValue.class, 10);
+      testSpecialArrayLayoutFromArray(array3, false);
+    }
+
+    // Test array creation from a field layout
+    try {
+      Class c = FieldsHolder.class;
+      Field f0 = c.getDeclaredField("sv");
+      int layout0 = UNSAFE.fieldLayout(f0);
+      testSpecialArrayFromFieldLayout(f0.getType(), layout0, !arrayFlatteningEnabled);
+      Field f1 = c.getDeclaredField("av");
+      int layout1 = UNSAFE.fieldLayout(f1);
+      testSpecialArrayFromFieldLayout(f1.getType(), layout1, !arrayFlatteningEnabled);
+      Field f2 = c.getDeclaredField("nav");
+      int layout2 = UNSAFE.fieldLayout(f2);
+      testSpecialArrayFromFieldLayout(f2.getType(), layout2, !arrayFlatteningEnabled);
+    } catch(NoSuchFieldException e) {
+      e.printStackTrace();
+    }
+
+    // Testing an invalid layout value
+    boolean exception = false;
+    try {
+      UNSAFE.newSpecialArray(SmallValue.class, 10, 100);
+    } catch(IllegalArgumentException e) {
+      e.printStackTrace();
+      exception = true;
+    }
+    assertEquals(exception, true, "Exception not received");
+  }
+
   public static void main(String[] args) throws NoSuchMethodException, InstantiationException,
                                                 IllegalAccessException, InvocationTargetException {
     testArrayAccesses();
     testArrayCopy();
+    testSpecialArrayCreation();
   }
 
  }