[GR-65058] Avoid direct intrinsification of Array#newInstance.

PullRequest: graal/20836

Author: vjovanov

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/hotspot/meta/HotSpotGraphBuilderPlugins.java

@@ -86,6 +86,7 @@
 import jdk.graal.compiler.core.common.memory.BarrierType;
 import jdk.graal.compiler.core.common.memory.MemoryOrderMode;
 import jdk.graal.compiler.core.common.spi.ForeignCallDescriptor;
+import jdk.graal.compiler.core.common.type.AbstractPointerStamp;
 import jdk.graal.compiler.core.common.type.ObjectStamp;
 import jdk.graal.compiler.core.common.type.StampFactory;
 import jdk.graal.compiler.core.common.type.TypeReference;
@@ -141,6 +142,7 @@
 import jdk.graal.compiler.nodes.calc.XorNode;
 import jdk.graal.compiler.nodes.extended.BranchProbabilityNode;
 import jdk.graal.compiler.nodes.extended.ForeignCallNode;
+import jdk.graal.compiler.nodes.extended.GuardingNode;
 import jdk.graal.compiler.nodes.extended.JavaReadNode;
 import jdk.graal.compiler.nodes.extended.JavaWriteNode;
 import jdk.graal.compiler.nodes.extended.LoadHubNode;
@@ -557,19 +559,20 @@ private static void registerArrayPlugins(InvocationPlugins plugins, Replacements
             @Override
             public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver, ValueNode componentType, ValueNode length) {
                 try (HotSpotInvocationPluginHelper helper = new HotSpotInvocationPluginHelper(b, targetMethod, config)) {
-                    // If (componentType == null) then deopt
-                    ValueNode nonNullComponentType = b.nullCheckedValue(componentType);
+                    // If (componentType == null) then take the fallback path
+                    GuardingNode guard = helper.doFallbackIf(IsNullNode.create(componentType), GraalDirectives.UNLIKELY_PROBABILITY);
+                    ValueNode nonNullComponentType = helper.piCast(componentType, guard, ((AbstractPointerStamp) componentType.stamp(NodeView.DEFAULT)).asNonNull());
                     // Read Class.array_klass
                     ValueNode arrayClass = helper.loadArrayKlass(nonNullComponentType);
-                    // Take the fallback path is the array klass is null
+                    // Take the fallback path if the array klass is null
                     helper.doFallbackIf(IsNullNode.create(arrayClass), GraalDirectives.UNLIKELY_PROBABILITY);
                     // Otherwise perform the array allocation
-                    helper.emitFinalReturn(JavaKind.Object, new DynamicNewArrayNode(nonNullComponentType, length,
-                                    true));
+                    helper.emitFinalReturn(JavaKind.Object, new DynamicNewArrayNode(nonNullComponentType, length, true));
                 }
                 return true;
             }
         });
+        r.register(StandardGraphBuilderPlugins.newArrayPlugin("newInstance"));
     }
 
     private static void registerStringPlugins(InvocationPlugins plugins, Replacements replacements, WordTypes wordTypes, ArrayCopyForeignCalls foreignCalls, GraalHotSpotVMConfig vmConfig) {

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/replacements/StandardGraphBuilderPlugins.java

@@ -548,9 +548,8 @@ private static void registerArraysPlugins(InvocationPlugins plugins, Replacement
         r.registerConditional(ArrayFillNode.isSupported(arch), new ArrayFillInvocationPlugin(JavaKind.Double, double[].class, double.class));
     }
 
-    private static void registerArrayPlugins(InvocationPlugins plugins, Replacements replacements) {
-        Registration r = new Registration(plugins, Array.class, replacements);
-        r.register(new InvocationPlugin("newInstance", Class.class, int.class) {
+    public static InvocationPlugin newArrayPlugin(final String methodName) {
+        return new InvocationPlugin(methodName, Class.class, int.class) {
             @Override
             public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver unused, ValueNode componentType, ValueNode length) {
                 ValueNode componentTypeNonNull = b.nullCheckedValue(componentType);
@@ -562,7 +561,11 @@ public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Rec
                 }
                 return true;
             }
-        });
+        };
+    }
+
+    private static void registerArrayPlugins(InvocationPlugins plugins, Replacements replacements) {
+        Registration r = new Registration(plugins, Array.class, replacements);
         r.register(new InvocationPlugin("getLength", Object.class) {
             @Override
             public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver unused, ValueNode object) {

substratevm/src/com.oracle.graal.pointsto/src/com/oracle/graal/pointsto/plugins/PointstoGraphBuilderPlugins.java

@@ -24,6 +24,8 @@
  */
 package com.oracle.graal.pointsto.plugins;
 
+import java.lang.reflect.Array;
+
 import com.oracle.graal.pointsto.nodes.AnalysisObjectCloneNode;
 
 import jdk.graal.compiler.nodes.ValueNode;
@@ -32,13 +34,19 @@
 import jdk.graal.compiler.nodes.graphbuilderconf.InvocationPlugin.RequiredInvocationPlugin;
 import jdk.graal.compiler.nodes.graphbuilderconf.InvocationPlugins;
 import jdk.graal.compiler.nodes.graphbuilderconf.InvocationPlugins.Registration;
+import jdk.graal.compiler.replacements.StandardGraphBuilderPlugins;
 import jdk.graal.compiler.replacements.arraycopy.ArrayCopySnippets;
 import jdk.graal.compiler.replacements.nodes.MacroNode.MacroParams;
 import jdk.vm.ci.meta.JavaKind;
 import jdk.vm.ci.meta.ResolvedJavaMethod;
 
 public class PointstoGraphBuilderPlugins {
 
+    public static void registerArrayPlugins(InvocationPlugins plugins) {
+        Registration r = new Registration(plugins, Array.class);
+        r.register(StandardGraphBuilderPlugins.newArrayPlugin("newInstance"));
+    }
+
     public static void registerSystemPlugins(InvocationPlugins plugins) {
         Registration r = new Registration(plugins, System.class).setAllowOverwrite(true);
         ArrayCopySnippets.registerSystemArraycopyPlugin(r);

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/graal/jdk/SubstrateObjectCloneSnippets.java

@@ -112,7 +112,7 @@ private static Object doClone(Object original) throws CloneNotSupportedException
         if (isArrayLike) {
             if (BranchProbabilityNode.probability(FAST_PATH_PROBABILITY, LayoutEncoding.isArray(layoutEncoding))) {
                 int length = ArrayLengthNode.arrayLength(original);
-                Object newArray = java.lang.reflect.Array.newInstance(DynamicHub.toClass(hub.getComponentHub()), length);
+                Object newArray = KnownIntrinsics.unvalidatedNewArray(DynamicHub.toClass(hub.getComponentHub()), length);
                 if (LayoutEncoding.isObjectArray(layoutEncoding)) {
                     JavaMemoryUtil.copyObjectArrayForward(original, 0, newArray, 0, length, layoutEncoding);
                 } else {

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/jdk/JavaLangReflectSubstitutions.java

@@ -38,6 +38,7 @@
 import com.oracle.svm.core.hub.DynamicHub;
 import com.oracle.svm.core.hub.LayoutEncoding;
 import com.oracle.svm.core.reflect.MissingReflectionRegistrationUtils;
+import com.oracle.svm.core.snippets.KnownIntrinsics;
 
 import jdk.graal.compiler.word.BarrieredAccess;
 
@@ -382,6 +383,12 @@ private static void set(Object a, int index, Object value) {
         throw new IllegalArgumentException();
     }
 
+    @Substitute
+    private static Object newArray(Class<?> componentType, int length)
+                    throws NegativeArraySizeException {
+        return KnownIntrinsics.unvalidatedNewArray(componentType, length);
+    }
+
     @Substitute
     private static Object multiNewArray(Class<?> componentType, int[] dimensions) {
         if (componentType == null) {

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/snippets/KnownIntrinsics.java

@@ -123,4 +123,10 @@ public class KnownIntrinsics {
      * the static analysis, and without the check that the class is already initialized.
      */
     public static native Object unvalidatedAllocateInstance(Class<?> hub);
+
+    /**
+     * Like {@link java.lang.reflect.Array#newInstance(Class, int)} but without the checks that the
+     * array of the desired class is registered for reflection.
+     */
+    public static native Object unvalidatedNewArray(Class<?> componentType, int length) throws NegativeArraySizeException;
 }

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/snippets/SubstrateGraphBuilderPlugins.java

@@ -1019,6 +1019,7 @@ public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Rec
                 return true;
             }
         });
+        r.register(StandardGraphBuilderPlugins.newArrayPlugin("unvalidatedNewArray"));
 
         registerCastExact(r);
     }