[GR-68604] Backport to 25.0: Add intrinsic for TStringOps#runByteSwap.

PullRequest: graal/22186

Author: djoooooe

compiler/src/jdk.graal.compiler.test/src/jdk/graal/compiler/truffle/test/strings/TStringOpsByteSwapTest.java

@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) 2025, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package jdk.graal.compiler.truffle.test.strings;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+import jdk.graal.compiler.replacements.nodes.ArrayCopyWithConversionsNode;
+
+@RunWith(Parameterized.class)
+public class TStringOpsByteSwapTest extends TStringOpsTest<ArrayCopyWithConversionsNode> {
+
+    @Parameters(name = "{index}: args: {1}, {2}, {3}")
+    public static List<Object[]> data() {
+        ArrayList<Object[]> ret = new ArrayList<>();
+        int offsetBytes = 20;
+        int contentLength = 129;
+        byte[] src = new byte[1024];
+        for (int i = 0; i < src.length; i++) {
+            src[i] = (byte) i;
+        }
+        for (int stride = 1; stride <= 2; stride++) {
+            for (int fromIndexA : new int[]{0, 1, 7, 15}) {
+                for (int fromIndexB : new int[]{0, 1, 7, 15}) {
+                    for (int length : new int[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 15, 16, 17, 31, 32, 33, 47, 48, 49, 63, 64, 65, 127, 128, 129}) {
+                        if (fromIndexA + length < contentLength && fromIndexB + length < contentLength) {
+                            int offsetA = offsetBytes + (fromIndexA << stride);
+                            int offsetB = offsetBytes + (fromIndexB << stride);
+                            ret.add(new Object[]{src, offsetA, offsetB, length});
+                        }
+                    }
+                }
+            }
+        }
+        return ret;
+    }
+
+    final byte[] arrayA;
+    final long offsetA;
+    final long offsetB;
+    final int lengthCPY;
+
+    public TStringOpsByteSwapTest(byte[] arrayA, int offsetA, int offsetB, int lengthCPY) {
+        super(ArrayCopyWithConversionsNode.class);
+        this.arrayA = arrayA;
+        this.offsetA = offsetA + byteArrayBaseOffset();
+        this.offsetB = offsetB + byteArrayBaseOffset();
+        this.lengthCPY = lengthCPY;
+    }
+
+    @Test
+    public void testByteSwapS1() {
+        ArgSupplier arrayB = () -> new byte[(int) (128 + offsetB + (lengthCPY << 1) + 128)];
+        testWithNativeExcept(getByteSwapS1(), null, 1 << 3, DUMMY_LOCATION, arrayA, offsetA, arrayB, offsetB + 128, lengthCPY);
+    }
+
+    @Test
+    public void testByteSwapS2() {
+        ArgSupplier arrayB = () -> new byte[(int) (128 + offsetB + (lengthCPY << 2) + 128)];
+        testWithNativeExcept(getByteSwapS2(), null, 1 << 3, DUMMY_LOCATION, arrayA, offsetA, arrayB, offsetB + 128, lengthCPY);
+    }
+
+    @Override
+    protected void checkIntrinsicNode(ArrayCopyWithConversionsNode node) {
+        Assert.assertTrue(node.isReverseBytes());
+    }
+}

compiler/src/jdk.graal.compiler.test/src/jdk/graal/compiler/truffle/test/strings/TStringOpsTest.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021, 2024, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2021, 2025, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -98,6 +98,20 @@ protected void testWithNative(ResolvedJavaMethod method, Object receiver, Object
         testWithNativeExcept(method, receiver, 0, args);
     }
 
+    /**
+     * Runs the given test once as-is and once replacing all argument pairs of
+     * {@code (byte[], long)} with {@code (null, native-pointer)}.
+     * <p>
+     * In most TruffleString operations, {@code (byte[] array, long offset)} stands for a string's
+     * managed or native contents, where in the managed case, the byte array is a regular Java
+     * array, and the offset is a byte offset into the byte array. In the native case, the byte
+     * array is {@code null}, and the offset a pointer into native (off-heap) memory.
+     * <p>
+     * This test helper covers the native case for all {@code (byte[], long)} pairs, except for
+     * parameters that have been marked as excluded by setting their corresponding bit in the
+     * {@code ignore}-parameter: If e.g. {@code ignore == (1 << 3)}, the fourth parameter will not
+     * be replaced by a native pointer.
+     */
     protected void testWithNativeExcept(ResolvedJavaMethod method, Object receiver, long ignore, Object... args) {
         test(method, receiver, args);
         Object[] argsWithNative = Arrays.copyOf(args, args.length);
@@ -107,9 +121,8 @@ protected void testWithNativeExcept(ResolvedJavaMethod method, Object receiver,
             ResolvedJavaMethod.Parameter[] parameters = method.getParameters();
             Assert.assertTrue(parameters.length <= 64);
             for (int i = 0; i < parameters.length; i++) {
-                if (parameters[i].getType().getName().equals("[B") && (ignore & (1L << i)) == 0) {
+                if (parameters[i].getType().getName().equals("[B") && (ignore & (1L << i)) == 0 && i + 1 < parameters.length && parameters[i + 1].getType().getName().equals("J")) {
                     Assert.assertTrue(argsWithNative[i].toString(), argsWithNative[i] instanceof byte[]);
-                    Assert.assertEquals("J", parameters[i + 1].getType().getName());
                     byte[] array = (byte[]) argsWithNative[i];
                     byteBuffers[nByteBuffers] = ByteBuffer.allocateDirect(array.length);
                     long bufferAddress = getBufferAddress(byteBuffers[nByteBuffers++]);
@@ -144,6 +157,18 @@ protected ResolvedJavaMethod getArrayCopyWithStrideIB() {
                         byte[].class, long.class, int.class, int.class);
     }
 
+    protected ResolvedJavaMethod getByteSwapS1() {
+        return getTStringOpsMethod("byteSwapS1",
+                        byte[].class, long.class,
+                        byte[].class, long.class, int.class);
+    }
+
+    protected ResolvedJavaMethod getByteSwapS2() {
+        return getTStringOpsMethod("byteSwapS2",
+                        byte[].class, long.class,
+                        byte[].class, long.class, int.class);
+    }
+
     protected ResolvedJavaMethod getMemcmpWithStrideIntl() {
         return getTStringOpsMethod("memcmpWithStrideIntl",
                         byte[].class, long.class, int.class,

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/asm/aarch64/AArch64Assembler.java

@@ -134,6 +134,7 @@
 import static jdk.graal.compiler.asm.aarch64.AArch64Assembler.Instruction.ORR;
 import static jdk.graal.compiler.asm.aarch64.AArch64Assembler.Instruction.RBIT;
 import static jdk.graal.compiler.asm.aarch64.AArch64Assembler.Instruction.RET;
+import static jdk.graal.compiler.asm.aarch64.AArch64Assembler.Instruction.REV16;
 import static jdk.graal.compiler.asm.aarch64.AArch64Assembler.Instruction.REVW;
 import static jdk.graal.compiler.asm.aarch64.AArch64Assembler.Instruction.REVX;
 import static jdk.graal.compiler.asm.aarch64.AArch64Assembler.Instruction.RORV;
@@ -981,6 +982,7 @@ public enum Instruction {
         CLS(0x00001400),
         CLZ(0x00001000),
         RBIT(0x00000000),
+        REV16(0x00000400),
         REVX(0x00000C00),
         REVW(0x00000800),
 
@@ -3037,6 +3039,18 @@ public void rev(int size, Register dst, Register src) {
         }
     }
 
+    /**
+     * C6.2.223 Reverse bytes in 16-bit halfwords.
+     *
+     * @param size register size. Has to be 32 or 64.
+     * @param dst general purpose register. May not be null or the stackpointer.
+     * @param src source register. May not be null or the stackpointer.
+     */
+    public void rev16(int size, Register dst, Register src) {
+        assert verifySizeAndRegistersRR(size, dst, src);
+        dataProcessing1SourceOp(REV16, dst, src, generalFromSize(size));
+    }
+
     /* Conditional Data Processing (5.5.6) */
 
     /**

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/asm/amd64/AMD64Assembler.java

@@ -5710,6 +5710,11 @@ public final void roll(Register dst, int imm8) {
         AMD64Shift.ROL.miOp.emit(this, OperandSize.DWORD, dst, (byte) imm8);
     }
 
+    public final void rorl(Register dst, int imm8) {
+        GraalError.guarantee(isByte(imm8), "only byte immediate is supported");
+        AMD64Shift.ROR.miOp.emit(this, OperandSize.DWORD, dst, (byte) imm8);
+    }
+
     public final void rorq(Register dst, int imm8) {
         GraalError.guarantee(isByte(imm8), "only byte immediate is supported");
         AMD64Shift.ROR.miOp.emit(this, OperandSize.QWORD, dst, (byte) imm8);

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/asm/amd64/AMD64MacroAssembler.java

@@ -627,6 +627,10 @@ public final int testlAndJcc(Register src, int imm32, ConditionFlag cc, Label br
         return applyMIOpAndJcc(AMD64MIOp.TEST, OperandSize.DWORD, src, imm32, cc, branchTarget, isShortJmp, false, null);
     }
 
+    public final int testqAndJcc(Register src, int imm32, ConditionFlag cc, Label branchTarget, boolean isShortJmp) {
+        return applyMIOpAndJcc(AMD64MIOp.TEST, OperandSize.QWORD, src, imm32, cc, branchTarget, isShortJmp, false, null);
+    }
+
     public final int testAndJcc(OperandSize size, Register src1, Register src2, ConditionFlag cc, Label branchTarget, boolean isShortJmp) {
         AMD64RMOp op = size == OperandSize.BYTE ? AMD64RMOp.TESTB : AMD64RMOp.TEST;
         return applyRMOpAndJcc(op, size, src1, src2, cc, branchTarget, isShortJmp);

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/core/aarch64/AArch64LIRGenerator.java

@@ -55,8 +55,8 @@
 import jdk.graal.compiler.lir.aarch64.AArch64ArithmeticOp;
 import jdk.graal.compiler.lir.aarch64.AArch64ArrayCompareToOp;
 import jdk.graal.compiler.lir.aarch64.AArch64ArrayCopyWithConversionsOp;
-import jdk.graal.compiler.lir.aarch64.AArch64ArrayFillOp;
 import jdk.graal.compiler.lir.aarch64.AArch64ArrayEqualsOp;
+import jdk.graal.compiler.lir.aarch64.AArch64ArrayFillOp;
 import jdk.graal.compiler.lir.aarch64.AArch64ArrayIndexOfOp;
 import jdk.graal.compiler.lir.aarch64.AArch64ArrayRegionCompareToOp;
 import jdk.graal.compiler.lir.aarch64.AArch64AtomicMove;
@@ -622,16 +622,22 @@ public Variable emitArrayRegionCompareTo(EnumSet<?> runtimeCheckedCPUFeatures, V
 
     @Override
     public void emitArrayCopyWithConversion(Stride strideSrc, Stride strideDst, EnumSet<?> runtimeCheckedCPUFeatures, Value arraySrc, Value offsetSrc, Value arrayDst, Value offsetDst, Value length) {
-        append(new AArch64ArrayCopyWithConversionsOp(this, strideSrc, strideDst,
+        append(new AArch64ArrayCopyWithConversionsOp(this, strideSrc, strideDst, false,
                         emitConvertNullToZero(arrayDst), asAllocatable(offsetDst), emitConvertNullToZero(arraySrc), asAllocatable(offsetSrc), asAllocatable(length), null));
     }
 
     @Override
     public void emitArrayCopyWithConversion(EnumSet<?> runtimeCheckedCPUFeatures, Value arraySrc, Value offsetSrc, Value arrayDst, Value offsetDst, Value length, Value dynamicStrides) {
-        append(new AArch64ArrayCopyWithConversionsOp(this, null, null,
+        append(new AArch64ArrayCopyWithConversionsOp(this, null, null, false,
                         emitConvertNullToZero(arrayDst), asAllocatable(offsetDst), emitConvertNullToZero(arraySrc), asAllocatable(offsetSrc), asAllocatable(length), asAllocatable(dynamicStrides)));
     }
 
+    @Override
+    public void emitArrayCopyWithReverseBytes(Stride stride, EnumSet<?> runtimeCheckedCPUFeatures, Value arraySrc, Value offsetSrc, Value arrayDst, Value offsetDst, Value length) {
+        append(new AArch64ArrayCopyWithConversionsOp(this, stride, stride, true,
+                        emitConvertNullToZero(arrayDst), asAllocatable(offsetDst), emitConvertNullToZero(arraySrc), asAllocatable(offsetSrc), asAllocatable(length), null));
+    }
+
     @Override
     public void emitArrayFill(JavaKind kind, Value array, Value arrayBaseOffset, Value length, Value value) {
         append(new AArch64ArrayFillOp(kind, emitConvertNullToZero(array), asAllocatable(arrayBaseOffset), asAllocatable(length), asAllocatable(value)));

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/core/amd64/AMD64LIRGenerator.java

@@ -881,6 +881,12 @@ public void emitArrayCopyWithConversion(EnumSet<?> runtimeCheckedCPUFeatures,
                         ZERO_EXTEND));
     }
 
+    @SuppressWarnings("unchecked")
+    @Override
+    public void emitArrayCopyWithReverseBytes(Stride stride, EnumSet<?> runtimeCheckedCPUFeatures, Value arraySrc, Value offsetSrc, Value arrayDst, Value offsetDst, Value length) {
+        append(AMD64ArrayCopyWithConversionsOp.movParamsAndCreateReverseBytes(this, stride, (EnumSet<CPUFeature>) runtimeCheckedCPUFeatures, arraySrc, offsetSrc, arrayDst, offsetDst, length));
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public Variable emitCalcStringAttributes(CalcStringAttributesEncoding encoding, EnumSet<?> runtimeCheckedCPUFeatures,