[GR-34193] Espresso in the browser

PullRequest: graal/22515

Author: patrick96

substratevm/src/com.oracle.svm.truffle/src/com/oracle/svm/truffle/TruffleBaseFeature.java

@@ -1253,7 +1253,9 @@ private static Class<?> loadClass(String name) {
 
         private static final class StaticObjectPodBasedSupport {
             static void onBuildInvocation(Class<?> storageSuperClass, Class<?> factoryInterface) {
-                PodSupport.singleton().registerSuperclass(storageSuperClass, factoryInterface);
+                if (PodSupport.isPresent()) {
+                    PodSupport.singleton().registerSuperclass(storageSuperClass, factoryInterface);
+                }
             }
 
         }

web-image/src/com.oracle.svm.hosted.webimage/src/com/oracle/svm/hosted/webimage/codegen/WebImageCodeGen.java

@@ -396,7 +396,7 @@ private void doEmitJSFile() {
 
             codeBuffer.emitText(codeGenTool.vmClassName() + ".");
             WebImageEntryFunctionLowerer.FUNCTION.emitCall(codeGenTool, Emitter.of("load_cmd_args()"), Emitter.of("config"));
-            codeBuffer.emitText(".catch(console.error)");
+            codeBuffer.emitText(".catch(e => { console.error(e); throw e; })");
 
             codeBuffer.emitInsEnd();
         } else {

web-image/src/com.oracle.svm.hosted.webimage/src/com/oracle/svm/hosted/webimage/wasmgc/WasmGCUnalignedUnsafeSupport.java

@@ -27,6 +27,7 @@
 
 import static jdk.graal.compiler.core.common.spi.ForeignCallDescriptor.CallSideEffect.HAS_SIDE_EFFECT;
 
+import java.lang.reflect.Array;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -106,29 +107,40 @@ public static byte readArrayByte(Object o, long offset) {
         int scaledOffset = getScaledOffset(o, offset);
         int indexScale = getArrayIndexScale(o);
         int index = scaledOffset / indexScale;
-        /*
-         * The raw bits read from the array expanded to a long. The indexScale number of least
-         * significant bytes contain the actual data, the rest is not relevant.
-         */
-        long longBits = switch (o) {
-            case boolean[] bools -> bools[index] ? 1 : 0;
-            case byte[] bytes -> bytes[index];
-            case short[] shorts -> shorts[index];
-            case char[] chars -> chars[index];
-            case int[] ints -> ints[index];
-            case long[] longs -> longs[index];
-            case float[] floats -> Float.floatToRawIntBits(floats[index]);
-            case double[] doubles -> Double.doubleToRawLongBits(doubles[index]);
-            default -> {
-                if (WasmGCUnsafeSupport.includeErrorMessage()) {
-                    WasmGCUnsafeSupport.fatalAccessError(o, "Unsupported type for unaligned array access", offset, true);
+        if (inWordRemainder(o, offset)) {
+            return 0;
+        }
+        try {
+            /*
+             * The raw bits read from the array expanded to a long. The indexScale number of least
+             * significant bytes contain the actual data, the rest is not relevant.
+             */
+            long longBits = switch (o) {
+                case boolean[] bools -> bools[index] ? 1 : 0;
+                case byte[] bytes -> bytes[index];
+                case short[] shorts -> shorts[index];
+                case char[] chars -> chars[index];
+                case int[] ints -> ints[index];
+                case long[] longs -> longs[index];
+                case float[] floats -> Float.floatToRawIntBits(floats[index]);
+                case double[] doubles -> Double.doubleToRawLongBits(doubles[index]);
+                default -> {
+                    if (WasmGCUnsafeSupport.includeErrorMessage()) {
+                        WasmGCUnsafeSupport.fatalAccessError(o, "Unsupported type for unaligned array access", offset, true);
+                    }
+                    throw new UnsupportedOperationException();
                 }
-                throw new UnsupportedOperationException();
+            };
+
+            int rightShift = 8 * elementByteOffset(scaledOffset, indexScale);
+            return (byte) (longBits >> rightShift);
+        } catch (ArrayIndexOutOfBoundsException e) {
+            if (WasmGCUnsafeSupport.includeErrorMessage()) {
+                WasmGCUnsafeSupport.fatalAccessError(o, e.toString(), offset, true);
             }
-        };
 
-        int rightShift = 8 * elementByteOffset(scaledOffset, indexScale);
-        return (byte) (longBits >> rightShift);
+            throw e;
+        }
     }
 
     @SubstrateForeignCallTarget(stubCallingConvention = false)
@@ -208,21 +220,35 @@ public static void writeArrayByte(Object o, long offset, byte value) {
         int index = scaledOffset / indexScale;
         // Byte offset within the array element value
         int valueOffset = elementByteOffset(scaledOffset, indexScale);
-        switch (o) {
-            case boolean[] bools -> bools[index] = value != 0;
-            case byte[] bytes -> bytes[index] = value;
-            case short[] shorts -> shorts[index] = (short) setByte(shorts[index], valueOffset, value);
-            case char[] chars -> chars[index] = (char) setByte(chars[index], valueOffset, value);
-            case int[] ints -> ints[index] = (int) setByte(ints[index], valueOffset, value);
-            case long[] longs -> longs[index] = setByte(longs[index], valueOffset, value);
-            case float[] floats -> floats[index] = Float.intBitsToFloat((int) setByte(Float.floatToRawIntBits(floats[index]), valueOffset, value));
-            case double[] doubles -> doubles[index] = Double.longBitsToDouble(setByte(Double.doubleToRawLongBits(doubles[index]), valueOffset, value));
-            default -> {
-                if (WasmGCUnsafeSupport.includeErrorMessage()) {
-                    WasmGCUnsafeSupport.fatalAccessError(o, "Unsupported type for unaligned array access", offset, true);
+
+        if (inWordRemainder(o, offset)) {
+            return;
+        }
+        try {
+            switch (o) {
+                case boolean[] bools -> bools[index] = value != 0;
+                case byte[] bytes -> bytes[index] = value;
+                case short[] shorts -> shorts[index] = (short) setByte(shorts[index], valueOffset, value);
+                case char[] chars -> chars[index] = (char) setByte(chars[index], valueOffset, value);
+                case int[] ints -> ints[index] = (int) setByte(ints[index], valueOffset, value);
+                case long[] longs -> longs[index] = setByte(longs[index], valueOffset, value);
+                case float[] floats ->
+                    floats[index] = Float.intBitsToFloat((int) setByte(Float.floatToRawIntBits(floats[index]), valueOffset, value));
+                case double[] doubles ->
+                    doubles[index] = Double.longBitsToDouble(setByte(Double.doubleToRawLongBits(doubles[index]), valueOffset, value));
+                default -> {
+                    if (WasmGCUnsafeSupport.includeErrorMessage()) {
+                        WasmGCUnsafeSupport.fatalAccessError(o, "Unsupported type for unaligned array access", offset, false);
+                    }
+                    throw new UnsupportedOperationException();
                 }
-                throw new UnsupportedOperationException();
             }
+        } catch (ArrayIndexOutOfBoundsException e) {
+            if (WasmGCUnsafeSupport.includeErrorMessage()) {
+                WasmGCUnsafeSupport.fatalAccessError(o, e.toString(), offset, false);
+            }
+
+            throw e;
         }
     }
 
@@ -343,4 +369,23 @@ private static int getArrayBaseOffset(JavaKind kind) {
     private static int getArrayIndexScale(JavaKind kind) {
         return ImageSingletons.lookup(ObjectLayout.class).getArrayIndexScale(kind);
     }
+
+    /**
+     * Detect out of bounds access that is still within the same 4-byte aligned 4-byte word as the
+     * last element. Such accesses are usually undefined behaviour, but to not produce unexpected
+     * behavior (i.e. a crash), out of bounds accesses where this method returns {@code true} should
+     * not crash and just return an arbitrary value and ignore any writes.
+     * <p>
+     * {@code jdk.internal.misc.Unsafe#compareAndExchangeByte} uses int accesses that may go out of
+     * bounds and does not expect a crash in that case, though it ignores the out-of-bounds bytes.
+     * For example, there might be an int access at the first element of a 1-element byte array.
+     *
+     */
+    private static boolean inWordRemainder(Object o, long offset) {
+        int scaledOffset = getScaledOffset(o, offset);
+        int indexScale = getArrayIndexScale(o);
+        int index = scaledOffset / indexScale;
+        int length = Array.getLength(o);
+        return index >= length && scaledOffset < ((index * indexScale + 4) & ~0x03);
+    }
 }