Omit receiver type check and hoist field read.

woess · woess · commit dcd86f369e95 · 2025-11-14T14:31:52.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.ReceiverCheck) {
+            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
@@ -43,6 +43,8 @@
 import java.util.Objects;
 import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
 
+import org.graalvm.nativeimage.ImageInfo;
+
 import com.oracle.truffle.api.Assumption;
 import com.oracle.truffle.api.CompilerAsserts;
 import com.oracle.truffle.api.CompilerDirectives;
@@ -201,26 +203,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;
-                offset = getFieldOffset();
+                base = field.unsafeReceiverCast(receiver);
+                offset = field.offset();
                 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 +233,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, field.offset(), guard, this);
                 if (this instanceof IntLocation) {
                     return (int) longValue;
                 } else if (this instanceof LongLocation) {
@@ -250,18 +254,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, field.offset(), guard, this);
                 return (int) longValue;
             }
         }
-        return getIntUnexpected(store, expectedShape, guard);
+        return getIntUnexpected(receiver, expectedShape, guard);
     }
 
     /**
@@ -277,17 +282,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, field.offset(), guard, this);
             }
         }
-        return getLongUnexpected(store, expectedShape, guard);
+        return getLongUnexpected(receiver, expectedShape, guard);
     }
 
     /**
@@ -303,18 +309,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, field.offset(), guard, this);
                 return Double.longBitsToDouble(longValue);
             }
         }
-        return getDoubleUnexpected(store, expectedShape, guard);
+        return getDoubleUnexpected(receiver, expectedShape, guard);
     }
 
     /**
@@ -436,16 +443,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,9 +477,8 @@ 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;
-                offset = getFieldOffset();
+                base = field.unsafeReceiverCast(receiver);
+                offset = field.offset();
                 UnsafeAccess.unsafePutObject(base, offset, value, this);
             }
         } else { // primitive location
@@ -519,9 +528,9 @@ final void setInternal(DynamicObject receiver, Object value, boolean guard, Shap
                 assert isConstantLocation() : this;
                 return;
             }
-            field.receiverCheck(receiver);
-            long offset = getFieldOffset();
-            UnsafeAccess.unsafePutLong(receiver, offset, longValue, this);
+            Object base = field.unsafeReceiverCast(receiver);
+            long offset = field.offset();
+            UnsafeAccess.unsafePutLong(base, offset, longValue, this);
         }
     }
 
@@ -773,6 +782,20 @@ static Object getPrimitiveArray(DynamicObject store, boolean condition) {
         return UnsafeAccess.hostUnsafeCast(store.getPrimitiveStore(), int[].class, condition, true, true);
     }
 
+    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.inInterpreter() && !ObjectStorageOptions.ReceiverCheck && ImageInfo.inImageCode()) {
+            return UnsafeAccess.hostUnsafeCast(receiver, DynamicObject.class, false, true, false);
+        } else {
+            return receiver;
+        }
+    }
+
     static RuntimeException incompatibleLocationException() {
         CompilerDirectives.transferToInterpreterAndInvalidate();
         throw UncheckedIncompatibleLocationException.instance();
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 ReceiverCheck = booleanOption(OPTION_PREFIX + "ReceiverCheck", 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;
+    }
 }
