tests/tcg/ppc64[le]: add tests for xs{max,min}cqp and xs{max,min}[cj]dp

target/ppc/fpu_helper.c

@@ -2540,7 +2540,7 @@ VSX_MAX_MIN(xvminsp, minnum, 4, float32, VsrW(i))
 void helper_##name(CPUPPCState *env,                                          \
                    ppc_vsr_t *xt, ppc_vsr_t *xa, ppc_vsr_t *xb)               \
 {                                                                             \
-    ppc_vsr_t t = *xt;                                                        \
+    ppc_vsr_t t = { };                                                        \
     bool vxsnan_flag = false, vex_flag = false;                               \
                                                                               \
     if (unlikely(tp##_is_any_nan(xa->fld) ||                                  \
@@ -2572,7 +2572,7 @@ VSX_MAX_MINC(XSMINCQP, minnum, float128, f128);
 void helper_##name(CPUPPCState *env,                                          \
                    ppc_vsr_t *xt, ppc_vsr_t *xa, ppc_vsr_t *xb)               \
 {                                                                             \
-    ppc_vsr_t t = *xt;                                                        \
+    ppc_vsr_t t = { };                                                        \
     bool vxsnan_flag = false, vex_flag = false;                               \
                                                                               \
     if (unlikely(float64_is_any_nan(xa->VsrD(0)))) {                          \

tests/tcg/ppc64/Makefile.target

@@ -10,12 +10,26 @@ PPC64_TESTS=bcdsub non_signalling_xscv
 endif
 $(PPC64_TESTS): CFLAGS += -mpower8-vector
 
-PPC64_TESTS += byte_reverse
-PPC64_TESTS += mtfsf
+PPC64_TESTS += byte_reverse mtfsf xsmaxmincqp xsmaxmincjdp
 ifneq ($(DOCKER_IMAGE)$(CROSS_CC_HAS_POWER10),)
+xsmaxmincqp: CFLAGS += -mcpu=power10
+run-xsmaxmincqp: QEMU_OPTS += -cpu POWER10
+run-plugin-xsmaxmincqp-with-%: QEMU_OPTS += -cpu POWER10
+
+xsmaxmincjdp: CFLAGS += -mcpu=power10
+run-xsmaxmincjdp: QEMU_OPTS += -cpu POWER10
+run-plugin-xsmaxmincjdp-with-%: QEMU_OPTS += -cpu POWER10
+
 run-byte_reverse: QEMU_OPTS+=-cpu POWER10
 run-plugin-byte_reverse-with-%: QEMU_OPTS+=-cpu POWER10
 else
+xsmaxmincqp:
+	$(call skip-test, "BUILD of $@", "missing compiler support")
+run-xsmaxmincqp:
+	$(call skip-test, "RUN of xsmaxmincqp", "not built")
+run-plugin-xsmaxmincqp-with-%:
+	$(call skip-test, "RUN of xsmaxmincqp ($*)", "not built")
+
 byte_reverse:
 	$(call skip-test, "BUILD of $@", "missing compiler support")
 run-byte_reverse:

tests/tcg/ppc64le/Makefile.target

@@ -10,12 +10,20 @@ endif
 $(PPC64LE_TESTS): CFLAGS += -mpower8-vector
 
 ifneq ($(DOCKER_IMAGE)$(CROSS_CC_HAS_POWER10),)
-PPC64LE_TESTS += byte_reverse
+PPC64LE_TESTS += byte_reverse xsmaxmincqp xsmaxmincjdp
 endif
 byte_reverse: CFLAGS += -mcpu=power10
 run-byte_reverse: QEMU_OPTS+=-cpu POWER10
 run-plugin-byte_reverse-with-%: QEMU_OPTS+=-cpu POWER10
 
+xsmaxmincjdp: CFLAGS += -mcpu=power10
+run-xsmaxmincjdp: QEMU_OPTS += -cpu POWER10
+run-plugin-xsmaxmincjdp-with-%: QEMU_OPTS += -cpu POWER10
+
+xsmaxmincqp: CFLAGS += -mcpu=power10
+run-xsmaxmincqp: QEMU_OPTS += -cpu POWER10
+run-plugin-xsmaxmincqp-with-%: QEMU_OPTS += -cpu POWER10
+
 PPC64LE_TESTS += mtfsf
 PPC64LE_TESTS += signal_save_restore_xer
 

tests/tcg/ppc64le/xsmaxmincjdp.c

@@ -0,0 +1,83 @@
+#include <assert.h>
+#include <limits.h>
+#include <unistd.h>
+#include <signal.h>
+#include <stdint.h>
+
+#define XSTR(x) #x
+#define STR(x) XSTR(x)
+#define I128(a, b) ((__int128)(a) << 64 | (b))
+
+#define TEST(INSN, A, B, EXP)                                          \
+    do {                                                               \
+        __uint128_t a = I128(A, 0);                                    \
+        __uint128_t b = I128(B, 0);                                    \
+        __uint128_t t;                                                 \
+                                                                       \
+        asm(INSN " %0, %1, %2\n\t" : "=wa"(t) : "wa"(a), "wa"(b));     \
+                                                                       \
+        assert(t == I128(EXP, 0));                                     \
+    } while (0)
+
+static inline void test_nan()
+{
+    TEST("xsmaxcdp", 0x42ULL, 0x7FF0000000000001ULL, 0x7FF0000000000001ULL);
+    TEST("xsmaxcdp", 0x7FF0000000000001ULL, 0x42ULL, 0x42ULL);
+
+    TEST("xsmaxcdp", 0x42ULL, 0x7FFF000000000000ULL, 0x7FFF000000000000ULL);
+    TEST("xsmaxcdp", 0x7FFF000000000000ULL, 0x42ULL, 0x42ULL);
+
+    TEST("xsmaxcdp", 0x42ULL, 0x7FF8000000000000ULL, 0x7FF8000000000000ULL);
+    TEST("xsmaxcdp", 0x7FF8000000000000ULL, 0x42ULL, 0x42ULL);
+
+    TEST("xsmincdp", 0x42ULL, 0x7FF0000000000001ULL, 0x7FF0000000000001ULL);
+    TEST("xsmincdp", 0x7FF0000000000001ULL, 0x42ULL, 0x42ULL);
+
+    TEST("xsmincdp", 0x42ULL, 0x7FFF000000000000ULL, 0x7FFF000000000000ULL);
+    TEST("xsmincdp", 0x7FFF000000000000ULL, 0x42ULL, 0x42ULL);
+
+    TEST("xsmincdp", 0x42ULL, 0x7FF8000000000000ULL, 0x7FF8000000000000ULL);
+    TEST("xsmincdp", 0x7FF8000000000000ULL, 0x42ULL, 0x42ULL);
+
+    TEST("xsmaxjdp", 0x42ULL, 0x7FF0000000000001ULL, 0x7FF0000000000001ULL);
+    TEST("xsmaxjdp", 0x7FF0000000000001ULL, 0x42ULL, 0x7FF0000000000001ULL);
+    TEST("xsmaxjdp", 0x7FF8000000000000ULL, 0x7FF0000000000001ULL,
+         0x7FF8000000000000ULL);
+    TEST("xsmaxjdp", 0x7FF0000000000001ULL, 0x7FF8000000000000ULL,
+         0x7FF0000000000001ULL);
+
+    TEST("xsminjdp", 0x42ULL, 0x7FF0000000000001ULL, 0x7FF0000000000001ULL);
+    TEST("xsminjdp", 0x7FF0000000000001ULL, 0x42ULL, 0x7FF0000000000001ULL);
+    TEST("xsminjdp", 0x7FF8000000000000ULL, 0x7FF0000000000001ULL,
+         0x7FF8000000000000ULL);
+    TEST("xsminjdp", 0x7FF0000000000001ULL, 0x7FF8000000000000ULL,
+         0x7FF0000000000001ULL);
+}
+
+static inline void test_general_case()
+{
+    TEST("xsmaxcdp", 0xad53f789, 0xbeaab9c5, 0xbeaab9c5);
+    TEST("xsmaxcdp", 0x8600dd9ea0, 0x4b9f8cffd7, 0x8600dd9ea0);
+
+    TEST("xsmincdp", 0xad53f789, 0xbeaab9c5, 0xad53f789);
+    TEST("xsmincdp", 0x8600dd9ea0, 0x4b9f8cffd7, 0x4b9f8cffd7);
+
+    TEST("xsmaxjdp", 0xad53f789, 0xbeaab9c5, 0xbeaab9c5);
+    TEST("xsmaxjdp", 0x8600dd9ea0, 0x4b9f8cffd7, 0x8600dd9ea0);
+
+    TEST("xsminjdp", 0xad53f789, 0xbeaab9c5, 0xad53f789);
+    TEST("xsminjdp", 0x8600dd9ea0, 0x4b9f8cffd7, 0x4b9f8cffd7);
+}
+
+int main(void)
+{
+    struct sigaction action;
+
+    action.sa_handler = _exit;
+    sigaction(SIGABRT, &action, NULL);
+
+    test_nan();
+    test_general_case();
+
+    return 0;
+}

tests/tcg/ppc64le/xsmaxmincqp.c

@@ -0,0 +1,59 @@
+#include <assert.h>
+#include <limits.h>
+#include <unistd.h>
+#include <signal.h>
+#include <stdint.h>
+
+#define XSTR(x) #x
+#define STR(x) XSTR(x)
+#define I128(a, b) ((__int128)(a) << 64 | (b))
+#define MAX128(a, b) (a > b ? a : b)
+#define MIN128(a, b) (a < b ? a : b)
+
+#define TEST(INSN, H1, L1, H2, L2, EXP)                                \
+    do {                                                               \
+        __uint128_t a = I128(H1, L1);                                  \
+        __uint128_t b = I128(H2, L2);                                  \
+        __uint128_t t;                                                 \
+                                                                       \
+        asm(INSN " %0, %1, %2\n\t" : "=v"(t) : "v"(a), "v"(b));        \
+                                                                       \
+        assert(t == EXP);                                              \
+    } while (0)
+
+#define TEST_NAN(H1, L1, H2, L2)                                       \
+    do {                                                               \
+        /* If any of the input is NaN, VRT <- VRB */                   \
+        TEST("xsmaxcqp", H1, L1, H2, L2, I128(H2, L2));                \
+        TEST("xsmaxcqp", H2, L2, H1, L1, I128(H1, L1));                \
+        TEST("xsmincqp", H1, L1, H2, L2, I128(H2, L2));                \
+        TEST("xsmincqp", H2, L2, H1, L1, I128(H1, L1));                \
+    } while (0)
+
+#define TEST_GENERAL_CASE(H1, L1, H2, L2)                                      \
+    do {                                                                       \
+        TEST("xsmaxcqp", H1, L1, H2, L2, MAX128(I128(H1, L1), I128(H2, L2)));  \
+        TEST("xsmaxcqp", H1, L1, H2, L2, MAX128(I128(H1, L1), I128(H2, L2)));  \
+        TEST("xsmincqp", H2, L2, H1, L1, MIN128(I128(H1, L1), I128(H2, L2)));  \
+        TEST("xsmincqp", H2, L2, H1, L1, MIN128(I128(H1, L1), I128(H2, L2)));  \
+    } while (0)
+
+int main(void)
+{
+    struct sigaction action;
+
+    action.sa_handler = _exit;
+    sigaction(SIGABRT, &action, NULL);
+
+    TEST_NAN(0xFFFFFFFFFFFFFFFFULL, 0xFFFFFFFFFFFFFFFFULL, 0x0ULL, 0X0ULL);
+    TEST_NAN(0xDEADC0DEULL, 0x0ULL, 0x7FFF000000000000ULL, 0x1ULL);
+
+    TEST_GENERAL_CASE(0x000087810000E078ULL, 0x0006E3C8000438F5ULL,
+                      0x000B48600003780FULL, 0x00C304E00069660ULL);
+    TEST_GENERAL_CASE(0x0ULL, 0xF3C0C1FC8F3230ULL, 0x0ULL, 0xBEAAB9C5ULL);
+    TEST_GENERAL_CASE(0xC0583916EA04ULL, 0xB11DCFB3C40C58E9ULL,
+                      0x32BB5C6435F8ULL, 0x3CDABBEC03DD171BULL);
+    TEST_GENERAL_CASE(0xDEADC0DEULL, 0x0ULL, 0x7FF8000000000000ULL, 0x1ULL);
+
+    return 0;
+}