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

Ensure extension arrays are seen as non-null in host compilation, too.
Remove DynamicField annotation from the array fields to not needlessly mark them as unsafe-accessed.

Author: woess

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

@@ -107,6 +107,7 @@ public static void register(Architecture architecture, InvocationPlugins plugins
         registerFramePlugins(plugins);
         registerBytecodePlugins(plugins);
         registerCompilerDirectivesPlugins(plugins);
+        registerDynamicObjectPlugins(plugins);
     }
 
     private static void registerFramePlugins(InvocationPlugins plugins) {
@@ -823,4 +824,10 @@ 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 UnsafeCastPlugin("hostUnsafeCast", false));
+    }
 }

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;
@@ -195,9 +196,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
@@ -324,15 +325,15 @@ final Object[] getObjectStore() {
     }
 
     final void setObjectStore(Object[] newArray) {
-        extRef = newArray;
+        extRef = Objects.requireNonNull(newArray);
     }
 
     final int[] getPrimitiveStore() {
         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/Location.java

@@ -830,11 +830,11 @@ final long getPrimitiveArrayOffset() {
     }
 
     static Object getObjectArray(DynamicObject store, boolean condition) {
-        return UnsafeAccess.unsafeCast(store.getObjectStore(), Object[].class, condition, true, true);
+        return UnsafeAccess.hostUnsafeCast(store.getObjectStore(), Object[].class, condition, true, true);
     }
 
     static Object getPrimitiveArray(DynamicObject store, boolean condition) {
-        return UnsafeAccess.unsafeCast(store.getPrimitiveStore(), int[].class, condition, true, true);
+        return UnsafeAccess.hostUnsafeCast(store.getPrimitiveStore(), int[].class, condition, true, true);
     }
 
     static RuntimeException incompatibleLocationException() {

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.
      */