riscv64: SystemArrayCopyChar/Int/Byte intrinsic

Implemented SystemArrayCopy for primitive types (Char, Int, Byte).
Used unrolling by 16 bytes for optimization.

Also add additional tests for ArrayCopy intrinsic

Test: testrunner.py --target --no-prebuild --jit-on-first-use --64
Change-Id: I60f59b8b6eb164c9daf0a61c669de1606712ad09

4 files changed, 487 insertions, 0 deletions

diff --git a/test/011-array-copy2/expected-stderr.txt b/test/011-array-copy2/expected-stderr.txt
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/test/011-array-copy2/expected-stderr.txt
diff --git a/test/011-array-copy2/expected-stdout.txt b/test/011-array-copy2/expected-stdout.txt
new file mode 100644
index 0000000000..203323f75a
--- /dev/null
+++ b/test/011-array-copy2/expected-stdout.txt
@@ -0,0 +1,3 @@
+[ByteArrayTests]: passed
+[CharArrayTests]: passed
+[IntArrayTests]: passed
diff --git a/test/011-array-copy2/info.txt b/test/011-array-copy2/info.txt
new file mode 100644
index 0000000000..540486c134
--- /dev/null
+++ b/test/011-array-copy2/info.txt
@@ -0,0 +1 @@
+Test additional corner cases of SystemArrayCopy.
diff --git a/test/011-array-copy2/src/Main.java b/test/011-array-copy2/src/Main.java
new file mode 100644
index 0000000000..fd8f9a1451
--- /dev/null
+++ b/test/011-array-copy2/src/Main.java
@@ -0,0 +1,483 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class Main {
+
+    private static class ByteArrayTests {
+        public static byte[] init(byte[] arr) {
+            for (byte i = 0; i < arr.length; i++) {
+                arr[i] = (byte) i;
+            }
+            return arr;
+        }
+
+        public static void assertEquals(int expected, int actual) {
+            if (expected != actual) {
+                throw new Error("Expected " + expected + ", got " + actual);
+            }
+        }
+
+        public static byte[] createArrayOfZeroes(int size) {
+            byte[] arr = new byte[size];
+            return arr;
+        }
+
+        public static byte[] createIncrementedArray(int size) {
+            byte[] arr = new byte[size];
+            init(arr);
+            return arr;
+        }
+
+        public static void checkIncrementedArray(byte[] dst) {
+            for (byte i = 0; i < dst.length; i++) {
+                assertEquals(i, dst[i]);
+            }
+        }
+
+        public static void $noinline$test1(byte[] src, byte[] dst) {
+            System.arraycopy(src, 0, dst, 0, 15);
+        }
+
+        public static void $noinline$test2(byte[] src, byte[] dst) {
+            System.arraycopy(src, 0, dst, 0, 127);
+        }
+
+        public static byte[] $noinline$test3() {
+            byte size = 15;
+            byte[] src = new byte[size];
+            src = init(src);
+            byte[] dst = new byte[size];
+
+            System.arraycopy(src, 0, dst, 0, size);
+            return dst;
+        }
+
+        public static byte[] $noinline$test4() {
+            int size = 127;
+            byte[] src = new byte[size];
+            src = init(src);
+            byte[] dst = new byte[size];
+
+            System.arraycopy(src, 0, dst, 0, size);
+            return dst;
+        }
+
+        public static byte[] $noinline$test5() {
+            byte[] src = new byte[80];
+            src = init(src);
+            byte[] dst = new byte[80];
+
+            System.arraycopy(src, 0, dst, 0, 80);
+            return dst;
+        }
+
+        public static byte[] $noinline$test6() {
+            byte[] src = new byte[127];
+            src = init(src);
+            byte[] dst = new byte[127];
+
+            System.arraycopy(src, 0, dst, 100, 27);
+            return dst;
+        }
+        public static void check6(byte[] dst) {
+            for (byte i = 0; i < 100; i++) {
+                assertEquals(0, dst[i]);
+            }
+            for (byte i = 100; i < 127; i++) {
+                assertEquals(i - 100, dst[i]);
+            }
+        }
+
+        public static byte[] $noinline$test7() {
+            byte[] src = new byte[127];
+            src = init(src);
+
+            System.arraycopy(src, 0, src, 100, 27);
+            return src;
+        }
+        public static void check7(byte[] dst) {
+            for (byte i = 0; i < 100; i++) {
+                assertEquals(i, dst[i]);
+            }
+            for (byte i = 100; i < 127; i++) {
+                assertEquals(i - 100, dst[i]);
+            }
+        }
+
+        public static byte[] $noinline$test8() {
+            byte[] src = new byte[127];
+            src = init(src);
+
+            System.arraycopy(src, 100, src, 0, 27);
+            return src;
+        }
+        public static void check8(byte[] dst) {
+            for (byte i = 0; i < 27; i++) {
+                assertEquals(100 + i, dst[i]);
+            }
+            for (byte i = 27; i < 127; i++) {
+                assertEquals(i, dst[i]);
+            }
+        }
+
+        public static void $noinline$test9(byte[] src, byte[] dst, byte i) {
+            System.arraycopy(src, 0, dst, 0, i);
+        }
+
+        public static void runTests() {
+            System.out.print("[ByteArrayTests]: ");
+
+            byte[] src15 = createIncrementedArray(15);
+            byte[] dst15 = createArrayOfZeroes(15);
+            $noinline$test1(src15, dst15);
+            checkIncrementedArray(dst15);
+
+            byte[] src150 = createIncrementedArray(127);
+            byte[] dst150 = createArrayOfZeroes(127);
+            $noinline$test2(src150, dst150);
+            checkIncrementedArray(dst150);
+
+            checkIncrementedArray($noinline$test3());
+            checkIncrementedArray($noinline$test4());
+            checkIncrementedArray($noinline$test5());
+
+            check6($noinline$test6());
+            check7($noinline$test7());
+            check8($noinline$test8());
+
+            for (byte i = 1; i < 127; i++) {
+                byte[] src = createIncrementedArray(i);
+                byte[] dst = createArrayOfZeroes(i);
+                $noinline$test9(src, dst, i);
+                checkIncrementedArray(dst);
+            }
+            System.out.println("passed");
+        }
+    }
+
+    private static class CharArrayTests {
+
+        public static char[] init(char[] arr) {
+            for (int i = 0; i < arr.length; i++) {
+                arr[i] = (char) i;
+            }
+            return arr;
+        }
+
+        public static void assertEquals(int expected, int actual) {
+            if (expected != actual) {
+                throw new Error("Expected " + expected + ", got " + actual);
+            }
+        }
+
+        public static char[] createArrayOfZeroes(int size) {
+            char[] arr = new char[size];
+            return arr;
+        }
+
+        public static char[] createIncrementedArray(int size) {
+            char[] arr = new char[size];
+            init(arr);
+            return arr;
+        }
+
+        public static void checkIncrementedArray(char[] dst) {
+            for (int i = 0; i < dst.length; i++) {
+                assertEquals(i, dst[i]);
+            }
+        }
+
+        public static void $noinline$test1(char[] src, char[] dst) {
+            System.arraycopy(src, 0, dst, 0, 15);
+        }
+
+        public static void $noinline$test2(char[] src, char[] dst) {
+            System.arraycopy(src, 0, dst, 0, 150);
+        }
+
+        public static char[] $noinline$test3() {
+            int size = 15;
+            char[] src = new char[size];
+            src = init(src);
+            char[] dst = new char[size];
+
+            System.arraycopy(src, 0, dst, 0, size);
+            return dst;
+        }
+
+        public static char[] $noinline$test4() {
+            int size = 150;
+            char[] src = new char[size];
+            src = init(src);
+            char[] dst = new char[size];
+
+            System.arraycopy(src, 0, dst, 0, size);
+            return dst;
+        }
+
+        public static char[] $noinline$test5() {
+            char[] src = new char[80];
+            src = init(src);
+            char[] dst = new char[80];
+
+            System.arraycopy(src, 0, dst, 0, 80);
+            return dst;
+        }
+
+        public static char[] $noinline$test6() {
+            char[] src = new char[150];
+            src = init(src);
+            char[] dst = new char[150];
+
+            System.arraycopy(src, 0, dst, 100, 50);
+            return dst;
+        }
+        public static void check6(char[] dst) {
+            for (int i = 0; i < 100; i++) {
+                assertEquals(0, dst[i]);
+            }
+            for (int i = 100; i < 150; i++) {
+                assertEquals(i-100, dst[i]);
+            }
+        }
+
+        public static char[] $noinline$test7() {
+            char[] src = new char[150];
+            src = init(src);
+
+            System.arraycopy(src, 0, src, 100, 50);
+            return src;
+        }
+        public static void check7(char[] dst) {
+            for (int i = 0; i < 100; i++) {
+                assertEquals(i, dst[i]);
+            }
+            for (int i = 100; i < 150; i++) {
+                assertEquals(i - 100, dst[i]);
+            }
+        }
+
+        public static char[] $noinline$test8() {
+            char[] src = new char[150];
+            src = init(src);
+
+            System.arraycopy(src, 100, src, 0, 50);
+            return src;
+        }
+        public static void check8(char[] dst) {
+            for (int i = 0; i < 50; i++) {
+                assertEquals(100 + i, dst[i]);
+            }
+            for (int i = 50; i < 150; i++) {
+                assertEquals(i, dst[i]);
+            }
+        }
+
+        public static void $noinline$test9(char[] src, char[] dst, int i) {
+            System.arraycopy(src, 0, dst, 0, i);
+        }
+
+        public static void runTests() {
+            System.out.print("[CharArrayTests]: ");
+
+            char[] src15 = createIncrementedArray(15);
+            char[] dst15 = createArrayOfZeroes(15);
+            $noinline$test1(src15, dst15);
+            checkIncrementedArray(dst15);
+
+            char[] src150 = createIncrementedArray(150);
+            char[] dst150 = createArrayOfZeroes(150);
+            $noinline$test2(src150, dst150);
+            checkIncrementedArray(dst150);
+
+            checkIncrementedArray($noinline$test3());
+            checkIncrementedArray($noinline$test4());
+            checkIncrementedArray($noinline$test5());
+
+            check6($noinline$test6());
+            check7($noinline$test7());
+            check8($noinline$test8());
+
+            for (int i = 1; i < 256; i++) {
+                char[] src = createIncrementedArray(i);
+                char[] dst = createArrayOfZeroes(i);
+                $noinline$test9(src, dst, i);
+                checkIncrementedArray(dst);
+            }
+
+            System.out.println("passed");
+        }
+    }
+
+    private static class IntArrayTests {
+        public static int[] init(int[] arr) {
+            for (int i = 0; i < arr.length; i++) {
+                arr[i] = (int) i;
+            }
+            return arr;
+        }
+
+        public static void assertEquals(int expected, int actual) {
+            if (expected != actual) {
+                throw new Error("Expected " + expected + ", got " + actual);
+            }
+        }
+
+        public static int[] createArrayOfZeroes(int size) {
+            int[] arr = new int[size];
+            return arr;
+        }
+
+        public static int[] createIncrementedArray(int size) {
+            int[] arr = new int[size];
+            init(arr);
+            return arr;
+        }
+
+        public static void checkIncrementedArray(int[] dst) {
+            for (int i = 0; i < dst.length; i++) {
+                assertEquals(i, dst[i]);
+            }
+        }
+
+        public static void $noinline$test1(int[] src, int[] dst) {
+            System.arraycopy(src, 0, dst, 0, 15);
+        }
+
+        public static void $noinline$test2(int[] src, int[] dst) {
+            System.arraycopy(src, 0, dst, 0, 150);
+        }
+
+        public static int[] $noinline$test3() {
+            int size = 15;
+            int[] src = new int[size];
+            src = init(src);
+            int[] dst = new int[size];
+
+            System.arraycopy(src, 0, dst, 0, size);
+            return dst;
+        }
+
+        public static int[] $noinline$test4() {
+            int size = 150;
+            int[] src = new int[size];
+            src = init(src);
+            int[] dst = new int[size];
+
+            System.arraycopy(src, 0, dst, 0, size);
+            return dst;
+        }
+
+        public static int[] $noinline$test5() {
+            int[] src = new int[80];
+            src = init(src);
+            int[] dst = new int[80];
+
+            System.arraycopy(src, 0, dst, 0, 80);
+            return dst;
+        }
+
+        public static int[] $noinline$test6() {
+            int[] src = new int[150];
+            src = init(src);
+            int[] dst = new int[150];
+
+            System.arraycopy(src, 0, dst, 100, 50);
+            return dst;
+        }
+        public static void check6(int[] dst) {
+            for (int i = 0; i < 100; i++) {
+                assertEquals(0, dst[i]);
+            }
+            for (int i = 100; i < 150; i++) {
+                assertEquals(i-100, dst[i]);
+            }
+        }
+
+        public static int[] $noinline$test7() {
+            int[] src = new int[150];
+            src = init(src);
+
+            System.arraycopy(src, 0, src, 100, 50);
+            return src;
+        }
+        public static void check7(int[] dst) {
+            for (int i = 0; i < 100; i++) {
+                assertEquals(i, dst[i]);
+            }
+            for (int i = 100; i < 150; i++) {
+                assertEquals(i - 100, dst[i]);
+            }
+        }
+
+        public static int[] $noinline$test8() {
+            int[] src = new int[150];
+            src = init(src);
+
+            System.arraycopy(src, 100, src, 0, 50);
+            return src;
+        }
+        public static void check8(int[] dst) {
+            for (int i = 0; i < 50; i++) {
+                assertEquals(100 + i, dst[i]);
+            }
+            for (int i = 50; i < 150; i++) {
+                assertEquals(i, dst[i]);
+            }
+        }
+
+        public static void $noinline$test9(int[] src, int[] dst, int i) {
+            System.arraycopy(src, 0, dst, 0, i);
+        }
+
+        public static void runTests() {
+            System.out.print("[IntArrayTests]: ");
+
+            int[] src15 = createIncrementedArray(15);
+            int[] dst15 = createArrayOfZeroes(15);
+            $noinline$test1(src15, dst15);
+            checkIncrementedArray(dst15);
+
+            int[] src150 = createIncrementedArray(150);
+            int[] dst150 = createArrayOfZeroes(150);
+            $noinline$test2(src150, dst150);
+            checkIncrementedArray(dst150);
+
+            checkIncrementedArray($noinline$test3());
+            checkIncrementedArray($noinline$test4());
+            checkIncrementedArray($noinline$test5());
+
+            check6($noinline$test6());
+            check7($noinline$test7());
+            check8($noinline$test8());
+
+            for (int i = 1; i < 256; i++) {
+                int[] src = createIncrementedArray(i);
+                int[] dst = createArrayOfZeroes(i);
+                $noinline$test9(src, dst, i);
+                checkIncrementedArray(dst);
+            }
+
+            System.out.println("passed");
+        }
+    }
+
+    public static void main(String[] args) {
+        ByteArrayTests.runTests();
+        CharArrayTests.runTests();
+        IntArrayTests.runTests();
+    }
+}