Use VarHandle and ByteArraySupport to read/write i16/i32/i64 values.

Author: woess

wasm/src/org.graalvm.wasm/src/org/graalvm/wasm/BinaryStreamParser.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, 2024, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2019, 2025, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * The Universal Permissive License (UPL), Version 1.0
@@ -42,19 +42,28 @@
 
 import static com.oracle.truffle.api.nodes.ExplodeLoop.LoopExplosionKind.FULL_EXPLODE_UNTIL_RETURN;
 
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.VarHandle;
+import java.nio.ByteOrder;
+import java.util.Arrays;
+
 import org.graalvm.wasm.constants.GlobalModifier;
 import org.graalvm.wasm.exception.Failure;
 import org.graalvm.wasm.exception.WasmException;
 
+import com.oracle.truffle.api.CompilerDirectives;
 import com.oracle.truffle.api.CompilerDirectives.CompilationFinal;
+import com.oracle.truffle.api.memory.ByteArraySupport;
 import com.oracle.truffle.api.nodes.ExplodeLoop;
 
-import java.util.Arrays;
-
 public abstract class BinaryStreamParser {
     protected static final int SINGLE_RESULT_VALUE = 0;
     protected static final int MULTI_RESULT_VALUE = 1;
 
+    private static final VarHandle I16LE = MethodHandles.byteArrayViewVarHandle(short[].class, ByteOrder.LITTLE_ENDIAN);
+    private static final VarHandle I32LE = MethodHandles.byteArrayViewVarHandle(int[].class, ByteOrder.LITTLE_ENDIAN);
+    private static final VarHandle I64LE = MethodHandles.byteArrayViewVarHandle(long[].class, ByteOrder.LITTLE_ENDIAN);
+
     @CompilationFinal(dimensions = 1) protected byte[] data;
     protected int offset;
 
@@ -353,7 +362,7 @@ public static byte peekLeb128Length(byte[] data, int initialOffset) {
 
     /**
      * Reads the unsigned byte value at the given bytecode offset.
-     * 
+     *
      * @param bytecode The bytecode
      * @param offset The offset in the bytecode
      * @return the unsigned byte value at the given bytecode offset.
@@ -364,7 +373,7 @@ public static int rawPeekU8(byte[] bytecode, int offset) {
 
     /**
      * Reads the signed byte value at the given bytecode offset.
-     * 
+     *
      * @param bytecode The bytecode
      * @param offset The offset in the bytecode
      * @return The signed byte value at the given bytecode offset.
@@ -375,27 +384,38 @@ public static byte rawPeekI8(byte[] bytecode, int offset) {
 
     /**
      * Reads the unsigned short value at the given bytecode offset.
-     * 
+     *
      * @param bytecode The bytecode
      * @param offset The offset in the bytecode
      * @return The unsigned short value at the given bytecode offset.
      */
     public static int rawPeekU16(byte[] bytecode, int offset) {
-        return ((bytecode[offset] & 0xFF) | ((bytecode[offset + 1] & 0xFF) << 8));
+        return Short.toUnsignedInt(rawPeekI16(bytecode, offset));
+    }
+
+    /**
+     * Reads the signed short value at the given bytecode offset.
+     *
+     * @param bytecode The bytecode
+     * @param offset The offset in the bytecode
+     * @return The signed short value at the given bytecode offset.
+     */
+    public static short rawPeekI16(byte[] bytecode, int offset) {
+        if (CompilerDirectives.inCompiledCode()) {
+            return ByteArraySupport.littleEndian().getShortUnaligned(bytecode, offset);
+        }
+        return (short) I16LE.get(bytecode, offset);
     }
 
     /**
      * Writes the unsigned short value to the given bytecode offset.
-     * 
+     *
      * @param bytecode The bytecode
      * @param offset The offset in the bytecode
      * @param value The value that should be written
      */
     public static void writeU16(byte[] bytecode, int offset, int value) {
-        final byte low = (byte) (value & 0xFF);
-        final byte high = (byte) ((value >> 8) & 0xFF);
-        bytecode[offset] = low;
-        bytecode[offset + 1] = high;
+        I16LE.set(bytecode, offset, (short) value);
     }
 
     /**
@@ -406,60 +426,46 @@ public static void writeU16(byte[] bytecode, int offset, int value) {
      * @return The unsigned integer value at the given bytecode offset.
      */
     public static long rawPeekU32(byte[] bytecode, int offset) {
-        return (bytecode[offset] & 0xFFL) |
-                        ((bytecode[offset + 1] & 0xFFL) << 8) |
-                        ((bytecode[offset + 2] & 0xFFL) << 16) |
-                        ((bytecode[offset + 3] & 0xFFL) << 24);
+        return Integer.toUnsignedLong(rawPeekI32(bytecode, offset));
     }
 
     /**
      * Reads the signed integer value at the given bytecode offset.
-     * 
+     *
      * @param bytecode The bytecode
      * @param offset The offset in the bytecode.
      * @return The signed integer value at the given bytecode offset.
      */
     public static int rawPeekI32(byte[] bytecode, int offset) {
-        return (bytecode[offset] & 0xFF) |
-                        ((bytecode[offset + 1] & 0xFF) << 8) |
-                        ((bytecode[offset + 2] & 0xFF) << 16) |
-                        ((bytecode[offset + 3] & 0xFF) << 24);
+        if (CompilerDirectives.inCompiledCode()) {
+            return ByteArraySupport.littleEndian().getIntUnaligned(bytecode, offset);
+        }
+        return (int) I32LE.get(bytecode, offset);
     }
 
     /**
      * Reads the signed long value at the given bytecode offset.
-     * 
+     *
      * @param bytecode The bytecode
      * @param offset The offset in the bytecode.
      * @return The signed long value at the given bytecode offset.
      */
     public static long rawPeekI64(byte[] bytecode, int offset) {
-        return (bytecode[offset] & 0xFFL) |
-                        ((bytecode[offset + 1] & 0xFFL) << 8) |
-                        ((bytecode[offset + 2] & 0xFFL) << 16) |
-                        ((bytecode[offset + 3] & 0xFFL) << 24) |
-                        ((bytecode[offset + 4] & 0xFFL) << 32) |
-                        ((bytecode[offset + 5] & 0xFFL) << 40) |
-                        ((bytecode[offset + 6] & 0xFFL) << 48) |
-                        ((bytecode[offset + 7] & 0xFFL) << 56);
+        if (CompilerDirectives.inCompiledCode()) {
+            return ByteArraySupport.littleEndian().getLongUnaligned(bytecode, offset);
+        }
+        return (long) I64LE.get(bytecode, offset);
     }
 
     /**
      * Writes the signed long value to the given bytecode offset.
-     * 
+     *
      * @param bytecode The bytecode
      * @param offset The offset in the bytecode
      * @param value The value that should be written
      */
     public static void writeI64(byte[] bytecode, int offset, long value) {
-        bytecode[offset] = (byte) (value & 0xFF);
-        bytecode[offset + 1] = (byte) ((value >> 8) & 0xFF);
-        bytecode[offset + 2] = (byte) ((value >> 16) & 0xFF);
-        bytecode[offset + 3] = (byte) ((value >> 24) & 0xFF);
-        bytecode[offset + 4] = (byte) ((value >> 32) & 0xFF);
-        bytecode[offset + 5] = (byte) ((value >> 40) & 0xFF);
-        bytecode[offset + 6] = (byte) ((value >> 48) & 0xFF);
-        bytecode[offset + 7] = (byte) ((value >> 56) & 0xFF);
+        I64LE.set(bytecode, offset, value);
     }
 
     /**