trap signals for "-serial mon:stdio"
[qemu.git] / tests / test-int128.c
1 /*
2 * Test Int128 arithmetic
3 *
4 * This work is licensed under the terms of the GNU LGPL, version 2 or later.
5 * See the COPYING.LIB file in the top-level directory.
6 *
7 */
8
9 #include <glib.h>
10 #include <stdio.h>
11 #include "qemu/int128.h"
12 #include "qemu/osdep.h"
13
14 static uint32_t tests[8] = {
15 0x00000000, 0x00000001, 0x7FFFFFFE, 0x7FFFFFFF,
16 0x80000000, 0x80000001, 0xFFFFFFFE, 0xFFFFFFFF,
17 };
18
19 #define LOW 3ULL
20 #define HIGH (1ULL << 63)
21 #define MIDDLE (-1ULL & ~LOW & ~HIGH)
22
23 static uint64_t expand16(unsigned x)
24 {
25 return (x & LOW) | ((x & 4) ? MIDDLE : 0) | (x & 0x8000 ? HIGH : 0);
26 }
27
28 static Int128 expand(uint32_t x)
29 {
30 uint64_t l, h;
31 l = expand16(x & 65535);
32 h = expand16(x >> 16);
33 return (Int128) {l, h};
34 };
35
36 static void test_and(void)
37 {
38 int i, j;
39
40 for (i = 0; i < ARRAY_SIZE(tests); ++i) {
41 for (j = 0; j < ARRAY_SIZE(tests); ++j) {
42 Int128 a = expand(tests[i]);
43 Int128 b = expand(tests[j]);
44 Int128 r = expand(tests[i] & tests[j]);
45 Int128 s = int128_and(a, b);
46 g_assert_cmpuint(r.lo, ==, s.lo);
47 g_assert_cmpuint(r.hi, ==, s.hi);
48 }
49 }
50 }
51
52 static void test_add(void)
53 {
54 int i, j;
55
56 for (i = 0; i < ARRAY_SIZE(tests); ++i) {
57 for (j = 0; j < ARRAY_SIZE(tests); ++j) {
58 Int128 a = expand(tests[i]);
59 Int128 b = expand(tests[j]);
60 Int128 r = expand(tests[i] + tests[j]);
61 Int128 s = int128_add(a, b);
62 g_assert_cmpuint(r.lo, ==, s.lo);
63 g_assert_cmpuint(r.hi, ==, s.hi);
64 }
65 }
66 }
67
68 static void test_sub(void)
69 {
70 int i, j;
71
72 for (i = 0; i < ARRAY_SIZE(tests); ++i) {
73 for (j = 0; j < ARRAY_SIZE(tests); ++j) {
74 Int128 a = expand(tests[i]);
75 Int128 b = expand(tests[j]);
76 Int128 r = expand(tests[i] - tests[j]);
77 Int128 s = int128_sub(a, b);
78 g_assert_cmpuint(r.lo, ==, s.lo);
79 g_assert_cmpuint(r.hi, ==, s.hi);
80 }
81 }
82 }
83
84 static void test_neg(void)
85 {
86 int i;
87
88 for (i = 0; i < ARRAY_SIZE(tests); ++i) {
89 Int128 a = expand(tests[i]);
90 Int128 r = expand(-tests[i]);
91 Int128 s = int128_neg(a);
92 g_assert_cmpuint(r.lo, ==, s.lo);
93 g_assert_cmpuint(r.hi, ==, s.hi);
94 }
95 }
96
97 static void test_nz(void)
98 {
99 int i, j;
100
101 for (i = 0; i < ARRAY_SIZE(tests); ++i) {
102 for (j = 0; j < ARRAY_SIZE(tests); ++j) {
103 Int128 a = expand(tests[i]);
104 g_assert_cmpuint(int128_nz(a), ==, tests[i] != 0);
105 }
106 }
107 }
108
109 static void test_le(void)
110 {
111 int i, j;
112
113 for (i = 0; i < ARRAY_SIZE(tests); ++i) {
114 for (j = 0; j < ARRAY_SIZE(tests); ++j) {
115 /* Signed comparison */
116 int32_t a = (int32_t) tests[i];
117 int32_t b = (int32_t) tests[j];
118 g_assert_cmpuint(int128_le(expand(a), expand(b)), ==, a <= b);
119 }
120 }
121 }
122
123 static void test_lt(void)
124 {
125 int i, j;
126
127 for (i = 0; i < ARRAY_SIZE(tests); ++i) {
128 for (j = 0; j < ARRAY_SIZE(tests); ++j) {
129 /* Signed comparison */
130 int32_t a = (int32_t) tests[i];
131 int32_t b = (int32_t) tests[j];
132 g_assert_cmpuint(int128_lt(expand(a), expand(b)), ==, a < b);
133 }
134 }
135 }
136
137 static void test_ge(void)
138 {
139 int i, j;
140
141 for (i = 0; i < ARRAY_SIZE(tests); ++i) {
142 for (j = 0; j < ARRAY_SIZE(tests); ++j) {
143 /* Signed comparison */
144 int32_t a = (int32_t) tests[i];
145 int32_t b = (int32_t) tests[j];
146 g_assert_cmpuint(int128_ge(expand(a), expand(b)), ==, a >= b);
147 }
148 }
149 }
150
151 static void test_gt(void)
152 {
153 int i, j;
154
155 for (i = 0; i < ARRAY_SIZE(tests); ++i) {
156 for (j = 0; j < ARRAY_SIZE(tests); ++j) {
157 /* Signed comparison */
158 int32_t a = (int32_t) tests[i];
159 int32_t b = (int32_t) tests[j];
160 g_assert_cmpuint(int128_gt(expand(a), expand(b)), ==, a > b);
161 }
162 }
163 }
164
165 /* Make sure to test undefined behavior at runtime! */
166
167 static void __attribute__((__noinline__, __noclone__))
168 test_rshift_one(uint32_t x, int n, uint64_t h, uint64_t l)
169 {
170 Int128 a = expand(x);
171 Int128 r = int128_rshift(a, n);
172 g_assert_cmpuint(r.lo, ==, l);
173 g_assert_cmpuint(r.hi, ==, h);
174 }
175
176 static void test_rshift(void)
177 {
178 test_rshift_one(0x00010000U, 64, 0x0000000000000000ULL, 0x0000000000000001ULL);
179 test_rshift_one(0x80010000U, 64, 0xFFFFFFFFFFFFFFFFULL, 0x8000000000000001ULL);
180 test_rshift_one(0x7FFE0000U, 64, 0x0000000000000000ULL, 0x7FFFFFFFFFFFFFFEULL);
181 test_rshift_one(0xFFFE0000U, 64, 0xFFFFFFFFFFFFFFFFULL, 0xFFFFFFFFFFFFFFFEULL);
182 test_rshift_one(0x00010000U, 60, 0x0000000000000000ULL, 0x0000000000000010ULL);
183 test_rshift_one(0x80010000U, 60, 0xFFFFFFFFFFFFFFF8ULL, 0x0000000000000010ULL);
184 test_rshift_one(0x00018000U, 60, 0x0000000000000000ULL, 0x0000000000000018ULL);
185 test_rshift_one(0x80018000U, 60, 0xFFFFFFFFFFFFFFF8ULL, 0x0000000000000018ULL);
186 test_rshift_one(0x7FFE0000U, 60, 0x0000000000000007ULL, 0xFFFFFFFFFFFFFFE0ULL);
187 test_rshift_one(0xFFFE0000U, 60, 0xFFFFFFFFFFFFFFFFULL, 0xFFFFFFFFFFFFFFE0ULL);
188 test_rshift_one(0x7FFE8000U, 60, 0x0000000000000007ULL, 0xFFFFFFFFFFFFFFE8ULL);
189 test_rshift_one(0xFFFE8000U, 60, 0xFFFFFFFFFFFFFFFFULL, 0xFFFFFFFFFFFFFFE8ULL);
190 test_rshift_one(0x00018000U, 0, 0x0000000000000001ULL, 0x8000000000000000ULL);
191 test_rshift_one(0x80018000U, 0, 0x8000000000000001ULL, 0x8000000000000000ULL);
192 test_rshift_one(0x7FFE0000U, 0, 0x7FFFFFFFFFFFFFFEULL, 0x0000000000000000ULL);
193 test_rshift_one(0xFFFE0000U, 0, 0xFFFFFFFFFFFFFFFEULL, 0x0000000000000000ULL);
194 test_rshift_one(0x7FFE8000U, 0, 0x7FFFFFFFFFFFFFFEULL, 0x8000000000000000ULL);
195 test_rshift_one(0xFFFE8000U, 0, 0xFFFFFFFFFFFFFFFEULL, 0x8000000000000000ULL);
196 }
197
198 int main(int argc, char **argv)
199 {
200 g_test_init(&argc, &argv, NULL);
201 g_test_add_func("/int128/int128_and", test_and);
202 g_test_add_func("/int128/int128_add", test_add);
203 g_test_add_func("/int128/int128_sub", test_sub);
204 g_test_add_func("/int128/int128_neg", test_neg);
205 g_test_add_func("/int128/int128_nz", test_nz);
206 g_test_add_func("/int128/int128_le", test_le);
207 g_test_add_func("/int128/int128_lt", test_lt);
208 g_test_add_func("/int128/int128_ge", test_ge);
209 g_test_add_func("/int128/int128_gt", test_gt);
210 g_test_add_func("/int128/int128_rshift", test_rshift);
211 return g_test_run();
212 }