1 #include <assert.h>
2 #include <unistd.h>
3 #include <signal.h>
4 #include <stdint.h>
5
6 #define CRF_LT (1 << 3)
7 #define CRF_GT (1 << 2)
8 #define CRF_EQ (1 << 1)
9 #define CRF_SO (1 << 0)
10 #define UNDEF 0
11
12 #ifdef __has_builtin
13 #if !__has_builtin(__builtin_bcdsub)
14 #define NO_BUILTIN_BCDSUB
15 #endif
16 #endif
17
18 #ifdef NO_BUILTIN_BCDSUB
19 #define BCDSUB(T, A, B, PS) \
20 ".long 4 << 26 | (" #T ") << 21 | (" #A ") << 16 | (" #B ") << 11" \
21 " | 1 << 10 | (" #PS ") << 9 | 65\n\t"
22 #else
23 #define BCDSUB(T, A, B, PS) "bcdsub. " #T ", " #A ", " #B ", " #PS "\n\t"
24 #endif
25
26 #define TEST(AH, AL, BH, BL, PS, TH, TL, CR6) \
27 do { \
28 int cr = 0; \
29 uint64_t th, tl; \
30 /* \
31 * Use GPR pairs to load the VSR values and place the resulting VSR and\
32 * CR6 in th, tl, and cr. Note that we avoid newer instructions (e.g., \
33 * mtvsrdd/mfvsrld) so we can run this test on POWER8 machines. \
34 */ \
35 asm ("mtvsrd 32, %3\n\t" \
36 "mtvsrd 33, %4\n\t" \
37 "xxmrghd 32, 32, 33\n\t" \
38 "mtvsrd 33, %5\n\t" \
39 "mtvsrd 34, %6\n\t" \
40 "xxmrghd 33, 33, 34\n\t" \
41 BCDSUB(0, 0, 1, PS) \
42 "mfocrf %0, 0b10\n\t" \
43 "mfvsrd %1, 32\n\t" \
44 "xxswapd 32, 32\n\t" \
45 "mfvsrd %2, 32\n\t" \
46 : "=r" (cr), "=r" (th), "=r" (tl) \
47 : "r" (AH), "r" (AL), "r" (BH), "r" (BL) \
48 : "v0", "v1", "v2"); \
49 if (TH != UNDEF || TL != UNDEF) { \
50 assert(tl == TL); \
51 assert(th == TH); \
52 } \
53 assert((cr >> 4) == CR6); \
54 } while (0)
55
56 /*
57 * Unbounded result is equal to zero:
58 * sign = (PS) ? 0b1111 : 0b1100
59 * CR6 = 0b0010
60 */
test_bcdsub_eq(void)61 void test_bcdsub_eq(void)
62 {
63 /* maximum positive BCD value */
64 TEST(0x9999999999999999, 0x999999999999999c,
65 0x9999999999999999, 0x999999999999999c,
66 0, 0x0, 0xc, CRF_EQ);
67 TEST(0x9999999999999999, 0x999999999999999c,
68 0x9999999999999999, 0x999999999999999c,
69 1, 0x0, 0xf, CRF_EQ);
70 }
71
72 /*
73 * Unbounded result is greater than zero:
74 * sign = (PS) ? 0b1111 : 0b1100
75 * CR6 = (overflow) ? 0b0101 : 0b0100
76 */
test_bcdsub_gt(void)77 void test_bcdsub_gt(void)
78 {
79 /* maximum positive and negative one BCD values */
80 TEST(0x9999999999999999, 0x999999999999999c, 0x0, 0x1d, 0,
81 0x0, 0xc, (CRF_GT | CRF_SO));
82 TEST(0x9999999999999999, 0x999999999999999c, 0x0, 0x1d, 1,
83 0x0, 0xf, (CRF_GT | CRF_SO));
84
85 TEST(0x9999999999999999, 0x999999999999998c, 0x0, 0x1d, 0,
86 0x9999999999999999, 0x999999999999999c, CRF_GT);
87 TEST(0x9999999999999999, 0x999999999999998c, 0x0, 0x1d, 1,
88 0x9999999999999999, 0x999999999999999f, CRF_GT);
89 }
90
91 /*
92 * Unbounded result is less than zero:
93 * sign = 0b1101
94 * CR6 = (overflow) ? 0b1001 : 0b1000
95 */
test_bcdsub_lt(void)96 void test_bcdsub_lt(void)
97 {
98 /* positive zero and positive one BCD values */
99 TEST(0x0, 0xc, 0x0, 0x1c, 0, 0x0, 0x1d, CRF_LT);
100 TEST(0x0, 0xc, 0x0, 0x1c, 1, 0x0, 0x1d, CRF_LT);
101
102 /* maximum negative and positive one BCD values */
103 TEST(0x9999999999999999, 0x999999999999999d, 0x0, 0x1c, 0,
104 0x0, 0xd, (CRF_LT | CRF_SO));
105 TEST(0x9999999999999999, 0x999999999999999d, 0x0, 0x1c, 1,
106 0x0, 0xd, (CRF_LT | CRF_SO));
107 }
108
test_bcdsub_invalid(void)109 void test_bcdsub_invalid(void)
110 {
111 TEST(0x0, 0x1c, 0x0, 0xf00, 0, UNDEF, UNDEF, CRF_SO);
112 TEST(0x0, 0x1c, 0x0, 0xf00, 1, UNDEF, UNDEF, CRF_SO);
113
114 TEST(0x0, 0xf00, 0x0, 0x1c, 0, UNDEF, UNDEF, CRF_SO);
115 TEST(0x0, 0xf00, 0x0, 0x1c, 1, UNDEF, UNDEF, CRF_SO);
116
117 TEST(0x0, 0xbad, 0x0, 0xf00, 0, UNDEF, UNDEF, CRF_SO);
118 TEST(0x0, 0xbad, 0x0, 0xf00, 1, UNDEF, UNDEF, CRF_SO);
119 }
120
main(void)121 int main(void)
122 {
123 struct sigaction action;
124
125 action.sa_handler = _exit;
126 sigaction(SIGABRT, &action, NULL);
127
128 test_bcdsub_eq();
129 test_bcdsub_gt();
130 test_bcdsub_lt();
131 test_bcdsub_invalid();
132
133 return 0;
134 }
135