Add UnsafeAccess.hostUnsafeCast and mark extension arrays as non-null.

Ensure extension arrays are seen as non-null in host compilation.
Remove DynamicField annotation from the array fields to avoid marking them as unsafe-accessed.

Author: woess

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/truffle/substitutions/TruffleInvocationPlugins.java

@@ -58,6 +58,7 @@
 import jdk.graal.compiler.nodes.calc.CompareNode;
 import jdk.graal.compiler.nodes.calc.FloatConvertNode;
 import jdk.graal.compiler.nodes.calc.LeftShiftNode;
+import jdk.graal.compiler.nodes.extended.ValueAnchorNode;
 import jdk.graal.compiler.nodes.graphbuilderconf.GraphBuilderContext;
 import jdk.graal.compiler.nodes.graphbuilderconf.InvocationPlugin;
 import jdk.graal.compiler.nodes.graphbuilderconf.InvocationPlugin.ConditionalInvocationPlugin;
@@ -111,6 +112,7 @@ public static void register(Architecture architecture, InvocationPlugins plugins
         registerFramePlugins(plugins);
         registerBytecodePlugins(plugins);
         registerCompilerDirectivesPlugins(plugins);
+        registerDynamicObjectPlugins(plugins);
     }
 
     private static void registerFramePlugins(InvocationPlugins plugins) {
@@ -830,4 +832,64 @@ public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Rec
             }
         });
     }
+
+    private static void registerDynamicObjectPlugins(InvocationPlugins plugins) {
+        plugins.registerIntrinsificationPredicate(t -> t.getName().equals("Lcom/oracle/truffle/api/object/UnsafeAccess;"));
+        InvocationPlugins.Registration r = new InvocationPlugins.Registration(plugins, "com.oracle.truffle.api.object.UnsafeAccess");
+        r.register(new OptionalInlineOnlyInvocationPlugin("hostUnsafeCast", Object.class, Class.class, boolean.class, boolean.class, boolean.class) {
+            @Override
+            public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver, ValueNode object, ValueNode clazz, ValueNode condition, ValueNode nonNull,
+                            ValueNode isExactType) {
+                if (!clazz.isConstant() || !nonNull.isConstant() || !isExactType.isConstant()) {
+                    b.push(JavaKind.Object, object);
+                    return true;
+                }
+                if (!Options.TruffleTrustedTypeCast.getValue(b.getOptions())) {
+                    b.push(JavaKind.Object, object);
+                    return true;
+                }
+                ConstantReflectionProvider constantReflection = b.getConstantReflection();
+                ResolvedJavaType javaType = constantReflection.asJavaType(clazz.asConstant());
+                if (javaType == null) {
+                    b.push(JavaKind.Object, object);
+                    return true;
+                }
+
+                TypeReference type;
+                if (isExactType.asJavaConstant().asInt() != 0) {
+                    assert javaType.isConcrete() || javaType.isArray() : "exact type is not a concrete class: " + javaType;
+                    type = TypeReference.createExactTrusted(javaType);
+                } else {
+                    type = TypeReference.createTrusted(b.getAssumptions(), javaType);
+                }
+
+                boolean trustedNonNull = nonNull.asJavaConstant().asInt() != 0 && Options.TruffleTrustedNonNullCast.getValue(b.getOptions());
+                Stamp piStamp = StampFactory.object(type, trustedNonNull);
+
+                ValueNode valueAnchorNode;
+                if (condition.isConstant()) {
+                    if (condition.asJavaConstant().asInt() == 1) {
+                        // Nothing to do.
+                        valueAnchorNode = null;
+                    } else {
+                        valueAnchorNode = b.add(new ValueAnchorNode());
+                    }
+                } else {
+                    LogicNode compareNode = CompareNode.createCompareNode(CanonicalCondition.EQ, condition, ConstantNode.forBoolean(true), constantReflection, NodeView.DEFAULT);
+                    if (compareNode instanceof LogicConstantNode logicConstantNode) {
+                        if (logicConstantNode.getValue()) {
+                            valueAnchorNode = null;
+                        } else {
+                            valueAnchorNode = b.add(new ValueAnchorNode());
+                        }
+                    } else {
+                        valueAnchorNode = b.add(new ConditionAnchorNode(compareNode));
+                    }
+                }
+
+                b.addPush(JavaKind.Object, PiNode.create(object, piStamp, valueAnchorNode));
+                return true;
+            }
+        });
+    }
 }

truffle/src/com.oracle.truffle.api.object/src/com/oracle/truffle/api/object/DynamicObject.java

@@ -49,6 +49,7 @@
 import java.lang.invoke.MethodHandles.Lookup;
 import java.lang.reflect.Field;
 import java.util.Map;
+import java.util.Objects;
 
 import com.oracle.truffle.api.CompilerAsserts;
 import com.oracle.truffle.api.CompilerDirectives;
@@ -196,9 +197,9 @@ public abstract class DynamicObject implements TruffleObject {
     private Shape shape;
 
     /** Object extension array. */
-    @DynamicField private Object[] extRef = EMPTY_OBJECT_ARRAY;
+    private Object[] extRef = EMPTY_OBJECT_ARRAY;
     /** Primitive extension array. */
-    @DynamicField private int[] extVal = EMPTY_INT_ARRAY;
+    private int[] extVal = EMPTY_INT_ARRAY;
 
     /**
      * Constructor for {@link DynamicObject} subclasses. Initializes the object with the provided
@@ -321,19 +322,25 @@ private static CloneNotSupportedException cloneNotSupported() throws CloneNotSup
     }
 
     final Object[] getObjectStore() {
+        if (CompilerDirectives.inInterpreter()) {
+            return UnsafeAccess.hostUnsafeCast(extRef, Object[].class, false, true, true);
+        }
         return extRef;
     }
 
     final void setObjectStore(Object[] newArray) {
-        extRef = newArray;
+        extRef = Objects.requireNonNull(newArray);
     }
 
     final int[] getPrimitiveStore() {
+        if (CompilerDirectives.inInterpreter()) {
+            return UnsafeAccess.hostUnsafeCast(extVal, int[].class, false, true, true);
+        }
         return extVal;
     }
 
     final void setPrimitiveStore(int[] newArray) {
-        extVal = newArray;
+        extVal = Objects.requireNonNull(newArray);
     }
 
     static Class<? extends Annotation> getDynamicFieldAnnotation() {

truffle/src/com.oracle.truffle.api.object/src/com/oracle/truffle/api/object/UnsafeAccess.java

@@ -74,8 +74,8 @@ static boolean booleanCast(int value) {
     }
 
     /**
-     * Casts the given value to the value of the given type without any checks. The type, nonNull,
-     * and exact must evaluate to a constant. The condition parameter gives a hint to the compiler
+     * Casts the given value to the given type without any checks. The type, nonNull, and exact
+     * parameters must evaluate to a constant. The condition parameter gives a hint to the compiler
      * under which circumstances this cast can be moved to an earlier location in the program.
      *
      * @param value the value that is known to have the specified type
@@ -90,6 +90,22 @@ static <T> T unsafeCast(Object value, Class<T> type, boolean condition, boolean
         return (T) value;
     }
 
+    /**
+     * Casts the given value to the given type without any checks during host compilation. The type,
+     * nonNull, and exact parameters must evaluate to a constant for the cast to have any effect.
+     *
+     * @param value the value that is known to have the specified type
+     * @param type the specified new type of the value
+     * @param condition the condition that makes this cast safe also at an earlier location
+     * @param nonNull whether value is known to never be null
+     * @param exact whether the value is known to be of exactly the specified class
+     * @return the value to be cast to the new type
+     */
+    @SuppressWarnings("unchecked")
+    static <T> T hostUnsafeCast(Object value, Class<T> type, boolean condition, boolean nonNull, boolean exact) {
+        return (T) value;
+    }
+
     /**
      * Like {@link System#arraycopy}, but kills any location.
      */