Omit receiver type check.

woess · woess · commit 3dffe983fcc2 · 2025-11-11T17:07:03.000+01:00
diff --git a/truffle/src/com.oracle.truffle.api.object/src/com/oracle/truffle/api/object/FieldInfo.java b/truffle/src/com.oracle.truffle.api.object/src/com/oracle/truffle/api/object/FieldInfo.java
@@ -42,6 +42,7 @@
 
 import java.lang.invoke.VarHandle;
 import java.lang.reflect.Field;
+import java.util.Objects;
 
 import com.oracle.truffle.api.CompilerAsserts;
 import com.oracle.truffle.api.CompilerDirectives;
@@ -158,4 +159,12 @@ private IllegalArgumentException illegalReceiver(DynamicObject store) {
         CompilerAsserts.neverPartOfCompilation();
         return new IllegalArgumentException("Invalid receiver type (expected " + getDeclaringClass() + ", was " + (store == null ? null : store.getClass()) + ")");
     }
+
+    DynamicObject unsafeReceiverCast(DynamicObject store) {
+        if (ObjectStorageOptions.ReceiverCast) {
+            return Objects.requireNonNull(tclass.cast(store));
+        } else {
+            return store;
+        }
+    }
 }
diff --git a/truffle/src/com.oracle.truffle.api.object/src/com/oracle/truffle/api/object/Location.java b/truffle/src/com.oracle.truffle.api.object/src/com/oracle/truffle/api/object/Location.java
@@ -201,26 +201,28 @@ protected double getDouble(DynamicObject store, boolean guard) throws Unexpected
      * @param guard the result of the shape check or {@code false}
      * @return the read value
      */
+    @SuppressWarnings("hiding")
     final Object getInternal(DynamicObject store, Shape expectedShape, boolean guard) {
+        DynamicObject receiver = unsafeNonNullCast(store);
         long idx = Integer.toUnsignedLong(index);
+        FieldInfo field = this.field;
         if (this instanceof ObjectLocation objectLocation) {
             Object base;
             long offset;
             Object value;
             if (field == null) {
-                base = getObjectArray(store, guard);
+                base = getObjectArray(receiver, guard);
                 offset = computeObjectArrayOffset(idx);
                 value = UnsafeAccess.unsafeGetObject(base, offset, guard, this);
             } else {
-                field.receiverCheck(store);
-                base = store;
+                base = field.unsafeReceiverCast(receiver);
                 offset = getFieldOffset();
                 value = UnsafeAccess.unsafeGetObject(base, offset, guard, this);
             }
             return CompilerDirectives.inInterpreter() ? value : objectLocation.assumedTypeCast(value, guard);
         } else {
             if (field == null) {
-                Object array = getPrimitiveArray(store, guard);
+                Object array = getPrimitiveArray(receiver, guard);
                 long offset = computePrimitiveArrayOffset(idx);
                 if (isIntLocation()) {
                     return UnsafeAccess.unsafeGetInt(array, offset, guard, this);
@@ -229,11 +231,11 @@ final Object getInternal(DynamicObject store, Shape expectedShape, boolean guard
                 } else if (isDoubleLocation()) {
                     return UnsafeAccess.unsafeGetDouble(array, offset, guard, this);
                 } else {
-                    return ((ConstantLocation) this).get(store, guard);
+                    return ((ConstantLocation) this).get(receiver, guard);
                 }
             } else {
-                field.receiverCheck(store);
-                long longValue = UnsafeAccess.unsafeGetLong(store, getFieldOffset(), guard, this);
+                Object base = field.unsafeReceiverCast(receiver);
+                long longValue = UnsafeAccess.unsafeGetLong(base, getFieldOffset(), guard, this);
                 if (this instanceof IntLocation) {
                     return (int) longValue;
                 } else if (this instanceof LongLocation) {
@@ -250,18 +252,19 @@ final Object getInternal(DynamicObject store, Shape expectedShape, boolean guard
      * @see #getInternal(DynamicObject, Shape, boolean)
      */
     final int getIntInternal(DynamicObject store, Shape expectedShape, boolean guard) throws UnexpectedResultException {
+        DynamicObject receiver = unsafeNonNullCast(store);
         if (isIntLocation()) {
             if (field == null) {
-                Object array = getPrimitiveArray(store, guard);
+                Object array = getPrimitiveArray(receiver, guard);
                 long offset = getPrimitiveArrayOffset();
                 return UnsafeAccess.unsafeGetInt(array, offset, guard, this);
             } else {
-                field.receiverCheck(store);
-                long longValue = UnsafeAccess.unsafeGetLong(store, getFieldOffset(), guard, this);
+                Object base = field.unsafeReceiverCast(receiver);
+                long longValue = UnsafeAccess.unsafeGetLong(base, getFieldOffset(), guard, this);
                 return (int) longValue;
             }
         }
-        return getIntUnexpected(store, expectedShape, guard);
+        return getIntUnexpected(receiver, expectedShape, guard);
     }
 
     /**
@@ -277,17 +280,18 @@ private int getIntUnexpected(DynamicObject store, Shape expectedShape, boolean g
      * @see #getInternal(DynamicObject, Shape, boolean)
      */
     final long getLongInternal(DynamicObject store, Shape expectedShape, boolean guard) throws UnexpectedResultException {
+        DynamicObject receiver = unsafeNonNullCast(store);
         if (isLongLocation()) {
             if (field == null) {
-                Object array = getPrimitiveArray(store, guard);
+                Object array = getPrimitiveArray(receiver, guard);
                 long offset = getPrimitiveArrayOffset();
                 return UnsafeAccess.unsafeGetLong(array, offset, guard, this);
             } else {
-                field.receiverCheck(store);
-                return UnsafeAccess.unsafeGetLong(store, getFieldOffset(), guard, this);
+                Object base = field.unsafeReceiverCast(receiver);
+                return UnsafeAccess.unsafeGetLong(base, getFieldOffset(), guard, this);
             }
         }
-        return getLongUnexpected(store, expectedShape, guard);
+        return getLongUnexpected(receiver, expectedShape, guard);
     }
 
     /**
@@ -303,18 +307,19 @@ private long getLongUnexpected(DynamicObject store, Shape expectedShape, boolean
      * @see #getInternal(DynamicObject, Shape, boolean)
      */
     final double getDoubleInternal(DynamicObject store, Shape expectedShape, boolean guard) throws UnexpectedResultException {
+        DynamicObject receiver = unsafeNonNullCast(store);
         if (isDoubleLocation()) {
             if (field == null) {
-                Object array = getPrimitiveArray(store, guard);
+                Object array = getPrimitiveArray(receiver, guard);
                 long offset = getPrimitiveArrayOffset();
                 return UnsafeAccess.unsafeGetDouble(array, offset, guard, this);
             } else {
-                field.receiverCheck(store);
-                long longValue = UnsafeAccess.unsafeGetLong(store, getFieldOffset(), guard, this);
+                Object base = field.unsafeReceiverCast(receiver);
+                long longValue = UnsafeAccess.unsafeGetLong(base, getFieldOffset(), guard, this);
                 return Double.longBitsToDouble(longValue);
             }
         }
-        return getDoubleUnexpected(store, expectedShape, guard);
+        return getDoubleUnexpected(receiver, expectedShape, guard);
     }
 
     /**
@@ -436,16 +441,19 @@ final void setDoubleSafe(DynamicObject store, double value, boolean guard, boole
      * Stores a value in this location. Grows the object if necessary. It is the caller's
      * responsibility to check that the value is compatible with this location first.
      *
-     * @param receiver storage object
+     * @param store storage object
      * @param value the value to be stored
      * @param guard the result of the shape check guarding this property write or {@code false}
      * @param oldShape the expected shape before the set
      * @param newShape the expected shape after the set
      * @see #canStoreValue(Object).
      */
-    final void setInternal(DynamicObject receiver, Object value, boolean guard, Shape oldShape, Shape newShape) {
+    @SuppressWarnings("hiding")
+    final void setInternal(DynamicObject store, Object value, boolean guard, Shape oldShape, Shape newShape) {
         assert canStoreValue(value) : value;
+        DynamicObject receiver = unsafeNonNullCast(store);
         long idx = Integer.toUnsignedLong(index);
+        FieldInfo field = this.field;
         boolean init = newShape != oldShape;
         if (init) {
             DynamicObjectSupport.grow(receiver, oldShape, newShape);
@@ -467,8 +475,7 @@ final void setInternal(DynamicObject receiver, Object value, boolean guard, Shap
                 offset = computeObjectArrayOffset(idx);
                 UnsafeAccess.unsafePutObject(base, offset, value, this);
             } else {
-                field.receiverCheck(receiver);
-                base = receiver;
+                base = field.unsafeReceiverCast(receiver);
                 offset = getFieldOffset();
                 UnsafeAccess.unsafePutObject(base, offset, value, this);
             }
@@ -519,9 +526,23 @@ final void setInternal(DynamicObject receiver, Object value, boolean guard, Shap
                 assert isConstantLocation() : this;
                 return;
             }
-            field.receiverCheck(receiver);
+            Object base = field.unsafeReceiverCast(receiver);
             long offset = getFieldOffset();
-            UnsafeAccess.unsafePutLong(receiver, offset, longValue, this);
+            UnsafeAccess.unsafePutLong(base, offset, longValue, this);
+        }
+    }
+
+    private static DynamicObject unsafeNonNullCast(DynamicObject receiver) {
+        /*
+         * The shape check already performs an implicit null check, so the receiver is guaranteed to
+         * be non-null here, but when compiling methods separately we might not know this yet.
+         * Hence, we use an unsafe cast in the interpreter to avoid compiling any null code paths.
+         * In PE OTOH, the redundant ValueAnchor+Pi would just mean extra work for the compiler.
+         */
+        if (CompilerDirectives.inCompiledCode() || ObjectStorageOptions.ReceiverCast) {
+            return receiver;
+        } else {
+            return UnsafeAccess.hostUnsafeCast(receiver, DynamicObject.class, false, true, false);
         }
     }
 
diff --git a/truffle/src/com.oracle.truffle.api.object/src/com/oracle/truffle/api/object/ObjectStorageOptions.java b/truffle/src/com.oracle.truffle.api.object/src/com/oracle/truffle/api/object/ObjectStorageOptions.java
@@ -47,6 +47,8 @@ final class ObjectStorageOptions {
     private ObjectStorageOptions() {
     }
 
+    static final boolean ASSERTIONS_ENABLED = assertionsEnabled();
+
     static final boolean PrimitiveLocations = booleanOption(OPTION_PREFIX + "PrimitiveLocations", true);
     static final boolean IntegerLocations = booleanOption(OPTION_PREFIX + "IntegerLocations", true);
     static final boolean DoubleLocations = booleanOption(OPTION_PREFIX + "DoubleLocations", true);
@@ -61,6 +63,10 @@ private ObjectStorageOptions() {
      * If set to true, use VarHandle rather than Unsafe to implement field accesses.
      */
     static final boolean UseVarHandle = booleanOption(OPTION_PREFIX + "UseVarHandle", false);
+    /**
+     * Enforce receiver type checks for unsafe field accesses.
+     */
+    static final boolean ReceiverCast = booleanOption(OPTION_PREFIX + "ReceiverCast", false) || ASSERTIONS_ENABLED;
 
     static final boolean TriePropertyMap = booleanOption(OPTION_PREFIX + "TriePropertyMap", true);
     static final boolean TrieTransitionMap = booleanOption(OPTION_PREFIX + "TrieTransitionMap", true);
@@ -94,4 +100,11 @@ static boolean booleanOption(String name, boolean defaultValue) {
         String value = System.getProperty(name);
         return value == null ? defaultValue : value.equalsIgnoreCase("true");
     }
+
+    @SuppressWarnings("all")
+    private static boolean assertionsEnabled() {
+        boolean enabled = false;
+        assert (enabled = true) == true;
+        return enabled;
+    }
 }
