selftests: riscv: Support xtheadvector in vector tests

Extend existing vector tests to be compatible with the xtheadvector
instructions.

Signed-off-by: Charlie Jenkins <charlie@rivosinc.com>
Tested-by: Yangyu Chen <cyy@cyyself.name>
Link: https://lore.kernel.org/r/20241113-xtheadvector-v11-13-236c22791ef9@rivosinc.com
Signed-off-by: Palmer Dabbelt <palmer@rivosinc.com>

diff --git a/tools/testing/selftests/riscv/vector/v_exec_initval_nolibc.c b/tools/testing/selftests/riscv/vector/v_exec_initval_nolibc.c
index 4a39cab29c34dc89a5e51203ed8e71e1d62d6442..35c0812e32de0c82a54f84bd52c4272507121e35 100644 (file)
--- a/tools/testing/selftests/riscv/vector/v_exec_initval_nolibc.c
+++ b/tools/testing/selftests/riscv/vector/v_exec_initval_nolibc.c
@@ -18,13 +18,22 @@ int main(int argc, char **argv)
        unsigned long vl;
        int first = 1;
 
-       asm volatile (
-               ".option push\n\t"
-               ".option arch, +v\n\t"
-               "vsetvli        %[vl], x0, e8, m1, ta, ma\n\t"
-               ".option pop\n\t"
-               : [vl] "=r" (vl)
-       );
+       if (argc > 2 && strcmp(argv[2], "x"))
+               asm volatile (
+                       // 0 | zimm[10:0] | rs1 | 1 1 1 | rd |1010111| vsetvli
+                       // vsetvli      t4, x0, e8, m1, d1
+                       ".4byte         0b00000000000000000111111011010111\n\t"
+                       "mv             %[vl], t4\n\t"
+                       : [vl] "=r" (vl) : : "t4"
+               );
+       else
+               asm volatile (
+                       ".option push\n\t"
+                       ".option arch, +v\n\t"
+                       "vsetvli        %[vl], x0, e8, m1, ta, ma\n\t"
+                       ".option pop\n\t"
+                       : [vl] "=r" (vl)
+               );
 
 #define CHECK_VECTOR_REGISTER(register) ({                                     \
        for (int i = 0; i < vl; i++) {                                          \

diff --git a/tools/testing/selftests/riscv/vector/v_helpers.c b/tools/testing/selftests/riscv/vector/v_helpers.c
index d50f4dfbf9e56f9d3377742233889342c099c28f..01a8799dcb78610b7c7a8ff8141c78202e02eb1a 100644 (file)
--- a/tools/testing/selftests/riscv/vector/v_helpers.c
+++ b/tools/testing/selftests/riscv/vector/v_helpers.c
@@ -1,12 +1,22 @@
 // SPDX-License-Identifier: GPL-2.0-only
 
 #include "../hwprobe/hwprobe.h"
+#include <asm/vendor/thead.h>
 #include <stdbool.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <unistd.h>
 #include <sys/wait.h>
 
+bool is_xtheadvector_supported(void)
+{
+       struct riscv_hwprobe pair;
+
+       pair.key = RISCV_HWPROBE_KEY_VENDOR_EXT_THEAD_0;
+       riscv_hwprobe(&pair, 1, 0, NULL, 0);
+       return pair.value & RISCV_HWPROBE_VENDOR_EXT_XTHEADVECTOR;
+}
+
 bool is_vector_supported(void)
 {
        struct riscv_hwprobe pair;
@@ -16,9 +26,9 @@ bool is_vector_supported(void)
        return pair.value & RISCV_HWPROBE_EXT_ZVE32X;
 }
 
-int launch_test(char *next_program, int test_inherit)
+int launch_test(char *next_program, int test_inherit, int xtheadvector)
 {
-       char *exec_argv[3], *exec_envp[1];
+       char *exec_argv[4], *exec_envp[1];
        int rc, pid, status;
 
        pid = fork();
@@ -30,7 +40,8 @@ int launch_test(char *next_program, int test_inherit)
        if (!pid) {
                exec_argv[0] = next_program;
                exec_argv[1] = test_inherit != 0 ? "x" : NULL;
-               exec_argv[2] = NULL;
+               exec_argv[2] = xtheadvector != 0 ? "x" : NULL;
+               exec_argv[3] = NULL;
                exec_envp[0] = NULL;
                /* launch the program again to check inherit */
                rc = execve(next_program, exec_argv, exec_envp);

diff --git a/tools/testing/selftests/riscv/vector/v_helpers.h b/tools/testing/selftests/riscv/vector/v_helpers.h
index faeeeb625b6ee066181092ff5f8ba3745573397a..763cddfe26dad22c22b26937a06a80901225a9af 100644 (file)
--- a/tools/testing/selftests/riscv/vector/v_helpers.h
+++ b/tools/testing/selftests/riscv/vector/v_helpers.h
@@ -1,6 +1,8 @@
 /* SPDX-License-Identifier: GPL-2.0-only */
 #include <stdbool.h>
 
+bool is_xtheadvector_supported(void);
+
 bool is_vector_supported(void);
 
-int launch_test(char *next_program, int test_inherit);
+int launch_test(char *next_program, int test_inherit, int xtheadvector);

diff --git a/tools/testing/selftests/riscv/vector/v_initval.c b/tools/testing/selftests/riscv/vector/v_initval.c
index f38b5797fa317183f2856c3fcbbd6e21d59e52cc..be9e1d18ad295a3f7b46cd76bc2a03a02cf0f439 100644 (file)
--- a/tools/testing/selftests/riscv/vector/v_initval.c
+++ b/tools/testing/selftests/riscv/vector/v_initval.c
@@ -7,10 +7,16 @@
 
 TEST(v_initval)
 {
-       if (!is_vector_supported())
-               SKIP(return, "Vector not supported");
+       int xtheadvector = 0;
 
-       ASSERT_EQ(0, launch_test(NEXT_PROGRAM, 0));
+       if (!is_vector_supported()) {
+               if (is_xtheadvector_supported())
+                       xtheadvector = 1;
+               else
+                       SKIP(return, "Vector not supported");
+       }
+
+       ASSERT_EQ(0, launch_test(NEXT_PROGRAM, 0, xtheadvector));
 }
 
 TEST_HARNESS_MAIN

diff --git a/tools/testing/selftests/riscv/vector/vstate_exec_nolibc.c b/tools/testing/selftests/riscv/vector/vstate_exec_nolibc.c
index 1f9969bed2355befb50355e23625d9af8a5a5256..7b7d6f21acb4505b54a24d96e38b464624894ebf 100644 (file)
--- a/tools/testing/selftests/riscv/vector/vstate_exec_nolibc.c
+++ b/tools/testing/selftests/riscv/vector/vstate_exec_nolibc.c
@@ -6,13 +6,16 @@
 
 int main(int argc, char **argv)
 {
-       int rc, pid, status, test_inherit = 0;
+       int rc, pid, status, test_inherit = 0, xtheadvector = 0;
        long ctrl, ctrl_c;
        char *exec_argv[2], *exec_envp[2];
 
-       if (argc > 1)
+       if (argc > 1 && strcmp(argv[1], "x"))
                test_inherit = 1;
 
+       if (argc > 2 && strcmp(argv[2], "x"))
+               xtheadvector = 1;
+
        ctrl = my_syscall1(__NR_prctl, PR_RISCV_V_GET_CONTROL);
        if (ctrl < 0) {
                puts("PR_RISCV_V_GET_CONTROL is not supported\n");
@@ -53,11 +56,14 @@ int main(int argc, char **argv)
                                puts("child's vstate_ctrl not equal to parent's\n");
                                exit(-1);
                        }
-                       asm volatile (".option push\n\t"
-                                     ".option arch, +v\n\t"
-                                     "vsetvli x0, x0, e32, m8, ta, ma\n\t"
-                                     ".option pop\n\t"
-                                     );
+                       if (xtheadvector)
+                               asm volatile (".4byte   0x00007ed7");
+                       else
+                               asm volatile (".option push\n\t"
+                                       ".option arch, +v\n\t"
+                                       "vsetvli x0, x0, e32, m8, ta, ma\n\t"
+                                       ".option pop\n\t"
+                                       );
                        exit(ctrl);
                }
        }

diff --git a/tools/testing/selftests/riscv/vector/vstate_prctl.c b/tools/testing/selftests/riscv/vector/vstate_prctl.c
index 2fc86924bf42684cd3eb4ade2dad9d4e93413e70..62fbb17a055669ad0a56446aba234ef8e27bbf12 100644 (file)
--- a/tools/testing/selftests/riscv/vector/vstate_prctl.c
+++ b/tools/testing/selftests/riscv/vector/vstate_prctl.c
@@ -11,7 +11,7 @@
 
 #define NEXT_PROGRAM "./vstate_exec_nolibc"
 
-int test_and_compare_child(long provided, long expected, int inherit)
+int test_and_compare_child(long provided, long expected, int inherit, int xtheadvector)
 {
        int rc;
 
@@ -21,7 +21,7 @@ int test_and_compare_child(long provided, long expected, int inherit)
                       provided, rc);
                return -1;
        }
-       rc = launch_test(NEXT_PROGRAM, inherit);
+       rc = launch_test(NEXT_PROGRAM, inherit, xtheadvector);
        if (rc != expected) {
                printf("Test failed, check %d != %ld\n", rc, expected);
                return -2;
@@ -36,7 +36,7 @@ TEST(get_control_no_v)
 {
        long rc;
 
-       if (is_vector_supported())
+       if (is_vector_supported() || is_xtheadvector_supported())
                SKIP(return, "Test expects vector to be not supported");
 
        rc = prctl(PR_RISCV_V_GET_CONTROL);
@@ -50,7 +50,7 @@ TEST(set_control_no_v)
 {
        long rc;
 
-       if (is_vector_supported())
+       if (is_vector_supported() || is_xtheadvector_supported())
                SKIP(return, "Test expects vector to be not supported");
 
        rc = prctl(PR_RISCV_V_SET_CONTROL, PR_RISCV_V_VSTATE_CTRL_ON);
@@ -65,12 +65,12 @@ TEST(vstate_on_current)
        long flag;
        long rc;
 
-       if (!is_vector_supported())
+       if (!is_vector_supported() && !is_xtheadvector_supported())
                SKIP(return, "Vector not supported");
 
        flag = PR_RISCV_V_VSTATE_CTRL_ON;
        rc = prctl(PR_RISCV_V_SET_CONTROL, flag);
-       EXPECT_EQ(0, rc) TH_LOG("Enabling V for current should always success");
+       EXPECT_EQ(0, rc) TH_LOG("Enabling V for current should always succeed");
 }
 
 TEST(vstate_off_eperm)
@@ -78,7 +78,7 @@ TEST(vstate_off_eperm)
        long flag;
        long rc;
 
-       if (!is_vector_supported())
+       if (!is_vector_supported() && !is_xtheadvector_supported())
                SKIP(return, "Vector not supported");
 
        flag = PR_RISCV_V_VSTATE_CTRL_OFF;
@@ -92,89 +92,116 @@ TEST(vstate_off_eperm)
 TEST(vstate_on_no_nesting)
 {
        long flag;
+       int xtheadvector = 0;
 
-       if (!is_vector_supported())
-               SKIP(return, "Vector not supported");
+       if (!is_vector_supported()) {
+               if (is_xtheadvector_supported())
+                       xtheadvector = 1;
+               else
+                       SKIP(return, "Vector not supported");
+       }
 
        /* Turn on next's vector explicitly and test */
        flag = PR_RISCV_V_VSTATE_CTRL_ON << PR_RISCV_V_VSTATE_CTRL_NEXT_SHIFT;
 
-       EXPECT_EQ(0,
-                 test_and_compare_child(flag, PR_RISCV_V_VSTATE_CTRL_ON, 0));
+       EXPECT_EQ(0, test_and_compare_child(flag, PR_RISCV_V_VSTATE_CTRL_ON, 0, xtheadvector));
 }
 
 TEST(vstate_off_nesting)
 {
        long flag;
+       int xtheadvector = 0;
 
-       if (!is_vector_supported())
-               SKIP(return, "Vector not supported");
+       if (!is_vector_supported()) {
+               if (is_xtheadvector_supported())
+                       xtheadvector = 1;
+               else
+                       SKIP(return, "Vector not supported");
+       }
 
        /* Turn off next's vector explicitly and test */
        flag = PR_RISCV_V_VSTATE_CTRL_OFF << PR_RISCV_V_VSTATE_CTRL_NEXT_SHIFT;
 
-       EXPECT_EQ(0,
-                 test_and_compare_child(flag, PR_RISCV_V_VSTATE_CTRL_OFF, 1));
+       EXPECT_EQ(0, test_and_compare_child(flag, PR_RISCV_V_VSTATE_CTRL_OFF, 1, xtheadvector));
 }
 
 TEST(vstate_on_inherit_no_nesting)
 {
        long flag, expected;
+       int xtheadvector = 0;
 
-       if (!is_vector_supported())
-               SKIP(return, "Vector not supported");
+       if (!is_vector_supported()) {
+               if (is_xtheadvector_supported())
+                       xtheadvector = 1;
+               else
+                       SKIP(return, "Vector not supported");
+       }
 
        /* Turn on next's vector explicitly and test no inherit */
        flag = PR_RISCV_V_VSTATE_CTRL_ON << PR_RISCV_V_VSTATE_CTRL_NEXT_SHIFT;
        flag |= PR_RISCV_V_VSTATE_CTRL_INHERIT;
        expected = flag | PR_RISCV_V_VSTATE_CTRL_ON;
 
-       EXPECT_EQ(0, test_and_compare_child(flag, expected, 0));
+       EXPECT_EQ(0, test_and_compare_child(flag, expected, 0, xtheadvector));
 }
 
 TEST(vstate_on_inherit)
 {
        long flag, expected;
+       int xtheadvector = 0;
 
-       if (!is_vector_supported())
-               SKIP(return, "Vector not supported");
+       if (!is_vector_supported()) {
+               if (is_xtheadvector_supported())
+                       xtheadvector = 1;
+               else
+                       SKIP(return, "Vector not supported");
+       }
 
        /* Turn on next's vector explicitly and test inherit */
        flag = PR_RISCV_V_VSTATE_CTRL_ON << PR_RISCV_V_VSTATE_CTRL_NEXT_SHIFT;
        flag |= PR_RISCV_V_VSTATE_CTRL_INHERIT;
        expected = flag | PR_RISCV_V_VSTATE_CTRL_ON;
 
-       EXPECT_EQ(0, test_and_compare_child(flag, expected, 1));
+       EXPECT_EQ(0, test_and_compare_child(flag, expected, 1, xtheadvector));
 }
 
 TEST(vstate_off_inherit_no_nesting)
 {
        long flag, expected;
+       int xtheadvector = 0;
 
-       if (!is_vector_supported())
-               SKIP(return, "Vector not supported");
-
+       if (!is_vector_supported()) {
+               if (is_xtheadvector_supported())
+                       xtheadvector = 1;
+               else
+                       SKIP(return, "Vector not supported");
+       }
        /* Turn off next's vector explicitly and test no inherit */
        flag = PR_RISCV_V_VSTATE_CTRL_OFF << PR_RISCV_V_VSTATE_CTRL_NEXT_SHIFT;
        flag |= PR_RISCV_V_VSTATE_CTRL_INHERIT;
        expected = flag | PR_RISCV_V_VSTATE_CTRL_OFF;
 
-       EXPECT_EQ(0, test_and_compare_child(flag, expected, 0));
+       EXPECT_EQ(0, test_and_compare_child(flag, expected, 0, xtheadvector));
 }
 
 TEST(vstate_off_inherit)
 {
        long flag, expected;
+       int xtheadvector = 0;
 
-       if (!is_vector_supported())
-               SKIP(return, "Vector not supported");
+       if (!is_vector_supported()) {
+               if (is_xtheadvector_supported())
+                       xtheadvector = 1;
+               else
+                       SKIP(return, "Vector not supported");
+       }
 
        /* Turn off next's vector explicitly and test inherit */
        flag = PR_RISCV_V_VSTATE_CTRL_OFF << PR_RISCV_V_VSTATE_CTRL_NEXT_SHIFT;
        flag |= PR_RISCV_V_VSTATE_CTRL_INHERIT;
        expected = flag | PR_RISCV_V_VSTATE_CTRL_OFF;
 
-       EXPECT_EQ(0, test_and_compare_child(flag, expected, 1));
+       EXPECT_EQ(0, test_and_compare_child(flag, expected, 1, xtheadvector));
 }
 
 /* arguments should fail with EINVAL */
@@ -182,7 +209,7 @@ TEST(inval_set_control_1)
 {
        int rc;
 
-       if (!is_vector_supported())
+       if (!is_vector_supported() && !is_xtheadvector_supported())
                SKIP(return, "Vector not supported");
 
        rc = prctl(PR_RISCV_V_SET_CONTROL, 0xff0);
@@ -195,7 +222,7 @@ TEST(inval_set_control_2)
 {
        int rc;
 
-       if (!is_vector_supported())
+       if (!is_vector_supported() && !is_xtheadvector_supported())
                SKIP(return, "Vector not supported");
 
        rc = prctl(PR_RISCV_V_SET_CONTROL, 0x3);
@@ -208,7 +235,7 @@ TEST(inval_set_control_3)
 {
        int rc;
 
-       if (!is_vector_supported())
+       if (!is_vector_supported() && !is_xtheadvector_supported())
                SKIP(return, "Vector not supported");
 
        rc = prctl(PR_RISCV_V_SET_CONTROL, 0xc);